ELIST_ITERATOR Class Reference

#include <elst.h>

Public Member Functions
	ELIST_ITERATOR ()
	ELIST_ITERATOR (ELIST *list_to_iterate)
void	set_to_list (ELIST *list_to_iterate)
void	add_after_then_move (ELIST_LINK *new_link)
void	add_after_stay_put (ELIST_LINK *new_link)
void	add_before_then_move (ELIST_LINK *new_link)
void	add_before_stay_put (ELIST_LINK *new_link)
void	add_list_after (ELIST *list_to_add)
void	add_list_before (ELIST *list_to_add)
ELIST_LINK *	data ()
ELIST_LINK *	data_relative (inT8 offset)
ELIST_LINK *	forward ()
ELIST_LINK *	extract ()
ELIST_LINK *	move_to_first ()
ELIST_LINK *	move_to_last ()
void	mark_cycle_pt ()
bool	empty ()
bool	current_extracted ()
bool	at_first ()
bool	at_last ()
bool	cycled_list ()
void	add_to_end (ELIST_LINK *new_link)
void	exchange (ELIST_ITERATOR *other_it)
inT32	length ()
void	sort (int comparator(const void *, const void *))

Friends
void	ELIST::assign_to_sublist (ELIST_ITERATOR *, ELIST_ITERATOR *)

Detailed Description

Definition at line 187 of file elst.h.

Constructor & Destructor Documentation

ELIST_ITERATOR() [1/2]

ELIST_ITERATOR::ELIST_ITERATOR ( )

inline

Definition at line 208 of file elst.h.

                     {  //constructor
      list = NULL;
    }                            //unassigned list

ELIST_ITERATOR() [2/2]

ELIST_ITERATOR::ELIST_ITERATOR ( ELIST *  list_to_iterate )

inlineexplicit

Definition at line 322 of file elst.h.

                                                            {
  set_to_list(list_to_iterate);
}

Member Function Documentation

add_after_stay_put()

void ELIST_ITERATOR::add_after_stay_put ( ELIST_LINK *  new_link )

inline

