tesseract::ELIST2_ITERATOR Class Reference

#include <elst2.h>

Public Member Functions
	ELIST2_ITERATOR (ELIST2 *list_to_iterate)
void	set_to_list (ELIST2 *list_to_iterate)
void	add_after_then_move (ELIST2_LINK *new_link)
void	add_after_stay_put (ELIST2_LINK *new_link)
void	add_before_then_move (ELIST2_LINK *new_link)
void	add_before_stay_put (ELIST2_LINK *new_link)
void	add_list_after (ELIST2 *list_to_add)
void	add_list_before (ELIST2 *list_to_add)
ELIST2_LINK *	data ()
ELIST2_LINK *	data_relative (int8_t offset)
ELIST2_LINK *	forward ()
ELIST2_LINK *	backward ()
ELIST2_LINK *	extract ()
ELIST2_LINK *	move_to_first ()
ELIST2_LINK *	move_to_last ()
void	mark_cycle_pt ()
bool	empty () const
bool	current_extracted () const
bool	at_first () const
bool	at_last () const
bool	cycled_list () const
void	add_to_end (ELIST2_LINK *new_link)
void	exchange (ELIST2_ITERATOR *other_it)
int32_t	length () const
void	sort (int comparator(const void *, const void *))

Friends
void	ELIST2::assign_to_sublist (ELIST2_ITERATOR *, ELIST2_ITERATOR *)

Detailed Description

Definition at line 151 of file elst2.h.

Constructor & Destructor Documentation

ELIST2_ITERATOR()

tesseract::ELIST2_ITERATOR::ELIST2_ITERATOR ( ELIST2 *  list_to_iterate )

inline

Definition at line 289 of file elst2.h.

                                                               {
  set_to_list(list_to_iterate);
}

Member Function Documentation

add_after_stay_put()

void tesseract::ELIST2_ITERATOR::add_after_stay_put ( ELIST2_LINK *  new_link )

inline

Definition at line 351 of file elst2.h.

                              {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::add_after_stay_put", ABORT);
  }
  if (!new_element) {
    BAD_PARAMETER.error("ELIST2_ITERATOR::add_after_stay_put", ABORT, "new_element is nullptr");
  }
  if (new_element->next) {
    STILL_LINKED.error("ELIST2_ITERATOR::add_after_stay_put", ABORT);
  }
#endif
 
  if (list->empty()) {
    new_element->next = new_element;
    new_element->prev = new_element;
    list->last = new_element;
    prev = next = new_element;
    ex_current_was_last = false;
    current = nullptr;
  } else {
    new_element->next = next;
    next->prev = new_element;
 
    if (current) { // not extracted
      new_element->prev = current;
      current->next = new_element;
      if (prev == current) {
        prev = new_element;
      }
      if (current == list->last) {
        list->last = new_element;
      }
    } else { // current extracted
      new_element->prev = prev;
      prev->next = new_element;
      if (ex_current_was_last) {
        list->last = new_element;
        ex_current_was_last = false;
      }
    }
    next = new_element;
  }
}

add_after_then_move()

void tesseract::ELIST2_ITERATOR::add_after_then_move ( ELIST2_LINK *  new_link )

inline

Definition at line 300 of file elst2.h.

                              {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::add_after_then_move", ABORT);
  }
  if (!new_element) {
    BAD_PARAMETER.error("ELIST2_ITERATOR::add_after_then_move", ABORT, "new_element is nullptr");
  }
  if (new_element->next) {
    STILL_LINKED.error("ELIST2_ITERATOR::add_after_then_move", ABORT);
  }
#endif
 
  if (list->empty()) {
    new_element->next = new_element;
    new_element->prev = new_element;
    list->last = new_element;
    prev = next = new_element;
  } else {
    new_element->next = next;
    next->prev = new_element;
 
    if (current) { // not extracted
      new_element->prev = current;
      current->next = new_element;
      prev = current;
      if (current == list->last) {
        list->last = new_element;
      }
    } else { // current extracted
      new_element->prev = prev;
      prev->next = new_element;
      if (ex_current_was_last) {
        list->last = new_element;
      }
      if (ex_current_was_cycle_pt) {
        cycle_pt = new_element;
      }
    }
  }
  current = new_element;
}

add_before_stay_put()

void tesseract::ELIST2_ITERATOR::add_before_stay_put ( ELIST2_LINK *  new_link )

