The Devil's Doorknob BBS Capture (1996-2003)/devilsdoorknobbbscapture1996-2003.iso/Dloads/OTHERUTI/TCPP10-8.ZIP/CLASSSRC.ZIP/DBLLIST.CPP

C/C++ Source or Header | 1990-09-26 | 15KB | 604 lines

//
// This file contains proprietary information of Borland International.
// Copying or reproduction without prior written approval is prohibited.
//
// Copyright (c) 1990
// Borland International
// 1800 Scotts Valley Dr.
// Scotts Valley, CA 95066
// [phone]
//

// 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 //


// 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 ---------------------------------------------------------------------
{
    DoubleListElement *cursor = head;

    if ( *(head->data) == toDetach )
    {
        if( head->next == 0 )
            tail = 0;
        head = head->next;
    }
    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 != 0 )
        {
            if ( *(cursor->data) == toDetach )
            {
                cursor->previous->next = cursor->next;
                cursor->next->previous = cursor->previous;
                break;
            }
            else // the object isn't the one we want.
            {
                cursor = cursor->next;
            }
        } // 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 )
        {
            delete cursor->data;
        }
        else
        {
            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 ---------------------------------------------------------------------
{
    DoubleListElement *cursor = tail;

    if ( *(tail->data) == toDetach )
    {
        if( tail->previous == 0 )
            head = 0;
        tail = tail->previous;
    }
    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 != 0 )
        {
            if ( *(cursor->data) == toDetach )
            {
                cursor->previous->next = cursor->next;
                cursor->next->previous = cursor->previous;
                break;
            }
            else // the object isn't the one we want.
            {
                cursor = cursor->previous;
            }
        } // 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 )
        {
            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 ---------------------------------------------------------------------
{
    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 //