vecNetIsctRecLst.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1999 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: vecNetIsctRecLst.h,v $ $Revision: 1.6 $ $State: Exp $
*********************************************************************/

#ifndef vecNetIsctRecLst_H_
#define vecNetIsctRecLst_H_

#include "gdb/gdbDefines.h"
#include <vlutil/vlList.h>
#include "gdb/vecNwrkIntRec.h"

// class DtVectorNetworkIntersectionRecordList:
//
// DtVectorNetworkIntersectionRecordList represents a list of
// DtVectorNetworkIntersectionRecords. This is useful for following 
// chord recording all of its intersections with a section of the 
// vector network.  As with the DtChordIntersectionRecordLists, and 
// unlike DtList, this class "owns" all of its 
// DtVectorNetworkIntersectionRecords and will delete them when it 
// is destroyed.

class DT_DLL_gdb DtVectorNetworkIntersectionRecordList
{
public:

   // default constructor
   DtVectorNetworkIntersectionRecordList();

   //copy constructor
   DtVectorNetworkIntersectionRecordList(const DtVectorNetworkIntersectionRecordList& orig);

   // destructor
   virtual ~DtVectorNetworkIntersectionRecordList();

   // assignment operator
   DtVectorNetworkIntersectionRecordList& operator=(
      const DtVectorNetworkIntersectionRecordList& orig);

   // Return first and last item on the list.  DtListItem is an envelope
   // for your data.  The data can be obtained using DtListItem::data().
   DtListItem* first() const;
   DtListItem* last() const;

   // A short-cut for looking at the first record
   DtVectorNetworkIntersectionRecord* firstVectorNetworkIntersectionRecord() const;

   // Returns the number of elements in the list.
   unsigned count() const;

   // Add element to the end of the list.  Returns the DtListItem envelope
   // object that contains your new element.
   DtListItem* add(const DtVectorNetworkIntersectionRecord& data);

   // Add element to the beginning of the list.  Returns the DtListItem 
   // envelope object that contains your new element.
   DtListItem* addToStart(const DtVectorNetworkIntersectionRecord& data);

   // Add element to the end of the list.  Returns the DtListItem envelope
   // object that contains your new element.
   DtListItem* addToEnd(const DtVectorNetworkIntersectionRecord& data);

   // Add element to the list just before the indicated item.
   // Returns the DtListItem envelope object that contains your new element.
   DtListItem* addBefore(const DtVectorNetworkIntersectionRecord& data,
      DtListItem* before);

   // Add element to the list just after the indicated item.
   // Returns the DtListItem envelope object that contains your new element.
   DtListItem* addAfter(const DtVectorNetworkIntersectionRecord& data,
      DtListItem* after);
    
   // Remove an element from the list.  Item is the envelope containing the
   // data element you would like to remove.  Return value is true if the
   // item was found in the list and the data pointer was non-zero.
   // Note: this version of remove DOES free the memory of data associated
   // with the item.
   bool remove(DtListItem* item);

   // Calls remove for all elements in the list.  It DOES delete the 
   // data in the list as well
   void removeAll();
    
   // Returns the DtListItem envelope object containing the indicated
   // data element.
   DtListItem* itemLookup(const DtVectorNetworkIntersectionRecord* data) const;

   //
   // Functions specific to DtVectorNetworkIntersectionRecordList
   //

   // Insert a DtVectorNetworkIntersectRecord in the appropriate spot. Assume list
   // is sorted in increasing distance from beginning of chord.
   virtual void insertAlongChord(const DtVectorNetworkIntersectionRecord& record);

   // Merge in another DtVectorNetworkIntersectionRecordList; assume both lists
   // are sorted in increasing distance from beginning of chord.
   virtual void mergeAlongChord(const DtVectorNetworkIntersectionRecordList& otherList);

protected:

   DtList myList;
};

//
// Inline functions
//

inline DtListItem* DtVectorNetworkIntersectionRecordList::first() const
{
   return myList.first();
}

inline DtListItem* DtVectorNetworkIntersectionRecordList::last() const
{
   return myList.last();
}

inline unsigned DtVectorNetworkIntersectionRecordList::count() const
{
   return myList.count();
}

inline DtVectorNetworkIntersectionRecord*
   DtVectorNetworkIntersectionRecordList::firstVectorNetworkIntersectionRecord() const
{
   if (count() != 0)
   {
      return static_cast<DtVectorNetworkIntersectionRecord*>(myList.first()->data());
   }
   else
   {
      return 0;
   }
}

inline DtListItem* DtVectorNetworkIntersectionRecordList::add(
   const DtVectorNetworkIntersectionRecord& data)
{
   return myList.add(data.clone());
}

inline DtListItem* DtVectorNetworkIntersectionRecordList::addToStart(
   const DtVectorNetworkIntersectionRecord& data)
{
   return myList.addToStart(data.clone());
}

inline DtListItem* DtVectorNetworkIntersectionRecordList::addToEnd(
   const DtVectorNetworkIntersectionRecord& data)
{
   return myList.addToEnd(data.clone());
}

inline DtListItem* DtVectorNetworkIntersectionRecordList::addBefore(
   const DtVectorNetworkIntersectionRecord& data, DtListItem* before)
{
   return myList.addBefore(data.clone(), before);
}

inline DtListItem* DtVectorNetworkIntersectionRecordList::addAfter(
   const DtVectorNetworkIntersectionRecord& data, DtListItem* after)
{
   return myList.addAfter(data.clone(), after);
}

inline DtListItem* DtVectorNetworkIntersectionRecordList::itemLookup(
   const DtVectorNetworkIntersectionRecord* data) const
{
   return myList.itemLookup(data);
}

#endif