vlList.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*********************************************************************/
#pragma once


#include "vlMachineTypes.h"
#include <stddef.h>

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

class DT_DLL_VLUTIL DtListItem 
{
public:

   friend class DtList;

public:

   virtual ~DtListItem();

   DtListItem* prev() const;
   DtListItem* next() const;

   void* data() const;

protected:

   DtListItem(void* d);

protected:

   DtListItem* myPrev;
   DtListItem* myNext;
   void*       myData;
};

class DT_DLL_VLUTIL DtList 
{

public:

   DtList();

   virtual ~DtList();

   DtList(const DtList& orig);

   DtList& operator=(const DtList& orig);

   DtListItem* first() const;
   DtListItem* last() const;

   unsigned count() const;

   DtListItem* add(void* data);

   DtListItem* addToStart(void* data);

   DtListItem* addToEnd(void* data);

   DtListItem* addBefore (void* data, DtListItem* before);

   DtListItem* addAfter(void* data, DtListItem* after);
    
   void* remove(DtListItem* item);

   void removeAll();
    
   DtListItem* itemLookup(const void* data) const;

protected:

   virtual void addToList(DtListItem* item, DtListItem* after);

   virtual void removeFromList(DtListItem* item);

protected:

   DtListItem* myFirst;
   DtListItem* myLast;
   unsigned  myCount;
};



class DT_DLL_VLUTIL DtListedObj
{  
public:

   friend class DtIntrusiveList;

public:

   DtListedObj();

   virtual ~DtListedObj();

   void* next() const;
   void* prev() const;

   void* wrapNext() const;
   void* wrapPrev() const;

protected:

   DtList* myList;
   DtListItem* myItem;
};



class DT_DLL_VLUTIL DtIntrusiveList : public DtList
{
protected:

   virtual void addToList(DtListItem* item, DtListItem* after);

   virtual void removeFromList(DtListItem* item);

   void removeAndDelete(const DtListedObj* data);

   virtual void removeAndDelete(DtListItem* item);

   virtual void removeAllAndDelete();   
};


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

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

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

inline DtListItem* DtList::first() const
{
   return myFirst; 
}

inline DtListItem* DtList::last() const
{
   return myLast;
}

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

inline DtListItem* DtList::add(void* data)  
{
   return addAfter(data, myLast); 
}

inline DtListItem* DtList::addToStart(void* data)  
{
   return addAfter(data, 0);  
}

inline DtListItem* DtList::addToEnd(void* data)
{
   return addAfter(data, myLast); 
}
/*lint -save -e818 */
inline DtListItem* DtList::addBefore (void* data, DtListItem* before) 
{
   return addAfter(data, before ? before->myPrev : (DtListItem*) 0); 
}
/*lint -restore */

inline void* DtListedObj::next() const 
{
   return (myItem && myItem->next()) ? myItem->next()->data() : 0; 
} 

inline void* DtListedObj::prev() const 
{
   return (myItem && myItem->prev()) ? myItem->prev()->data() : 0; 
}

inline void* DtListedObj::wrapNext() const 
{ 
  return next() ? next() : 
     ((myList && myList->first()) ? myList->first()->data() : 0);
}

inline void* DtListedObj::wrapPrev() const
{ 
   return prev() ? prev() : 
      ((myList && myList->last()) ? myList->last()->data() : 0);      
}

#define looplist(theData, list) \
for (DtListItem* item=(list)->first();  \
   theData = (item ? item->data() : 0); \
   item = item->next())

#define looptlist(theData, type, list) \
for (DtListItem* item=(list)->first();  \
   theData = (type)(item ? item->data() : 0); \
   item = item->next())

#define looptlist2(theData, type, list) \
for (item=(list)->first();  \
   theData = (type)(item ? item->data() : 0); \
   item = item->next())

#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif