remoteObjectManager.h

Go to the documentation of this file.

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

#pragma once

#include "vrlinkNetworkInterface/vrlinkNetworkInterfaceDefines.h"
#include "vrlinkNetworkInterface/simObjectNetInterface.h"
#include "vrlinkNetworkInterface/reflectedObjectLists.h"
#include "vrfutil/vrfCallbackQueue.h"
#include "vlutil/vlPerformanceStats.h"
#include "vrfStateData/stateData.h"
#include <tbb/spin_mutex.h>
#include <unordered_map>
#include <vlpi/metocEnums.h>
#include <vrfutil/profiler.h>
#include <vrfutil/predefinedEntityTypes.h>
#include <vrvUtil/signalslib.h>

class DtTimeAndDateStateRepository;
class DtVrfCallbackQueue;
class DtReflectedDIGuyObject;
class DtExerciseConn;
class DtReflectedObject;
class DtReflectedAerodrome;
class DtAggregateStateRepository;
class DtReflectedRectangularPyramid;
class DtReflectedAggregate;
class DtReflectedExtEntity;
class DtReflectedExtAggregate;
class DtReflectedVrfExtAggregateList;
class DtReflectedEnvironmentProcess;
class DtBaseEntityStateRepository;
class DtReflectedControlObjectList;
class DtReflectedVrfControlObjectList;
class DtReflectedEntity;   
class DtReflectedActiveSonar;
class DtReflectedPropulsionNoise;
class DtReflectedEmitterSystem;
class DtReflectedIff;
class DtReflectedDesignator;
class DtReflectedRadioTransmitter;
class DtReflectedRadioReceiver;
class DtReflectedNavAid;
class DtExerciseConn;
class DtReflectedDynamicTerrain;
class DtVrfParameterDb;
class DtReflectedEntityList;

#if DtHLA_1516_EVOLVED
#include <tbb/queuing_mutex.h>
#include <atomic>
#endif

#if DtHLA
namespace makVrfVrlinkExtToolkit
{
   class DtReflectedExtendedAttributesObject;
   class DtReflectedExtendedAttributesObjectList;
}
#endif

namespace makVrf
{
   class DtRemoteEnvironmentManager;
   class DtRemoteObjectManager;

   class DtStateDataManager;
   class DtRemoteStateComponentNetInterface;
   class DtVrlinkNetworkInterface;

   class DT_DLL_vrlinkNetworkInterface DtRemoteObjectManager
   {
   public:

      typedef std::map< DtReflectedObject*, DtSimObjectNetInterface* > InterfacesByReflectedObjectMap;

      DtRemoteObjectManager(DtVrlinkNetworkInterface*);

      virtual ~DtRemoteObjectManager();

      virtual void printReflectedObjectCounts() const;

      virtual void init(DtStateDataManager*, DtExerciseConn*, const DtReflectedObjectLists&);
      virtual void setReflectedLists(const DtReflectedObjectLists& lists);

#if DtHLA
      virtual void setRequestUpdates(bool shouldRequestUpdates);
#endif
      virtual void beginFrame();
      virtual void beginFrame(DtVrfCallbackQueue*);

      virtual void advanceFrame(DtVrfCallbackQueue*);

      virtual void finishFrame();

      virtual bool stateDataAboutToBeRemoved(const DtStateData* sd);

      virtual void setParameterDatabase(DtVrfParameterDb*);

      virtual bool hasDiscoveredObjects() const;

      virtual void setPreferredDateAndTimeRepository(DtTimeAndDateStateRepository*);

#if DtDIS
      virtual void setDefaultObjectTimeout(int);
      int defaultObjectTimeout() const
      {
         return myDefaultObjectTimeout;
      }
      virtual void setDisableTimeoutProcessing(bool);
      bool timeoutProcessingDisabled() const
      {
         return myDisableTimeoutProcessing;
      }
#endif

      virtual bool acceptRemoteEnvironmental(const DtEntityType& et) const;

