ccutil/clst.cpp

Go to the documentation of this file.

#include "mfcpch.h"     //precompiled headers
#include <stdlib.h>
#include "clst.h"

/* ==================
 *  MEMBER FUNCTIONS OF CLASS: CLIST
 *  ================================
 ==================== */

void
CLIST::internal_deep_clear (     //destroy all links
void (*zapper) (void *)) {       //ptr to zapper functn
  CLIST_LINK *ptr;
  CLIST_LINK *next;

  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST::internal_deep_clear", ABORT, NULL);
  #endif

  if (!empty ()) {
    ptr = last->next;            //set to first
    last->next = NULL;           //break circle
    last = NULL;                 //set list empty
    while (ptr) {
      next = ptr->next;
      zapper (ptr->data);
      delete(ptr);
      ptr = next;
    }
  }
}


void CLIST::shallow_clear() {  //destroy all links
  CLIST_LINK *ptr;
  CLIST_LINK *next;

  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST::shallow_clear", ABORT, NULL);
  #endif

  if (!empty ()) {
    ptr = last->next;            //set to first
    last->next = NULL;           //break circle
    last = NULL;                 //set list empty
    while (ptr) {
      next = ptr->next;
      delete(ptr);
      ptr = next;
    }
  }
}


void CLIST::internal_deep_copy (
   void *(*copier) (void *), //ptr to copier functn
   const CLIST * list) {            //list being copied
  CLIST_ITERATOR from_it ((CLIST *) list);
  CLIST_ITERATOR to_it(this);

  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST::internal_deep_copy", ABORT, NULL);
  if (!list)
    BAD_PARAMETER.error ("CLIST::internal_deep_copy", ABORT,
      "source list is NULL");
  #endif

  for (from_it.mark_cycle_pt (); !from_it.cycled_list (); from_it.forward ())
    to_it.add_after_then_move (copier (from_it.data ()));
}


void CLIST::assign_to_sublist(                           //to this list
                              CLIST_ITERATOR *start_it,  //from list start
                              CLIST_ITERATOR *end_it) {  //from list end
  const ERRCODE LIST_NOT_EMPTY =
    "Destination list must be empty before extracting a sublist";

  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST::assign_to_sublist", ABORT, NULL);
  #endif

  if (!empty ())
    LIST_NOT_EMPTY.error ("CLIST.assign_to_sublist", ABORT, NULL);

  last = start_it->extract_sublist (end_it);
}


INT32 CLIST::length() {  //count elements
  CLIST_ITERATOR it(this);
  INT32 count = 0;

  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST::length", ABORT, NULL);
  #endif

  for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ())
    count++;
  return count;
}


void
CLIST::sort (                    //sort elements
int comparator (                 //comparison routine
const void *, const void *)) {
  CLIST_ITERATOR it(this);
  INT32 count;
  void **base;                   //ptr array to sort
  void **current;
  INT32 i;

  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST::sort", ABORT, NULL);
  #endif

  /* Allocate an array of pointers, one per list element */
  count = length ();
  base = (void **) malloc (count * sizeof (void *));

  /* Extract all elements, putting the pointers in the array */
  current = base;
  for (it.mark_cycle_pt (); !it.cycled_list (); it.forward ()) {
    *current = it.extract ();
    current++;
  }

  /* Sort the pointer array */
  qsort ((char *) base, count, sizeof (*base), comparator);

  /* Rebuild the list from the sorted pointers */
  current = base;
  for (i = 0; i < count; i++) {
    it.add_to_end (*current);
    current++;
  }
  free(base);
}


void CLIST::prep_serialise() {
  CLIST_ITERATOR this_it(this);
  INT32 count = 0;

  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST::prep_serialise", ABORT, NULL);
  #endif

  count = 0;
  if (!empty ())
    for (this_it.mark_cycle_pt ();
    !this_it.cycled_list (); this_it.forward ())
  count++;
  last = (CLIST_LINK *) count;
}


void
CLIST::internal_dump (FILE * f, void element_serialiser (FILE *, void *)) {
  CLIST_ITERATOR this_it(this);

  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST::internal_dump", ABORT, NULL);
  #endif

  if (!empty ())
    for (this_it.mark_cycle_pt ();
    !this_it.cycled_list (); this_it.forward ())
  element_serialiser (f, this_it.data ());
}


void
CLIST::internal_de_dump (FILE * f, void *element_de_serialiser (FILE *)) {
  INT32 count = (ptrdiff_t) last;
  CLIST_ITERATOR this_it;

  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST::internal_de_dump", ABORT, NULL);
  #endif

  last = NULL;
  this_it.set_to_list (this);
  for (; count > 0; count--)
    this_it.add_to_end (element_de_serialiser (f));
}


/* ==================
 *  MEMBER FUNCTIONS OF CLASS: CLIST_ITERATOR
 *  =========================================
 ==================== */

