sortedList.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1997 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: sortedList.h,v $ $Revision: 1.4 $ $State: Exp $
*********************************************************************/


#ifndef DtSortedList_H_
#define DtSortedList_H_

#include "rtiMsConfig.h"
#include <stddef.h>
#include <vlutil/vlMachineTypes.h>

class DT_DLL_RTIUTIL DtSortedListItem
{
public:

   friend class DtSortedList;

public:

   virtual ~DtSortedListItem();

   DtSortedListItem* prev() const;
   DtSortedListItem* next() const;

   void* data() const;

   virtual bool operator<= (const DtSortedListItem&) const;
   virtual bool operator<  (const DtSortedListItem&) const;
   virtual bool operator>= (const DtSortedListItem&) const;
   virtual bool operator>  (const DtSortedListItem&) const;
   virtual bool operator== (const DtSortedListItem&) const;

   virtual void printData();

protected:

   DtSortedListItem(void* d);

protected:

   DtSortedListItem* myPrev;
   DtSortedListItem* myNext;
   void* myData;
};

inline void* DtSortedListItem::data() const
{
   return myData;
}

inline DtSortedListItem* DtSortedListItem::prev() const
{
   return myPrev;
}

inline DtSortedListItem* DtSortedListItem::next() const
{
   return myNext;
}

enum DtSortOrder
{
   DtSortOrderAscending,
   DtSortOrderDescending
};


class DT_DLL_RTIUTIL DtSortedList
{

public:

   DtSortedList(DtSortOrder sortOrderVal=DtSortOrderAscending);

   virtual ~DtSortedList();

   DtSortedList(const DtSortedList& orig);

   DtSortedList& operator=(const DtSortedList& orig);

   virtual void setSortOrder(DtSortOrder sortOrderValue);
   virtual DtSortOrder sortOrder() const;

   virtual DtSortedListItem* first() const;
   virtual DtSortedListItem* last() const;

   unsigned count() const;

   virtual bool compareItems(const DtSortedListItem& firstItem,
      const DtSortedListItem& secondItem) const;

   virtual DtSortedListItem* add(void* data);

   virtual void* remove(DtSortedListItem* item);

   virtual void removeAll();
    
   virtual DtSortedListItem* itemLookup(void* data) const;

   virtual void reverseSortOrder();

   virtual void printData(DtSortOrder order=DtSortOrderAscending);

protected:

   virtual DtSortedListItem* newItem(void* data);

   virtual void addToList(DtSortedListItem* item, DtSortedListItem* before);

   virtual void removeFromList(DtSortedListItem* item);

   virtual void reposition(DtSortedListItem* item);

   virtual void repositionForward(DtSortedListItem* item,
      DtSortedListItem* positionItem);

   virtual void repositionBackward(DtSortedListItem* item,
      DtSortedListItem* positionItem);

   virtual void insertBefore(DtSortedListItem* item,
      DtSortedListItem* positionItem);

   virtual void insertAfter(DtSortedListItem* item,
      DtSortedListItem* positionItem);

protected:

   DtSortedListItem* myFirst;
   DtSortedListItem* myLast;
   unsigned  myCount;
   DtSortOrder mySortOrder;
};

inline DtSortOrder DtSortedList::sortOrder() const
{
   return mySortOrder;
}

inline bool DtSortedList::compareItems(const DtSortedListItem& firstItem,
   const DtSortedListItem& secondItem) const
{
   return (mySortOrder == DtSortOrderAscending)
      ? (firstItem <= secondItem) : (firstItem >= secondItem);
}

inline DtSortedListItem* DtSortedList::first() const
{
   return myFirst;
}

inline DtSortedListItem* DtSortedList::last() const
{
   return myLast;
}

inline unsigned DtSortedList::count() const
{
   return myCount;
}

#endif