rwTemplatedList.h

Go to the documentation of this file.

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


#pragma once

#include "vrfutil/rwList.h"
#include "vrfutil/iteratorBase.h"
#include "vrfutil/bufferSerialize.h"

template <typename T>
class DtRwTemplatedListPtr : public DtRwList
{
public:
   typedef DtIteratorBase<T> iterator;
   typedef DtIteratorBase<const T> const_iterator;

   DtRwTemplatedListPtr();

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

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

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

   DtRwTemplatedListPtr(const DtRwTemplatedListPtr& orig, 
      DtReaderWriterRegistry* parentRegistry = NULL);

   DtRwTemplatedListPtr& operator=(const DtRwTemplatedListPtr& orig);

   virtual ~DtRwTemplatedListPtr();

   DtlObjPtr getData(DtlObjPtr args, const DtFilename& searchPath,
      const DtVariableBindingsList& variableBindings);

   void removeAll();
   void* remove(DtListItem* item);
   void* remove(T* item);

   void removeAndDeleteAll();

   bool operator==(const DtRwTemplatedListPtr&) const;
   bool operator!=(const DtRwTemplatedListPtr&) const;

public:

   void setAutoDelete(bool b) { myAutoDelete = b; };
   bool autoDelete() const { return myAutoDelete; };

   const char* readerWriterType() const;

   void copyList(const DtRwTemplatedListPtr& orig);

protected:
   bool myAutoDelete;
};

namespace DtBufferSerialize
{
   template <typename T>
   int getSize(const DtRwTemplatedListPtr<T>& val);

   template <typename T>
   char *encode(const DtRwTemplatedListPtr<T>& val, char *buffer);

   template <typename T>
   const char *decode(DtRwTemplatedListPtr<T>& val, const char *buffer) ;
};

template <typename T>
DtRwTemplatedListPtr<T>::DtRwTemplatedListPtr() :
   DtRwList(),
myAutoDelete(false)
{
}

template <typename T>
DtRwTemplatedListPtr<T>::DtRwTemplatedListPtr(const DtString& name, DtReaderWriterRegistry * parentRegistry) :
   DtRwList(name, parentRegistry),
myAutoDelete(false)
{
}

template <typename T>
DtRwTemplatedListPtr<T>::DtRwTemplatedListPtr(const DtSymbolString& name, DtReaderWriterRegistry * parentRegistry) :
   DtRwList(name, parentRegistry),
myAutoDelete(false)
{
}

template <typename T>
DtRwTemplatedListPtr<T>::DtRwTemplatedListPtr(const DtString& name,  const DtRwTemplatedListPtr<T>& orig, 
   DtReaderWriterRegistry * parentRegistry) :
DtRwList(name, orig, parentRegistry),
myAutoDelete(orig.myAutoDelete)
{
   copyList(orig);
}

template <typename T>
DtRwTemplatedListPtr<T>::DtRwTemplatedListPtr(const DtSymbolString& name,  const DtRwTemplatedListPtr<T>& orig, 
   DtReaderWriterRegistry * parentRegistry) :
DtRwList(name, orig, parentRegistry),
myAutoDelete(orig.myAutoDelete)
{
   copyList(orig);
}

template <typename T>
DtRwTemplatedListPtr<T>::DtRwTemplatedListPtr(const DtRwTemplatedListPtr<T>& orig, 
                                              DtReaderWriterRegistry * parentRegistry) :
DtRwList(orig.name(), orig, parentRegistry),
myAutoDelete(orig.myAutoDelete)
{
   copyList(orig);
}

template <typename T>
DtRwTemplatedListPtr<T>::~DtRwTemplatedListPtr()
{
   if (myAutoDelete)
   {
      removeAndDeleteAll();
   }
}

template <typename T>
DtRwTemplatedListPtr<T>& DtRwTemplatedListPtr<T>::operator=(const DtRwTemplatedListPtr<T>& orig)
{
   if (this != &orig)
   {
      removeAll();
      copyList(orig);
      myAutoDelete = orig.myAutoDelete;
   }

   return *this;
}

