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 "vrfutil/vrfCallbackQueue.h"
#include <vl/reflectedObjectList.h>
#include "vrfStateData/stateData.h"
#include <boost/signals2.hpp>
#include <tbb/spin_mutex.h>

class DtVrfCallbackQueue;
class DtExerciseConn;
class DtReflectedObject;
class DtAggregateStateRepository;
class DtReflectedAggregate;
class DtReflectedExtEntity;
class DtReflectedExtAggregate;
class DtReflectedExtEntityList;
class DtReflectedVrfExtEntityList;
class DtReflectedExtAggregateList;
class DtReflectedEmitterSystemList;
class DtReflectedVrfExtAggregateList;
class DtReflectedEnvironmentProcess;
class DtBaseEntityStateRepository;
class DtReflectedControlObjectList;
class DtReflectedVrfControlObjectList;
class DtReflectedEntity;   
class DtReflectedDesignatorList;
class DtReflectedActiveSonar;
class DtReflectedActiveSonarList;
class DtReflectedPropulsionNoise;
class DtReflectedPropulsionNoiseList;
class DtReflectedEmitterSystem;
class DtReflectedIffList;
class DtReflectedIff;
class DtReflectedDesignator;
class DtReflectedRadioTransmitter;
class DtReflectedRadioReceiver;
class DtReflectedRadioTransmitterList;
class DtReflectedNavAidList;
class DtReflectedNavAid;
class DtReflectedRadioReceiverList;
class DtExerciseConn;
class DtReflectedDynamicTerrain;
class DtReflectedDynamicTerrainList;
class DtVrfParameterDb;
class DtReflectedEntityList;
class DtReflectedAggregateList;
class DtReflectedEnvironmentProcessList;

#include <boost/signal.hpp>

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

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

namespace makVrf
{
   class DtStateDataManager;
   class DtRemoteStateComponentNetInterface;
   class DtVrlinkNetworkInterface;

   class DT_DLL_vrlinkNetworkInterface DtRemoteObjectManager
   {
   public:

      DtRemoteObjectManager(DtVrlinkNetworkInterface*);

      virtual ~DtRemoteObjectManager();

      virtual void printReflectedObjectCounts() const;

      virtual void init(DtStateDataManager*, DtExerciseConn*, DtReflectedEntityList* = nullptr,
         DtReflectedAggregateList* = nullptr, DtReflectedEnvironmentProcessList* = nullptr
#if DtHLA
      , makVrfVrlinkExtToolkit::DtReflectedExtendedAttributesObjectList* lst = nullptr
#endif
      );
      virtual void setReflectedLists(DtReflectedEntityList* = nullptr,
         DtReflectedAggregateList* = nullptr, DtReflectedEnvironmentProcessList* = nullptr
#if DtHLA
      , makVrfVrlinkExtToolkit::DtReflectedExtendedAttributesObjectList* lst = nullptr
#endif
      );

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

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

      virtual bool acceptRemoteEnvironmental(const DtEntityType& et) const;

      virtual void requestUpdatesForRemoteNonVrfObjects() const;

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

      DtStateDataManager* stateDataManager()
      {
         return myStateDataManager;
      }

      DtReflectedExtEntityList* reflectedEntityList() const
      {
         return myRemoteEntitiesList;
      }

      DtReflectedExtAggregateList* reflectedAggregateList() const
      {
         return myRemoteAggregateEntitiesList;
      }

      DtReflectedControlObjectList* reflectedEnvironmentProcessList() const
      {
         return myRemoteEnvironmentalsList;
      }

      DtReflectedDesignatorList* reflectedDesignatorList() const
      {
         return myRemoteDesignatorsList;
      }

      DtReflectedActiveSonarList* reflectedActiveSonarList() const
      {
         return myRemoteActiveSonarList;
      }

      DtReflectedPropulsionNoiseList* reflectedPropulsionNoiseList() const
      {
         return myRemotePropulsionNoiseList;
      }

