DtElementDefinitionManager.h

Go to the documentation of this file.

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

#pragma once
#include <vrvCore/vrvCore.h>

#include <vrvCore/DtRecordSettingsBackup.h>
#include <vrvCore/DtVisualizerDefinition.h>
#include <vrvCore/DtVisualizerAttribute.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtDebugLog.h>
#include <vlutil/vlPrint.h>

#include <unordered_map>

namespace makArchives
{
   class DtElementDefinitionRecord;
   class DtElementsRecord;
}

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

   class DT_DLL_VRVCORE DtElementDefinitionManager
   {
   public:
      enum class DefinitionFileType
      {
         FileTypeHierarchy,
         FileTypeLeaf,
         FileTypeBoth
      };

   public:
      typedef std::map<DtUnicode, DtElementDefinition*>
         DefinitionMap;

      typedef std::map<std::string, makArchives::DtElementsRecord> StringToElementsRecordMap;

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

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

   public:

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

      static makArchives::DtElementDefinitionRecord buildElementDefinitionRecord(const DtElementDefinition& elementDef);

      static void setupVisualizerDefs(makArchives::DtElementDefinitionRecord &elementRec,
         const DtElementDefinition &elementDef, DtModelSetId modelSet);

      static bool isHierFileName(const std::string& fileName);

   public:

      DtElementDefinitionManager() = delete;

      DtElementDefinitionManager& operator=(const DtElementDefinitionManager&) = delete;

      virtual ~DtElementDefinitionManager();

      virtual const std::string& name() const;

      virtual const DtUnicode& screenName() const;

      virtual const std::string& rootsFilesname() const;

      virtual unsigned int numberOfElementDefinitions() const;

      virtual const DefinitionMap& elementDefinitions() const;

      virtual DtElementDefinition* findElementDefinition(const DtUnicode& definitionName);

      virtual const DtElementDefinition* findElementDefinition(const DtUnicode& definitionName) const;

      virtual DtElementDefinition* createElementDefinition(const DtUnicode& definitionName);

      virtual DtElementDefinition* createElementDefinition(const DtUnicode& definitionName, DtElementDefinition* parentDefinition);

      virtual void destroyElementDefinition(DtElementDefinition*);

      virtual void destroyElementDefinitionAndChildren(DtElementDefinition*);

      virtual DtElementDefinition* copyElementDefinition(DtElementDefinition& def, const DtUnicode& newName);

      virtual DtBackupInterface* backup();

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

      virtual void loadDefaults();

      virtual void loadDefaults(bool loadOnlyFactory);

      virtual DefinitionMap& modifiedDefinitions();

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

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

      virtual bool shouldSkipDefLoading();

      virtual 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 exportHierSettings(std::vector<std::string>& fileList);

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

      virtual void exportSelectedLeafSetting(const std::string& name, const std::string& fileName);

      virtual void exportSelectedHierSetting(const std::string& name, const std::string& fileName, bool allLevels=true);

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

      virtual bool importAndReplaceSettings(const std::string& fileName);

     virtual bool importAndReplaceHierRecords(StringToElementsRecordMap& recordMap, const std::string& importFileName);

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

      // TDL - This method is called on backup restore, which is currently
      // disabled.  If we come up with way to use this sensibly it needs to be
      // modified with the changes made to setFromRecords...

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

      virtual void setFromRecords(StringToElementsRecordMap& elemRecords, ElementDefinitions& addedDefinitions, ElementDefinitions& skippedDefinitions, bool& forceSaveAfterLoad);

      virtual void mergeRecords(StringToElementsRecordMap& recordMap, ElementDefinitions& addedDefinitions, ElementDefinitions& skippedDefinitions);

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

      virtual void mergeLeafRecords( StringToElementsRecordMap& recordMap, ElementDefinitions& addedDefinitions, ElementDefinitions& skippedDefinitions);

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

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

      virtual void getRecord(makArchives::DtElementsRecord& rec, const std::string& fileName) const;

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

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

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

      virtual void addRecords(makArchives::DtElementsRecord& recs,  makArchives::DtElementsRecord& combinedRec);
      
      virtual void enableFilePathReadWriteOnRecord( makArchives::DtElementsRecord& recs );
      
      virtual void splitRecordElemMgr(makArchives::DtElementsRecord& rec, makArchives::DtElementsRecord& recHier, makArchives::DtElementsRecord& recLeaves);

      virtual void setAutoSave(bool enabled);

      virtual bool validateElementDefinition(const DtElementDefinition& def);

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

      virtual DtUnicode getElementDefinitionError(const DtElementDefinition& def);

      virtual bool canUseHierLeaf();

      virtual bool modifiedSinceStartup();

      virtual void resetModifiedSinceStartupFlag();

      virtual void addToModifiedDefinitionsMap(DtElementDefinition* modelDefinition);

      virtual void addToAddedDefinitionsMap(DtElementDefinition* modelDefinition);

      virtual DefinitionMap getDeletedDefinitionsMap();

      virtual void addToDeletedDefinitionsMap(DtElementDefinition* modelDefinition);

      virtual void resetModifiedFlags();

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

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

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

      virtual void removeElementFromChangeMaps(const DtUnicode& definitionName);

      virtual void removeElementsFromChangeMaps(DefinitionFileType fileType);
      
      virtual void getChangedFiles(std::vector<std::string>& changedFiles, DefinitionFileType fileType);

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

   protected:

      friend class DtElementDefinitionTypeManager;

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

      DtElementDefinitionManager(const DtElementDefinitionManager& rhs);

      virtual void registerDefinitionHierarchy(DtElementDefinition* root);

      typedef std::pair < std::string, const makArchives::DtElementDefinitionRecord*> ElementPair;

      typedef std::vector<ElementPair> ElementGroup;

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

      virtual void buildElementVisualizerDefinitions(DtElementDefinition& newDef,
         const makArchives::DtElementDefinitionRecord& defRecord);

      virtual void buildElementVisualizerDefinitionsForModelSet(const makArchives::DtElementDefinitionRecord &defRecord, DtElementDefinition &newDef, DtModelSetId modelSet);

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

      virtual void registerBackup();

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

      virtual bool recordMatchesDefinitionModelSet(const makArchives::DtElementDefinitionRecord* childRec, const DtElementDefinition* existingChildDef, DtModelSetId modelSet) const;

      virtual void generateParentToElement(ParentToElementsMap& parentToElements, StringToElementsRecordMap& rec);

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

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

      virtual bool loadDefaultsFromHierLeafDir(StringToElementsRecordMap& recordMap);

      virtual bool isEntityDefinitions() const;

      virtual bool isTacticalGraphicsDefinitions() const;

      virtual bool isUnitDefinitions() const;

      virtual void checkDefinitionName(const DtUnicode& definitionName);

      virtual void processVisualizerDefinitionAttributes(DtVisualizerDefinition* vd, const makArchives::DtVisualizerDefinitionRecord& vdRecord, 
         const std::string& defName, DtModelSetId modelSet);

      virtual void logWarning(const std::string& message);

      virtual void getFilesFromDefinitionMap(const DefinitionMap& defMap, std::set<std::string>& changedFiles);

      virtual void removeElementsFromDefnitionMap(DefinitionMap& defMap, DefinitionFileType fileType);

      virtual DtVisualizerDefinition* convertLoadedVisualizerDefinition(const makArchives::DtVisualizerDefinitionRecord& vdRecord,
         DtVisualizerDefinitionSet& vdSet, int visualizerIndex, DtElementDefinition* ancestor);

      virtual bool hierarchyNeedsConversion(const makArchives::DtElementDefinitionRecord* elemRec) const;
      
      virtual void clearDefinitionMap(DefinitionMap& map);

      virtual bool validateVisualizerDefinitionSet(const DtElementDefinition& newDef, const DtVisualizerDefinitionSet& vdSet,
         const makArchives::DtVisualizerDefinitionSetRecords* vdRecordSet);

      virtual void convertLeafToUuid(const std::vector<makArchives::DtVisualizerDefinitionRecord>& visualizerDefinitionRecords, 
         const Utf8String& elementName, const Utf8String& parentName, DtVisualizerDefinitionSet& vdSet);

      typedef std::multimap<const std::string, DtVisualizerDefinition*> ParentSchemaDataMap;
      typedef std::multimap<const std::string, DtVisualizerDefinition*>::iterator ParentSchemaDataInterator;
      typedef std::multimap<const std::string, DtVisualizerDefinition*>::const_iterator ConstParentSchemaDataInterator;

      virtual DtVisualizerDefinition* findAncestorVisualizerDefinition(const std::string& schemaName, ParentSchemaDataMap& schemaDataMap);

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

      VisualizerDefinitionValidatorMap myValidators;

      std::string myName;
      std::string myRootsFilename;
      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;
      DefinitionMap myModifiedDefinitions;
      DefinitionMap myAddedDefinitions;
      bool myConvertingHierarchy;
      DefinitionMap myDeletedDefinitions;

      bool myConvertWarningsToInfo = false;
   };


   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 std::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::signalslib::signal<void(const DtUnicode& oldName, const DtUnicode& newName)>
         signal_elementRenamed;

   protected:
      DtElementDefinitionSignaler();

   private:
      DtElementDefinitionSignaler(const DtElementDefinitionSignaler&);

      DtElementDefinitionSignaler& operator=(const DtElementDefinitionSignaler&);
   };
}