      virtual void requestUpdatesForRemoteNonVrfObjects() const;

      virtual bool waitingToAddObjects() const;

      virtual DtReflectedObject* reflectedObjectFor(const DtGlobalObjectDesignator&) const;

      virtual void lostControlOf(DtReflectedObject*);
      virtual void lostControlOf(DtReflectedDIGuyObject*);

#if DtHLA
      virtual void lostControlOf(makVrfVrlinkExtToolkit::DtReflectedExtendedAttributesObject*);

      virtual DtReflectedObject* gainControlOfExtendedAttribute(DtHlaObject*);
      virtual void gainedConntrolOfUnknownHlaObject(DtHlaObject*);
#endif

      virtual void gainControlOf(const DtGlobalObjectDesignator&);

#if DtHLA
      virtual DtUUID uuidFor(DtHlaObject*) const;
#endif

      virtual void setEnabled(bool);
      bool enabled() const
      {
         return myEnabled;
      }

      DtStateDataManager* stateDataManager()
      {
         return myStateDataManager;
      }

      DtReflectedAerodromeList* reflectedAerodromeList() const
      {
         return myReflectedLists.reflectedAerodromesList.reflectedList;
      }

      DtReflectedEntityList* reflectedEntityList() const
      {
         return myReflectedLists.reflectedEntitiesList.reflectedList;
      }

      DtReflectedAggregateList* reflectedAggregateList() const
      {
         return myReflectedLists.reflectedAggregatesList.reflectedList;
      }

      DtReflectedEnvironmentProcessList* reflectedEnvironmentProcessList() const
      {
         return myReflectedLists.reflectedEnvironmentalsList.reflectedList;
      }

      DtReflectedDesignatorList* reflectedDesignatorList() const
      {
         return myReflectedLists.reflectedDesignatorsList.reflectedList;
      }

      DtReflectedActiveSonarList* reflectedActiveSonarList() const
      {
         return myReflectedLists.reflectedActiveSonarList.reflectedList;
      }

      DtReflectedPropulsionNoiseList* reflectedPropulsionNoiseList() const
      {
         return myReflectedLists.reflectedPropulsionNoiseList.reflectedList;
      }

      DtReflectedRadioTransmitterList* reflectedRadioTransmitterList() const
      {
         return myReflectedLists.reflectedRadioTransmitterList.reflectedList;
      }

      DtReflectedNavAidList* reflectedNavAidTransmitterList() const
      {
         return myReflectedLists.reflectedNavAidTransmitterList.reflectedList;
      }

      DtReflectedRadioReceiverList* reflectedRadioReceiverList() const
      {
         return myReflectedLists.reflectedRadioReceiverList.reflectedList;
      }

      DtReflectedDynamicTerrainList* reflectedDynamicTerrainList() const
      {
         return myReflectedLists.reflectedDynamicTerrainList.reflectedList;
      }

      DtReflectedIffList* reflectedIffList() const
      {
         return myReflectedLists.reflectedIffList.reflectedList;
      }

      const DtReflectedObjectLists& reflectedLists() const
      {
         return myReflectedLists;
      }

      virtual bool hasNetworkRepresentation(const DtUUID&) const;

      virtual void setLongScenarioLoadDiscoveryTime(double);
      double longScenarioLoadDiscoveryTime() const
      {
         return myLongScenarioLoadDiscoveryTime;
      }

      virtual void setBulkAddTimeout(double);
      virtual double bulkAddTimeout() const
      {
         return myBulkAddTimeout;
      }

      DtExerciseConn* exerciseConnection() const
      {
         return myExerciseConnection;
      }

      virtual void setStaticObjectDiscoveryTime(double);
      double staticObjectDiscoveryTime() const
      {
         return myStaticObjectDiscoveryTime;
      }

      virtual void setDynamicTerrainStateData(DtStateData*);
      virtual bool finishDiscovery();
      virtual void setNumCallbackThreads(int);