template <typename T>
void * DtRwTemplatedListPtr<T>::remove(T* item)
{
   DtListItem* listItem = itemLookup(item);

   if (listItem)
   {
      return remove(listItem);
   }

   return NULL;
}

template <typename T>
void* DtRwTemplatedListPtr<T>::remove(DtListItem* item)
{
   T* d = (T*)DtRwList::remove(static_cast<DtReaderWriter*>(item->data()), item);
   if (myAutoDelete)
   {
      delete d;
      d = NULL;
      return NULL;
   }
   else
   {
      return d;
   }
}

template <typename T>
void DtRwTemplatedListPtr<T>::removeAndDeleteAll()
{
   std::vector<T*> toDelete;

   iterator iter(*this);

   for (T* info = iter.first(); info; info = iter.next())
   {
      toDelete.push_back(info);
   }

   DtRwList::removeAll();

   int iLimit = toDelete.size();

   for (int i = 0; i < iLimit; i++)
   {
      delete toDelete[i];
   }
}

template <typename T>
DtlObjPtr DtRwTemplatedListPtr<T>::getData(DtlObjPtr args, const DtFilename& searchPath,
                                           const DtVariableBindingsList& variableBindings)
{
   DtlObjPtr nameObj = DtcCar(args);
   DtlObjPtr nextItem = DtcCdr(args);
   if(nextItem == DtlObjPtr::nil())
   {
      return nextItem;
   }

   T* value = new T(nameObj->pname());
   value->getSelf(args, searchPath, variableBindings);

   add(value);

   return DtcCdr(DtcCdr(args));
}

template <typename T>
void DtRwTemplatedListPtr<T>::removeAll()
{
   if (myAutoDelete)
   {
      removeAndDeleteAll();
   }
   else
   {
      DtRwList::removeAll();
   }
}

template <typename T>
void DtRwTemplatedListPtr<T>::copyList(const DtRwTemplatedListPtr<T>& orig)
{
   iterator iter(orig);

   for (T* info = iter.first(); info; info = iter.next())
   {
      add(new T(*info));
   }
}

template <typename T>
const char* DtRwTemplatedListPtr<T>::readerWriterType() const
{
   static T theDefaultType("default-name");

   return theDefaultType.readerWriterType();
}

template <typename T>
bool DtRwTemplatedListPtr<T>::operator==(const DtRwTemplatedListPtr& rhs) const
{
   if (count() == rhs.count())
   {
      DtListItem* thisItem = first();
      DtListItem* thatItem = rhs.first();

      while (thisItem && thatItem)
      {
         T* thisElement = static_cast<T*>(thisItem->data());
         T* thatElement = static_cast<T*>(thatItem->data());

         if (*thisElement != *thatElement)
         {
            return false;
         }

         thisItem = thisItem->next();
         thatItem = thatItem->next();
      }

      return true;
   }

   return false;
}

template <typename T>
bool DtRwTemplatedListPtr<T>::operator!=(const DtRwTemplatedListPtr& rhs) const
{
   return !(*this == rhs);
}

namespace DtBufferSerialize
{
   template <typename T>
   int getSize(const DtRwTemplatedListPtr<T>& val)
   {
      DtU16 a;
      int size = getSize(a);
      DtListItem* item = val.first();
      while(item)
      {
         const T* itemValue = static_cast<const T*>(item->data());
         size += getSize(*itemValue);
         item = item->next();
      }
      return size;
   }

   template <typename T>
   char *encode(const DtRwTemplatedListPtr<T>& val, char *buffer)
   {
      DtU16 n = val.count();
      buffer = encode(n, buffer);
      DtListItem* item = val.first();
      while(item)
      {
         const T* itemValue = static_cast<const T*>(item->data());
         buffer = encode(*itemValue, buffer);
         item = item->next();
      }
      return buffer;
   }

   template <typename T>
   const char *decode(DtRwTemplatedListPtr<T>& val, const char *buffer) 
   {
      DtU16 n = 0;
      buffer = decode(n, buffer);
      val.removeAndDeleteAll();
      for(int i = 0; i < n;++i)
      {
         T* itemValue = new T("item", &(val.registry()));
         buffer = decode(*itemValue, buffer);
         val.addToEnd(itemValue);
      }
      return buffer;
   }
};