rwTemplatedMap.h

Go to the documentation of this file.

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


#pragma once

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

template <typename FirstType, typename SecondType>
class DtRwTemplatedPair : public DtReaderWriter
{
public:


   DtRwTemplatedPair();

   DtRwTemplatedPair(const DtString& name,
      DtReaderWriterRegistry* const parentRegistry = NULL,
      const DtString& firstName = "first", const DtString& secondName = "second");
   DtRwTemplatedPair(const DtSymbolString& name,
      DtReaderWriterRegistry* const parentRegistry = NULL,
      const DtString& firstName = "first", const DtString& secondName = "second");

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

   virtual ~DtRwTemplatedPair() {};

   DtRwTemplatedPair& operator=(const DtRwTemplatedPair& orig);

   bool operator==(const DtRwTemplatedPair&) const;

   virtual const FirstType& first() const { return myFirst; }

   virtual void setFirst(const FirstType& f) { myFirst = f; }

   virtual const SecondType& second() const { return mySecond; }

   virtual void setSecond(const SecondType& s) { mySecond = s; }


   virtual DtString firstName() const { return myFirst.name().c_str(); }
   virtual void setFirstName(const DtString& n) { myFirst.setName(n); }


   virtual DtString secondName() const { return mySecond.name().c_str(); }
   virtual void setSecondName(const DtString& n) { mySecond.setName(n); }

protected:

   FirstType myFirst;
   SecondType mySecond;
};

namespace DtBufferSerialize
{
   template <typename FirstType, typename SecondType>
   int getSize(const DtRwTemplatedPair<FirstType, SecondType>& val);

   template <typename FirstType, typename SecondType>
   char *encode(const DtRwTemplatedPair<FirstType, SecondType>& val, char *buffer);

   template <typename FirstType, typename SecondType>
   const char *decode(DtRwTemplatedPair<FirstType, SecondType>& val, const char *buffer);
};


template <typename KeyType, typename ValType>
class DtRwTemplatedMapPtr : public DtRwList
{
public:
   typedef DtRwTemplatedPair<KeyType, ValType> RwPairType;
   typedef typename std::map<KeyType, ValType>::iterator iterator;
   typedef typename std::map<KeyType, ValType>::const_iterator const_iterator;

   DtRwTemplatedMapPtr();


   DtRwTemplatedMapPtr(const DtString& name,
      DtReaderWriterRegistry* parentRegistry = NULL,
      const DtString& keyName = "key", const DtString& valueName = "value");
   DtRwTemplatedMapPtr(const DtSymbolString& name,
      DtReaderWriterRegistry* parentRegistry = NULL,
      const DtString& keyName = "key", const DtString& valueName = "value");


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

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

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

   DtRwTemplatedMapPtr& operator=(const DtRwTemplatedMapPtr& orig);

   virtual ~DtRwTemplatedMapPtr();

   virtual void removeAndDeleteAll();

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

   virtual void prePutSelf();

   virtual void postGetSelf();

   virtual void setFromMap(const std::map<KeyType, ValType> sourceMap);

   virtual const std::map<KeyType, ValType>& convertToMap() const;

   virtual void clear() { return myMap.clear(); }

   virtual unsigned size() const { return myMap.size(); }


   virtual iterator begin() { return myMap.begin(); }
   virtual const_iterator begin() const { return myMap.begin(); }


   virtual iterator end() { return myMap.end(); }
   virtual const_iterator end() const { return myMap.end(); }


   std::pair<iterator, bool> insert(const std::pair<KeyType, ValType>& item);
   std::pair<iterator, bool> insert(const RwPairType& item);
   std::pair<iterator, bool> insert(const KeyType& key, const ValType& val);


   void erase(iterator pos) { myMap.erase(pos); }
   void erase(const KeyType& key) { myMap.erase(key); }


   virtual iterator find(const KeyType& key) { return myMap.find(key); }
   virtual const_iterator find(const KeyType& key) const { return myMap.find(key); }


   virtual iterator lower_bound(const KeyType& key) { return myMap.lower_bound(key); }
   virtual const_iterator lower_bound(const KeyType& key) const { return myMap.lower_bound(key); }


   virtual iterator upper_bound(const KeyType& key) { return myMap.upper_bound(key); }
   virtual const_iterator upper_bound(const KeyType& key) const { return myMap.upper_bound(key); }



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


   virtual const DtString& keyName() const { return myKeyName; }
   virtual void setKeyName(const DtString& keyName) { myKeyName = keyName; }


   virtual const DtString& valueName() const { return myValueName; }
   virtual void setValueName(const DtString& valName) { myValueName = valName; }

   static const char* theXmlType()
   {
      static DtString xmlType(DtString(KeyType::theXmlType()) + "-" +
         DtString(ValType::theXmlType()) + "-map");
      return xmlType.c_str();
   }

   virtual const char* xmlType() const
   {
      return theXmlType();
   }

public:

   const char* readerWriterType() const;

   static const char* ListReaderWriterType();

protected:
   DtString myXmlType;

   std::map<KeyType, ValType> myMap;
   DtString myKeyName;
   DtString myValueName;
};

namespace DtBufferSerialize
{
   template <typename KeyType, typename ValType>
   int getSize(const DtRwTemplatedMapPtr<KeyType, ValType>& m);

   template <typename KeyType, typename ValType>
   char *encode(const DtRwTemplatedMapPtr<KeyType, ValType>& m, char *buffer);

   template <typename KeyType, typename ValType>
   const char *decode(DtRwTemplatedMapPtr<KeyType, ValType>& m, const char *buffer);
};

#include "vrfutil/rwTemplatedMap.inl"