slList.h

Go to the documentation of this file.

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

#ifndef slList_H_
#define slList_H_

#include "gdb/gdbDefines.h"
#include <vlutil/vlMachineTypes.h>

//forward declaration
class DtSimpleListItem;

// class DtSimpleList:
//
// DtSimpleList is fashioned after DtList in VR-Link. However, it provides
// a singly-linked list for situations where a simple traversal of the 
// list is all that is required.  
// @note This class has no virtual functions on purpose to reduce the size
// of the items as DtGroups use DtSimpleLists to hold their children, which
// means at least one DtSimpleList for every type of group node in the 
// scene, which adds up for large scenes.  Additionally, other classes should
// @b not be derived from this class as it is just a container.
// 
class DT_DLL_gdb DtSimpleList
{
public:

   // constructor
   DtSimpleList();

   // destructor
   // Note: ~DtSimpleList() does not free memory of data associated
   // with the items. It only frees the items.
   ~DtSimpleList();

   // returns first item on list
   DtSimpleListItem* first() const;

   // returns last item on list
   DtSimpleListItem* last() const;

   // returns size of list
   unsigned int count() const; 

   // add an element to the end of the list
   DtSimpleListItem* add(void* data);  

   // add an element to the beginning of the list 
   DtSimpleListItem* addToStart(void* data);  

   // add an element to the end of the list
   DtSimpleListItem* addToEnd(void* data);  

   // add an element with specified data component to list, appearing 
   // immediately after list element specified as 'after'  
   DtSimpleListItem* addAfter(void* data, DtSimpleListItem* after);

   // Note: remove does not free memory of data associated
   // with the item. It only frees the item. The data is
   // returned to the caller for deletion if required. 
   void* remove(DtSimpleListItem* item);


   // Does NOT delete the data in the list.  Merely removes the data
   // from the list.  Data must be deleted later.  
   void removeAll();

   // return list element whose data component is as specified.   
   DtSimpleListItem* itemLookup(void* data) const;

   // The sort method sorts the items according to a user-defined comparison 
   // function. If the comparison function is compare(), then compare(e1,e2)
   // should return an int value <0 if e1<e2, 0 if e1=e2, and >0 if e1>e2.
   // The parameters e1 and e2 are void pointers to raw data type.
   // The items are sorted in increasing order.

   void sort(int(* compare)(const void *e1,const void *e2));

   // If a copy constructor is implemented, the assignment operator should
   // also be implemented.  Should generally implement both of them anyway to
   // avoid memory problems due to inappropriate compiler provided defaults.
   // Access varies so need to put proper access keyword above these 
   // declarations.

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

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


protected:

   // add list item to appear immediately after list item 'after'
   void addToList(DtSimpleListItem* item, DtSimpleListItem* after);

   // remove specified item from list
   void removeFromList(DtSimpleListItem* item);

protected:

   DtSimpleListItem* myFirst;
   DtSimpleListItem* myLast;
   unsigned int myCount;   

};


inline DtSimpleListItem* DtSimpleList::first() const 
{ 
   return myFirst; 
}

inline DtSimpleListItem* DtSimpleList::last() const 
{ 
   return myLast; 
}

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

// add an element to the end of the list
inline DtSimpleListItem* DtSimpleList::add(void* data) 
{   
   return addAfter(data, myLast); 
}

// add an elemnt to the beginning of the list 
inline DtSimpleListItem* DtSimpleList::addToStart(void* data)  
{
   return addAfter(data, 0);  
}

// add an element to the end of the list
inline DtSimpleListItem* DtSimpleList::addToEnd(void* data)  
{
   return addAfter(data, myLast); 
}

#endif