tesseract  4.1.1
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_LINKdata ()
 
ELIST2_LINKdata_relative (int8_t offset)
 
ELIST2_LINKforward ()
 
ELIST2_LINKbackward ()
 
ELIST2_LINKextract ()
 
ELIST2_LINKmove_to_first ()
 
ELIST2_LINKmove_to_last ()
 
void mark_cycle_pt ()
 
bool empty ()
 
bool current_extracted ()
 
bool at_first ()
 
bool at_last ()
 
bool cycled_list ()
 
void add_to_end (ELIST2_LINK *new_link)
 
void exchange (ELIST2_ITERATOR *other_it)
 
int32_t length ()
 
void sort (int comparator(const void *, const void *))
 

Friends

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

Detailed Description

Definition at line 149 of file elst2.h.

Constructor & Destructor Documentation

◆ ELIST2_ITERATOR()

ELIST2_ITERATOR::ELIST2_ITERATOR ( ELIST2 list_to_iterate)
inline

Definition at line 282 of file elst2.h.

282  {
283  set_to_list(list_to_iterate);
284 }

Member Function Documentation

◆ add_after_stay_put()

void ELIST2_ITERATOR::add_after_stay_put ( ELIST2_LINK new_link)
inline

Definition at line 341 of file elst2.h.

342  {
343  #ifndef NDEBUG
344  if (!list)
345  NO_LIST.error ("ELIST2_ITERATOR::add_after_stay_put", ABORT, nullptr);
346  if (!new_element)
347  BAD_PARAMETER.error ("ELIST2_ITERATOR::add_after_stay_put", ABORT,
348  "new_element is nullptr");
349  if (new_element->next)
350  STILL_LINKED.error ("ELIST2_ITERATOR::add_after_stay_put", ABORT, nullptr);
351  #endif
352 
353  if (list->empty ()) {
354  new_element->next = new_element;
355  new_element->prev = new_element;
356  list->last = new_element;
357  prev = next = new_element;
358  ex_current_was_last = false;
359  current = nullptr;
360  }
361  else {
362  new_element->next = next;
363  next->prev = new_element;
364 
365  if (current) { //not extracted
366  new_element->prev = current;
367  current->next = new_element;
368  if (prev == current)
369  prev = new_element;
370  if (current == list->last)
371  list->last = new_element;
372  }
373  else { //current extracted
374  new_element->prev = prev;
375  prev->next = new_element;
376  if (ex_current_was_last) {
377  list->last = new_element;
378  ex_current_was_last = false;
379  }
380  }
381  next = new_element;
382  }
383 }

◆ add_after_then_move()

void ELIST2_ITERATOR::add_after_then_move ( ELIST2_LINK new_link)
inline

Definition at line 293 of file elst2.h.

294  {
295  #ifndef NDEBUG
296  if (!list)
297  NO_LIST.error ("ELIST2_ITERATOR::add_after_then_move", ABORT, nullptr);
298  if (!new_element)
299  BAD_PARAMETER.error ("ELIST2_ITERATOR::add_after_then_move", ABORT,
300  "new_element is nullptr");
301  if (new_element->next)
302  STILL_LINKED.error ("ELIST2_ITERATOR::add_after_then_move", ABORT, nullptr);
303  #endif
304 
305  if (list->empty ()) {
306  new_element->next = new_element;
307  new_element->prev = new_element;
308  list->last = new_element;
309  prev = next = new_element;
310  }
311  else {
312  new_element->next = next;
313  next->prev = new_element;
314 
315  if (current) { //not extracted
316  new_element->prev = current;
317  current->next = new_element;
318  prev = current;
319  if (current == list->last)
320  list->last = new_element;
321  }
322  else { //current extracted
323  new_element->prev = prev;
324  prev->next = new_element;
325  if (ex_current_was_last)
326  list->last = new_element;
327  if (ex_current_was_cycle_pt)
328  cycle_pt = new_element;
329  }
330  }
331  current = new_element;
332 }

◆ add_before_stay_put()

void ELIST2_ITERATOR::add_before_stay_put ( ELIST2_LINK new_link)
inline

Definition at line 438 of file elst2.h.