      virtual DtGlobalObjectDesignator entityThatHostsRadio(const DtGlobalObjectDesignator&, int radioIndex) const;

   protected:
      virtual bool isLocal(const DtBaseEntityStateRepository& stateRep);

      virtual bool selfReflecting() const;

      virtual void processAerodromeAddedCallback(DtReflectedAerodrome* entity);
      virtual void processAerodromeRemovedCallback(DtReflectedAerodrome* entity);
      virtual bool initializeRemoteAerodrome(DtStateData*, DtReflectedAerodrome*);

      virtual DtReflectedControlObjectList* createReflectedControlObjectList(DtExerciseConn* exConn);
      virtual void createRemoteEnvironmentalsList(DtExerciseConn* exConn);

      friend class RemoteEntityCreator; 
      virtual void processEntityAddedCallback(DtReflectedExtEntity* entity);
      virtual bool initializeRemoteEntity(DtStateData*, DtReflectedExtEntity*);

      friend class RemoteAggregateCreator; 
      virtual void processAggregateAddedCallback(DtReflectedExtAggregate* aggregate);
      virtual bool initializeRemoteAggregate(DtStateData*, DtReflectedExtAggregate*);

      virtual void processEntityRemovedCallback(DtReflectedExtEntity* entity);
      virtual void processAggregateRemovedCallback(DtReflectedExtAggregate* aggregate);

      virtual void processDesignatorAddedCallback(DtReflectedDesignator * des);
      virtual void processDesignatorRemovedCallback(DtReflectedDesignator * des);
      virtual DtBoolean processDesignatorDiscoveryCriteria(DtReflectedDesignator * des);

      virtual void processRectangularPyramidAddedCallback(DtReflectedRectangularPyramid * des);
      virtual void processRectangularPyramidRemovedCallback(DtReflectedRectangularPyramid * des);
      virtual DtBoolean processRectangularPyramidDiscoveryCriteria(DtReflectedRectangularPyramid * des);

      virtual void processActiveSonarAddedCallback(DtReflectedActiveSonar* des);
      virtual void processActiveSonarRemovedCallback(DtReflectedActiveSonar* des);
      virtual DtBoolean processActiveSonarDiscoveryCriteria(DtReflectedActiveSonar* des);

      virtual void processPropulsionNoiseAddedCallback(DtReflectedPropulsionNoise* des);
      virtual void processPropulsionNoiseRemovedCallback(DtReflectedPropulsionNoise* des);
      virtual DtBoolean processPropulsionNoiseDiscoveryCriteria(DtReflectedPropulsionNoise* des);

      virtual void processRadioTransmitterAddedCallback(DtReflectedRadioTransmitter* tran);
      virtual void processRadioTransmitterRemovedCallback(DtReflectedRadioTransmitter* tran);
      virtual DtBoolean processRadioTransmitterDiscoveryCriteria(DtReflectedRadioTransmitter*);

      virtual void processNavAidTransmitterAddedCallback(DtReflectedNavAid* tran);
      virtual void processNavAidTransmitterRemovedCallback(DtReflectedNavAid* tran);
      virtual DtBoolean processNavAidRadioTransmitterDiscoveryCriteria(DtReflectedNavAid*);

      virtual void processRadioReceiverAddedCallback(DtReflectedRadioReceiver* tran);
      virtual void processRadioReceiverRemovedCallback(DtReflectedRadioReceiver* tran);

      virtual void processIffAddedCallback(DtReflectedIff* des);
      virtual void processIffRemovedCallback(DtReflectedIff* des);
      virtual DtBoolean processIffDiscoveryCriteria(DtReflectedIff*);

      virtual void processEmitterSystemAddedCallback(DtReflectedEmitterSystem* des);
      virtual void processEmitterSystemRemovedCallback(DtReflectedEmitterSystem* des);
      virtual DtBoolean processEmitterSystemDiscoveryCriteria(DtReflectedEmitterSystem*);

