tesseract 4.1.1
Loading...
Searching...
No Matches
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}
void set_to_list(ELIST2 *list_to_iterate)
Definition: elst2.h:258

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}
@ ABORT
Definition: errcode.h:29
constexpr ERRCODE BAD_PARAMETER("List parameter error")
constexpr ERRCODE STILL_LINKED("Attempting to add an element with non nullptr links, to a list")
constexpr ERRCODE NO_LIST("Iterator not set to a list")
bool empty() const
Definition: elst2.h:105
void error(const char *caller, TessErrorLogCode action, const char *format,...) const
Definition: errcode.cpp:35

◆ 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}
bool at_last()
Definition: elst2.h:709
void add_after_stay_put(ELIST2_LINK *new_link)
Definition: elst2.h:341
void add_before_stay_put(ELIST2_LINK *new_link)
Definition: elst2.h:438
bool at_first()
Definition: elst2.h:690

◆ 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}
constexpr ERRCODE NULL_DATA("List would have returned a nullptr data pointer")
constexpr ERRCODE NULL_PREV("Previous element on the list is nullptr")

◆ current_extracted()

bool ELIST2_ITERATOR::current_extracted ( )
inline

Definition at line 224 of file elst2.h.

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

◆ 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 190 of file elst2.h.

190 { //get current data
191 #ifndef NDEBUG
192 if (!current)
193 NULL_DATA.error ("ELIST2_ITERATOR::data", ABORT, nullptr);
194 if (!list)
195 NO_LIST.error ("ELIST2_ITERATOR::data", ABORT, nullptr);
196 #endif
197 return current;
198 }

◆ 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}
constexpr ERRCODE EMPTY_LIST("List is empty")

◆ empty()

bool ELIST2_ITERATOR::empty ( )
inline

Definition at line 216 of file elst2.h.

216 { //is list empty?
217 #ifndef NDEBUG
218 if (!list)
219 NO_LIST.error ("ELIST2_ITERATOR::empty", ABORT, nullptr);
220 #endif
221 return list->empty ();
222 }

◆ 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}
constexpr ERRCODE NULL_CURRENT("List current position is nullptr")
bool singleton() const
Definition: elst2.h:109

◆ 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}
constexpr ERRCODE NULL_NEXT("Next element on the list is nullptr")

◆ 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}
int32_t length() const
Definition: elst2.cpp:89

◆ 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);
772}
void sort(int comparator(const void *, const void *))
Definition: elst2.cpp:107
ELIST2_LINK * move_to_first()
Definition: elst2.h:628

Friends And Related Function Documentation

◆ ELIST2::assign_to_sublist


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