sharedModelSet.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/orderedKeyList.h>
#include <vrfGuiCore/guiSimObject.h>
#include <vrvCore/DtSharedSettings.h>
#include <vrvCore/DtWriteSettingsLock.h>
#include <vlutil/vlFilename.h>
#include <readerWriter/rwProperties.h>
#include <vrfutil/rwDIGuyCharacterInfo.h>
#include <readerWriter/rwVariableBindings.h>
#include <vrvUtil/event_signal.h>
#include <matrix/3dBoundingVolume.h>
#include <mutex>
#include <tbb/spin_mutex.h>

#include <map>

class DtModelSet;
class DtModelSetEntry;
class DtSimulationModelSet;
class DtRwNLengthStringVector;
class DtVrfObjectParameters;
class DtSimulationObjectGroupModelSetEntry;
class DtObjectSensorDescriptor;
class DtComponentSystemDescriptorList;
class DtComponentDescriptorList;
class DtComponentDescriptor;

namespace makVrf
{
   class DtEntityMapperKey;

   class DT_DLL_VRFGUICORE DtSharedModelSet : public makVrv::DtSharedSettings
   {
   public:
      class WriteSettingsLock
      {
      public:
         WriteSettingsLock(makVrv::DtSharedSettingsManager& manager)
         {
            myLock = new std::unique_lock<std::mutex>(DtSharedModelSet::theSafetyMutex);
            myVrvLock = new makVrv::DtWriteSettingsLock<DtSharedModelSet>(manager);
         }

         virtual ~WriteSettingsLock()
         {
            delete myVrvLock;
            myVrvLock = nullptr;

            delete myLock;
            myLock = nullptr;
         }

         makVrv::DtWriteSettingsLock<DtSharedModelSet>& operator->() { return *myVrvLock; };

      protected:
         std::unique_lock<std::mutex> * myLock = nullptr;
         makVrv::DtWriteSettingsLock<DtSharedModelSet>* myVrvLock = nullptr;
      };

   public:
      friend class makVrv::DtReadSettingsLock<DtSharedModelSet>;
      friend class makVrv::DtWriteSettingsLock<DtSharedModelSet>;
      friend class makVrv::DtSharedSettingsManager;
      
      static std::string className();

      virtual ~DtSharedModelSet() override;

      virtual void setModelSet(DtModelSet*);

      virtual void clearModelSet();

      virtual bool load(const DtFilename&, std::set<DtString>& iconLists, bool signal = false);

      virtual void setVariableBindings(const DtRwVariableBindings*);
      const DtVariableBindingsSharedPtr& variableBindings() const
      {
         return myVariableBindings;
      }

      virtual void setSimulationModelSets(const std::vector<DtSimulationModelSet*>& sets);
      virtual const std::vector<DtSimulationModelSet*>& simulationModelSets() const;

      virtual void setSearchPaths(const DtReaderWriter::SearchPaths&);
      const DtReaderWriter::SearchPaths& searchPaths() const
      {
         return mySearchPaths;
      }

      virtual void addSimulationObjectGroupModelSetEntry(DtSimulationObjectGroupModelSetEntry* entry);

      virtual DtSimulationObjectGroupModelSetEntry findSimulationObjectGroup(const std::string& sogName) const;

      virtual void getSupportPoints(const DtEntityType& et,
         DtVector& left, DtVector& right, DtVector& other);

      virtual std::string getNavDataPath(const DtEntityType& et);

      virtual Dt3dBoundingVolume getBoundingVolume(const DtEntityMapperKey& et);

      virtual double getMaximumSpeed(const DtEntityType& et);

      virtual double getMinimumSpeed(const DtEntityType& et);

      virtual double getDefaultOrderedSpeed(const DtEntityType& et);

      virtual double getMaximumAcceleration(const DtEntityType& et);

      virtual double getMaximumDeceleration(const DtEntityType& et);

      virtual bool loadFromDataFiles(const DtFilename& entities, const DtFilename& platforms, std::set<DtString>& iconLists, bool signal = true, DtModelSet* preloadModelSet = 0);

      virtual void mergeFavorites(const DtModelSet* f);

      virtual bool hasComponentDescriptor(const DtEntityMapperKey&, const DtString& type);

      virtual std::vector<DtComponentDescriptor*> componentDescriptorsFrom(const DtEntityMapperKey&, const DtString& type);

      virtual DtEntityType nameToType(const DtString&) const;

      virtual DtModelSetEntry* modelSetEntry(const DtEntityMapperKey& key) const;

      virtual std::string additionalKeywords(const DtEntityMapperKey&) const;
      virtual void setAdditionalKeywords(const DtEntityMapperKey&, const std::string&, bool replace = false);

      virtual DtModelSetEntry* exactModelSetEntry(const DtEntityMapperKey& key) const;

      virtual bool canHoldSubordinates(const DtEntityMapperKey& key) const;