      friend class RemoteEnvironmentalCreator; 
      virtual void processEnvProcessAddedCallback(DtReflectedEnvironmentProcess* envProcess);
      virtual bool initializeRemoteEnvProcess(DtStateData*, DtReflectedEnvironmentProcess*);

      virtual void processEnvProcessRemovedCallback(DtReflectedEnvironmentProcess* envProcess);
      virtual bool processEnvProcessDiscoveryCriteria(DtReflectedEnvironmentProcess* envProcess);

      virtual void createRemoteEntitiesList(DtExerciseConn* exConn);
      virtual void createRemoteAggregatesList(DtExerciseConn* exConn);
      virtual void createRemoteAerodromesList(DtExerciseConn* exConn);

      static void aerodromeAddedCallback(DtReflectedAerodrome*, void* userData);
      static void aerodromeRemovedCallback(DtReflectedAerodrome*, void* userData);

      static void entityAddedCallback(DtReflectedExtEntity* entity, void* userData);

      static void entityRemovedCallback(DtReflectedExtEntity* entity,
         void* userData);

      static void aggregateAddedCallback(DtReflectedExtAggregate* entity,
         void* userData);

      static void aggregateRemovedCallback(DtReflectedExtAggregate* entity,
         void* userData);

      static bool entityDiscoveryCriteriaCallback(DtReflectedObject* entity,
         void* userData);

      static bool aggregateDiscoveryCriteriaCallback(DtReflectedObject* aggregate,
         void* userData);

      static bool aerodromeDiscoveryCriteriaCallback(DtReflectedObject* aggregate,
         void* userData);

      virtual bool processEntityDiscoveryCriteria(
         DtReflectedEntity* entity);

      virtual bool processAggregateDiscoveryCriteria(
         DtReflectedAggregate* aggregate); 

      virtual bool processAerodromeDiscoveryCriteria(
         DtReflectedAerodrome* aggregate); 

      virtual void createRemoteDesignatorsList(DtExerciseConn* exConn);
      virtual void createRemoteRectangularPyramidList(DtExerciseConn* exConn);
      virtual void createRemoteActiveSonarList(DtExerciseConn* exConn);
      virtual void createRemotePropulsionNoiseList(DtExerciseConn* exConn);
      virtual void createRemoteRadioTransmitterList(DtExerciseConn* exConn);
      virtual void createRemoteNavAidTransmitterList(DtExerciseConn* exConn);
      virtual void createRemoteRadioReceiverList(DtExerciseConn* exConn);
      virtual void createRemoteEmitterSystemList(DtExerciseConn* exConn);
      virtual void createRemoteIffList(DtExerciseConn* exConn);
      virtual void createReflectedDynamicTerrainList(DtExerciseConn* exConn);

   #if DtHLA
      virtual void createRemoteExtendedAttributesList(DtExerciseConn* exConn);
   #endif
      static void rectangularPyramidAddedCallback(DtReflectedRectangularPyramid * des,
         void * userData);
      static void rectangularPyramidRemovedCallback(DtReflectedRectangularPyramid * des,
         void * userData);
      static DtBoolean rectangularPyramidDiscoveryCriteriaCallback(DtReflectedObject * des,
         void * userData);

      static void designatorAddedCallback(DtReflectedDesignator * des,
         void * userData);

      static void designatorRemovedCallback(DtReflectedDesignator * des,
         void * userData);

      static DtBoolean designatorDiscoveryCriteriaCallback(DtReflectedObject * des,
         void * userData);

      static void activeSonarAddedCallback(DtReflectedActiveSonar* activeSonar,
         void* userData);
      static void activeSonarRemovedCallback(DtReflectedActiveSonar* activeSonar,
         void* userData);
      static DtBoolean activeSonarDiscoveryCriteriaCallback(
         DtReflectedObject* activeSonar, void* userData);