      DtReflectedRadioTransmitterList* reflectedRadioTransmitterList() const
      {
         return myRemoteTransmitterList;
      }

      DtReflectedNavAidList* reflectedNavAidTransmitterList() const
      {
         return myRemoteNavAidTransmitterList;
      }

      DtReflectedRadioReceiverList* reflectedRadioReceiverList() const
      {
         return myRemoteReceiverList;
      }

      DtReflectedDynamicTerrainList* reflectedDynamicTerrainList() const
      {
         return myReflectedDynamicTerrainList;
      }

      DtReflectedIffList* reflectedIffList() const
      {
         return myReflectedIffList;
      }

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

      virtual bool hasDiscoveryJobs() const;

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

      static int aggregateSuperType(DtAggregateStateRepository* aggregate);

      virtual bool selfReflecting() const;

      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 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 startingJob();
      virtual void stoppingJob();

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

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

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

      virtual bool processEntityDiscoveryCriteria(
         DtReflectedEntity* entity);

      virtual bool processAggregateDiscoveryCriteria(
         DtReflectedAggregate* aggregate); 

      virtual void createRemoteDesignatorsList(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 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 void grabUnhostedComponents(DtStateData*);

      virtual DtEntityType standardAggregateTypeToVrfAggregateType(const DtEntityType& aggType) const;

   protected:
      DtReflectedExtEntityList* myRemoteEntitiesList;
      bool myOwnsRemoteEntitiesList;

      DtReflectedExtAggregateList* myRemoteAggregateEntitiesList;
      bool myOwnsRemoteAggregateEntitiesList;

      DtReflectedControlObjectList* myRemoteEnvironmentalsList;
      bool  myOwnsRemoteEnvironmentalsList;

      DtReflectedDesignatorList* myRemoteDesignatorsList;

      DtReflectedActiveSonarList* myRemoteActiveSonarList;
      DtReflectedPropulsionNoiseList* myRemotePropulsionNoiseList;
      DtReflectedRadioTransmitterList* myRemoteTransmitterList;
      DtReflectedNavAidList* myRemoteNavAidTransmitterList;
      DtReflectedRadioReceiverList* myRemoteReceiverList;
      DtReflectedDynamicTerrainList* myReflectedDynamicTerrainList;

      DtReflectedIffList* myReflectedIffList;
      DtReflectedEmitterSystemList* myReflectedEmitterSystemList;

   #if DtHLA
      makVrfVrlinkExtToolkit::DtReflectedExtendedAttributesObjectList* myRemoteExtendedAttributesObjectsList;
      bool myOwnsRemoteExtendedAttributesObjectsList;
   #endif

      DtExerciseConn* myExerciseConnection;
      DtStateDataManager* myStateDataManager;

      bool myEnabled;
      DtVrlinkNetworkInterface* myVrlinkNetworkInterface;
      DtSimulationAddress mySimulationAddress;

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

      struct ReflectedObjectInformation
      {
         boost::signals2::connection deleteObjectConnection;
         DtFrameStateInterface* frameStateInterface;
         DtRemoteStateComponentNetInterface* remoteStateComponentNetInterface;
      };

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

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

      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;

      struct DiscoveryCondition
      {
         DiscoveryCondition() : fcn(nullptr), userData(nullptr) {};
         void clear() { fcn = nullptr; userData = nullptr; };
         DtDiscoveryCondition fcn;
         void* userData;
      };

      DiscoveryCondition myAdditionalRemoteEnvironmentalDiscoveryCondition;
      DiscoveryCondition myAdditionalRemoteEntityDiscoveryCondition;
      DiscoveryCondition myAdditionalRemoteAggregateDiscoveryCondition;

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

      DtVrfCallbackQueue myJobProcessor;

      std::vector<unsigned long long> myStateDataToRemove;
#if DtDIS
      int myDefaultObjectTimeout;
#endif

      std::set<DtGlobalObjectDesignator> myJustDeleted;
      tbb::atomic<int> myJobCount;
   };
}