liblevenshtein::StateIterator Class Reference

Iterates over the Position nodes in the linked-list of a Levenshtein State. More...

#include <state_iterator.h>

Collaboration diagram for liblevenshtein::StateIterator:

Public Member Functions
	StateIterator (State *state, Position *head, StateIterator *outer=nullptr)
	Constructs a new StateIterator of the Position nodes of state, with an optional outer pointer for unsubsumption.
void	insert (Position *position)
	Inserts a new Position after the current one in the linked-list.
void	remove ()
	Removes the current Position from the linked-list.
auto	operator++ () -> StateIterator &
	Advances the Position in the linked-list by one.
auto	operator* () const -> Position *
	Returns a pointer to the current Position in the linked-list.
auto	operator== (const StateIterator &other) const -> bool
	Returns whether this StateIterator is equivalent to another.

Private Member Functions
void	advance ()
	Advances the Position being iterated over by one.

Private Attributes
StateIterator *	_outer = nullptr
	Outermost iterator over the same linked-list, used for unsubsumption.
State *	_state = nullptr
	Levenshtein State that owns the linked-list being iterated over.
Position *	_next = nullptr
	Next Position to be iterated over.
Position *	_curr = nullptr
	Current Position being iterated over.
Position *	_prev = nullptr
	Previous Position being iterated over.

Detailed Description

Iterates over the Position nodes in the linked-list of a Levenshtein State.

Definition at line 14 of file state_iterator.h.

Constructor & Destructor Documentation

StateIterator()

liblevenshtein::StateIterator::StateIterator	(	State *	state,
		Position *	head,
		StateIterator *	outer = nullptr )

Constructs a new StateIterator of the Position nodes of state, with an optional outer pointer for unsubsumption.

Parameters

state	Levenshtein State owning the linked-list being iterated over.
head	Head Position of the current sub-list.
outer	Iterator during unsubsumption that owns the outermost level of iteration over the linked-list.

Definition at line 6 of file state_iterator.cpp.

  : _outer(outer),
    _state(state),
    _curr(head),
    _next(head != nullptr ? head->next() : nullptr)
{}

Member Function Documentation

advance()

void liblevenshtein::StateIterator::advance ( )

private

Advances the Position being iterated over by one.

Definition at line 45 of file state_iterator.cpp.

                            {
  if (_curr != nullptr) {
    _prev = _curr;
  }
 
  _curr = _next;
 
  if (_next != nullptr) {
    _next = _next->next();
  }
}

References _curr, _next, _prev, and liblevenshtein::Position::next().

Here is the call graph for this function:

insert()

void liblevenshtein::StateIterator::insert

(

Position *

position

)

Inserts a new Position after the current one in the linked-list.

Parameters

position

New Position to add after the current one in the linked-list.

Definition at line 26 of file state_iterator.cpp.

                                             {
  if (_curr != nullptr) {
    _state->insert_after(_curr, position);
  } else {
    _state->head(position);
  }
  _next = position;
}

References _curr, _next, _state, liblevenshtein::State::head(), liblevenshtein::State::insert_after(), and query().

Here is the call graph for this function:

operator*()

auto liblevenshtein::StateIterator::operator*

(

)

const -> Position *

Returns a pointer to the current Position in the linked-list.

Returns

A pointer to the current Position in the linked-list.

Definition at line 18 of file state_iterator.cpp.

                                                  {
  return _curr;
}

References _curr.

operator++()

auto liblevenshtein::StateIterator::operator++

(

)

-> StateIterator &

Advances the Position in the linked-list by one.

Returns

A reference to the iterator containing the advanced state.

Definition at line 13 of file state_iterator.cpp.

                                                  {
  advance();
  return *this;
}

operator==()

auto liblevenshtein::StateIterator::operator==

(

const StateIterator &

other

)

const -> bool

Returns whether this StateIterator is equivalent to another.

By convention, the iterators must be over the same linked-list.

Parameters

other

A StateIterator to compare with this one for equivalence.

Returns

Whether this StateIterator is equivalent to the other.

Definition at line 22 of file state_iterator.cpp.

                                                                       {
  return (_curr == other._curr) && (_next == other._next);
}

References query().

Here is the call graph for this function:

remove()

void liblevenshtein::StateIterator::remove

(

)

Removes the current Position from the linked-list.

Definition at line 35 of file state_iterator.cpp.

                           {
  if (_curr != nullptr) {
    if (_outer != nullptr && _outer->_next == _curr) {
      _outer->_next = _outer->_next->next();
    }
    _state->remove(_prev, _curr);
    _curr = nullptr;
  }
}

References _curr, _next, _outer, _prev, _state, liblevenshtein::Position::next(), and liblevenshtein::State::remove().

Here is the call graph for this function:

Member Data Documentation

_curr

Position* liblevenshtein::StateIterator::_curr = nullptr

private

Current Position being iterated over.

Definition at line 75 of file state_iterator.h.

Referenced by advance(), insert(), operator*(), and remove().

_next

Position* liblevenshtein::StateIterator::_next = nullptr

private

Next Position to be iterated over.

Definition at line 72 of file state_iterator.h.

Referenced by advance(), insert(), and remove().

_outer

StateIterator* liblevenshtein::StateIterator::_outer = nullptr

private

Outermost iterator over the same linked-list, used for unsubsumption.

Definition at line 66 of file state_iterator.h.

Referenced by remove().

_prev

Position* liblevenshtein::StateIterator::_prev = nullptr

private

Previous Position being iterated over.

Definition at line 78 of file state_iterator.h.

Referenced by advance(), and remove().

_state

State* liblevenshtein::StateIterator::_state = nullptr

private

Levenshtein State that owns the linked-list being iterated over.

Definition at line 69 of file state_iterator.h.

Referenced by insert(), and remove().

---

The documentation for this class was generated from the following files:

• src/liblevenshtein/transducer/state_iterator.h
• src/liblevenshtein/transducer/state_iterator.cpp