Piper's Pit BBS/FTP: ibm 0040 - 0049/ibm0040-0049/ibm0040.tar/ibm0040/BCPPOWL1.ZIP/CLSRC.ZIP/DBLLIST.CPP

C/C++ Source or Header | 1991-08-28 | 14.9 KB | 626 lines

// Borland C++ - (C) Copyright 1991 by Borland International

// Contents ----------------------------------------------------------------
//
//      DoubleList::isA
//      DoubleList::nameOf
//      DoubleList::add
//      DoubleList::addAtHead
//      DoubleList::addAtTail
//      DoubleList::detach
//      DoubleList::detachFromHead
//      DoubleList::detachFromTail
//      DoubleList::initIterator
//      DoubleList::initReverseIterator
//         DoubleList::hashValue
//
//      DoubleListIterator::operator int
//      DoubleListIterator::operator Object&
//      DoubleListIterator::operator ++
//      DoubleListIterator::restart
//      DoubleListIterator::operator --
//
// Description
//
//      Implementation of class DoubleList member functions.
//
// End ---------------------------------------------------------------------

// Interface Dependencies ---------------------------------------------------

#ifndef __IOSTREAM_H
#include <iostream.h>
#define __IOSTREAM_H
#endif

#ifndef __CLSTYPES_H
#include <clstypes.h>
#endif

#ifndef __OBJECT_H
#include <object.h>
#endif

#ifndef __CONTAIN_H
#include <contain.h>
#endif

#ifndef __DLSTELEM_H
#include <dlstelem.h>
#endif

#ifndef __DBLLIST_H
#include <dbllist.h>
#endif

// End Interface Dependencies ------------------------------------------------

// Implementation Dependencies ----------------------------------------------
// End Implementation Dependencies -------------------------------------------


// Member Function //

DoubleList::~DoubleList()

// Summary -----------------------------------------------------------------
//
//      Destructor for a DoubleList object.
//
// End ---------------------------------------------------------------------
{
    while( head != 0 )
        {
        DoubleListElement *temp = head;
        head = head->next;
        delete temp;
        }
}
// End Destructor //

RObject DoubleList::peekAtHead() const
{
      if(head)
         return *(head->data);
      else
         return NOOBJECT;
}

RObject DoubleList::peekAtTail() const
{
      if(tail)
         return *(tail->data);
      else
         return NOOBJECT;
}

// Member Function //

classType DoubleList::isA() const

// Summary -----------------------------------------------------------------
//
//         Returns the class type of a double list.
//
// End ---------------------------------------------------------------------
{
    return doubleListClass;
}
// End Member Function DoubleList::isA //


// Member Function //

char *DoubleList::nameOf() const

// Summary -----------------------------------------------------------------
//
//         Returns a pointer to the character string "DoubleList."
//
// End ---------------------------------------------------------------------
{
    return "DoubleList";
}
// End Member Function DoubleList::nameOf //


// Member Function //

void DoubleList::add( Object& toAdd )

// Summary -----------------------------------------------------------------
//
//      Adds the given object on the double list at the head of the list.
//
// Parameters
//
//      toAdd
//
//      The object we are to add to the head of the list.  Once the object is
//      added, it is owned by the double list.
//
// Functional Description
//
//      Wrap of addAtHead.
//
// End ---------------------------------------------------------------------
{
    addAtHead( toAdd );
}
// End Member Function DoubleList::add //


// Member Function //

void DoubleList::addAtHead( Object& toAdd )

// Summary -----------------------------------------------------------------
//
//      Adds the given object on the double list at the head of the list.
//
// Parameters
//
//      toAdd
//
//      The object we are to add to the head of the list.  Once the object is
//      added, it is owned by the double list.
//
// End ---------------------------------------------------------------------
{
    DoubleListElement *newElement = new DoubleListElement( &toAdd );

    if ( head )
    {
        head->previous = newElement;
        newElement->next = head;
        head = newElement;
    }
    else
    {
        tail = head = newElement;
    }
    itemsInContainer++;
}
// End Member Function DoubleList::addAtHead //


// Member Function //

void DoubleList::addAtTail( Object& toAdd )