Definition at line 379 of file elst.h.

                                                                        {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::add_after_stay_put", ABORT, NULL);
  if (!new_element)
    BAD_PARAMETER.error ("ELIST_ITERATOR::add_after_stay_put", ABORT,
      "new_element is NULL");
  if (new_element->next)
    STILL_LINKED.error ("ELIST_ITERATOR::add_after_stay_put", ABORT, NULL);
  #endif

  if (list->empty ()) {
    new_element->next = new_element;
    list->last = new_element;
    prev = next = new_element;
    ex_current_was_last = FALSE;
    current = NULL;
  }
  else {
    new_element->next = next;

    if (current) {               //not extracted
      current->next = new_element;
      if (prev == current)
        prev = new_element;
      if (current == list->last)
        list->last = new_element;
    }
    else {                       //current extracted
      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 ELIST_ITERATOR::add_after_then_move ( ELIST_LINK *  new_link )

inline

Definition at line 334 of file elst.h.

                                                                         {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::add_after_then_move", ABORT, NULL);
  if (!new_element)
    BAD_PARAMETER.error ("ELIST_ITERATOR::add_after_then_move", ABORT,
      "new_element is NULL");
  if (new_element->next)
    STILL_LINKED.error ("ELIST_ITERATOR::add_after_then_move", ABORT, NULL);
  #endif

  if (list->empty ()) {
    new_element->next = new_element;
    list->last = new_element;
    prev = next = new_element;
  }
  else {
    new_element->next = next;

    if (current) {               //not extracted
      current->next = new_element;
      prev = current;
      if (current == list->last)
        list->last = new_element;
    }
    else {                       //current extracted
      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 ELIST_ITERATOR::add_before_stay_put ( ELIST_LINK *  new_link )

inline

Definition at line 468 of file elst.h.

                                                                         {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::add_before_stay_put", ABORT, NULL);
  if (!new_element)
    BAD_PARAMETER.error ("ELIST_ITERATOR::add_before_stay_put", ABORT,
      "new_element is NULL");
  if (new_element->next)
    STILL_LINKED.error ("ELIST_ITERATOR::add_before_stay_put", ABORT, NULL);
  #endif

  if (list->empty ()) {
    new_element->next = new_element;
    list->last = new_element;
    prev = next = new_element;
    ex_current_was_last = TRUE;
    current = NULL;
  }
  else {
    prev->next = new_element;
    if (current) {               //not extracted
      new_element->next = current;
      if (next == current)
        next = new_element;
    }
    else {                       //current extracted
      new_element->next = next;
      if (ex_current_was_last)
        list->last = new_element;
    }
    prev = new_element;
  }
}

add_before_then_move()

void ELIST_ITERATOR::add_before_then_move ( ELIST_LINK *  new_link )

inline

Definition at line 427 of file elst.h.

                                                                          {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::add_before_then_move", ABORT, NULL);
  if (!new_element)
    BAD_PARAMETER.error ("ELIST_ITERATOR::add_before_then_move", ABORT,
      "new_element is NULL");
  if (new_element->next)
    STILL_LINKED.error ("ELIST_ITERATOR::add_before_then_move", ABORT, NULL);
  #endif

  if (list->empty ()) {
    new_element->next = new_element;
    list->last = new_element;
    prev = next = new_element;
  }
  else {
    prev->next = new_element;
    if (current) {               //not extracted
      new_element->next = current;
      next = current;
    }
    else {                       //current extracted
      new_element->next = next;
      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 ELIST_ITERATOR::add_list_after ( ELIST *  list_to_add )

inline

Definition at line 511 of file elst.h.

                                                             {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::add_list_after", ABORT, NULL);
  if (!list_to_add)
    BAD_PARAMETER.error ("ELIST_ITERATOR::add_list_after", ABORT,
      "list_to_add is NULL");
  #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 = NULL;
    }
    else {
      if (current) {             //not extracted
        current->next = list_to_add->First ();
        if (current == list->last)
          list->last = list_to_add->last;
        list_to_add->last->next = next;
        next = current->next;
      }
      else {                     //current extracted
        prev->next = list_to_add->First ();
        if (ex_current_was_last) {
          list->last = list_to_add->last;
          ex_current_was_last = FALSE;
        }
        list_to_add->last->next = next;
        next = prev->next;
      }
    }
    list_to_add->last = NULL;
  }
}

add_list_before()

void ELIST_ITERATOR::add_list_before ( ELIST *  list_to_add )

inline

Definition at line 559 of file elst.h.

                                                              {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::add_list_before", ABORT, NULL);
  if (!list_to_add)
    BAD_PARAMETER.error ("ELIST_ITERATOR::add_list_before", ABORT,
      "list_to_add is NULL");
  #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 ();
      if (current) {             //not extracted
        list_to_add->last->next = current;
      }
      else {                     //current extracted
        list_to_add->last->next = next;
        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 = NULL;
  }
}

add_to_end()

void ELIST_ITERATOR::add_to_end ( ELIST_LINK *  new_link )

inline

Definition at line 790 of file elst.h.

                                                                {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::add_to_end", ABORT, NULL);
  if (!new_element)
    BAD_PARAMETER.error ("ELIST_ITERATOR::add_to_end", ABORT,
      "new_element is NULL");
  if (new_element->next)
    STILL_LINKED.error ("ELIST_ITERATOR::add_to_end", ABORT, NULL);
  #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;
      list->last->next = new_element;
      list->last = new_element;
    }
  }
}

at_first()

bool ELIST_ITERATOR::at_first ( )

inline

Definition at line 691 of file elst.h.

                                     {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::at_first", ABORT, NULL);
  #endif

                                 //we're at a deleted
  return ((list->empty ()) || (current == list->First ()) || ((current == NULL) &&
    (prev == list->last) &&      //NON-last pt between
    !ex_current_was_last));      //first and last
}

at_last()

bool ELIST_ITERATOR::at_last ( )

inline

Definition at line 711 of file elst.h.

                                    {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::at_last", ABORT, NULL);
  #endif

                                 //we're at a deleted
  return ((list->empty ()) || (current == list->last) || ((current == NULL) &&
    (prev == list->last) &&      //last point between
    ex_current_was_last));       //first and last
}

current_extracted()

bool ELIST_ITERATOR::current_extracted ( )

inline

Definition at line 266 of file elst.h.

                             {  //current extracted?
      return !current;
    }

cycled_list()

bool ELIST_ITERATOR::cycled_list ( )

inline

Definition at line 731 of file elst.h.

                                        {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::cycled_list", ABORT, NULL);
  #endif

  return ((list->empty ()) || ((current == cycle_pt) && started_cycling));

}

data()

ELIST_LINK* ELIST_ITERATOR::data ( )

inline

Definition at line 235 of file elst.h.

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

data_relative()

ELIST_LINK * ELIST_ITERATOR::data_relative

(

inT8

offset

)

Definition at line 233 of file elst.cpp.

                                                       {  //offset from current
  ELIST_LINK *ptr;

  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::data_relative", ABORT, NULL);
  if (list->empty ())
    EMPTY_LIST.error ("ELIST_ITERATOR::data_relative", ABORT, NULL);
  if (offset < -1)
    BAD_PARAMETER.error ("ELIST_ITERATOR::data_relative", ABORT,
      "offset < -l");
  #endif

  if (offset == -1)
    ptr = prev;
  else
    for (ptr = current ? current : prev; offset-- > 0; ptr = ptr->next);

  #ifndef NDEBUG
  if (!ptr)
    NULL_DATA.error ("ELIST_ITERATOR::data_relative", ABORT, NULL);
  #endif

  return ptr;
}

empty()

bool ELIST_ITERATOR::empty ( )

inline

Definition at line 258 of file elst.h.

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

exchange()

void ELIST_ITERATOR::exchange

(

ELIST_ITERATOR *

other_it

)

Definition at line 290 of file elst.cpp.

                                                        {  //other iterator
  const ERRCODE DONT_EXCHANGE_DELETED =
    "Can't exchange deleted elements of lists";

  ELIST_LINK *old_current;

  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::exchange", ABORT, NULL);
  if (!other_it)
    BAD_PARAMETER.error ("ELIST_ITERATOR::exchange", ABORT, "other_it NULL");
  if (!(other_it->list))
    NO_LIST.error ("ELIST_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 ("ELIST_ITERATOR.exchange", ABORT, NULL);

  /* 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;
        current->next = 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;
        other_it->current->next = current;
        next = current;
        other_it->prev = other_it->current;
      }
    }
  }
  else {                         //no overlap
    prev->next = other_it->current;
    current->next = other_it->next;
    other_it->prev->next = current;
    other_it->current->next = next;
  }

  /* 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()

ELIST_LINK * ELIST_ITERATOR::extract ( )

inline

Definition at line 605 of file elst.h.

                                           {
  ELIST_LINK *extracted_link;

  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::extract", ABORT, NULL);
  if (!current)                  //list empty or
                                 //element extracted
    NULL_CURRENT.error ("ELIST_ITERATOR::extract",
      ABORT, NULL);
  #endif

  if (list->singleton()) {
    // Special case where we do need to change the iterator.
    prev = next = list->last = NULL;
  } else {
    prev->next = next;           //remove from list

    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) ? TRUE : FALSE;
  extracted_link = current;
  extracted_link->next = NULL;   //for safety
  current = NULL;
  return extracted_link;
}

forward()

ELIST_LINK * ELIST_ITERATOR::forward

(

)

Definition at line 194 of file elst.cpp.

                                    {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::forward", ABORT, NULL);
  #endif
  if (list->empty ())
    return NULL;

  if (current) {                 //not removed so
                                 //set previous
    prev = current;
    started_cycling = TRUE;
    // In case next is deleted by another iterator, get next from current.
    current = current->next;
  } else {
    if (ex_current_was_cycle_pt)
      cycle_pt = next;
    current = next;
  }
  next = current->next;

  #ifndef NDEBUG
  if (!current)
    NULL_DATA.error ("ELIST_ITERATOR::forward", ABORT, NULL);
  if (!next)
    NULL_NEXT.error ("ELIST_ITERATOR::forward", ABORT,
                     "This is: %p  Current is: %p", this, current);
  #endif
  return current;
}

length()

inT32 ELIST_ITERATOR::length ( )

inline

Definition at line 749 of file elst.h.

                                    {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::length", ABORT, NULL);
  #endif

  return list->length ();
}

mark_cycle_pt()

void ELIST_ITERATOR::mark_cycle_pt ( )

inline

Definition at line 670 of file elst.h.

                                          {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::mark_cycle_pt", ABORT, NULL);
  #endif

  if (current)
    cycle_pt = current;
  else
    ex_current_was_cycle_pt = TRUE;
  started_cycling = FALSE;
}

move_to_first()

ELIST_LINK * ELIST_ITERATOR::move_to_first ( )

inline

Definition at line 646 of file elst.h.

                                                 {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::move_to_first", ABORT, NULL);
  #endif

  current = list->First ();
  prev = list->last;
  next = current ? current->next : NULL;
  return current;
}

move_to_last()

ELIST_LINK * ELIST_ITERATOR::move_to_last

(

)

Definition at line 268 of file elst.cpp.

                                         {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::move_to_last", ABORT, NULL);
  #endif

  while (current != list->last)
    forward();

  return current;
}

set_to_list()

void ELIST_ITERATOR::set_to_list ( ELIST *  list_to_iterate )

inline

Definition at line 297 of file elst.h.

                                                                {
  #ifndef NDEBUG
  if (!list_to_iterate)
    BAD_PARAMETER.error ("ELIST_ITERATOR::set_to_list", ABORT,
      "list_to_iterate is NULL");
  #endif

  list = list_to_iterate;
  prev = list->last;
  current = list->First ();
  next = current ? current->next : NULL;
  cycle_pt = NULL;               //await explicit set
  started_cycling = FALSE;
  ex_current_was_last = FALSE;
  ex_current_was_cycle_pt = FALSE;
}

sort()

void ELIST_ITERATOR::sort ( int   comparator const void *, const void * )

inline

Definition at line 767 of file elst.h.

                             {
  #ifndef NDEBUG
  if (!list)
    NO_LIST.error ("ELIST_ITERATOR::sort", ABORT, NULL);
  #endif

  list->sort (comparator);
  move_to_first();
}

Friends And Related Function Documentation

ELIST::assign_to_sublist

void ELIST::assign_to_sublist ( ELIST_ITERATOR *  , ELIST_ITERATOR *    )

friend

---

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

• ccutil/elst.h
• ccutil/elst.cpp