void *CLIST_ITERATOR::forward() {
  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST_ITERATOR::forward", ABORT, NULL);
  if (!list)
    NO_LIST.error ("CLIST_ITERATOR::forward", ABORT, NULL);
  #endif
  if (list->empty ())
    return NULL;

  if (current) {                 //not removed so
                                 //set previous
    prev = current;
    started_cycling = TRUE;
  }
  else {
    if (ex_current_was_cycle_pt)
      cycle_pt = next;
  }
  current = next;
  next = current->next;

  #ifdef _DEBUG
  if (!current)
    NULL_DATA.error ("CLIST_ITERATOR::forward", ABORT, NULL);
  if (!next)
    NULL_NEXT.error ("CLIST_ITERATOR::forward", ABORT,
      "This is: %i  Current is: %i",
      (int) this, (int) current);
  #endif
  return current->data;
}


void *CLIST_ITERATOR::data_relative(                //get data + or - ...
                                    INT8 offset) {  //offset from current
  CLIST_LINK *ptr;

  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST_ITERATOR::data_relative", ABORT, NULL);
  if (!list)
    NO_LIST.error ("CLIST_ITERATOR::data_relative", ABORT, NULL);
  if (list->empty ())
    EMPTY_LIST.error ("CLIST_ITERATOR::data_relative", ABORT, NULL);
  if (offset < -1)
    BAD_PARAMETER.error ("CLIST_ITERATOR::data_relative", ABORT,
      "offset < -l");
  #endif

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

  #ifdef _DEBUG
  if (!ptr)
    NULL_DATA.error ("CLIST_ITERATOR::data_relative", ABORT, NULL);
  #endif

  return ptr->data;
}


void *CLIST_ITERATOR::move_to_last() {
  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST_ITERATOR::move_to_last", ABORT, NULL);
  if (!list)
    NO_LIST.error ("CLIST_ITERATOR::move_to_last", ABORT, NULL);
  #endif

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

  if (current == NULL)
    return NULL;
  else
    return current->data;
}


void CLIST_ITERATOR::exchange(     //positions of 2 links
                              CLIST_ITERATOR *other_it) {  //other iterator
  const ERRCODE DONT_EXCHANGE_DELETED =
    "Can't exchange deleted elements of lists";

  CLIST_LINK *old_current;

  #ifdef _DEBUG
  if (!this)
    NULL_OBJECT.error ("CLIST_ITERATOR::exchange", ABORT, NULL);
  if (!list)
    NO_LIST.error ("CLIST_ITERATOR::exchange", ABORT, NULL);
  if (!other_it)
    BAD_PARAMETER.error ("CLIST_ITERATOR::exchange", ABORT, "other_it NULL");
  if (!(other_it->list))
    NO_LIST.error ("CLIST_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 ("CLIST_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;
}


CLIST_LINK *CLIST_ITERATOR::extract_sublist(   //from this current
          CLIST_ITERATOR *other_it) {  //to other current
  CLIST_ITERATOR temp_it = *this;
  CLIST_LINK *end_of_new_list;

  const ERRCODE BAD_SUBLIST = "Can't find sublist end point in original list";
  #ifdef _DEBUG
  const ERRCODE BAD_EXTRACTION_PTS =
    "Can't extract sublist from points on different lists";
  const ERRCODE DONT_EXTRACT_DELETED =
    "Can't extract a sublist marked by deleted points";

  if (!this)
    NULL_OBJECT.error ("CLIST_ITERATOR::extract_sublist", ABORT, NULL);
  if (!other_it)
    BAD_PARAMETER.error ("CLIST_ITERATOR::extract_sublist", ABORT,
      "other_it NULL");
  if (!list)
    NO_LIST.error ("CLIST_ITERATOR::extract_sublist", ABORT, NULL);
  if (list != other_it->list)
    BAD_EXTRACTION_PTS.error ("CLIST_ITERATOR.extract_sublist", ABORT, NULL);
  if (list->empty ())
    EMPTY_LIST.error ("CLIST_ITERATOR::extract_sublist", ABORT, NULL);

  if (!current || !other_it->current)
    DONT_EXTRACT_DELETED.error ("CLIST_ITERATOR.extract_sublist", ABORT,
      NULL);
  #endif

  ex_current_was_last = other_it->ex_current_was_last = FALSE;
  ex_current_was_cycle_pt = FALSE;
  other_it->ex_current_was_cycle_pt = FALSE;

  temp_it.mark_cycle_pt ();
  do {                           //walk sublist
    if (temp_it.cycled_list ())  //cant find end pt
      BAD_SUBLIST.error ("CLIST_ITERATOR.extract_sublist", ABORT, NULL);

    if (temp_it.at_last ()) {
      list->last = prev;
      ex_current_was_last = other_it->ex_current_was_last = TRUE;
    }

    if (temp_it.current == cycle_pt)
      ex_current_was_cycle_pt = TRUE;

    if (temp_it.current == other_it->cycle_pt)
      other_it->ex_current_was_cycle_pt = TRUE;

    temp_it.forward ();
  }
  while (temp_it.prev != other_it->current);

                                 //circularise sublist
  other_it->current->next = current;
  end_of_new_list = other_it->current;

                                 //sublist = whole list
  if (prev == other_it->current) {
    list->last = NULL;
    prev = current = next = NULL;
    other_it->prev = other_it->current = other_it->next = NULL;
  }
  else {
    prev->next = other_it->next;
    current = other_it->current = NULL;
    next = other_it->next;
    other_it->prev = prev;
  }
  return end_of_new_list;
}

---