DtElementDefinitionManager.h

Go to the documentation of this file.

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

#pragma once

#include <vrvCore/DtRecordSettingsBackup.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvCore/DtVisualizerDefinition.h>
#include <vrvCore/DtVisualizerAttribute.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(const std::string& type);

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

      virtual bool shouldSkipDefLoading();

      void revertSettings();

      virtual void saveAsDefaults();

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

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

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

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

      virtual void exportLeafSettings(const std::string& fileName, std::vector<std::string>& fileList);

      virtual void exportSelectedLeafSettings(const 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& elemRecord);

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

      virtual void setFromRecords(std::map<std::string, makArchives::DtElementsRecord>& elemRecords,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

      virtual void mergeRecords(
         std::map<std::string, makArchives::DtElementsRecord>& recordMap,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

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

      virtual void mergeLeafRecords(
         std::map<std::string, makArchives::DtElementsRecord>& recordMap,
         ElementDefinitions& addedDefinitions,
         ElementDefinitions& skippedDefinitions);

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

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

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

      virtual void getRecordIncludingParent(const 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);

      virtual bool validateElementAttribute(const DtVisualizerDefinition::SortedAttributeMap::iterator& attr);

      virtual DtUnicode getElementDefinitionError(const DtElementDefinitionNew& def);

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

      virtual bool canUseHierLeaf();

      virtual bool modifiedSinceStartup();

      virtual void resetModifiedSinceStartupFlag();

      virtual void addToModifiedDefinitionsMap(DtElementDefinitionNew* modelDefinition);

      virtual void addToAddedDefinitionsMap(DtElementDefinitionNew* modelDefinition);

      DefinitionMap getDeletedDefinitionsMap();

      virtual void addToDeletedDefinitionsMap(DtElementDefinitionNew* modelDefinition);

      virtual void resetModifiedFlags();

      DtUnicode findFirstDefWithAttribPair(const DtUnicode& attributeName, const DtUnicode& attributeValue);

      DtVisualizerAttributeStringVector::StringVector findAllAttributeValues(
         const DtUnicode& elementDefName, const DtUnicode& attributeName);

      virtual std::string getModelSetDisplayName(int modelSet) const;

   public:
      boost::signal<void()> signal_managerAboutTobeDeleted;

   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::pair < std::string, const makArchives::DtElementDefinitionRecord*> ElementPair;

      typedef std::vector<ElementPair> ElementGroup;

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

      virtual void buildElementVisualizers(DtElementDefinitionNew& newDef,
         const makArchives::DtElementDefinitionRecord& defRecord);

      virtual void buildElementVisualizersForModelSet(
         const makArchives::DtElementDefinitionRecord &defRecord,
         DtElementDefinitionNew &newDef, 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,
         std::map<std::string, makArchives::DtElementsRecord>& rec);

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

      virtual bool replaceMergeLeaves(
         std::map<std::string, makArchives::DtElementsRecord>& firstRecMap,
         std::map<std::string, makArchives::DtElementsRecord>& secondRecMap,
         const std::vector<std::string>& leafFiles);

      virtual bool loadDefaultsFromHierLeafDir(std::map<std::string, makArchives::DtElementsRecord>& recordMap);

      virtual bool isEntityDefinitions();

      virtual void checkDefinitionName(const DtUnicode& definitionName);

   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;
      boost::unordered_map<std::string, std::string> myDefinitionNameCheck;
      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);

      virtual DtElementDefinitionTypeManager* clone();

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