DtModelDefinitionManager.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2010 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
/****************************************************************************** 
** $RCSfile: DtModelDefinitionManager.h,v $ $Revision: 1.16 $ $State: Exp $ 
******************************************************************************/ 
 
 
#pragma once
 
#include <vrvCore/DtModelDefinition.h>
#include <vrvCore/DtSettingsBackupManager.h>
#include <string>
#include <boost/signal.hpp>

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

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

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

   class DT_DLL_VRVCORE DtModelDefinitionManager
   { 
   public:
      friend class DtModelDefinitionManagerCreator;

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

      virtual ~DtModelDefinitionManager();

      virtual void loadDefinitions();

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

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

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

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

      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();

      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;
      bool        myAutoSave;

      bool myModelInstancingFlag;
      DtModelDefinitionManagerSignaler& mySignaler;
      DtModelDefinitionManagerBackup* myBackup;

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

   class DT_DLL_VRVCORE DtModelDefinitionManagerSignaler : public DtVirtualBaseClass
   {
   public:

      static DtModelDefinitionManagerSignaler& instance(DtDe& de);

      virtual ~DtModelDefinitionManagerSignaler();

      boost::signal<void ()> signal_modelDefinitionManagerReset;

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

      boost::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)