simulationModelSetLoader.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2013 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/


#pragma once

#include "entityEditorImpl/entityEditorImplDefines.h"
#include "entityEditorImpl/embarkationInformation.h"
#include "entityEditorImpl/diGuyInformation.h"
#include "entityEditorImpl/sensorSignatureInformation.h"
#include <vrvUtil/signalslib.h>
#include "vrfutil/simulationModelSet.h"
#include <vrfutil/rwForces.h>
#include <vrfutil/subObjList.h>
#include <vrfutil/subObjEntry.h>
#include <vrfutil/formTbl.h>
#include <vlutil/vlFilename.h>
#include <mtl/envValue.h>
#include <matrix/3dBoundingVolume.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <QtCore/QHash>
#include <QtGui/QPixmap>
#include <QtCore/QObject>

#include <vrfExtProtocol/objType.h>
#include <entityEditorImpl/orderedObjectTypeList.h>

class DtEnvList;
class DtRwVariableBindingsList;
class DtComponentSystemDescriptorList;
class DtVrfObjectParameters;
class DtComponentSystemDefinition;

namespace makVrf
{
   class DtEntityMapperKey;
}

namespace makVrv
{
   class DtForceManager;
}

class DtObjectType;
class DtModelSet;
class DtModelSetEntry;
class DtComponentSystemDatabase;
class QComboBox;
class DtSimulationModelSetLoader;
class DtEnvironment;
class DtVariableBindingList;

class DT_DLL_entityeditorimpl DtSimulationModelSetLoader : public makVrv::DtVirtualBaseClass
{
public:
   enum LoadFlags
   {
      LoadDataFiles = 0x00000001,
      LoadParameterFiles = 0x00000002,
      LoadSystemFiles = 0x00000004,
      LoadSupportingFiles = 0x00000008,
      LoadAll = LoadDataFiles | LoadParameterFiles | LoadSystemFiles | LoadSupportingFiles
   };

   typedef std::map<DtString, DtVrfObjectParameters*> ParametersMap;

   class EnvironmentContainer
   {
   public:
      EnvironmentContainer();
      EnvironmentContainer(DtEnvironmentSP original);

      virtual ~EnvironmentContainer();

      void seedFrom(DtEnvironmentSP env, DtEnvValueSP root);

      DtEnvironmentSP copyEnvironment(DtEnvironmentSP) const;
      void reparentEnvironmentChildren(DtEnvList*, DtEnvValueSP root) const;

      DtEnvValueSP backup();
      DtEnvValueSP update();

      void remove(DtEnvValueSP originalNode, DtEnvValueSP modifiedNode);
      bool isEmpty() const;

      DtEnvValueSP replace(DtEnvironmentSP env, DtEnvValueSP node, DtEnvValueSP replaceWith);
      void reparentRoots(DtEnvValueSP templateRoot, DtEnvValueSP newRoot) const;

      DtEnvironmentSP myOriginal;
      DtEnvironmentSP myModified;
   };

   typedef boost::shared_ptr<EnvironmentContainer> EnvironmentContainerSP;

   class EntityData : public DtObjectType
   {
   public:
      EntityData();
      virtual ~EntityData();
      EntityData(const DtObjectType& objectType, const DtObjectType& matchType = DtObjectType::nullType());
      EntityData(const EntityData& t);

      //sets the object type
      EntityData& operator=(const DtObjectType&);

      EntityData& operator=(const EntityData&);

      virtual EntityData* clone() const;
      
      //compares to the object type
      bool operator>(const DtObjectType& rhs) const
      {
         if (*this < rhs)
         {
            return false;
         }
         else
         {
            return true;
         }
      }

      //compares to the object type
      bool operator>(const EntityData& rhs) const
      {
         if (*this < rhs)
         {
            return false;
         }
         else
         {
            return true;
         }
      }

      std::string myDataFile;

      EnvironmentContainerSP myEnvironment;

      DtObjectType myMatchType;
      DtObjectType myOriginalMatchType;

      DtRwVariableBindingsList* myOriginalSystems;
      DtEnvValueSP myOriginalObjectNode;
      DtVariableBindingsList* myOriginalVariableBindings;
      DtFormationTable* myOriginalFormationTable;
      DtVrfSubObjectParameterList* myOriginalSubordinateInformation;
      DtEmbarkationInformation* myOriginalEmbarkationInformation;
      DtDIGuyInformation* myOriginalDIGuyInformation;
      DtSensorSignatureInformation* myOriginalSensorSignatureInformation;