439  {
440  #ifndef NDEBUG
441  if (!list)
442  NO_LIST.error ("ELIST2_ITERATOR::add_before_stay_put", ABORT, nullptr);
443  if (!new_element)
444  BAD_PARAMETER.error ("ELIST2_ITERATOR::add_before_stay_put", ABORT,
445  "new_element is nullptr");
446  if (new_element->next)
447  STILL_LINKED.error ("ELIST2_ITERATOR::add_before_stay_put", ABORT, nullptr);
448  #endif
449 
450  if (list->empty ()) {
451  new_element->next = new_element;
452  new_element->prev = new_element;
453  list->last = new_element;
454  prev = next = new_element;
455  ex_current_was_last = true;
456  current = nullptr;
457  }
458  else {
459  prev->next = new_element;
460  new_element->prev = prev;
461 
462  if (current) { //not extracted
463  new_element->next = current;
464  current->prev = new_element;
465  if (next == current)
466  next = new_element;
467  }
468  else { //current extracted
469  new_element->next = next;
470  next->prev = new_element;
471  if (ex_current_was_last)
472  list->last = new_element;
473  }
474  prev = new_element;
475  }
476 }

◆ add_before_then_move()

void ELIST2_ITERATOR::add_before_then_move ( ELIST2_LINK new_link)
inline

Definition at line 392 of file elst2.h.

393  {
394  #ifndef NDEBUG
395  if (!list)
396  NO_LIST.error ("ELIST2_ITERATOR::add_before_then_move", ABORT, nullptr);
397  if (!new_element)
398  BAD_PARAMETER.error ("ELIST2_ITERATOR::add_before_then_move", ABORT,
399  "new_element is nullptr");
400  if (new_element->next)
401  STILL_LINKED.error ("ELIST2_ITERATOR::add_before_then_move", ABORT, nullptr);
402  #endif
403 
404  if (list->empty ()) {
405  new_element->next = new_element;
406  new_element->prev = new_element;
407  list->last = new_element;
408  prev = next = new_element;
409  }
410  else {
411  prev->next = new_element;
412  new_element->prev = prev;
413 
414  if (current) { //not extracted
415  new_element->next = current;
416  current->prev = new_element;
417  next = current;
418  }
419  else { //current extracted
420  new_element->next = next;
421  next->prev = new_element;
422  if (ex_current_was_last)
423  list->last = new_element;
424  if (ex_current_was_cycle_pt)
425  cycle_pt = new_element;
426  }
427  }
428  current = new_element;
429 }

◆ add_list_after()

void ELIST2_ITERATOR::add_list_after ( ELIST2 list_to_add)
inline

Definition at line 486 of file elst2.h.

486  {
487  #ifndef NDEBUG
488  if (!list)
489  NO_LIST.error ("ELIST2_ITERATOR::add_list_after", ABORT, nullptr);
490  if (!list_to_add)
491  BAD_PARAMETER.error ("ELIST2_ITERATOR::add_list_after", ABORT,
492  "list_to_add is nullptr");
493  #endif
494 
495  if (!list_to_add->empty ()) {
496  if (list->empty ()) {
497  list->last = list_to_add->last;
498  prev = list->last;
499  next = list->First ();
500  ex_current_was_last = true;
501  current = nullptr;
502  }
503  else {
504  if (current) { //not extracted
505  current->next = list_to_add->First ();
506  current->next->prev = current;
507  if (current == list->last)
508  list->last = list_to_add->last;
509  list_to_add->last->next = next;
510  next->prev = list_to_add->last;
511  next = current->next;
512  }
513  else { //current extracted
514  prev->next = list_to_add->First ();
515  prev->next->prev = prev;
516  if (ex_current_was_last) {
517  list->last = list_to_add->last;
518  ex_current_was_last = false;
519  }
520  list_to_add->last->next = next;
521  next->prev = list_to_add->last;
522  next = prev->next;
523  }
524  }
525  list_to_add->last = nullptr;
526  }
527 }

◆ add_list_before()

void ELIST2_ITERATOR::add_list_before ( ELIST2 list_to_add)
inline

Definition at line 537 of file elst2.h.