      static void propulsionNoiseAddedCallback(DtReflectedPropulsionNoise* propNoise,
         void* userData);
      static void propulsionNoiseRemovedCallback(DtReflectedPropulsionNoise* propNoise,
         void* userData);
      static void propulsionNoiseChangedCallback(DtReflectedPropulsionNoise* propNoise,
         void* userData);
      static DtBoolean propulsionNoiseDiscoveryCriteriaCallback(
         DtReflectedObject* propNoise, void* userData);

      static void radioTransmitterAddedCallback(DtReflectedRadioTransmitter* transmitter,
         void* userData);
      static void radioTransmitterRemovedCallback(DtReflectedRadioTransmitter* transmitter,
         void* userData);
      static DtBoolean radioTransmitterDiscoveryCriteriaCallback(DtReflectedObject* des, void*);

      static void navAidTransmitterAddedCallback(DtReflectedNavAid* transmitter,
         void* userData);
      static void navAidTransmitterRemovedCallback(DtReflectedNavAid* transmitter,
         void* userData);
      static DtBoolean navAidRadioTransmitterDiscoveryCriteriaCallback(DtReflectedObject* des, void*);

      static void radioReceiverAddedCallback(DtReflectedRadioReceiver* transmitter,
         void* userData);
      static void radioReceiverRemovedCallback(DtReflectedRadioReceiver* transmitter,
         void* userData);

      static void iffAddedCallback(DtReflectedIff* propNoise,
         void* userData);
      static void iffRemovedCallback(DtReflectedIff* propNoise,
         void* userData);
      static DtBoolean iffDiscoveryCriteriaCallback(
         DtReflectedObject* iff, void* userData);

      static void emitterSystemAddedCallback(DtReflectedEmitterSystem* propNoise,
         void* userData);
      static void emitterSystemRemovedCallback(DtReflectedEmitterSystem* propNoise,
         void* userData);
      static DtBoolean emitterSystemDiscoveryCriteriaCallback(
         DtReflectedObject* iff, void* userData);

      static void envProcessAddedCallback(
         DtReflectedEnvironmentProcess* envProcess, void* userData);
      static void envProcessRemovedCallback(
         DtReflectedEnvironmentProcess* envProcess, void* userData);
      static bool envProcessDiscoveryCriteria(
         DtReflectedObject* envProcess, void* userData);

      virtual void cleanup();
   
      virtual void stateComponentToBeDeleted(DtFrameStateInterface*);

      virtual void removeReflectedComponentObject(DtReflectedObject*);


      static void dynamicTerrainObjectAddedCallback(DtReflectedDynamicTerrain* object, void* usr);
      virtual void processDynamicTerrainObjectAdded(DtReflectedDynamicTerrain* object);

      virtual DtBoolean processReflectedDynamicTerrainDiscoveryCriteria(DtReflectedDynamicTerrain*);
      static DtBoolean reflectedDynamicTerrainDiscoveryCriteriaCallback(
         DtReflectedObject*, void* userData);


      static void dynamicTerrainObjectRemovedCallback(DtReflectedDynamicTerrain* object, void* usr);
      virtual void processDynamicTerrainObjectRemoved(DtReflectedDynamicTerrain* object);

      virtual bool createUnhostedComponent(DtReflectedObject* obj, const DtString& hostId, int componentType, const char* componentInterfaceType);

      virtual bool createRemoteHostedComponent(DtReflectedObject* obj, const DtString& hostId, int componentType, const char* componentInterfaceType);

      virtual void grabUnhostedComponents(DtStateData*);

      virtual DtEntityType standardAggregateTypeToVrfAggregateType(const DtEntityType& aggType) const;

      virtual void checkDiscoveryForHostedObjects();

   protected:
      DtReflectedObjectLists myReflectedLists;

   #if DtHLA
      makVrfVrlinkExtToolkit::DtReflectedExtendedAttributesObjectList* myLastAssociatedList = nullptr;
   #endif