      DtRwVariableBindingsList* myModifiedSystems;
      DtEnvValueSP myModifiedObjectNode;
      DtVariableBindingsList* myModifiedVariableBindings;
      DtFormationTable* myModifiedFormationTable;
      DtVrfSubObjectParameterList* myModifiedSubordinateInformation;
      DtEmbarkationInformation* myModifiedEmbarkationInformation;
      DtDIGuyInformation* myModifiedDIGuyInformation;
      DtSensorSignatureInformation* myModifiedSensorSignatureInformation;

      bool myIsNew;
      bool myIsDeleted;
   };

   DtSimulationModelSetLoader(makVrv::DtDe&);

   virtual ~DtSimulationModelSetLoader();

   virtual bool load(const DtSimulationModelSet&, LoadFlags flags = LoadAll);
   virtual bool save(const DtFilename&);

   static DtSimulationModelSetLoader& instance(makVrv::DtDe&);
   static void registerInstance(makVrv::DtDe&, DtSimulationModelSetLoader*);

   virtual void setDisplayDe(makVrv::DtDe*);
   virtual makVrv::DtDe& displayDe();

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

public:
   virtual bool hasFileNamed(const std::string& s) const;

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

   virtual std::string platform(const makVrf::DtEntityMapperKey& k) const;

   virtual std::string platformFileType(const makVrf::DtEntityMapperKey& k) const;

   DtFilename getSystemDirectory() const;
   DtFilename getFormationDirectory() const;
   DtFilename path() const;

   DtFilename simulationModelSetFilename() const;

   virtual bool openSystemFiles(const DtFilename& directory);

   virtual bool loadForceHostilityFile(const DtFilename& f);

   virtual bool loadDataFiles(const DtString&);

   virtual bool loadParameterFiles(const DtString&);

   virtual bool loadModelSet();

   virtual DtModelSetEntry* modelEntry(const DtObjectType&, bool matchPattern = false) const;

   virtual DtModelSetEntry createModelSetEntryFrom(DtEnvironmentSP env, DtEnvValueSP objectNode) const;
   virtual DtModelSetEntry createModelSetEntryFrom(const DtObjectType&) const;

   virtual void revertData(const makVrf::DtEntityMapperKey& key);

   virtual EntityData* dataFor(const DtObjectType&) const;

   virtual bool containsObjectType(const DtObjectType&) const;

   virtual bool hasModelNamed(const DtString&);

   virtual const ParametersMap& availableParameters() const
   {
      return myAvailableParameters;
   }

   virtual bool createRwVariable(const DtObjectType&, const std::string& rwType, const std::string& rwName, DtReaderWriter*& source,
      DtReaderWriter*& backup);

   virtual void replaceSystem(const DtFilename&);

   virtual bool isModified(const DtObjectType&) const;
   virtual bool isModified(EntityData*) const;
   virtual bool isModified() const;

   virtual bool isNew(const DtObjectType&) const;
   virtual bool isNew(EntityData*) const;

   virtual bool isDeleted(const DtObjectType&) const;
   virtual bool isDeleted(EntityData*) const;

   virtual void deleteModel(DtModelSetEntry*);
   virtual void deleteModel(const DtObjectType&);
   virtual void deleteModel(EntityData*);

   virtual bool changeObjectType(const DtObjectType& oldType, const DtObjectType& newType);

   virtual bool changeMatchType(const DtObjectType& oldType, const DtObjectType& newType);

   virtual void updateGuiInformation(EntityData*);

   virtual void updateSystemData(EntityData*);

   virtual void sharedSystems(const DtFilename& systemFile, std::vector<DtModelSetEntry*>& result) const;

   virtual void loadSystemFile(const DtFilename&);

   virtual void updateDataInformation(EntityData*);

   virtual void convertRegistryToEnvironment(const DtReaderWriterRegistry& data, DtEnvironmentSP env, DtEnvValueSP objectNode) const;

   virtual void removeSystem(DtEnvironmentSP env, const DtString& system, DtEnvValueSP objectNode);

   virtual void addSystem(DtEnvironmentSP env, const DtRwVariableBindings*, DtEnvValueSP objectNode);

   virtual void changeDefaultCategory(const QString& old, const QString& newCat);
   virtual void addDefaultCategories(QComboBox*);

   void setDefaultCategories(const QStringList&);
   void addDefaultCategory(const QString&);
   const QStringList& defaultCategories() const;
   virtual void revertCategories();
   virtual bool hasModifiedCategories() const;

