DtVisualizerDefinitionRecord.h

Go to the documentation of this file.

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

#pragma once

#include <makArchives/DtSerialize.h>
#include <makArchives/DtXmlFileIo.h>

#include <boost/tuple/tuple_comparison.hpp>

#include <map>

namespace makArchives
{
   namespace oldRecords
   {
      class DT_DLL_MAKARCHIVES Dt3Tuple
      {
      public:
         double myX;
         double myY;
         double myZ;

      protected:

         friend class boost::serialization::access;

         template <typename Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(myX);
            ar & BOOST_SERIALIZATION_NVP(myY);
            ar & BOOST_SERIALIZATION_NVP(myZ);
         }
      };

      class DT_DLL_MAKARCHIVES DtVisualColor
      {
      public:
         float myR;
         float myG;
         float myB;
         float myA;

      protected:

         friend class boost::serialization::access;

         template <typename Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(myR);
            ar & BOOST_SERIALIZATION_NVP(myG);
            ar & BOOST_SERIALIZATION_NVP(myB);
            ar & BOOST_SERIALIZATION_NVP(myA);
         }
      };

      class DT_DLL_MAKARCHIVES DtVisualAttributeInterface
      {
      public:
         DtVisualAttributeInterface();
         DtVisualAttributeInterface(const DtVisualAttributeInterface&);
         virtual ~DtVisualAttributeInterface();

         virtual std::string classType() const = 0;

         virtual void write(boost::archive::xml_oarchive& out, const unsigned int) = 0;
         virtual void read(boost::archive::xml_iarchive& in, const unsigned int) = 0;

      protected:
         friend class boost::serialization::access;

         template <typename Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            if (Archive::is_loading::value)
            {
               read(*(boost::archive::xml_iarchive*)&ar,version);
            }
            else
            {
               write(*(boost::archive::xml_oarchive*)&ar,version);
            }
         }
      };

      typedef DtVisualAttributeInterface* (*DtVisualAttributeCreatorFcn)();

      class DT_DLL_MAKARCHIVES DtVisualAttributeFactory
      {
      public:
         DtVisualAttributeFactory();
         virtual ~DtVisualAttributeFactory();

      public:
         static bool addAttributeCreator(const std::string& name, DtVisualAttributeCreatorFcn f);
         static DtVisualAttributeInterface* createAttribute(const std::string& name);
      };

      // @{

      template <typename Type>
      class DtVisualAttribute : public DtVisualAttributeInterface
      {
      public:
         DtVisualAttribute()
            : DtVisualAttributeInterface()
         {
         }

         DtVisualAttribute(const DtVisualAttribute& orig)
            : DtVisualAttributeInterface(orig)
            , myValue(orig.myValue)
         {
         }

         DtVisualAttribute& operator=(const DtVisualAttribute& rhs)
         {
            if (this != &rhs)
            {
               myValue = rhs.myValue;
            }

            return *this;
         }

         virtual ~DtVisualAttribute()
         {
         }

         Type myValue;

      protected:

         friend class boost::serialization::access;

         virtual void write(boost::archive::xml_oarchive& out, const unsigned int version)
         {
            out & BOOST_SERIALIZATION_NVP(myValue);
         }

         virtual void read(boost::archive::xml_iarchive& in, const unsigned int version)
         {
            in & BOOST_SERIALIZATION_NVP(myValue);
         }
      };

      typedef std::map<std::string, DtVisualAttributeCreatorFcn > DtVisualAttributeCreatorMap;

      static DtVisualAttributeCreatorMap* theAttributeCreatorMap = 0;

      #define REGISTER_VISUAL_ATTRIBUTE(Attribute) static bool Attribute##_Registered = \
      DtVisualAttributeFactory::addAttributeCreator(Attribute::theClassType(), &Attribute::create);

      #define DEFINE_VISUAL_ATTRIBUTE(ATTRIBUTE, VALUETYPE, DEFAULTVALUE)\
      class DT_DLL_MAKARCHIVES ATTRIBUTE : public DtVisualAttribute<VALUETYPE>\
      {\
      public:\
      ATTRIBUTE() { myValue = DEFAULTVALUE ; }\
      ATTRIBUTE(const ATTRIBUTE& s) : DtVisualAttribute<VALUETYPE>(s) {}\
      virtual ~ATTRIBUTE() {}\
      static std::string theClassType() { return #ATTRIBUTE ; }\
      virtual std::string classType() const { return theClassType();}\
      static DtVisualAttributeInterface* create() { return new ATTRIBUTE(); }\
      };

      class DT_DLL_MAKARCHIVES DtVisualDefinition
      {
      public:
         typedef std::map<std::string, DtVisualAttributeInterface*> DtVisualAttributeMap;

      protected:
         friend class boost::serialization::access;

         template <typename Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(myVisualDefinitionName);

            if (Archive::is_loading::value)
            {
               int size = 0;
               std::string classType;
               std::string name;

               ar & BOOST_SERIALIZATION_NVP(size);

               for (int i = 0; i < size; i++)
               {
                  ar & BOOST_SERIALIZATION_NVP(name);
                  ar & BOOST_SERIALIZATION_NVP(classType);
                  DtVisualAttributeInterface* iface =
                     DtVisualAttributeFactory::createAttribute(classType);

                  if (iface)
                  {
                     DtVisualAttributeInterface& visualDefinition = *iface;
                     ar & BOOST_SERIALIZATION_NVP(visualDefinition);
                     myAttributes[name] = iface;
                  }
               }

            }
            else
            {
               int size = myAttributes.size();
               ar & BOOST_SERIALIZATION_NVP(size);
               DtVisualAttributeMap::const_iterator iter = myAttributes.begin();

               while (iter != myAttributes.end())
               {
                  std::string name = iter->first;

                  ar & BOOST_SERIALIZATION_NVP(name);
                  std::string classType = iter->second->classType();
                  ar & BOOST_SERIALIZATION_NVP(classType);

                  DtVisualAttributeInterface& visualDefinition = *iter->second;
                  ar & BOOST_SERIALIZATION_NVP(visualDefinition);

                  ++iter;
               }
            }
         }

      public:
         std::string             myVisualDefinitionName;
         DtVisualAttributeMap    myAttributes;
      };

      class DT_DLL_MAKARCHIVES DtVisualDefinitionSet
      {
      public:
         typedef std::map<std::string, makArchives::oldRecords::DtVisualDefinition> DtVisualDefinitionMap;

      protected:
         friend class boost::serialization::access;

         template <typename Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(myVisualDefinitionSetName);
            ar & BOOST_SERIALIZATION_NVP(myVisualDefinitions);
         }

      public:
         std::string             myVisualDefinitionSetName;
         DtVisualDefinitionMap   myVisualDefinitions;
      };

      class DT_DLL_MAKARCHIVES DtElementDefinition
      {
      public:
         typedef std::map<int, makArchives::oldRecords::DtVisualDefinitionSet> VisualDefinitionSetMap;

      protected:
         friend class boost::serialization::access;

         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(myVisualDefinitionSets);
         }

      public:
         VisualDefinitionSetMap myVisualDefinitionSets;
      };

      class DT_DLL_MAKARCHIVES DtElementDefinitionNode
      {
      public:
         typedef std::map<std::string, makArchives::oldRecords::DtElementDefinitionNode> DtNodeChildren;

      protected:
         friend class boost::serialization::access;

         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(myRoot);
            ar & BOOST_SERIALIZATION_NVP(myChildren);
         }

      public:
         makArchives::oldRecords::DtElementDefinition myRoot;
         DtElementDefinitionNode::DtNodeChildren myChildren;
      };

      class DT_DLL_MAKARCHIVES DtElementDefinitionHierarchy
      {
      public:
         typedef std::map<std::string, makArchives::oldRecords::DtElementDefinitionNode> ElementDefinitionRoots;

      protected:
         friend class boost::serialization::access;

         template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
         {
            ar & BOOST_SERIALIZATION_NVP(myHierarchy);
         }

      public:
         ElementDefinitionRoots myHierarchy;
      };

      DEFINE_VISUAL_ATTRIBUTE(DtVisualAttributeBool, bool, false)
      DEFINE_VISUAL_ATTRIBUTE(DtVisualAttributeInteger, int, 0)
      DEFINE_VISUAL_ATTRIBUTE(DtVisualAttributeFontGlyph, unsigned int, 0)
      DEFINE_VISUAL_ATTRIBUTE(DtVisualAttributeString, std::string, std::string(""))
      DEFINE_VISUAL_ATTRIBUTE(DtVisualAttributeEnumeration, std::string, std::string(""))
      DEFINE_VISUAL_ATTRIBUTE(DtVisualAttributeFilename, std::string, std::string(""))
      DEFINE_VISUAL_ATTRIBUTE(DtVisualAttributeStringVector, std::vector<std::string>, std::vector<std::string>())
      DEFINE_VISUAL_ATTRIBUTE(DtVisualAttributeColor, DtVisualColor, DtVisualColor())
      DEFINE_VISUAL_ATTRIBUTE(DtVisualAttributeVector, Dt3Tuple, Dt3Tuple())
      DEFINE_VISUAL_ATTRIBUTE(DtVisualAttributeDouble, double, 0.0)

      REGISTER_VISUAL_ATTRIBUTE(DtVisualAttributeBool)
      REGISTER_VISUAL_ATTRIBUTE(DtVisualAttributeInteger)
      REGISTER_VISUAL_ATTRIBUTE(DtVisualAttributeFontGlyph)
      REGISTER_VISUAL_ATTRIBUTE(DtVisualAttributeString)
      REGISTER_VISUAL_ATTRIBUTE(DtVisualAttributeEnumeration)
      REGISTER_VISUAL_ATTRIBUTE(DtVisualAttributeFilename)
      REGISTER_VISUAL_ATTRIBUTE(DtVisualAttributeStringVector)
      REGISTER_VISUAL_ATTRIBUTE(DtVisualAttributeColor)
      REGISTER_VISUAL_ATTRIBUTE(DtVisualAttributeVector)
      REGISTER_VISUAL_ATTRIBUTE(DtVisualAttributeDouble)

   }
}

