DtElementDefinitionManager.h

Go to the documentation of this file.

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

#pragma once

#include <vrvCore/DtRecordSettingsBackup.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <boost/unordered_map.hpp>

namespace makArchives
{
   class DtElementDefinitionRecord;
   class DtElementsRecord;

   namespace oldRecords
   {
      class DtElementDefinition;
      class DtElementDefinitionHierarchy;
      class DtElementDefinitionNode;
      class DtVisualAttributeInterface;
   };
}

namespace makVrv
{
   class DtDe;
   class DtBaseConnection;
   class DtElementDefinitionNew;
   class DtDeSettings;
   class DtBackupInterface;
   class DtVisualizerDefinitionValidator;

   class DT_DLL_VRVCORE DtElementDefinitionManager
   {
   public:
      typedef std::map<DtUnicode, DtElementDefinitionNew*>
            DefinitionMap;

      typedef std::vector<const DtElementDefinitionNew*> ElementDefinitions;

      typedef std::vector<std::string>::const_iterator ParentToElementIter;

      static const DtElementDefinitionManager* createConstCopy(
         const DtElementDefinitionManager& orig);

      virtual ~DtElementDefinitionManager();

      const std::string& name() const;

      const DtUnicode& screenName() const;

      unsigned int numberOfElementDefinitions() const;

      const DefinitionMap& elementDefinitions() const;

      DtElementDefinitionNew* findElementDefinition(
         const DtUnicode& definitionName);

      const DtElementDefinitionNew* findElementDefinition(
         const DtUnicode& definitionName) const;

      DtElementDefinitionNew* createElementDefinition(
         const DtUnicode& definitionName);
      
      DtElementDefinitionNew* createElementDefinition( 
         const DtUnicode& definitionName, 
         DtElementDefinitionNew* parentDefinition);

      void destroyElementDefinition(DtElementDefinitionNew*);

      void destroyElementDefinitionAndChildren(DtElementDefinitionNew*);

      DtElementDefinitionNew* copyElementDefinition(DtElementDefinitionNew& def,
         const DtUnicode& newName);

      DtBackupInterface* backup();

      bool renameElementDefinition(const DtUnicode& oldName, 
         const DtUnicode& newName);

      void loadDefaults();

      void loadDefaults(bool loadOnlyFactory);

      virtual std::vector<std::string> retrieveHierFilesToMerge(std::string type);

      virtual std::vector<std::string> retrieveLeafFilesToMerge(std::string type);

      virtual bool shouldSkipDefLoading();

      void revertSettings();

      virtual void saveAsDefaults();

      virtual void splitAndWriteToDir(makArchives::DtElementsRecord& elementsRec, 
         std::string existingDirName);

      virtual void exportSettings(const std::string& fileOrDirName);

      virtual void exportHierSettings(const std::string& fileName);

      virtual void exportLeafSettings(const std::string& fileName);

      virtual void exportSelectedLeafSettings(std::vector<std::string>& names,const std::string& fileName);

      void createFolderFromPathAndSplit(const std::string &fileOrDirName,
         std::string& newPath, std::string& dirName);

