tesseract::ELIST Class Reference

#include <elst.h>

Public Member Functions
void	internal_clear (void(*zapper)(void *))
bool	empty () const
bool	singleton () const
void	shallow_copy (ELIST *from_list)
void	internal_deep_copy (ELIST_LINK *(*copier)(ELIST_LINK *), const ELIST *list)
void	assign_to_sublist (ELIST_ITERATOR *start_it, ELIST_ITERATOR *end_it)
int32_t	length () const
void	sort (int comparator(const void *, const void *))
ELIST_LINK *	add_sorted_and_find (int comparator(const void *, const void *), bool unique, ELIST_LINK *new_link)
bool	add_sorted (int comparator(const void *, const void *), bool unique, ELIST_LINK *new_link)

Friends
class	ELIST_ITERATOR

Detailed Description

Definition at line 111 of file elst.h.

Member Function Documentation

add_sorted()

bool tesseract::ELIST::add_sorted ( int   comparatorconst void *, const void *, bool  unique, ELIST_LINK *  new_link  )

inline

Definition at line 176 of file elst.h.

                                                                                                 {
    return (add_sorted_and_find(comparator, unique, new_link) == new_link);
  }

add_sorted_and_find()

ELIST_LINK * tesseract::ELIST::add_sorted_and_find	(	int	comparatorconst void *, const void *,
		bool	unique,
		ELIST_LINK *	new_link
	)

Definition at line 125 of file elst.cpp.

                                                             {
  // Check for adding at the end.
  if (last == nullptr || comparator(&last, &new_link) < 0) {
    if (last == nullptr) {
      new_link->next = new_link;
    } else {
      new_link->next = last->next;
      last->next = new_link;
    }
    last = new_link;
  } else {
    // Need to use an iterator.
    ELIST_ITERATOR it(this);
    for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
      ELIST_LINK *link = it.data();
      int compare = comparator(&link, &new_link);
      if (compare > 0) {
        break;
      } else if (unique && compare == 0) {
        return link;
      }
    }
    if (it.cycled_list()) {
      it.add_to_end(new_link);
    } else {
      it.add_before_then_move(new_link);
    }
  }
  return new_link;
}

assign_to_sublist()

void tesseract::ELIST::assign_to_sublist	(	ELIST_ITERATOR *	start_it,
		ELIST_ITERATOR *	end_it
	)

Definition at line 67 of file elst.cpp.

                            {  // from list end
  constexpr ERRCODE LIST_NOT_EMPTY("Destination list must be empty before extracting a sublist");
 
  if (!empty()) {
    LIST_NOT_EMPTY.error("ELIST.assign_to_sublist", ABORT);
  }
 
  last = start_it->extract_sublist(end_it);
}

empty()

bool tesseract::ELIST::empty ( ) const

inline

Definition at line 124 of file elst.h.

                     {
    return !last;
  }

internal_clear()

void tesseract::ELIST::internal_clear

(

void(*)(void *)

zapper

)

Definition at line 36 of file elst.cpp.

                            {
  // ptr to zapper functn
  ELIST_LINK *ptr;
  ELIST_LINK *next;
 
  if (!empty()) {
    ptr = last->next;     // set to first
    last->next = nullptr; // break circle
    last = nullptr;       // set list empty
    while (ptr) {
      next = ptr->next;
      zapper(ptr);
      ptr = next;
    }
  }
}

internal_deep_copy()

void tesseract::ELIST::internal_deep_copy	(	ELIST_LINK *(*)(ELIST_LINK *)	copier,
		const ELIST *	list
	)

length()

int32_t tesseract::ELIST::length ( ) const

inline

Definition at line 146 of file elst.h.

                         {
    int32_t count = 0;
    if (last != nullptr) {
      count = 1;
      for (auto it = last->next; it != last; it = it->next) {
        count++;
      }
    }
    return count;
  }

shallow_copy()

void tesseract::ELIST::shallow_copy ( ELIST *  from_list )

inline

Definition at line 132 of file elst.h.

                        { // beware destructors!!
    last = from_list->last;
  }

singleton()

bool tesseract::ELIST::singleton ( ) const

inline

Definition at line 128 of file elst.h.

                         {
    return last ? (last == last->next) : false;
  }

sort()

void tesseract::ELIST::sort

(

int

comparator const void *, const void *

)

Definition at line 87 of file elst.cpp.

                                     {
  // Allocate an array of pointers, one per list element.
  auto count = length();
 
  if (count > 0) {
    // ptr array to sort
    std::vector<ELIST_LINK *> base;
    base.reserve(count);
 
    ELIST_ITERATOR it(this);
 
    // Extract all elements, putting the pointers in the array.
    for (it.mark_cycle_pt(); !it.cycled_list(); it.forward()) {
      base.push_back(it.extract());
    }
 
    // Sort the pointer array.
    qsort(&base[0], count, sizeof(base[0]), comparator);
 
    // Rebuild the list from the sorted pointers.
    for (auto current : base) {
      it.add_to_end(current);
    }
  }
}

Friends And Related Function Documentation

ELIST_ITERATOR

friend class ELIST_ITERATOR

friend

Definition at line 112 of file elst.h.

---

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

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