inline

Definition at line 452 of file elst2.h.

                              {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::add_before_stay_put", ABORT);
  }
  if (!new_element) {
    BAD_PARAMETER.error("ELIST2_ITERATOR::add_before_stay_put", ABORT, "new_element is nullptr");
  }
  if (new_element->next) {
    STILL_LINKED.error("ELIST2_ITERATOR::add_before_stay_put", ABORT);
  }
#endif
 
  if (list->empty()) {
    new_element->next = new_element;
    new_element->prev = new_element;
    list->last = new_element;
    prev = next = new_element;
    ex_current_was_last = true;
    current = nullptr;
  } else {
    prev->next = new_element;
    new_element->prev = prev;
 
    if (current) { // not extracted
      new_element->next = current;
      current->prev = new_element;
      if (next == current) {
        next = new_element;
      }
    } else { // current extracted
      new_element->next = next;
      next->prev = new_element;
      if (ex_current_was_last) {
        list->last = new_element;
      }
    }
    prev = new_element;
  }
}

add_before_then_move()

void tesseract::ELIST2_ITERATOR::add_before_then_move ( ELIST2_LINK *  new_link )

inline

Definition at line 404 of file elst2.h.

                              {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::add_before_then_move", ABORT);
  }
  if (!new_element) {
    BAD_PARAMETER.error("ELIST2_ITERATOR::add_before_then_move", ABORT, "new_element is nullptr");
  }
  if (new_element->next) {
    STILL_LINKED.error("ELIST2_ITERATOR::add_before_then_move", ABORT);
  }
#endif
 
  if (list->empty()) {
    new_element->next = new_element;
    new_element->prev = new_element;
    list->last = new_element;
    prev = next = new_element;
  } else {
    prev->next = new_element;
    new_element->prev = prev;
 
    if (current) { // not extracted
      new_element->next = current;
      current->prev = new_element;
      next = current;
    } else { // current extracted
      new_element->next = next;
      next->prev = new_element;
      if (ex_current_was_last) {
        list->last = new_element;
      }
      if (ex_current_was_cycle_pt) {
        cycle_pt = new_element;
      }
    }
  }
  current = new_element;
}

add_list_after()

void tesseract::ELIST2_ITERATOR::add_list_after ( ELIST2 *  list_to_add )

inline

Definition at line 502 of file elst2.h.

                                                               {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::add_list_after", ABORT);
  }
  if (!list_to_add) {
    BAD_PARAMETER.error("ELIST2_ITERATOR::add_list_after", ABORT, "list_to_add is nullptr");
  }
#endif
 
  if (!list_to_add->empty()) {
    if (list->empty()) {
      list->last = list_to_add->last;
      prev = list->last;
      next = list->First();
      ex_current_was_last = true;
      current = nullptr;
    } else {
      if (current) { // not extracted
        current->next = list_to_add->First();
        current->next->prev = current;
        if (current == list->last) {
          list->last = list_to_add->last;
        }
        list_to_add->last->next = next;
        next->prev = list_to_add->last;
        next = current->next;
      } else { // current extracted
        prev->next = list_to_add->First();
        prev->next->prev = prev;
        if (ex_current_was_last) {
          list->last = list_to_add->last;
          ex_current_was_last = false;
        }
        list_to_add->last->next = next;
        next->prev = list_to_add->last;
        next = prev->next;
      }
    }
    list_to_add->last = nullptr;
  }
}

add_list_before()

void tesseract::ELIST2_ITERATOR::add_list_before ( ELIST2 *  list_to_add )

inline

Definition at line 553 of file elst2.h.

                                                                {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::add_list_before", ABORT);
  }
  if (!list_to_add) {
    BAD_PARAMETER.error("ELIST2_ITERATOR::add_list_before", ABORT, "list_to_add is nullptr");
  }
#endif
 
  if (!list_to_add->empty()) {
    if (list->empty()) {
      list->last = list_to_add->last;
      prev = list->last;
      current = list->First();
      next = current->next;
      ex_current_was_last = false;
    } else {
      prev->next = list_to_add->First();
      prev->next->prev = prev;
 
      if (current) { // not extracted
        list_to_add->last->next = current;
        current->prev = list_to_add->last;
      } else { // current extracted
        list_to_add->last->next = next;
        next->prev = list_to_add->last;
        if (ex_current_was_last) {
          list->last = list_to_add->last;
        }
        if (ex_current_was_cycle_pt) {
          cycle_pt = prev->next;
        }
      }
      current = prev->next;
      next = current->next;
    }
    list_to_add->last = nullptr;
  }
}

