DtModelDefinition.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h> 

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

#include <vrvUtil/DtKeywordMixin.h>

#include <boost/serialization/version.hpp>
#include <boost/unordered_map.hpp>
#include <boost/thread/recursive_mutex.hpp>

#include <matrix/vlVector.h>
#include <map>

#include <vrvMath/DtVector3.h>
#include <vrvMath/DtVector4.h>

namespace makArchives
{
   class DtModelDefinitionRecord;
}

namespace makVrv
{
   class DtVirtualBaseClass;

   class DT_DLL_VRVCORE DtModelDefinition : public DtKeywordMixin
   {
   public:

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

      struct CaseInsensitiveFunc
      {
         struct comp
         {
            bool operator() (const unsigned char& c1, const unsigned char& c2) const;
         };

         bool operator() (const std::string& s1, const std::string& s2) const;
      };

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

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

      DtModelDefinition(const DtModelDefinition& copy);

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

      virtual ~DtModelDefinition();

      DtModelDefinition& operator=(const DtModelDefinition&);

      bool operator==(const DtModelDefinition&) const;

      bool operator!=(const DtModelDefinition&) const;

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

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

      DT_DECLARE_serialize_FUNCTIONS
         DT_DECLARE_PORTABLE_serialize_FUNCTIONS

         void clearCache();

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

      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;

      const ParameterMap& parameters() const;

      const std::string& name() const;

      const std::string& fileName() const;

      const std::string& schema() const;

      const std::vector<std::string>& listOfSharedFiles() const;

      void addToListOfSharedFiles(const std::string& sharedFile);

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

      void setFileName(const std::string& fileNameStr);

      void setPersistent(bool persistent);

      bool persistent() const;

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

      bool duplicate() const;
      void setDuplicate(bool);

      const void getVectorParameter(const std::string& parameterName, DtVector& parameterVector) const;

      //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;

      boost::recursive_mutex& modelLoadingMutex();

      virtual bool replaceParameter(const std::string& findWhat, const std::string& replaceWith);

      virtual DtVector3<float> readVec3(const std::string& paramName, const DtVector3<float>& initValue) const;

      virtual DtVector4<float> readVec4(const std::string& paramName, const DtVector4<float>& initValue) const;

      virtual bool getAltitudeBasedScaleConfigurationRecordCollectionParameter(const std::string& parameterName, 
         makArchives::DtAltitudeBasedScaleConfigurationRecordCollection& parameterValue) const;

      virtual bool getBoolean(const std::string& parameterName, bool& parameterValue) const;
      
      virtual bool getDouble(const std::string& parameterName, double& parameterValue) const;

   protected:

      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 myFileName;

      std::string mySchema;
      std::vector<std::string> myListOfSharedFiles;
      SerializableParameterMap myParameters;


      CacheMap myRuntimeCache;
      bool myPersistentFlag;
      bool myModifiedFlag;
      bool myDuplicateFlag;

      boost::recursive_mutex myModelLoadingMutex;
   
   };
}

BOOST_CLASS_VERSION(makVrv::DtModelDefinition, 3)