readerWriterFactory.h

Go to the documentation of this file.

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



#pragma once

#include "readerWriter/readerWriterDefines.h"
#include <map>
#include <vlutil/vlString.h>
#include "readerWriter/bufferSerialize.h"

#include <boost/function.hpp>

class DtReaderWriterRegistry;
class DtReaderWriter;

class DT_DLL_readerWriter DtReaderWriterFactory
{
public:
   typedef DtReaderWriter* (*DtRWCreatorFcn)(const DtString& name, DtReaderWriterRegistry* parentRegistry);
   typedef void (*DtRWCopyFcn)(const DtReaderWriter* source, DtReaderWriter* dest);
   typedef int (*DtRwGetSizeFcn)(const DtReaderWriter* source);
   typedef bool (*DtRwCompareFcn)(const DtReaderWriter* lhs, const DtReaderWriter* rhs);
   typedef char* (*DtRwEncodeFcn)(const DtReaderWriter* source, char*);
   typedef const char* (*DtRwDecodeFcn)(DtReaderWriter* source, const char*);

   struct DtRwFunctions
   {
      DtRWCreatorFcn creatorFcn;
      DtRwCompareFcn compareFcn;
      DtRWCopyFcn copyFcn;
      DtRwGetSizeFcn getSizeFcn;
      DtRwEncodeFcn encodeFcn;
      DtRwDecodeFcn decodeFcn;
   };

   typedef std::map<DtString, DtRwFunctions> DtRwFunctionMap;

public:
   DtReaderWriterFactory(bool registerDefaults = true);

   virtual const std::set<DtString>& xmlTypes() const;

   virtual DtString mapXmlToRwType(const DtString& xmlType) const;

   virtual DtString mapRwToXmlType(const DtString& rwType) const;

   virtual DtReaderWriter* createItem(const DtString& type, const DtString& name,
      DtReaderWriterRegistry* parentRegistry) const;

   virtual bool copyReaderWriter(const DtReaderWriter* sourceRw, DtReaderWriter* destRw) const;

   virtual bool compareReaderWriter(const DtReaderWriter* sourceRw, const DtReaderWriter* destRw) const;

   virtual DtReaderWriter* cloneReaderWriter(const DtString& name,
      const DtReaderWriter* sourceRw, DtReaderWriterRegistry* parentRegistry) const;

   void addDefaultRwCreators();

   template<typename T_RWType>
   void registerType(const DtString& rwTypeString);

   template<typename T_RWType>
   void registerNumericType(const DtString& rwTypeString);

   template<typename T_RWType>
   void registerTypeWithoutSerialization(const DtString& rwTypeString);

   const DtRwFunctionMap& functionMap() const;

   bool typeRegistered(const DtString& rwTypeString) const;

   virtual int getSize(const DtReaderWriter*) const;

   virtual char* encode(const DtReaderWriter*, char*) const;

   virtual const char* decode(DtReaderWriter*, const char*);

protected:
   virtual void mapRwToXml(const DtString& rwType, const DtString& xmlType);

   template <typename T_RWType>
   static DtReaderWriter* createRWType(const DtString& name, DtReaderWriterRegistry* parentRegistry);

   template <typename T_RWType>
   static void copyRwType(const DtReaderWriter* sourceRw, DtReaderWriter* destRw);

   template <typename T_RWType>
   static void copyNumericRwType(const DtReaderWriter* sourceRw, DtReaderWriter* destRw);

   template <typename T_RWType>
   static bool compareRwType(const DtReaderWriter* sourceRw, const DtReaderWriter* destRw);

   template <typename T_RWType>
   static int getRwSize(const DtReaderWriter* sourceRw);

   template <typename T_RWType>
   static char* encodeRwType(const DtReaderWriter* sourceRw, char* buf);

   template <typename T_RWType>
   static const char* decodeRwType(DtReaderWriter* sourceRw, const char* buf);

protected:
   DtRwFunctionMap myRwFunctionMap;

   typedef std::map<DtString, DtString> StringMap;
   StringMap myRwToXmlType;
   StringMap myXmlToRwType;

   std::set<DtString> myXmlTypes;
};

struct DtMergePathStruct
{
   DtMergePathStruct(DtReaderWriter* s, DtReaderWriter* d) : source(s), destination(d) {};
   DtMergePathStruct(const DtMergePathStruct& orig) : source(orig.source), destination(orig.destination) {};

   DtReaderWriter* source;
   DtReaderWriter* destination;
};

typedef std::vector<DtMergePathStruct> DtMergePath;

typedef boost::function<bool (const DtReaderWriter* source, DtReaderWriter* destination,
   const DtMergePath& path)> DtPropertyRollUpFunction;

class DT_DLL_readerWriter DtReaderWriterPropertyFactory : public DtReaderWriterFactory
{
public:
   typedef std::map<DtString, DtPropertyRollUpFunction> RollUpRules;

   DtReaderWriterPropertyFactory(bool registerDefaults = true);
   virtual ~DtReaderWriterPropertyFactory();

   virtual bool defaultRollUpFunction(const DtReaderWriter* source, DtReaderWriter* destination);
   virtual DtPropertyRollUpFunction defaultRollUpRule() const;
   virtual void setDefaultRollUpRule(DtPropertyRollUpFunction);

   virtual void setRollUpRule(const DtString& type, DtPropertyRollUpFunction fcn);

   virtual bool rollUpReaderWriter(const DtReaderWriter* source, DtReaderWriter* destination,
      const DtMergePath&) const;

   virtual const RollUpRules& rollUpRules() const
   {
      return myRollUpRules;
   }

   virtual RollUpRules& rollUpRules()
   {
      return myRollUpRules;
   }

protected:
   RollUpRules myRollUpRules;

   DtPropertyRollUpFunction myDefaultRollUpRule;
};

#define readerWriterFactory_inl_
#include "readerWriter/readerWriterFactory.inl"
#undef  readerWriterFactory_inl_