   virtual void changeDefaultDeployedCountry(const QString& old, const QString& newCat);
   virtual void addDefaultDeployedCountries(QComboBox*);
   void setDefaultDeployedCountries(const QStringList&);
   void addDefaultDeployedCountry(const QString&);
   const QStringList& defaultDeployedCountries() const;
   virtual void revertDeployedCountries();
   virtual bool hasModifiedDeployedCountries() const;

   virtual DtRwVariableBindings* createVariableBindingsForSystem(const DtFilename&, const DtString& newSystemName);

   virtual DtModelSetEntry* addNewEntity(const DtObjectType& base, const DtObjectType& newType, const DtString& name,
      const DtRwNLengthStringVector& categories, const DtString& uniqueID);

   virtual DtModelSetEntry* addNewEntity(const std::string& platformType, const DtObjectType& newType, const DtString& name,
      const DtRwNLengthStringVector& categories, const DtString& uniqueID);

   DtModelSetEntry* addNewEntity(EntityData* baseData, const DtObjectType& newType, const DtString& name,
      const DtRwNLengthStringVector& categories, const DtString& uniqueID);

   virtual void removeSystem(const DtFilename&);

   virtual const DtRwVariableBindings* variableBindings() const;

   virtual QPixmap getIcon(const makVrf::DtEntityMapperKey& key, int pointSize = 48,
      bool sizeToFont = false);

   virtual void clearIcons(const makVrf::DtEntityMapperKey& key);

   static DtSimulationModelSetLoader* create(makVrv::DtDe*);

   virtual void changeSubordinateTypes(const DtObjectType& oldType, const DtObjectType& newType);

   virtual DtVrfSubObjectParameterList subordinateObjectsFor(const DtObjectType&) const;
   virtual DtVrfSubObjectParameterList subordinateObjectsFor(DtEnvironmentSP, DtEnvValueSP objectNode) const;

   virtual void updateSubordinateObjects(const DtObjectType&, const DtVrfSubObjectParameterList&);
   virtual void updateSubordinateObjects(DtEnvironmentSP, DtEnvValueSP objectNode, const DtVrfSubObjectParameterList&);

   virtual void updateFormationTable(const DtObjectType&, const DtFormationTable&);

   virtual DtEmbarkationInformation embarkationInformationFor(const DtObjectType&) const;
   virtual DtEmbarkationInformation embarkationInformationFor(DtEnvironmentSP, DtEnvValueSP objectNode) const;

   virtual void updateEmbarkationInformation(const DtObjectType&, const DtEmbarkationInformation&);
   virtual void updateEmbarkationInformation(DtEnvironmentSP, DtEnvValueSP objectNode, const DtEmbarkationInformation&);

   virtual DtDIGuyInformation diGuyInformationFor(const DtObjectType&) const;

   virtual void updateDIGuyInformation(const DtObjectType&, const DtDIGuyInformation&);

   virtual DtSensorSignatureInformation sensorSignatureInformationFor(const DtObjectType&) const;
   virtual DtSensorSignatureInformation sensorSignatureInformationFor(DtEnvironmentSP, DtEnvValueSP root) const;

   virtual void updateSensorSignatureInformation(const DtObjectType&, const DtSensorSignatureInformation&);
   virtual void updateSensorSignatureInformation(DtEnvironmentSP, DtEnvValueSP root, const DtSensorSignatureInformation&);

   virtual DtFormationTable* formationTableFor(const DtObjectType&);
   virtual DtFormationTable* originalFormationTableFor(const DtObjectType&);

   virtual Dt3dBoundingVolume boundingVolumeFor(const DtObjectType&) const;

   virtual bool isAggregate(const DtObjectType&) const;

   bool loaded() const
   {
      return myLoaded;
   }

   const DtOrderedObjectTypeList<EntityData*>& entityData() const
   {
      return myEntityData;
   }

   virtual bool saveData();

   virtual bool saveFavorites();

   virtual DtObjectType templateObjectType(const std::string& parameterType) const;

   virtual void addInternalItem(const std::string&, bool markDataAsWell = true);

   virtual std::vector<DtReaderWriter*> supportPointsFor(const DtObjectType&) const;

   virtual DtObjectType uniqueEntityTypeFrom(const DtObjectType&) const;

public:
   const DtModelSet* modelSet() const;
   DtModelSet* modelSet();

   virtual makVrv::DtForceManager* forceManager();

