DtModelDefinitionManager.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2023 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
 
 
#pragma once
 
#include <vrvCore/DtModelDefinition.h>
#include <vrvCore/DtSettingsBackupManager.h>

#include <makArchives/DtModelDefinitionRecord.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <string>
#include <vrvUtil/signalslib.h>

namespace makVrv 
{ 
   class DtDe;
   class DtModelDefinitionManagerSignaler;
   class DtModelDefinitionBackup;
   class DtModelDefinitionManager;

   class DT_DLL_VRVCORE DtModelDefinitionManagerBackup : public DtSettingsBackup
   {
   public:
      DtModelDefinitionManagerBackup(DtModelDefinitionManager& manager, DtDe& de);
      virtual ~DtModelDefinitionManagerBackup();

   protected:
      virtual void restore(const DtSettingsBackup* from);

      virtual std::string backupClassType() const;
      virtual std::string backupName() const;

      virtual DtSettingsBackup* create() const;

      virtual void write(boost::archive::xml_oarchive& ar);

      virtual void read(boost::archive::xml_iarchive& ar);

      virtual void readIncremental(boost::archive::xml_iarchive& ar);

      const DtModelDefinitionManager* restoredManager() const
      {
         return myRestoredManager;
      }

   protected:
      DtModelDefinitionManager&  mySourceManager;
      DtDe&                      myDe;
      DtModelDefinitionManager*  myRestoredManager;
   };

   class DT_DLL_VRVCORE DtModelDefinitionManager
   { 
      friend class DtModelDefinitionManagerCreator;

   public:
      typedef std::map<std::string, DtModelDefinition> DefinitionMap;

      static bool getFloatParameterValueFromDefinition(
         const std::string& paramName, const DtModelDefinition& definition, float& result);

      static bool getVectorParameterValueFromDefinition(
         const std::string& paramName, const DtModelDefinition& definition, float(&result)[3]);

      static bool getColorParameterValueFromDefinition(
         const std::string& paramName, const DtModelDefinition& definition, float(&result)[4]);

   public:
      virtual ~DtModelDefinitionManager();

      virtual void loadDefinitions();

      virtual bool skipDefaultDefinitions();

      virtual void saveDefinitions();

      virtual void saveAllDefinitions();

      virtual void saveDefinitions(const std::string&);


      virtual void addDefinition(const DtModelDefinition& definition, bool autoSave = true);
      
      virtual void destroyDefinition(const DtModelDefinition& def);

      const DtModelDefinition* findDefinition(const std::string& modelName) const;

      DtModelDefinition* findDefinitionNonConst(const std::string& modelName);

      const DefinitionMap& definitions() const;
      DefinitionMap& definitions();

      void renameDefinition(const std::string& oldModelName, const std::string& newModelName);

      const std::string& modelFilename() const;

      void setModelFilename(const std::string& extension);

      bool modelInstancingEnabled() const;

      void setModelInstancingEnabled(bool enabled);

      void clearModelInstancingCache();

      void clear();

      virtual void merge(const DtModelDefinitionManager&);

      virtual bool loadModelDefinitions(const std::string& filename, bool merge = true);
      
      virtual bool loadModelDefinition(const std::string& filename);

      virtual bool exportToFile(const std::vector<std::string>& defs, const std::string& filename) const;

      virtual bool schemaInUse(const std::string&) const;

      virtual bool schemaInUse(const std::string&, std::vector<std::string>&) const;

      virtual void backup();

      virtual bool mergeModelDefinitions(const std::string& fileOrDirName);

      virtual bool modifiedSinceStartup();

      virtual void addToModifiedDefinitionsMap(DtModelDefinition modelDefinition);

      virtual void addToAddedDefinitionsMap(DtModelDefinition modelDefinition);

      virtual void addToDeletedDefinitionsMap(DtModelDefinition modelDefinition);

      virtual void resetModifiedFlags();

      virtual int getNumOfDefinitionsExcludeTerrain();

      const DtSettingsBackup* settingsBackup() const
      {
         return myBackup;
      }

      DtSettingsBackup* settingsBackup()
      {
         return myBackup;
      }

      virtual DtModelDefinitionManager& operator=(const DtModelDefinitionManager&);

      void setAutoSave(bool b)
      {
         myAutoSave = b;
      }

      bool autoSave() const
      {
         return myAutoSave;
      }

      virtual void removeNonPersistentItems();

   protected:

      friend class DtModelDefinitionManagerBackup;

      DtModelDefinitionManager(DtDe&);
      DtModelDefinitionManager(const DtModelDefinitionManager&);

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

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

   protected:
      
      DtDe& myDe;
      DefinitionMap myDefinitions;
      std::string myModelFileName;
      std::string myModelFileExtension;
      bool        myAutoSave;

      DtSignalConnectionManager myConnectionManager;

      bool myModelInstancingFlag;
      DtModelDefinitionManagerSignaler& mySignaler;
      DtModelDefinitionManagerBackup* myBackup;
      int myStartupNumOfDefinition;
      DefinitionMap myModifiedDefinitions;
      DefinitionMap myAddedDefinitions;
      DefinitionMap myDeletedDefinitions;

  private:
      bool loadModelDefinitionsFromXML(const std::string& filename, bool shouldMerge);
      bool loadModelDefinitionsFromBinary(const std::string& filename, bool shouldMerge);
   }; 

   class DT_DLL_VRVCORE DtModelDefinitionManagerSignaler : public DtVirtualBaseClass
   {
   public:

      static DtModelDefinitionManagerSignaler& instance(DtDe& de);

      virtual ~DtModelDefinitionManagerSignaler();

      boost::signalslib::signal<void ()> signal_modelDefinitionManagerReset;

      boost::signalslib::signal<void (const DtModelDefinition&)> signal_modelDefinitionAdded;

      boost::signalslib::signal<void (const DtModelDefinition&)> signal_modelDefinitionToBeRemoved;

   protected:

      DtModelDefinitionManagerSignaler();

   };

   class DT_DLL_VRVCORE DtModelDefinitionManagerCreator : public DtVirtualBaseClass
   {
   public:
      DtModelDefinitionManagerCreator();

      virtual ~DtModelDefinitionManagerCreator();

      static DtModelDefinitionManagerCreator& instance(DtDe& de);

      virtual DtModelDefinitionManager* create(DtDe&);
   };
} 

BOOST_CLASS_VERSION(makVrv::DtModelDefinitionManager, 1)