      DtExerciseConn* myExerciseConnection;
      DtStateDataManager* myStateDataManager;

      bool myEnabled;
      DtVrlinkNetworkInterface* myVrlinkNetworkInterface;
      DtSimulationAddress mySimulationAddress;

      template <typename T_Exec>
      class DtVrfPublisherContainer : public DtPublisherContainer<T_Exec>
      {
      public:
         int size() const { return DtPublisherContainer<T_Exec>::myExecVec.size(); };
      };

      typedef DtVrfPublisherContainer<DtSimObjectNetInterface> PublisherContainer;
      tbb::spin_mutex myInterfacesMutex;
      PublisherContainer myInterfaces;
      typedef std::map<makVrf::SimStateID, std::pair<DtReflectedObject*, DtSimObjectNetInterface*> > RemoteInterfacesById;
      RemoteInterfacesById myRemoteInterfacesById;

      struct ReflectedObjectInformation
      {
         makVrv::vrvSignalsLib::connection deleteObjectConnection;
         DtFrameStateInterface* frameStateInterface;
         DtRemoteStateComponentNetInterface* remoteStateComponentNetInterface;
      };

      typedef std::map<unsigned long long, std::set<uintptr_t>> InterfacesByStateData;
      InterfacesByStateData myInterfacesByStateData;

      typedef std::map<uintptr_t, ReflectedObjectInformation> ReflectedObjectToComponentMap;
      ReflectedObjectToComponentMap myReflectedObjectToComponentMap;

      typedef std::map<uintptr_t, DtSimObjectNetInterface*> RemoteInterfacesByReflectedObject;
      RemoteInterfacesByReflectedObject myRemoteInterfacesByReflectedObject;

      typedef std::map<DtUUID, DtSimObjectNetInterface*> RemoteInterfacesByUUID;
      RemoteInterfacesByUUID myRemoteInterfacesByUUID;

      DtStateData* myDynamicTerrainStateData;

      typedef std::vector<DtStateComponent*> StateComponentVector;
      typedef std::map<DtString, StateComponentVector> UnhostedComponents;
      UnhostedComponents myUnhostedComponents;
      DtVrfParameterDb* myParameterDatabase;

      typedef std::map<DtString, std::vector<DtReflectedObject*> > AwaitingReflectedTransmitters;
      AwaitingReflectedTransmitters myReflectedRadioTransmitters;
      AwaitingReflectedTransmitters myNavAidReflectedRadioTransmitters;

      typedef std::map<DtString, DtStateData*> UnhostedStateData;
      UnhostedStateData myUnhostedStateData;

      bool myQueueJobs = false;

      std::unordered_map<DtUUID, unsigned long long> myStateDataToRemove;
#if DtDIS
      int myDefaultObjectTimeout;
      bool myDisableTimeoutProcessing = false;
#endif

      std::set<DtGlobalObjectDesignator> myJustDeleted;

      struct CreationInfo
      {
         CreationInfo() : uuid(DtUUID::nullUUID()) {};
         CreationInfo(const DtEntityType& o, const DtUUID& u) : objectType(o), uuid(u) {};
         DtEntityType objectType;
         DtUUID uuid;
      };

      typedef std::map<DtReflectedObject*, CreationInfo> ObjectsToCreate;
      ObjectsToCreate myPendingEntityJobs;
      ObjectsToCreate myPendingAggregateJobs;
      ObjectsToCreate myPendingEnvironmentalJobs;
      mutable DtTimedSection myDiscoveryTimer;
      mutable double myTimeSinceLastObjectDiscovery = 0.;
      mutable double myTotalTimeSinceLastAddition = 0.;
      double myLongScenarioLoadDiscoveryTime = 10.;
      double myStaticObjectDiscoveryTime = 0.50;
      int myMaxJobs = -1;
      mutable int myLastJobCount = 0;
      double myBulkAddTimeout = 1.0 / 10.0;
   };
}