DtModelDefinition.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2014 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
 
 
#pragma once

#include <vrvCore/vrvCore.h> 
#include <makArchives/DtSerialize.h>
#include <vrvUtil/DtKeywordMixin.h>
#include <makArchives/DtModelDefinitionRecord.h>

#include <boost/serialization/version.hpp>
#include <boost/serialization/set.hpp>
#include <boost/serialization/map.hpp>
#include <boost/unordered_map.hpp>
#include <map>
#include <string>
#include <set>
 
namespace makVrv 
{ 
   class DtVirtualBaseClass;

   class DT_DLL_VRVCORE DtModelDefinition : public DtKeywordMixin
   {
   public:

      //Global public empty string.
      static const std::string theEmptyString;

      typedef std::map<std::string,std::string> ParameterMap;

      DtModelDefinition(const std::string& modelName = "");
      
      DtModelDefinition(const DtModelDefinition& copy);

      DtModelDefinition(const std::string& modelName,const DtModelDefinition& copy);
      
      ~DtModelDefinition();

      DtModelDefinition& operator=(const DtModelDefinition&);

      virtual void getRecord(makArchives::DtModelDefinitionRecord& rec);

      virtual void setFromRecord(const makArchives::DtModelDefinitionRecord& rec);
      
      DT_DECLARE_serialize_FUNCTIONS
      DT_DECLARE_PORTABLE_serialize_FUNCTIONS

      void clearCache();

      DtVirtualBaseClass* findCachedData(const std::string& name);

      void setCachedData(const std::string& name,DtVirtualBaseClass* data);

      inline void deleteCachedData(const std::string& name)
      {
         setCachedData(name,0);
      }

      void setParameter(const std::string& parameterName,
         const std::string& parameterValue);

      bool clearParameter(const std::string& parameterName);

      const std::string& parameter(const std::string& parameterName) const;

      const std::string* findParameter(const std::string& parameterName) const;

      std::string* findParameter(const std::string& parameterName);

      const ParameterMap& parameters() const;

      const std::string& name() const;

      const std::string& schema() const;

      void setSchema(const std::string& schemaStr);

      void setPersistent(bool persistent);

      bool persistent() const;

      bool modified() const;
      void setModified(bool);

      //void addKeyWord( const std::string& keyword);

      //void removeKeyWord( const std::string& keyword);

      //const std::set<std::string>& keyWords() const;

      //bool hasKeyWords(const std::set<std::string>&) const;
      
   protected:

      static std::string cleanName(const std::string& name);
      
      class SerializableParameterMap : public ParameterMap
      {
      public:
         template <typename Archive>
         void serialize(Archive& ar,unsigned int version)
         {
            ar & DT_SERIALIZE_BASE(ParameterMap);
         }
      };

      typedef boost::unordered_map<std::string,DtVirtualBaseClass*> CacheMap;

      template <typename Archive>
      void _serialize(Archive& ar,unsigned int version)
      {
         ar & DT_SERIALIZE_MEMBER(myName);

         //If not initial version.
         if(version > 1)
         {
            ar& DT_SERIALIZE_MEMBER(mySchema);
         }
         ar & DT_SERIALIZE_MEMBER(myParameters);

         if(version > 2)
         {
            ar & DT_SERIALIZE_MEMBER(myKeywords);
         }

         //We're no longer modified if we save or load.
         myModifiedFlag = false;
      }
     
      std::string myName;
      std::string mySchema;
      SerializableParameterMap myParameters;      


      CacheMap myRuntimeCache;
      bool myPersistentFlag;
      bool myModifiedFlag;      
   };
}

BOOST_CLASS_VERSION(makVrv::DtModelDefinition,3)