   const DtSimulationModelSet& simulationModelSet() const;
   const DtFilename& parameterFilename() const;
   const DtComponentSystemDatabase* systemDatabase() const;
   DtFilename modelSetDirectory() const;

   virtual void forceRemoved(DtForceType forceType);

   const DtRwForces& allForces() const;

   virtual std::vector<const DtComponentSystemDefinition*> systemDefinitionsFor(const DtObjectType& o) const;

   virtual const DtReaderWriter* findVariable(const DtVariableBindingsList&, const DtString&) const;

protected:
   virtual void markInternalItemsAsReadOnly(DtVariableBindingsList*);

   virtual void loadSystemFilesFromDirectory(const QString& directoryName, const DtVariableBindingsList& variableBindings);

   virtual void cleanup();

   virtual bool saveForceHostility(const DtFilename& filename);

   virtual bool warned(const DtFilename&);
   virtual void removeEntityFromSubObjects(const DtObjectType&);

   virtual DtModelSet* createFavoritesFromModelSet(DtModelSet* s);

   virtual void mergeFavoritesIntoModelSet(DtModelSet* favorites, DtModelSet* set);

   virtual DtVariableBindingsList* copyBindingsList(const DtVariableBindingsList* orig) const;

   virtual EntityData* createParameterDataFrom(DtVrfObjectParameters*) const;

   virtual DtFormationTable* formationTableFor(DtEnvironmentSP, DtEnvValueSP objectNode) const;

   virtual void updateFormationTable(DtEnvironmentSP, DtEnvValueSP objectNode, const DtFormationTable&);

   virtual std::vector<EntityData*> addDataFromFile(const std::string& file);

   virtual void addModelSetEntriesFromEnvironment(DtEnvironmentSP, DtEnvValueSP node);
   virtual void addToInternalCategories(DtModelSetEntry* entry);

protected:
   QStringList myWarned;
   DtSimulationModelSet mySimulationModelSet;
   DtComponentSystemDatabase* mySystemDatabase;
   DtFilename        myParameterFilename;
   DtModelSet*       myModelSet;
   DtRwForces        myAllForces;
   QStringList       myDefaultCategories;
   QStringList       myDefaultDeployedCountries;
   makVrv::DtDe&     myDe;
   makVrv::DtDe*     myDisplayDe;
   bool myLoaded;

   DtOrderedObjectTypeList<EntityData*> myEntityData;

   ParametersMap myAvailableParameters;

   typedef std::map<std::string, EntityData*> ParametersData;
   ParametersData myParametersData;

   std::set<std::string> myInternalItems;
   DtModelSet* myFavoritesModelSet;
};

inline DtFilename DtSimulationModelSetLoader::simulationModelSetFilename() const
{
   return mySimulationModelSet.filename();
}

inline const DtSimulationModelSet& DtSimulationModelSetLoader::simulationModelSet() const
{
   return mySimulationModelSet;
}

inline const DtModelSet* DtSimulationModelSetLoader::modelSet() const
{
   return myModelSet;
}

inline DtModelSet* DtSimulationModelSetLoader::modelSet()
{
   return myModelSet;
}

inline const DtFilename& DtSimulationModelSetLoader::parameterFilename() const
{
   return myParameterFilename;
}

inline const DtRwForces& DtSimulationModelSetLoader::allForces() const
{
   return myAllForces;
}

inline const QStringList& DtSimulationModelSetLoader::defaultCategories() const
{
   return myDefaultCategories;
}

inline void DtSimulationModelSetLoader::setDefaultCategories(const QStringList& l)
{
   myDefaultCategories = l;
}

inline void DtSimulationModelSetLoader::addDefaultCategory(const QString& l)
{
   myDefaultCategories.push_back(l);
}

inline const QStringList& DtSimulationModelSetLoader::defaultDeployedCountries() const
{
   return myDefaultDeployedCountries;
}

inline void DtSimulationModelSetLoader::setDefaultDeployedCountries(const QStringList& l)
{
   myDefaultDeployedCountries = l;
}

inline void DtSimulationModelSetLoader::addDefaultDeployedCountry(const QString& l)
{
   myDefaultDeployedCountries.push_back(l);
   myDefaultDeployedCountries.sort();
}

extern DT_DLL_entityeditorimpl makVrf::DtEntityMapperKey mapperKeyConversion(const DtObjectType&, int force);

inline bool operator>(const DtObjectType& lhs, const DtSimulationModelSetLoader::EntityData& rhs)
{
   return !(lhs.operator<(rhs));
}