BOOST_CLASS_VERSION(makArchives::oldRecords::DtElementDefinitionHierarchy, 1);
BOOST_CLASS_VERSION(makArchives::oldRecords::DtElementDefinitionNode, 1);
BOOST_CLASS_VERSION(makArchives::oldRecords::DtElementDefinition, 1);
BOOST_CLASS_VERSION(makArchives::oldRecords::DtVisualDefinitionSet, 1);
BOOST_CLASS_VERSION(makArchives::oldRecords::DtVisualDefinition, 1);
BOOST_CLASS_VERSION(makArchives::oldRecords::DtVisualAttributeBool, 1)
BOOST_CLASS_VERSION(makArchives::oldRecords::DtVisualAttributeColor, 1)
BOOST_CLASS_VERSION(makArchives::oldRecords::DtVisualAttributeDouble, 1)
BOOST_CLASS_VERSION(makArchives::oldRecords::DtVisualAttributeInteger, 1)
BOOST_CLASS_VERSION(makArchives::oldRecords::DtVisualAttributeFontGlyph, 1)
BOOST_CLASS_VERSION(makArchives::oldRecords::DtVisualAttributeString, 1)
BOOST_CLASS_VERSION(makArchives::oldRecords::DtVisualAttributeEnumeration, 1)
BOOST_CLASS_VERSION(makArchives::oldRecords::DtVisualAttributeFilename, 1)
BOOST_CLASS_VERSION(makArchives::oldRecords::DtVisualAttributeStringVector, 1)
BOOST_CLASS_VERSION(makArchives::oldRecords::DtVisualAttributeVector, 1)