// Summary -----------------------------------------------------------------
//
//      Adds the given object on the double list at the tail of the list.
//
// Parameters
//
//      toAdd
//
//      The object we are to add to the tail of the list.  Once the object is
//      added, it is owned by the double list.
//
// End ---------------------------------------------------------------------
{
    DoubleListElement *newElement = new DoubleListElement( &toAdd );

    if ( tail )
    {
        tail->next = newElement;
        newElement->previous = tail;
        tail = newElement;
    }
    else
    {
        head = tail = newElement;
    }
    itemsInContainer++;
}
// End Member Function DoubleList::addAtTail //


// Member Function //

void DoubleList::detach( const Object& toDetach, int destroyToo )

// Summary -----------------------------------------------------------------
//
//      Detaches an object from a double list.  By default the object
//         is searched for starting at the head of the list.
//
// Parameter
//
//      toDetach
//
//      The object we are to search for and destroy from the DoubleList.
//
//         destroyToo
//
//         Indicates whether we are also to destroy the object.
//
// Functional Description
//
//      Wrap of detachFromHead.
//
// Remarks
//
//  warnings:
//      No error condition is generated if the object which was specified
//      isn't on the double list.
//
// End ---------------------------------------------------------------------
{
    detachFromHead( toDetach, destroyToo );
}
// End Member Function DoubleList::detach //


// Member Function //

void DoubleList::detachFromHead( const Object& toDetach, int deleteToo )

// Summary -----------------------------------------------------------------
//
//      Detaches an object from the head of a double list.
//
// Parameter
//
//      toDetach
//
//      The object we are to search for and detach from the DoubleList.
//
//      deleteToo
//
//      Specifies whether we are to delete the object.
//
// Functional Description
//
//      If the object specified is at the head of the double list, we remove
//      the reference right away.  Otherwise, we iterate through the double list until
//      we find it, then remove the reference.
//
// Remarks
//
//  warnings:
//      No error condition is generated if the object which was specified
//      isn't on the double list.
//
// End ---------------------------------------------------------------------
{
   if(head == 0)
      return;

    DoubleListElement *cursor = head;

    if ( *(head->data) == toDetach )
    {
        if( head->next == 0 )
            tail = 0;
        head = head->next;
        head->previous = 0;
    }
    else  // the object isn't at the head of the list.
    {

// Body Comment
//
//         Normally we would do this iteration with a list iterator.
//         Since we need to keep track of not only the objects in the
//         list but also the list elements, i.e. the pointer nodes,
//         we don't use the iterator.
//
// End


       while ( (cursor = cursor->next) != 0 )
        {
            if ( *(cursor->data) == toDetach )
            {
                cursor->previous->next = cursor->next;
                if( cursor->next )
                    cursor->next->previous = cursor->previous;
                else
                    tail = cursor->previous;
                break;
            }
        } // end while

    } // end else the object wasn't at the head of the list.

// Body Comment
//
//  Now cursor points to the object that we've found
//
// End

   if( cursor != 0 )
   {
      itemsInContainer--;

      if ( !deleteToo )
         cursor->data = 0;       // insure that we don't delete the data

      delete cursor;
   }
}

// End Member Function DoubleList::detachFromHead //


// Member Function //

void DoubleList::detachFromTail( const Object& toDetach, int deleteToo )

// Summary -----------------------------------------------------------------
//
//      Detaches an object from the tail of a double list.
//
// Parameter
//
//      toDetach
//
//      The object we are to search for and detach from the DoubleList.
//
//      deleteToo
//
//      Specifies whether we are to delete the object.
//
// Functional Description
//
//      If the object specified is at the tail of the double list, we remove
//      the reference right away.  Otherwise, we iterate backwards through
//      the double list until we find it, then remove the reference.
//
// Remarks
//
//  warnings:
//      No error condition is generated if the object which was specified
//      isn't on the double list.
//
// End ---------------------------------------------------------------------
{
   if(tail == 0)
      return;

    DoubleListElement *cursor = tail;

    if ( *(tail->data) == toDetach )
    {
        if( tail->previous == 0 )
            head = 0;
        tail = tail->previous;
        tail->next = 0;
       }
    else  // the object isn't at the tail of the list.
    {

// Body Comment
//
//         Normally we would do this iteration with a list iterator.
//         Since we need to keep track of not only the objects in the
//         list but also the list elements, i.e. the pointer nodes,
//         we don't use the iterator.
//
// End


        while ( (cursor = cursor->previous) != 0 )
        {
            if ( *(cursor->data) == toDetach )
            {
                if (cursor->previous)
                    cursor->previous->next = cursor->next;
                else
                    head = cursor->next;
                cursor->next->previous = cursor->previous;
                break;
            }
        } // end while

    } // end else the object wasn't at the tail of the list.

// Body Comment
//
//  Now cursor points to the object that we've found
//
// End

   if( cursor != 0 )
      {
      itemsInContainer--;
      if ( !deleteToo )
         {
         cursor->data = 0;       // insure that we don't delete the data
         }
      delete cursor;
      }

//    if( cursor != 0 )
//    {
//        itemsInContainer--;
//        if ( deleteToo )
//        {
//            delete cursor->data;
//        }
//        else
//        {
//            cursor->data = 0;       // insure that we don't delete the data
//        }
//
//        delete cursor;
//    }
}
// End Member Function DoubleList::detachFromTail //