      virtual void importSettings(const std::string& fileName,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      virtual void importSettings(const std::string& fileName);

      virtual void mergeHierSettings(const std::string& hierFileOrDirName);

      virtual void mergeHierSettings(const std::string& hierFileOrDirName,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      virtual void mergeLeafSettings(const std::string& leafFileOrDirName);

      virtual void mergeLeafSettings(const std::string& fileOrDirName,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      virtual void mergeSettings(const std::string& fileName,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      virtual void markRecordsAsHier(makArchives::DtElementsRecord& rec);

      virtual DtDeSettings* settings();

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

      virtual void setFromRecord(const makArchives::DtElementsRecord& rec,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      virtual void mergeRecord(
         const makArchives::DtElementsRecord& rec,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      virtual void mergeHierRecord(
         const makArchives::DtElementsRecord& rec,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      virtual void mergeLeafRecord(
         const makArchives::DtElementsRecord& rec,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

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

      virtual void getRecord(std::vector<std::string> elementDefinitions, makArchives::DtElementsRecord& rec);

      virtual void getSplitRecord(std::vector<makArchives::DtElementsRecord>& rec, 
         std::vector<std::string>& fileNames);

      virtual void addRecords(makArchives::DtElementsRecord& recs,
         makArchives::DtElementsRecord& combinedRec);

      virtual void splitRecordElemMgr(makArchives::DtElementsRecord& rec,
         makArchives::DtElementsRecord& recHier,
         makArchives::DtElementsRecord& recLeaves);

      virtual void setAutoSave(bool enabled);

      virtual bool validateElementDefinition(const DtElementDefinitionNew& def);

      static makArchives::DtElementDefinitionRecord
         buildElementDefinitionRecord( DtElementDefinitionNew& elementDef);

      virtual bool canUseHierLeaf();

      virtual bool modifiedSinceStartup();

      virtual void addToModifiedDefinitionsMap(DtElementDefinitionNew* modelDefinition);

      virtual void addToAddedDefinitionsMap(DtElementDefinitionNew* modelDefinition);

      virtual void addToDeletedDefinitionsMap(DtElementDefinitionNew* modelDefinition);

      virtual void resetModifiedFlags();

   protected:

      friend class DtElementDefinitionTypeManager;

      DtElementDefinitionManager(const std::string& name, 
         const DtUnicode& screenName, DtDe& de, bool procedural);

      DtElementDefinitionManager(const DtElementDefinitionManager& rhs);

      void registerDefinitionHierarchy(DtElementDefinitionNew* root);

      typedef std::vector<const makArchives::DtElementDefinitionRecord*> ElementGroup;

      typedef std::map<DtUnicode, ElementGroup> ParentToElementsMap;

      virtual void buildElementVisualizers(DtElementDefinitionNew& ed,
         const makArchives::DtElementDefinitionRecord& rec);

      virtual void buildElementVisualizersForModelSet(
         const makArchives::DtElementDefinitionRecord &rec, 
         DtElementDefinitionNew &ed, int modelSet);

      virtual void buildElementChildren(
         DtElementDefinitionNew& ed, ParentToElementsMap& parentToElementsMap,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      static void setupVisualizerDefs(makArchives::DtElementDefinitionRecord &elementRec, 
         DtElementDefinitionNew &elementDef, unsigned int modelSet);

      virtual void registerBackup();

      virtual bool recordMatchesDefinition(
         const makArchives::DtElementDefinitionRecord* childRec,
         const DtElementDefinitionNew* existingChildDef) const;

      virtual bool recordMatchesDefinitionModelSet(
         const makArchives::DtElementDefinitionRecord* childRec, 
         const DtElementDefinitionNew* existingChildDef,
         int modelSet) const;

      virtual void generateParentToElement(ParentToElementsMap& parentToElements,
         makArchives::DtElementsRecord& rec);

      virtual bool checkRecordsAreLeavesInHier(ParentToElementsMap& parentToElements,
         std::vector<makArchives::DtElementsRecord>& recVec,
         std::vector<std::string>& leafFiles);

      virtual bool replaceMergeLeaves(
         makArchives::DtElementsRecord& rec,
         std::vector<makArchives::DtElementsRecord>& recVec,
         const std::vector<std::string>& leafFiles);

      virtual bool loadDefaultsFromHierLeafDir(makArchives::DtElementsRecord& rec);

      virtual bool isEntityDefinitions();

   private:
      DtElementDefinitionManager();

      DtElementDefinitionManager& operator=( const DtElementDefinitionManager& );

   protected:
      typedef std::map<std::string, DtVisualizerDefinitionValidator*> VisualizerDefinitionValidatorMap;
      typedef DtRecordSettingsBackup<DtElementDefinitionManager, makArchives::DtElementsRecord>
         ElementDefinitionsBackup;

      VisualizerDefinitionValidatorMap myValidators;

      std::string myName;
      std::string myHierName;
      std::string myLeafName;
      DtUnicode myScreenName;

      DtDe* myOptionalDe;
      DefinitionMap myDefinitions;
      bool myProceduralFlag;
      bool myAutoSave;

      ElementDefinitionsBackup* myBackup;
      int myStartupNumOfDefinition;
      DefinitionMap myModifiedDefinitions;
      DefinitionMap myAddedDefinitions;
      DefinitionMap myDeletedDefinitions;
   };


   class DT_DLL_VRVCORE DtElementDefinitionTypeManager :
      public DtVirtualBaseClass
   {
   public:

      typedef unsigned int ElementDefinitionType;

      enum BuiltInElementTypes
      {
         Entity,
         TacticalGraphics,
         Interaction,
         Unit,                
         Intervisibility,
         TacticalSmoke,
         BuiltInElementTypes_End,
      };

      static DtElementDefinitionTypeManager& instance(DtDe& de);

      static DtElementDefinitionTypeManager& instance(DtBaseConnection& con);

      static void copyInstance(DtBaseConnection& con, DtDe&);

      static const DtElementDefinitionTypeManager* createConstCopy(DtDe& de);

      virtual ~DtElementDefinitionTypeManager();

      virtual void registerElementType(ElementDefinitionType type,
         const std::string& name, const DtUnicode& typeScreenName, 
         bool proceduralOnly);

      virtual DtElementDefinitionManager* findElementManager(ElementDefinitionType type);

      virtual DtElementDefinitionManager& elementManager(ElementDefinitionType type);

      virtual const DtElementDefinitionManager& elementManager(
         ElementDefinitionType type) const;

      virtual void loadDefaults();

      virtual DtElementDefinitionTypeManager::ElementDefinitionType getElementDefinitionType(const DtElementDefinitionManager& element);

   protected:

      template <typename ManagerClass>
      friend ManagerClass& defaultManagerInstanceFunction(DtDe&,bool);

      template <typename ManagerClass>
      friend void defaultManagerRegisterInstanceFunction(DtDe&, ManagerClass*);

      DtElementDefinitionTypeManager();

      DtElementDefinitionTypeManager(DtDe&);

      DtElementDefinitionTypeManager(const DtElementDefinitionTypeManager&);

   private:
      DtElementDefinitionTypeManager&
         operator=( const DtElementDefinitionTypeManager& );

   protected:

      typedef boost::unordered_map<unsigned int, DtElementDefinitionManager*>
         ManagerMap;

      DtDe* myOptionalDe;
      DtSignalConnectionManager myConnections;
      ManagerMap myManagers;
   };


   class DT_DLL_VRVCORE DtElementDefinitionSignaler : public DtVirtualBaseClass
   {
   public:
      static DtElementDefinitionSignaler& instance(DtDe&);

      virtual ~DtElementDefinitionSignaler();

      //Signals.
      boost::signal<void (const DtUnicode& oldName, const DtUnicode& newName)>
         signal_elementRenamed;

   protected:
      DtElementDefinitionSignaler();

   private:
      DtElementDefinitionSignaler( const DtElementDefinitionSignaler& );

      DtElementDefinitionSignaler& operator=( const DtElementDefinitionSignaler& );

   };
}