add_to_end()

void tesseract::ELIST2_ITERATOR::add_to_end ( ELIST2_LINK *  new_link )

inline

Definition at line 792 of file elst2.h.

                              {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::add_to_end", ABORT);
  }
  if (!new_element) {
    BAD_PARAMETER.error("ELIST2_ITERATOR::add_to_end", ABORT, "new_element is nullptr");
  }
  if (new_element->next) {
    STILL_LINKED.error("ELIST2_ITERATOR::add_to_end", ABORT);
  }
#endif
 
  if (this->at_last()) {
    this->add_after_stay_put(new_element);
  } else {
    if (this->at_first()) {
      this->add_before_stay_put(new_element);
      list->last = new_element;
    } else { // Iteratr is elsewhere
      new_element->next = list->last->next;
      new_element->prev = list->last;
      list->last->next->prev = new_element;
      list->last->next = new_element;
      list->last = new_element;
    }
  }
}

at_first()

bool tesseract::ELIST2_ITERATOR::at_first ( ) const

inline

Definition at line 712 of file elst2.h.

                                            {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::at_first", ABORT);
  }
#endif
 
  // we're at a deleted
  return ((list->empty()) || (current == list->First()) ||
          ((current == nullptr) && (prev == list->last) && // NON-last pt between
           !ex_current_was_last));                         // first and last
}

at_last()

bool tesseract::ELIST2_ITERATOR::at_last ( ) const

inline

Definition at line 732 of file elst2.h.

                                           {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::at_last", ABORT);
  }
#endif
 
  // we're at a deleted
  return ((list->empty()) || (current == list->last) ||
          ((current == nullptr) && (prev == list->last) && // last point between
           ex_current_was_last));                          // first and last
}

backward()

ELIST2_LINK * tesseract::ELIST2_ITERATOR::backward

(

)

Definition at line 210 of file elst2.cpp.

                                       {
#ifndef NDEBUG
  if (!list)
    NO_LIST.error("ELIST2_ITERATOR::backward", ABORT);
#endif
  if (list->empty()) {
    return nullptr;
  }
 
  if (current) { // not removed so
                 // set previous
    next = current;
    started_cycling = true;
    // In case prev is deleted by another iterator, get it from current.
    current = current->prev;
  } else {
    if (ex_current_was_cycle_pt) {
      cycle_pt = prev;
    }
    current = prev;
  }
 
#ifndef NDEBUG
  if (!current)
    NULL_DATA.error("ELIST2_ITERATOR::backward", ABORT);
  if (!prev) {
    NULL_PREV.error("ELIST2_ITERATOR::backward", ABORT,
                    "This is: %p  Current is: %p",
                    static_cast<void *>(this),
                    static_cast<void *>(current));
  }
#endif
 
  prev = current->prev;
  return current;
}

current_extracted()

bool tesseract::ELIST2_ITERATOR::current_extracted ( ) const

inline

Definition at line 228 of file elst2.h.

                                 { // current extracted?
    return !current;
  }

cycled_list()

bool tesseract::ELIST2_ITERATOR::cycled_list ( ) const

inline

Definition at line 752 of file elst2.h.

                                               {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::cycled_list", ABORT);
  }
#endif
 
  return ((list->empty()) || ((current == cycle_pt) && started_cycling));
}

data()

ELIST2_LINK * tesseract::ELIST2_ITERATOR::data ( )

inline

Definition at line 191 of file elst2.h.

                      { // get current data
#ifndef NDEBUG
    if (!current) {
      NULL_DATA.error("ELIST2_ITERATOR::data", ABORT);
    }
    if (!list) {
      NO_LIST.error("ELIST2_ITERATOR::data", ABORT);
    }
#endif
    return current;
  }

data_relative()

ELIST2_LINK * tesseract::ELIST2_ITERATOR::data_relative

(

int8_t

offset

)