// Member Function //

ContainerIterator& DoubleList::initIterator() const

// Summary -----------------------------------------------------------------
//
//      Initializes an iterator for a double list.
//
// End ---------------------------------------------------------------------
{
    return *( (ContainerIterator *)new DoubleListIterator( *this ) );
}
// End Member Function DoubleList::initIterator //


// Member Function //

ContainerIterator& DoubleList::initReverseIterator() const

// Summary -----------------------------------------------------------------
//
//      Initializes an iterator for a double list.
//
// End ---------------------------------------------------------------------
{
    return *( (ContainerIterator *)new DoubleListIterator( *this, 0 ) );
}
// End Member Function DoubleList::initReverseIterator //


// Member Function //

hashValueType DoubleList::hashValue() const

// Summary -----------------------------------------------------------------
//
//      Returns the hash value of a double list.
//
// End ---------------------------------------------------------------------
{
    return hashValueType(0);
}
// End Member Function DoubleList::hashValue //


// Member Function //

DoubleListIterator::operator int()

// Summary -----------------------------------------------------------------
//
//      Integer conversion operator for a Double List iterator.
//
// End ---------------------------------------------------------------------
{
    return ( currentElement != 0 );
}
// End Member Function DoubleListIterator::operator int //


// Member Function //

DoubleListIterator::operator Object&()

// Summary -----------------------------------------------------------------
//
//      Object conversion operator for a Double List iterator.
//
// End ---------------------------------------------------------------------
{
   if(currentElement)
      return ( (Object&)(*(currentElement->data)) );
   else
      return NOOBJECT;

//    return ( (Object&)(*(currentElement->data)) );
}
// End Member Function DoubleListIterator::operator Object& //


// Member Function //

Object& DoubleListIterator::operator ++()

// Summary -----------------------------------------------------------------
//
//         Increments the list iterator and returns the next object.
//
// Return Value
//
//         listObject
//
//      A reference to the object which is after the current object
//         in the iterator sequence.
//
// End ---------------------------------------------------------------------
{
    DoubleListElement *trailer = currentElement;

    if ( currentElement != 0 )
    {
        currentElement = currentElement->next;
        return ( (Object&)(*(trailer->data)) );
    }
    else // no more elements in the list.
    {
        return NOOBJECT;
    }
}
// End Member Function DoubleListIterator::operator ++ //


// Member Function //

void DoubleListIterator::restart()

// Summary -----------------------------------------------------------------
//
//      Restart function for a list iterator object.
//
// End ---------------------------------------------------------------------
{
    currentElement = startingElement;
}
// End Member Function DoubleListIterator::restart //


// Member Function //

Object& DoubleListIterator::operator --()

// Summary -----------------------------------------------------------------
//
//         Decrements the list iterator and returns the previous object.
//
// Return Value
//
//         listObject
//
//      A reference to the object which is before the current object
//         in the iterator sequence.
//
// End ---------------------------------------------------------------------
{
    DoubleListElement *trailer = currentElement;

    if ( currentElement != 0 )
    {
        currentElement = currentElement->previous;
        return ( (Object&)(*(trailer->data)) );
    }
    else // no more elements in the list.
    {
        return NOOBJECT;
    }
}
// End Member Function DoubleListIterator::operator -- //


// Destructor //

DoubleListIterator::~DoubleListIterator()

// Summary -----------------------------------------------------------------
//
//      Destructor for a DoubleListIterator object.
//
// End ---------------------------------------------------------------------
{
}
// End Destructor //