rwIntrusiveList.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1999 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

class DtRwIntrusiveList;
class DtRwListedObj;

#include <mtl/mtl.h>
#include <vlutil/vlList.h>
#include "vrfutil/readerWriter.h"

#include "vrfutil/vrfutilDefines.h"
class DT_DLL_vrfutil DtRwIntrusiveList : public DtReaderWriter
{
public:

   DtRwIntrusiveList();

   DtRwIntrusiveList(const DtString& name,
      DtReaderWriterRegistry* parentRegistry = NULL);
   DtRwIntrusiveList(const DtSymbolString& name,
      DtReaderWriterRegistry* parentRegistry = NULL);
  
   DtRwIntrusiveList(const DtString& name,  const DtRwIntrusiveList& orig, 
      DtReaderWriterRegistry* parentRegistry = NULL);
   DtRwIntrusiveList(const DtSymbolString& name,  const DtRwIntrusiveList& orig, 
      DtReaderWriterRegistry* parentRegistry = NULL);

   virtual ~DtRwIntrusiveList();

   DtRwIntrusiveList& operator=(const DtRwIntrusiveList& orig);

   DtRwListedObj* firstObj() const;
   DtRwListedObj* lastObj() const;

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

   unsigned count() const;

   DtListItem* add(DtRwListedObj* data);

   DtListItem* addToStart(DtRwListedObj* data);

   DtListItem* addToEnd(DtRwListedObj* data);

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

   DtListItem* addAfter(DtRwListedObj* data, DtRwListedObj* after);

   DtRwListedObj* remove(DtRwListedObj* data);

   virtual DtRwListedObj* remove(DtListItem* item);

   void removeAndDelete(DtRwListedObj* data);

   virtual void removeAndDelete(DtListItem* item);

   virtual void removeAll();

   virtual void removeAllAndDelete();

   DtListItem* itemLookup(DtRwListedObj* data) const;

   virtual void getSelf(DtlObjPtr args, const DtReaderWriter::SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings);  

   virtual DtlObjPtr getData(DtlObjPtr args, const DtReaderWriter::SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings) = 0;

   virtual DtlObjPtr getLocalData(DtlObjPtr args);

   virtual const char* readerWriterType() const;

protected:

   DtRwIntrusiveList(const DtRwIntrusiveList& orig);

   virtual DtListItem* addToList(DtRwListedObj* data, DtRwListedObj* after);
   
   DtList myList;
};

class DT_DLL_vrfutil DtRwListedObj : public DtReaderWriter
{  
public:

   friend class DtRwIntrusiveList;

public:

   DtRwListedObj();

   DtRwListedObj(const DtString& name, 
      DtReaderWriterRegistry* parentRegistry = NULL);

   DtRwListedObj(const DtSymbolString& name, 
      DtReaderWriterRegistry* parentRegistry = NULL);

   DtRwListedObj(const DtRwListedObj& orig);

   virtual ~DtRwListedObj();

   DtRwListedObj& operator=(const DtRwListedObj & orig);

   DtRwListedObj* next() const;
   DtRwListedObj* prev() const;

   DtRwListedObj* wrapNext() const;
   DtRwListedObj* wrapPrev() const;

   virtual const char* readerWriterType() const;

protected:

   DtList* myList;
   DtListItem* myItem;
};


inline DtRwListedObj* DtRwIntrusiveList::firstObj() const
{
   if (myList.first())
   {
      return (DtRwListedObj*) myList.first()->data();
   }

   else
   {
      return 0;
   }

}

inline DtRwListedObj* DtRwIntrusiveList::lastObj() const
{
   if (myList.last())
   {
      return (DtRwListedObj*) myList.last()->data();
   }

   else
   {
      return 0;
   }
}

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

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

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

inline DtListItem* DtRwIntrusiveList::addToEnd(DtRwListedObj* data)
{
   DtListItem* last = myList.last();
   DtRwListedObj* lastObj = 0;
   if (last)
   {
      lastObj = (DtRwListedObj *)last->data();
   }
   return addToList(data, lastObj);
}

inline DtRwListedObj* DtRwListedObj::next() const
{
   DtRwListedObj* result =
      (DtRwListedObj*)
      ((myItem && myItem->next()) ? myItem->next()->data() : NULL); 
   return result;
} 
inline DtRwListedObj* DtRwListedObj::prev() const
{
   DtRwListedObj* result=
      (DtRwListedObj*)
      ((myItem && myItem->prev()) ? myItem->prev()->data() : NULL);
   return result;
}

inline DtRwListedObj* DtRwListedObj::wrapNext() const
{ 
   DtRwListedObj* result =
      (DtRwListedObj*)
      (next() ? next() : 
         ((myList && myList->first()) ? myList->first()->data() : NULL));
   return result;
}
inline DtRwListedObj* DtRwListedObj::wrapPrev() const
{ 
   DtRwListedObj* result =
      (DtRwListedObj*)
      (prev() ? prev() : 
         ((myList && myList->last()) ? myList->last()->data() : NULL));
   return result; 
}

inline DtListItem* DtRwIntrusiveList::add(DtRwListedObj* data)
{
   return addToEnd(data);
}

inline DtListItem* DtRwIntrusiveList::addAfter(DtRwListedObj* data,
   DtRwListedObj* after)
{
   return addToList(data, after); 
}

inline DtListItem* DtRwIntrusiveList::addBefore(DtRwListedObj* data,
   DtRwListedObj* before)
{
   return addToList(data, before ? before->prev() : (DtRwListedObj*) NULL);
}

inline DtListItem* DtRwIntrusiveList::addToStart(DtRwListedObj* data)
{
   DtListItem* first = myList.first();
   DtRwListedObj* firstObj = NULL;
   if (first)
   {
      firstObj = (DtRwListedObj *)first->data();
   }

   return addBefore(data, firstObj);
}

inline DtListItem* DtRwIntrusiveList::itemLookup(DtRwListedObj* data) const
{
   return myList.itemLookup(data);
}

inline DtRwListedObj* DtRwIntrusiveList::remove(DtRwListedObj* data)
{
   return remove(data->myItem);
}

inline void DtRwIntrusiveList::removeAndDelete(DtRwListedObj* data)
{
   removeAndDelete(data->myItem);
}