Definition at line 254 of file elst2.cpp.

                   {                         // offset from current
  ELIST2_LINK *ptr;
 
#ifndef NDEBUG
  if (!list)
    NO_LIST.error("ELIST2_ITERATOR::data_relative", ABORT);
  if (list->empty())
    EMPTY_LIST.error("ELIST2_ITERATOR::data_relative", ABORT);
#endif
 
  if (offset < 0) {
    for (ptr = current ? current : next; offset++ < 0; ptr = ptr->prev) {
      ;
    }
  } else {
    for (ptr = current ? current : prev; offset-- > 0; ptr = ptr->next) {
      ;
    }
  }
 
#ifndef NDEBUG
  if (!ptr)
    NULL_DATA.error("ELIST2_ITERATOR::data_relative", ABORT);
#endif
 
  return ptr;
}

empty()

bool tesseract::ELIST2_ITERATOR::empty ( ) const

inline

Definition at line 219 of file elst2.h.

                     { // is list empty?
#ifndef NDEBUG
    if (!list) {
      NO_LIST.error("ELIST2_ITERATOR::empty", ABORT);
    }
#endif
    return list->empty();
  }

exchange()

void tesseract::ELIST2_ITERATOR::exchange

(

ELIST2_ITERATOR *

other_it

)

Definition at line 293 of file elst2.cpp.

                               { // other iterator
  constexpr ERRCODE DONT_EXCHANGE_DELETED("Can't exchange deleted elements of lists");
 
  ELIST2_LINK *old_current;
 
#ifndef NDEBUG
  if (!list)
    NO_LIST.error("ELIST2_ITERATOR::exchange", ABORT);
  if (!other_it)
    BAD_PARAMETER.error("ELIST2_ITERATOR::exchange", ABORT, "other_it nullptr");
  if (!(other_it->list))
    NO_LIST.error("ELIST2_ITERATOR::exchange", ABORT, "other_it");
#endif
 
  /* Do nothing if either list is empty or if both iterators reference the same
link */
 
  if ((list->empty()) || (other_it->list->empty()) || (current == other_it->current)) {
    return;
  }
 
  /* Error if either current element is deleted */
 
  if (!current || !other_it->current) {
    DONT_EXCHANGE_DELETED.error("ELIST2_ITERATOR.exchange", ABORT);
  }
 
  /* Now handle the 4 cases: doubleton list; non-doubleton adjacent elements
(other before this); non-doubleton adjacent elements (this before other);
non-adjacent elements. */
 
  // adjacent links
  if ((next == other_it->current) || (other_it->next == current)) {
    // doubleton list
    if ((next == other_it->current) && (other_it->next == current)) {
      prev = next = current;
      other_it->prev = other_it->next = other_it->current;
    } else { // non-doubleton with
             // adjacent links
             // other before this
      if (other_it->next == current) {
        other_it->prev->next = current;
        other_it->current->next = next;
        other_it->current->prev = current;
        current->next = other_it->current;
        current->prev = other_it->prev;
        next->prev = other_it->current;
 
        other_it->next = other_it->current;
        prev = current;
      } else { // this before other
        prev->next = other_it->current;
        current->next = other_it->next;
        current->prev = other_it->current;
        other_it->current->next = current;
        other_it->current->prev = prev;
        other_it->next->prev = current;
 
        next = current;
        other_it->prev = other_it->current;
      }
    }
  } else { // no overlap
    prev->next = other_it->current;
    current->next = other_it->next;
    current->prev = other_it->prev;
    next->prev = other_it->current;
    other_it->prev->next = current;
    other_it->current->next = next;
    other_it->current->prev = prev;
    other_it->next->prev = current;
  }
 
  /* update end of list pointer when necessary (remember that the 2 iterators
  may iterate over different lists!) */
 
  if (list->last == current) {
    list->last = other_it->current;
  }
  if (other_it->list->last == other_it->current) {
    other_it->list->last = current;
  }
 
  if (current == cycle_pt) {
    cycle_pt = other_it->cycle_pt;
  }
  if (other_it->current == other_it->cycle_pt) {
    other_it->cycle_pt = cycle_pt;
  }
 
  /* The actual exchange - in all cases*/
 
  old_current = current;
  current = other_it->current;
  other_it->current = old_current;
}

extract()

ELIST2_LINK * tesseract::ELIST2_ITERATOR::extract ( )

inline

Definition at line 603 of file elst2.h.

                                             {
  ELIST2_LINK *extracted_link;
 
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::extract", ABORT);
  }
  if (!current) { // list empty or
                  // element extracted
    NULL_CURRENT.error("ELIST2_ITERATOR::extract", ABORT);
  }