537  {
538  #ifndef NDEBUG
539  if (!list)
540  NO_LIST.error ("ELIST2_ITERATOR::add_list_before", ABORT, nullptr);
541  if (!list_to_add)
542  BAD_PARAMETER.error ("ELIST2_ITERATOR::add_list_before", ABORT,
543  "list_to_add is nullptr");
544  #endif
545 
546  if (!list_to_add->empty ()) {
547  if (list->empty ()) {
548  list->last = list_to_add->last;
549  prev = list->last;
550  current = list->First ();
551  next = current->next;
552  ex_current_was_last = false;
553  }
554  else {
555  prev->next = list_to_add->First ();
556  prev->next->prev = prev;
557 
558  if (current) { //not extracted
559  list_to_add->last->next = current;
560  current->prev = list_to_add->last;
561  }
562  else { //current extracted
563  list_to_add->last->next = next;
564  next->prev = list_to_add->last;
565  if (ex_current_was_last)
566  list->last = list_to_add->last;
567  if (ex_current_was_cycle_pt)
568  cycle_pt = prev->next;
569  }
570  current = prev->next;
571  next = current->next;
572  }
573  list_to_add->last = nullptr;
574  }
575 }

◆ add_to_end()

void ELIST2_ITERATOR::add_to_end ( ELIST2_LINK new_link)
inline

Definition at line 784 of file elst2.h.

785  {
786  #ifndef NDEBUG
787  if (!list)
788  NO_LIST.error ("ELIST2_ITERATOR::add_to_end", ABORT, nullptr);
789  if (!new_element)
790  BAD_PARAMETER.error ("ELIST2_ITERATOR::add_to_end", ABORT,
791  "new_element is nullptr");
792  if (new_element->next)
793  STILL_LINKED.error ("ELIST2_ITERATOR::add_to_end", ABORT, nullptr);
794  #endif
795 
796  if (this->at_last ()) {
797  this->add_after_stay_put (new_element);
798  }
799  else {
800  if (this->at_first ()) {
801  this->add_before_stay_put (new_element);
802  list->last = new_element;
803  }
804  else { //Iteratr is elsewhere
805  new_element->next = list->last->next;
806  new_element->prev = list->last;
807  list->last->next->prev = new_element;
808  list->last->next = new_element;
809  list->last = new_element;
810  }
811  }
812 }

◆ at_first()

bool ELIST2_ITERATOR::at_first ( )
inline

Definition at line 690 of file elst2.h.

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

◆ at_last()

bool ELIST2_ITERATOR::at_last ( )
inline

Definition at line 709 of file elst2.h.

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

◆ backward()

ELIST2_LINK * ELIST2_ITERATOR::backward ( )

Definition at line 229 of file elst2.cpp.

229  {
230  #ifndef NDEBUG
231  if (!list)
232  NO_LIST.error ("ELIST2_ITERATOR::backward", ABORT, nullptr);
233  #endif
234  if (list->empty ())
235  return nullptr;
236 
237  if (current) { //not removed so
238  //set previous
239  next = current;
240  started_cycling = true;
241  // In case prev is deleted by another iterator, get it from current.
242  current = current->prev;
243  } else {
244  if (ex_current_was_cycle_pt)
245  cycle_pt = prev;
246  current = prev;
247  }
248 
249  #ifndef NDEBUG
250  if (!current)
251  NULL_DATA.error ("ELIST2_ITERATOR::backward", ABORT, nullptr);
252  if (!prev)
253  NULL_PREV.error ("ELIST2_ITERATOR::backward", ABORT,
254  "This is: %p Current is: %p", this, current);
255  #endif
256 
257  prev = current->prev;
258  return current;
259 }

◆ current_extracted()

bool ELIST2_ITERATOR::current_extracted ( )
inline

Definition at line 229 of file elst2.h.

246  :
247  // Don't use the following constructor.

◆ cycled_list()

bool ELIST2_ITERATOR::cycled_list ( )
inline

Definition at line 728 of file elst2.h.