      virtual DtModelSetEntry* addModelSetEntry(const DtString& label, const DtEntityMapperKey&,
         const DtRwNLengthStringVector& cats);

      virtual void removeModelSetEntry(const DtEntityMapperKey& e);

      virtual std::string nameFor(const DtEntityMapperKey&) const;

      virtual std::string keywordsFor(const DtEntityMapperKey&) const;

      virtual DtModelSet* modelSet() const;
      
      virtual void statePropertiesFor(const DtEntityType&, DtRwProperties&) const;
      
      virtual void parameterPropertiesFor(const DtEntityType&, DtRwProperties&);
      
      virtual void statePropertiesForPlatform(const DtString&, DtRwProperties&) const;
      
      virtual void parameterPropertiesForPlatform(const DtString&, DtRwProperties&) const;

      virtual void parameterPropertiesFor(
         const std::set<DtSimObjectReference>& states, DtRwProperties&);

      virtual std::shared_ptr<DtReaderWriter> rwProperty(const DtEntityType&, const std::string& prop) const;

      bool addStateProperty(const DtEntityType& key, DtPropertyInterface* prop) const;

      virtual void loadPlatforms(const DtString&);

      virtual void clearPlatforms();

      virtual DtRwDIGuyCharacterInfo getDIGuyCharacterInformation(const DtEntityMapperKey&);

      virtual DtVrfObjectParameters* lookupParametersFor(DtModelSetEntry* entry);
      virtual DtVrfObjectParameters* lookupParametersFor(const DtEntityType&);

      virtual DtEntityType nextAvailableSimulationObjectGroupObjectType() const;

      virtual bool enabledRadarCoverageDescriptors(const DtEntityMapperKey&, std::vector<DtObjectSensorDescriptor*>&);

      typedef std::pair<DtString, unsigned> EquipmentTypeCountPair;
      struct ObjectTypeAndLabel
      {
         ObjectTypeAndLabel() {};
         ObjectTypeAndLabel(const DtEntityType& ot, const DtString& l,
            const DtString& c = DtString::nullString())
            : objectType(ot), label(l), category(c) {};

         DtEntityType objectType;
         DtString label;
         DtString category;
      };
      typedef std::multimap<EquipmentTypeCountPair, ObjectTypeAndLabel> EquipmentTypeMap;

      virtual EquipmentTypeMap baseEquipment(const DtEntityType&);

      virtual void signalLoaded();

   protected:
      DtSharedModelSet(makVrv::DtSharedSettingsManager&);

      typedef std::map<std::string, std::shared_ptr<DtReaderWriter> > PropertiesMap;

      struct PlatformStruct
      {
         DtFilename fullPath;
         PropertiesMap properties;
         DtVrfObjectParameters* parameters = nullptr;
      };

      typedef std::map<DtString, PlatformStruct> PlatformsMap;

      virtual PlatformsMap::const_iterator availablePlatform(const DtString& str) const;

      virtual void clearSimulationModelSets();

   protected:
      DtModelSet* myModelSet;

      mutable PlatformsMap myAvailablePlatforms;

      mutable tbb::spin_mutex theAvailablePlatformMutex;
      typedef std::map<DtModelSetEntry*, DtVrfObjectParameters*> ParameterData;

      ParameterData myParameterData;

      DtReaderWriter::SearchPaths mySearchPaths;

      class AdditionalKey : public DtEntityMapperKey
      {
      public:
         AdditionalKey(const DtEntityMapperKey& kw) : DtEntityMapperKey(kw) {};
         AdditionalKey(const AdditionalKey& orig) : DtEntityMapperKey(orig), myAdditionalKeywords(orig.myAdditionalKeywords) {};

         std::string myAdditionalKeywords;
      };

      typedef DtOrderedKeyList<AdditionalKey*> AdditionalKeywords;
      AdditionalKeywords myAdditionalKeywords;
      std::vector<DtSimulationModelSet*> mySimulationModelSets;

      DtVariableBindingsSharedPtr myVariableBindings;
      static std::mutex theSafetyMutex;
   };

   class DT_DLL_VRFGUICORE DtSharedModelSetSignaler : public makVrv::DtVirtualBaseClass
   {
   public:

      static DtSharedModelSetSignaler& instance(const makVrv::DtSharedSettingsManager&);

      static DtSharedModelSetSignaler& instance(makVrv::DtEventQueueInterface&);

      static DtSharedModelSetSignaler* findInstance(
         makVrv::DtEventQueueInterface*);

      virtual ~DtSharedModelSetSignaler() override;

      makVrv::event_signal<void()> signal_modelSetLoaded;

      makVrv::event_signal<void(std::vector<DtSimulationModelSet*>) > signal_simulationModelSetsChanged;

   protected:
      DtSharedModelSetSignaler(makVrv::DtEventQueueInterface& eqi);

   private:
      DtSharedModelSetSignaler(const DtSharedModelSetSignaler&);
      DtSharedModelSetSignaler& operator=(const DtSharedModelSetSignaler&);
   };
}