#endif
 
  if (list->singleton()) {
    // Special case where we do need to change the iterator.
    prev = next = list->last = nullptr;
  } else {
    prev->next = next; // remove from list
    next->prev = prev;
 
    if (current == list->last) {
      list->last = prev;
      ex_current_was_last = true;
    } else {
      ex_current_was_last = false;
    }
  }
  // Always set ex_current_was_cycle_pt so an add/forward will work in a loop.
  ex_current_was_cycle_pt = (current == cycle_pt);
  extracted_link = current;
  extracted_link->next = nullptr; // for safety
  extracted_link->prev = nullptr; // for safety
  current = nullptr;
  return extracted_link;
}

forward()

ELIST2_LINK * tesseract::ELIST2_ITERATOR::forward

(

)

Definition at line 162 of file elst2.cpp.

                                      {
#ifndef NDEBUG
  if (!list)
    NO_LIST.error("ELIST2_ITERATOR::forward", ABORT);
#endif
  if (list->empty()) {
    return nullptr;
  }
 
  if (current) { // not removed so
                 // set previous
    prev = current;
    started_cycling = true;
    // In case next is deleted by another iterator, get it from the current.
    current = current->next;
  } else {
    if (ex_current_was_cycle_pt) {
      cycle_pt = next;
    }
    current = next;
  }
 
#ifndef NDEBUG
  if (!current)
    NULL_DATA.error("ELIST2_ITERATOR::forward", ABORT);
#endif
 
  next = current->next;
 
#ifndef NDEBUG
  if (!next) {
    NULL_NEXT.error("ELIST2_ITERATOR::forward", ABORT,
                    "This is: %p  Current is: %p",
                    static_cast<void *>(this),
                    static_cast<void *>(current));
  }
#endif
 
  return current;
}

length()

int32_t tesseract::ELIST2_ITERATOR::length ( ) const

inline

Definition at line 245 of file elst2.h.

                         {
    return list->length();
  }

mark_cycle_pt()

void tesseract::ELIST2_ITERATOR::mark_cycle_pt ( )

inline

Definition at line 690 of file elst2.h.

                                           {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::mark_cycle_pt", ABORT);
  }
#endif
 
  if (current) {
    cycle_pt = current;
  } else {
    ex_current_was_cycle_pt = true;
  }
  started_cycling = false;
}

move_to_first()

ELIST2_LINK * tesseract::ELIST2_ITERATOR::move_to_first ( )

inline

Definition at line 646 of file elst2.h.

                                                   {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::move_to_first", ABORT);
  }
#endif
 
  current = list->First();
  prev = list->last;
  next = current ? current->next : nullptr;
  return current;
}

move_to_last()

ELIST2_LINK * tesseract::ELIST2_ITERATOR::move_to_last ( )

inline

Definition at line 666 of file elst2.h.

                                                  {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::move_to_last", ABORT);
  }
#endif
 
  current = list->last;
  prev = current ? current->prev : nullptr;
  next = current ? current->next : nullptr;
  return current;
}

set_to_list()

void tesseract::ELIST2_ITERATOR::set_to_list ( ELIST2 *  list_to_iterate )

inline

Definition at line 265 of file elst2.h.

                             {
#ifndef NDEBUG
  if (!list_to_iterate) {
    BAD_PARAMETER.error("ELIST2_ITERATOR::set_to_list", ABORT, "list_to_iterate is nullptr");
  }
#endif
 
  list = list_to_iterate;
  prev = list->last;
  current = list->First();
  next = current ? current->next : nullptr;
  cycle_pt = nullptr; // await explicit set
  started_cycling = false;
  ex_current_was_last = false;
  ex_current_was_cycle_pt = false;
}

sort()

void tesseract::ELIST2_ITERATOR::sort ( int   comparator const void *, const void * )

inline

Definition at line 769 of file elst2.h.

                                     {
#ifndef NDEBUG
  if (!list) {
    NO_LIST.error("ELIST2_ITERATOR::sort", ABORT);
  }
#endif
 
  list->sort(comparator);
  move_to_first();
}

Friends And Related Function Documentation

ELIST2::assign_to_sublist

void ELIST2::assign_to_sublist ( ELIST2_ITERATOR *  , ELIST2_ITERATOR *    )

friend

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccutil/elst2.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccutil/elst2.cpp