728  {
729  #ifndef NDEBUG
730  if (!list)
731  NO_LIST.error ("ELIST2_ITERATOR::cycled_list", ABORT, nullptr);
732  #endif
733 
734  return ((list->empty ()) || ((current == cycle_pt) && started_cycling));
735 
736 }

◆ data()

ELIST2_LINK* ELIST2_ITERATOR::data ( )
inline

Definition at line 195 of file elst2.h.

216  { //is list empty?

◆ data_relative()

ELIST2_LINK * ELIST2_ITERATOR::data_relative ( int8_t  offset)

Definition at line 268 of file elst2.cpp.

269  { //offset from current
270  ELIST2_LINK *ptr;
271 
272  #ifndef NDEBUG
273  if (!list)
274  NO_LIST.error ("ELIST2_ITERATOR::data_relative", ABORT, nullptr);
275  if (list->empty ())
276  EMPTY_LIST.error ("ELIST2_ITERATOR::data_relative", ABORT, nullptr);
277  #endif
278 
279  if (offset < 0)
280  for (ptr = current ? current : next; offset++ < 0; ptr = ptr->prev);
281  else
282  for (ptr = current ? current : prev; offset-- > 0; ptr = ptr->next);
283 
284  #ifndef NDEBUG
285  if (!ptr)
286  NULL_DATA.error ("ELIST2_ITERATOR::data_relative", ABORT, nullptr);
287  #endif
288 
289  return ptr;
290 }

◆ empty()

bool ELIST2_ITERATOR::empty ( )
inline

Definition at line 221 of file elst2.h.

224  { //current extracted?
225  return !current;
226  }
227 

◆ exchange()

void ELIST2_ITERATOR::exchange ( ELIST2_ITERATOR other_it)

Definition at line 302 of file elst2.cpp.

303  { //other iterator
304  constexpr ERRCODE DONT_EXCHANGE_DELETED(
305  "Can't exchange deleted elements of lists");
306 
307  ELIST2_LINK *old_current;
308 
309  #ifndef NDEBUG
310  if (!list)
311  NO_LIST.error ("ELIST2_ITERATOR::exchange", ABORT, nullptr);
312  if (!other_it)
313  BAD_PARAMETER.error ("ELIST2_ITERATOR::exchange", ABORT, "other_it nullptr");
314  if (!(other_it->list))
315  NO_LIST.error ("ELIST2_ITERATOR::exchange", ABORT, "other_it");
316  #endif
317 
318  /* Do nothing if either list is empty or if both iterators reference the same
319  link */
320 
321  if ((list->empty ()) ||
322  (other_it->list->empty ()) || (current == other_it->current))
323  return;
324 
325  /* Error if either current element is deleted */
326 
327  if (!current || !other_it->current)
328  DONT_EXCHANGE_DELETED.error ("ELIST2_ITERATOR.exchange", ABORT, nullptr);
329 
330  /* Now handle the 4 cases: doubleton list; non-doubleton adjacent elements
331  (other before this); non-doubleton adjacent elements (this before other);
332  non-adjacent elements. */
333 
334  //adjacent links
335  if ((next == other_it->current) ||
336  (other_it->next == current)) {
337  //doubleton list
338  if ((next == other_it->current) &&
339  (other_it->next == current)) {
340  prev = next = current;
341  other_it->prev = other_it->next = other_it->current;
342  }
343  else { //non-doubleton with
344  //adjacent links
345  //other before this
346  if (other_it->next == current) {
347  other_it->prev->next = current;
348  other_it->current->next = next;
349  other_it->current->prev = current;
350  current->next = other_it->current;
351  current->prev = other_it->prev;
352  next->prev = other_it->current;
353 
354  other_it->next = other_it->current;
355  prev = current;
356  }
357  else { //this before other
358  prev->next = other_it->current;
359  current->next = other_it->next;
360  current->prev = other_it->current;
361  other_it->current->next = current;
362  other_it->current->prev = prev;
363  other_it->next->prev = current;
364 
365  next = current;
366  other_it->prev = other_it->current;
367  }
368  }
369  }
370  else { //no overlap
371  prev->next = other_it->current;
372  current->next = other_it->next;
373  current->prev = other_it->prev;
374  next->prev = other_it->current;
375  other_it->prev->next = current;
376  other_it->current->next = next;
377  other_it->current->prev = prev;
378  other_it->next->prev = current;
379  }
380 
381  /* update end of list pointer when necessary (remember that the 2 iterators
382  may iterate over different lists!) */
383 
384  if (list->last == current)
385  list->last = other_it->current;
386  if (other_it->list->last == other_it->current)
387  other_it->list->last = current;
388 
389  if (current == cycle_pt)
390  cycle_pt = other_it->cycle_pt;
391  if (other_it->current == other_it->cycle_pt)
392  other_it->cycle_pt = cycle_pt;
393 
394  /* The actual exchange - in all cases*/
395 
396  old_current = current;
397  current = other_it->current;
398  other_it->current = old_current;
399 }

◆ extract()

ELIST2_LINK * ELIST2_ITERATOR::extract ( )
inline

Definition at line 586 of file elst2.h.

586  {
587  ELIST2_LINK *extracted_link;
588 
589  #ifndef NDEBUG
590  if (!list)
591  NO_LIST.error ("ELIST2_ITERATOR::extract", ABORT, nullptr);
592  if (!current) //list empty or
593  //element extracted
594  NULL_CURRENT.error ("ELIST2_ITERATOR::extract",
595  ABORT, nullptr);
596  #endif
597 
598  if (list->singleton()) {
599  // Special case where we do need to change the iterator.
600  prev = next = list->last = nullptr;
601  } else {
602  prev->next = next; //remove from list
603  next->prev = prev;
604 
605  if (current == list->last) {
606  list->last = prev;
607  ex_current_was_last = true;
608  } else {
609  ex_current_was_last = false;
610  }
611  }
612  // Always set ex_current_was_cycle_pt so an add/forward will work in a loop.
613  ex_current_was_cycle_pt = (current == cycle_pt);
614  extracted_link = current;
615  extracted_link->next = nullptr; //for safety
616  extracted_link->prev = nullptr; //for safety
617  current = nullptr;
618  return extracted_link;
619 }

◆ forward()

ELIST2_LINK * ELIST2_ITERATOR::forward ( )

Definition at line 185 of file elst2.cpp.

185  {
186  #ifndef NDEBUG
187  if (!list)
188  NO_LIST.error ("ELIST2_ITERATOR::forward", ABORT, nullptr);
189  #endif
190  if (list->empty ())
191  return nullptr;
192 
193  if (current) { //not removed so
194  //set previous
195  prev = current;
196  started_cycling = true;
197  // In case next is deleted by another iterator, get it from the current.
198  current = current->next;
199  }
200  else {
201  if (ex_current_was_cycle_pt)
202  cycle_pt = next;
203  current = next;
204  }
205 
206 #ifndef NDEBUG
207  if (!current)
208  NULL_DATA.error ("ELIST2_ITERATOR::forward", ABORT, nullptr);
209 #endif
210 
211  next = current->next;
212 
213 #ifndef NDEBUG
214  if (!next)
215  NULL_NEXT.error ("ELIST2_ITERATOR::forward", ABORT,
216  "This is: %p Current is: %p", this, current);
217 #endif
218 
219  return current;
220 }

◆ length()

int32_t ELIST2_ITERATOR::length ( )
inline

Definition at line 745 of file elst2.h.

745  {
746  #ifndef NDEBUG
747  if (!list)
748  NO_LIST.error ("ELIST2_ITERATOR::length", ABORT, nullptr);
749  #endif
750 
751  return list->length ();
752 }

◆ mark_cycle_pt()

void ELIST2_ITERATOR::mark_cycle_pt ( )
inline

Definition at line 670 of file elst2.h.

670  {
671  #ifndef NDEBUG
672  if (!list)
673  NO_LIST.error ("ELIST2_ITERATOR::mark_cycle_pt", ABORT, nullptr);
674  #endif
675 
676  if (current)
677  cycle_pt = current;
678  else
679  ex_current_was_cycle_pt = true;
680  started_cycling = false;
681 }

◆ move_to_first()

ELIST2_LINK * ELIST2_ITERATOR::move_to_first ( )
inline

Definition at line 628 of file elst2.h.

628  {
629  #ifndef NDEBUG
630  if (!list)
631  NO_LIST.error ("ELIST2_ITERATOR::move_to_first", ABORT, nullptr);
632  #endif
633 
634  current = list->First ();
635  prev = list->last;
636  next = current ? current->next : nullptr;
637  return current;
638 }

◆ move_to_last()

ELIST2_LINK * ELIST2_ITERATOR::move_to_last ( )
inline

Definition at line 647 of file elst2.h.

647  {
648  #ifndef NDEBUG
649  if (!list)
650  NO_LIST.error ("ELIST2_ITERATOR::move_to_last", ABORT, nullptr);
651  #endif
652 
653  current = list->last;
654  prev = current ? current->prev : nullptr;
655  next = current ? current->next : nullptr;
656  return current;
657 }

◆ set_to_list()

void ELIST2_ITERATOR::set_to_list ( ELIST2 list_to_iterate)
inline

Definition at line 258 of file elst2.h.

259  {
260  #ifndef NDEBUG
261  if (!list_to_iterate)
262  BAD_PARAMETER.error ("ELIST2_ITERATOR::set_to_list", ABORT,
263  "list_to_iterate is nullptr");
264  #endif
265 
266  list = list_to_iterate;
267  prev = list->last;
268  current = list->First ();
269  next = current ? current->next : nullptr;
270  cycle_pt = nullptr; //await explicit set
271  started_cycling = false;
272  ex_current_was_last = false;
273  ex_current_was_cycle_pt = false;
274 }

◆ sort()

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

Definition at line 762 of file elst2.h.

764  {
765  #ifndef NDEBUG
766  if (!list)
767  NO_LIST.error ("ELIST2_ITERATOR::sort", ABORT, nullptr);
768  #endif
769 
770  list->sort (comparator);
771  move_to_first();
772 }

Friends And Related Function Documentation

◆ ELIST2::assign_to_sublist


The documentation for this class was generated from the following files:
ELIST2::singleton
bool singleton() const
Definition: elst2.h:113
ERRCODE
Definition: errcode.h:68
EMPTY_LIST
constexpr ERRCODE EMPTY_LIST("List is empty")
ELIST2::sort
void sort(int comparator(const void *, const void *))
Definition: elst2.cpp:107
STILL_LINKED
constexpr ERRCODE STILL_LINKED("Attempting to add an element with non nullptr links, to a list")
ERRCODE::error
void error(const char *caller, TessErrorLogCode action, const char *format,...) const
Definition: errcode.cpp:35
ELIST2_ITERATOR::move_to_first
ELIST2_LINK * move_to_first()
Definition: elst2.h:628
BAD_PARAMETER
constexpr ERRCODE BAD_PARAMETER("List parameter error")
ELIST2_ITERATOR::at_last
bool at_last()
Definition: elst2.h:709
NO_LIST
constexpr ERRCODE NO_LIST("Iterator not set to a list")
NULL_PREV
constexpr ERRCODE NULL_PREV("Previous element on the list is nullptr")
NULL_CURRENT
constexpr ERRCODE NULL_CURRENT("List current position is nullptr")
ELIST2_ITERATOR::at_first
bool at_first()
Definition: elst2.h:690
ELIST2_ITERATOR::add_after_stay_put
void add_after_stay_put(ELIST2_LINK *new_link)
Definition: elst2.h:341
ELIST2_LINK
Definition: elst2.h:57
ELIST2_ITERATOR::set_to_list
void set_to_list(ELIST2 *list_to_iterate)
Definition: elst2.h:258
ELIST2::empty
bool empty() const
Definition: elst2.h:109
ELIST2::length
int32_t length() const
Definition: elst2.cpp:89
NULL_DATA
constexpr ERRCODE NULL_DATA("List would have returned a nullptr data pointer")
NULL_NEXT
constexpr ERRCODE NULL_NEXT("Next element on the list is nullptr")
ELIST2_ITERATOR::add_before_stay_put
void add_before_stay_put(ELIST2_LINK *new_link)
Definition: elst2.h:438
ABORT
@ ABORT
Definition: errcode.h:45