vrlinkNetworkInterface.h

Go to the documentation of this file.

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

#pragma once

#include "vrlinkNetworkInterface/vrlinkNetworkInterfaceDefines.h"
#include "vrfMsgTransport/networkManagerInterface.h"
#include <vrlinkNetworkInterface/simObjectNetInterface.h>
#include <vrlinkNetworkInterface/simObjectNetInterfaceFactory.h>
#include <vrlinkNetworkInterface/simObjectNetInterface.h>
#include "vrlinkNetworkInterface/reflectedObjectLists.h"
#include "vrlinkNetworkInterface/defaultSimulationModelSetValidatorManager.h"
#include <vrfGuiCore/orderedEntityTypeList.h>
#include <vrfStateData/stateComponent.h>
#include "vrfutil/fastForwardSettings.h"
#include "vrfutil/vrfCallbackQueue.h"
#include <vl/globalObjectDesignator.h>
#include <vl/vrlinkStateStateRepository.h>
#include <tbb/spin_mutex.h>
#include <tbb/mutex.h>
#include <map>
#include <set>
#include <atomic>
#include <tbb/tbb_thread.h>
#include <boost/function.hpp>

class DtExerciseConn;
class DtExerciseClock;
class DtVrfParameterDb;
class DtVrfObjectParameters;
class DtObjectType;
class DtVrfObjectIdGenerator;
class DtReflectedEntityList;
class DtReflectedAggregateList;
class DtReflectedAerodromeList;
class DtReflectedEnvironmentProcessList;
class DtGeoReferenceVariant;

namespace makVrf
{
   class DtRemoteObjectManager;
   class DtVrfEntityIdentifierFactory;
   class DtVrlinkNetworkInterface;
   class DtVrlinkEventTranslatorManager;
   class DtVrlinkEventTranslator;
   class DtStateDataManager;
#if DtHLA
   class DtHlaExerciseClock;
#endif

   typedef DtVrlinkNetworkInterface* (*DtVrlinkNetworkInterfaceCreatorFcn)(DtExerciseConn*, bool);
   typedef DtRemoteObjectManager* (*DtRemoteObjectManagerCreatorFcn)(DtVrlinkNetworkInterface*);

   class DT_DLL_vrlinkNetworkInterface DtVrlinkNetworkInterface : public DtNetworkManagerInterface
   {
   public:
      class DefaultNetworkInterfaceEntry
      {
      public:
         DtString local;
         DtString remote;
      };


   public:
      typedef DtPublisherContainer<DtSimObjectNetInterface> PublisherContainer;

      DtVrlinkNetworkInterface(DtExerciseConn*, int clockMode = 0);

      virtual ~DtVrlinkNetworkInterface();

      virtual void beginFrame(double) override;
      virtual bool preAdvanceFrame() override;
      virtual void advanceFrame(double* networkTime = nullptr) override;

      virtual void setBlockOnUnfinishedRemoteDiscovery(bool);
      bool blockOnUnfinishedRemoteDiscovery() const
      {
         return myBlockOnUnfinishedRemoteDiscovery;
      }

      static void SetRemoteObjectManagerCreatorFcn(DtRemoteObjectManagerCreatorFcn);
      static DtRemoteObjectManagerCreatorFcn RemoteObjectManagerCreatorFcn();

      virtual const char* type() const { return Type(); };
      static const char* Type() { return "vrlink-network-interface"; };

      virtual bool printDataToStream(const DtUUID&, DtOutputStream& stream) const;

      virtual void setInterest(const DtVector& geocentricCenter, double radius);
      
      virtual DtUUID entityThatHostsRadio(const DtGlobalObjectDesignator&, int radioIndex) const;

      virtual DtGlobalObjectDesignator radioGlobalObjectDesignatorFor(const DtUUID& entityUUID, int radioIndex, bool* radioFound = nullptr) const;

      virtual DtStateData* stateDataForGlobalId(const DtString&) const;
      virtual DtStateData* stateDataForEntityId(const DtString&) const;
      virtual const DtStateData* stateDataForUUID(const DtUUID&) const;
      virtual DtStateData* stateDataForUUID(const DtUUID&);

      virtual DtUUID uuidForGeoReferenceVariant(const DtGeoReferenceVariant& georeference) const;
      virtual DtStateData* stateDataForGeoReferenceVariant(const DtGeoReferenceVariant&) const;
      virtual void mapStateDataByGeoReferenceVariant(DtStateData* std, const DtGeoReferenceVariant& grv);
      virtual bool unmapStateDataByGeoReferenceVariant(const DtGeoReferenceVariant& grv);

      virtual void setExerciseStartTime(double);
      virtual void setSimTime(double);
      virtual void setTimeMultiplier(double);

      virtual void resetSimulation();

      virtual void setControlsDrainInput(bool);
      bool controlsDrainInput() const;

      virtual std::string protocol() const override
      {
#if DtDIS == 1
         return std::string("DIS");
#elif DDtHLA_1516_EVOLVED == 1
         return std::string("HLA1516e");
#elif DDtHLA_1516 == 1
         return std::string("HLA1516");
#else //This is HLA13
         return std::string("HLA13");
#endif
      }

   #if DtHLA
      virtual bool runningInTimeManagedMode() const;

      static void startTimeManagement(void* usr);
      static void stopTimeManagement(void* usr);

      virtual void processStartTimeManagement();
      virtual void processStopTimeManagement();

      virtual void setReflectedListRequestUpdates(bool yesOrNo);
   #endif

      virtual void setMetocPublishingEnabled(bool);
      bool metocPublishingEnabled() const
      {
         return true; 
      }

      virtual void setDisableRemoteDiscovery(bool);
      bool disableRemoteDiscovery() const
      {
         return myDisableRemoteDiscovery;
      }

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

      struct ComponentTypeUserData : public ComponentRuleUserData
      {
         ComponentTypeUserData(DtStateComponent::StateComponentType t) : type(t) {};
         ComponentTypeUserData(const ComponentTypeUserData& orig) : type(orig.type) {};
         virtual ComponentRuleUserData* clone() const { return new ComponentTypeUserData(*this); };

         DtStateComponent::StateComponentType type;
      };

      typedef boost::function<bool (const DtStateComponent*, const DtStateData*, std::shared_ptr<ComponentRuleUserData>)> CreationRule;
      virtual void setComponentPublisherCreatorRule(CreationRule, const DtString& networkInterface, const ComponentRuleUserData& userData = ComponentRuleUserData(),
         const DtString& testBeforeInterface = "");

      virtual bool createInterfaceIfComponentIs(const DtStateComponent* c, const DtStateData* d, std::shared_ptr<ComponentRuleUserData>);

      virtual DtSimObjectNetInterface* createNetInterface(DtStateData* sd);

      virtual void reserveEntityId(const DtEntityIdentifier&);

      virtual void setRunFullyThreaded(bool);
      virtual bool runFullyThreaded() const;

      virtual void setEnabled(bool);

      virtual void setCoordinateSystem(const Coordinate_System*);
      const Coordinate_System* coordinateSystem() const
      {
         return myCoordinateSystem;
      }

      DtExerciseConn* exerciseConnection()
      {
         return myExerciseConnection;
      }

      virtual void removeAndDeleteAll();
      virtual bool wantsToSelfReflect(unsigned int) const;

      virtual bool selfReflecting() const;

      virtual void setSelfReflecting(bool) {};

      virtual void setParameterDatabase(DtVrfParameterDb*db);
      DtVrfParameterDb* parameterDatabase() const
      {
         return myParameterDatabase;
      }

      virtual unsigned int maxNameLengthForType(const DtObjectType&) const;

      virtual void setVrfSessionId(int);
      virtual int vrfSessionId() const
      {
         return myVrfSessionId;
      }

      virtual void setVrfMessageVersionSupported(int);
      virtual int vrfMessageVersionSupported() const
      {
         return myVrfMessageVersionSupported;
      }

      virtual void setPublishZeroVelocityWhenPaused(bool);
      bool publishZeroVelocityWhenPaused() const
      {
         return myPublishZeroVelocityWhenPaused;
      }

      unsigned int simMgmtPduProcessLevel() const
      {
         return mySimMgmtPduProcessLevel;
      }

      virtual void setSimMgmtPduProcessLevel(unsigned int level);

      virtual void setDeadReckoningAlgorithmToStaticOnPause(bool);
      bool setDeadReckoningAlgorithmToStaticOnPause() const
      {
         return mySetDeadReckoningAlgorithmToStaticOnPause;
      }

      virtual void overrideDeadReckoningAlgorithm(int drAlg);

      virtual bool isDeadReckonAlgorithmOverridden(int& drAlg) const;
   
      virtual void removeDeadReckoningAlgorithmOverride();

      virtual DtEntityIdentifier nextEntityIdentifier(const DtStateData* = 0, const DtEntityIdentifier& = DtEntityIdentifier());

      virtual DtEntityIdentifier objectIdentifierFor(SimStateID) const;
      virtual DtEntityIdentifier objectIdentifierFor(const DtUUID&) const;

   #if DtDIS
      virtual DtEntityIdentifier globalObjectIdentifierFor(const DtUUID&) const;
      virtual DtEntityIdentifier globalObjectIdentifierFor(SimStateID) const;
   #else
      virtual DtGlobalObjectDesignator globalObjectIdentifierFor(const DtUUID&) const;
      virtual DtGlobalObjectDesignator globalObjectIdentifierFor(SimStateID) const;
   #endif

      virtual DtUUID uuidForObjectIdentifier(const DtEntityIdentifier&) const;

   #if DtHLA
      virtual DtUUID uuidForObjectIdentifier(const DtGlobalObjectDesignator&) const;
   #endif

      virtual void setSiteAppId(int, int);

      virtual DtString nextEventId(const DtString& entId = DtString::nullString()) override;

      virtual int setAppIdRangeMax(int);

      virtual DtVrfEntityIdentifierFactory* createVrfEntityIdentifierFactory();

      virtual void startScenarioLoad(bool);

      virtual void endScenarioLoad(bool);

      virtual AddEventResult addEvent(const makVrfEvents::DtEvent&, bool& selfReflect);
      virtual AddEventResult sendEvent(const makVrfEvents::DtEvent&);

      virtual double determineSimTime(double& dt, DtCommunicationManagerPerformanceTimerInformation* performanceTimerInformation = nullptr) override;

      virtual double simTime() const;

      virtual void setMaxDrainInputTime(double maxTime);
      virtual double maxDrainInputTime() const;

      virtual void setFrameRateMode(const DtString& mode, double deltaTime, bool manageTime = false);
      virtual void rewindScenario();

   #ifdef DtHLA
      virtual void setMinDrainInputTime(double minTime);
      virtual double minDrainInputTime() const;

      virtual void setFrameDeltaTime(double);
      virtual double frameDeltaTime() const;

      virtual void beginBulkCreate() override;
      virtual void endBulkCreate() override;
   #else
      virtual void setMaxDrainInputReads(int maxReads);
      virtual int maxDrainInputReads() const;
   #endif

      virtual void addEventTranslator(int eventType, DtVrlinkEventTranslator*);

      virtual void removeEventTranslator(int eventType);

      virtual DtVrlinkEventTranslator* eventTranslatorFor(int eventType) const;

      virtual void run();

      virtual void pause();

      static void setVrlinkNetworkInterfaceCreatorFcn(DtVrlinkNetworkInterfaceCreatorFcn fcn);
      static DtVrlinkNetworkInterface* createVrlinkNetworkInterface(DtExerciseConn*, int clockMode = 0);

      virtual bool typeIsPublishable(const DtEntityType&) const { return true; };

      virtual void setEventManager(makVrfEvents::DtEventManager*);
      makVrfEvents::DtEventManager* eventManager()
      {
         return myEventManager;
      }
   
      DtCommunicationManager* communicationManager()
      {
         return myCommunicationManager;
      }

      DtRemoteObjectManager* remoteObjectManager()
      {
         return myRemoteObjectManager;
      }

      virtual void setNumCallbackThreads(unsigned);

      virtual void setNumRemoteCallbackThreads(unsigned);

      virtual void addDefaultNetworkInterface(const DtEntityType&, const DtString& local, const DtString& remote);
      virtual void removeDefaultNetworkInterface(const DtEntityType&);

      virtual DtString defaultInterfaceTypeFor(const DtStateData*) const;

      virtual void setUseNetworkThread(bool);
      virtual bool usingNetworkThread() const;

      virtual void setDisableParallelPublisherTick(bool);
      virtual bool disableParallelPublisherTick() const;

      virtual void setTickPublishersDuringEntityTick(bool);
      virtual bool tickPublishersDuringEntityTick() const;

      virtual void reserve(unsigned numToReserve);

      virtual bool willRediscoverObjects() const;


      virtual void setReflectedLists(const DtReflectedObjectLists&);

      virtual double networkFrameTime() const
      {
         return myNetworkFrameTime;
      }

      virtual void setSendMessagesInNetworkProcess(bool);
      bool sendMessagesInNetworkProcess() const
      {
         return mySendMessagesInNetworkProcess;
      }

#if DtHLA_1516_EVOLVED
      virtual void setAutoReserve(int);
      int autoReserve() const;

      virtual bool isNameReserved(const DtString& name) const;
      virtual bool isNameReservationPending(const DtString& name) const;
#endif

      virtual DtString nextGlobalObjectId(const DtString& defaultId = DtString::nullString());


      virtual void setLimitSizeToMtu(bool limitToMtu);
      virtual bool limitSizeToMtu() const;

      virtual unsigned maxInteractionSize() const;

   protected:
      virtual void slot_convertedToLocal(DtStateData*);

      virtual void sendQueuedMessages();

      virtual bool init(DtCommunicationManager*);

      virtual DtRemoteObjectManager* createRemoteObjectManager();

      virtual void reserveGlobalObjectIds(unsigned numToReserve);

      virtual bool isPublishableComponent(DtStateComponent* sc) const;

      virtual void stateComponentAdded(DtStateComponent*);

      virtual void stateComponentRemoved(const DtStateComponent*);

      virtual bool validateScenario(const DtScenario& s, DtString& error) const;

      virtual bool hasSimulationTime() const { return true; };

      virtual bool needsUnpublishedDatabase() const
      {
         return false;
      }

   protected:
      virtual void advanceFrame(DtVrfCallbackQueue*);

      virtual bool stateDataAdded(DtStateData*);

      virtual void slot_prepareForHandoff(DtStateData*, bool becomingLocal);

      virtual void stateDataAboutToBeRemoved(const DtStateData*);

      virtual void printReflectedObjectCounts() const;

      virtual void requestUpdatesForRemoteNonVrfObjects() const;

      void createExerciseClock(int clockMode = 0);

      virtual void drainInput();

      virtual void createNetInterfaceFor(DtStateComponent*);

      virtual void cleanupNetworkThread();

      virtual void runNetwork();
      virtual void resolvePendingIds();
      virtual const DtVrfObjectParameters* lookupParameterEntry(const DtObjectType& ot) const;

      virtual void createAndInitRemoteObjectManager();

      virtual bool rediscoverObjects();

      virtual bool publishingOnLegionNetwork() const { return false; };

      virtual void stateDataManagerDeleted();

#if DtHLA_1516_EVOLVED
      virtual void reservedNamesSuceeded(const std::set<std::wstring>& theNames);

      virtual void reservedNamesFailed(const std::set<std::wstring>& theNames);

      static void nameSetReservationSucceededCb(const std::set<std::wstring>& nameSet,
         void* userData);
      static void nameSetReservationFailedCb(const std::set<std::wstring>& nameSet,
         void* userData);
#endif

#if DtHLA
      virtual void setExecutionState(DtVRLExecutionStatus status);
#endif

   protected:
      DtExerciseConn* myExerciseConnection;
      DtStateDataManager* myStateDataManager;
      bool myEnabled;
      bool myRunFullyThreaded;
      PublisherContainer myNeedsPublishersCreated;
      PublisherContainer myTickableInterfaces;

      typedef std::map<SimStateID, DtSimObjectNetInterface*> Publishing;
      Publishing myPublishing;

      typedef std::map<DtStateComponent*, DtSimObjectNetInterface*> StateComponentsPublishing;
      typedef std::map<SimStateID, StateComponentsPublishing> ComponentsPublishing;
      ComponentsPublishing myComponentsPublishing;

      mutable tbb::queuing_rw_mutex myPublishingMutex;
      mutable tbb::spin_rw_mutex myStateDataMutex;

      typedef std::map<DtGlobalObjectDesignator, DtSimObjectNetInterface*> GlobalIdForNetworkInterface;
      GlobalIdForNetworkInterface myGlobalIdForNetworkInterface;

      DtRemoteObjectManager* myRemoteObjectManager;

   #if DtHLA
      typedef std::map<DtString, DtStateData*> StateDataByGlobalId;
      StateDataByGlobalId myStateDataByGlobalId;
      std::set<DtStateData*> myPendingGlobalIds;
   #endif

      typedef std::map<DtString, DtStateData*> StateDataByEntityId;
      StateDataByEntityId myStateDataByEntityId;
      std::set<DtStateData*> myPendingEntityIds;

      typedef std::map<DtGeoReferenceVariant, DtStateData*> StateDataByGeoreferenceVariant;
      StateDataByGeoreferenceVariant myStateDataByGeoreferenceVariant;

      struct ComponentCreationRule
      {
         CreationRule creationRule;
         DtString networkInterface;
         std::shared_ptr<ComponentRuleUserData> userData;
      };

      typedef std::vector<ComponentCreationRule> ComponentCreationRules;
      ComponentCreationRules myComponentCreationRules;

      const Coordinate_System* myCoordinateSystem;

      DtVrfParameterDb* myParameterDatabase;
      int myVrfSessionId;
      int myVrfMessageVersionSupported;

      bool myPublishZeroVelocityWhenPaused;
      bool myIsDeadReckonAlgorithmOverridden;
      int myDeadReckonOverrideAlgorithm;
      bool mySetDeadReckoningAlgorithmToStaticOnPause;
      bool myBlockOnUnfinishedRemoteDiscovery;

      tbb::spin_mutex myEventIdMutex;
      int myAppIdRangeMax;
      DtVrfEntityIdentifierFactory* myEntityIdentifierFactory;
      makVrfEvents::DtEventManager* myEventManager;
      double myMaxDrainInputTime;

   #if DtHLA
      DtHlaExerciseClock* myExerciseClock;
      double myMinDrainInputTime;
      double myFrameDeltaTime;

   #if DtHLA_1516_EVOLVED
      std::set<DtGlobalObjectDesignator> myReservedGlobalIds;
      std::set<DtGlobalObjectDesignator> myPendingReservedGlobalIds;
      tbb::queuing_mutex myGlobalIdReserveMutex;
      int myAutoReserve;
   #endif
   #else
      DtExerciseClock* myExerciseClock;
      int myMaxDrainInputReads;
   #endif

      DtFilename myFastForwardSettingsFile;
      DtFastForwardSettings myFastForwardSettings;
      DtDefaultSimulationModelSetValidatorManager mySimulationModelSetValidator;
      static DtVrlinkNetworkInterfaceCreatorFcn theCreator;
      DtVrlinkEventTranslatorManager* myVrlinkEventTranslatorManager;
      std::set<DtStateComponent*> myCreateNetInterfaceFor;
      unsigned int mySimMgmtPduProcessLevel;

      DtCommunicationManager* myCommunicationManager;

      typedef tbb::interface5::condition_variable Condition;
      typedef tbb::mutex ConditionMutex;
      typedef tbb::interface5::unique_lock<ConditionMutex> ConditionLock;

      std::auto_ptr<tbb::tbb_thread> myNetworkThread;
      mutable Condition myStartNetworkCondition;
      mutable ConditionMutex myStartNetworkConditionMutex;
      std::atomic<bool> myShutdownNetworkThreadFlag;
      DtVrfCallbackQueue* myNetworkCallbackQueue;
      tbb::mutex myNetworkThreadMutex;

      bool myDisableRemoteDiscovery;
      bool myControlsDrainInput;
      bool myTickPublishersInNetworkThread;
      bool myMetocPublishingEnabled;

#if DtHLA
      bool myReflectedListRequestUpdatesOn;
      struct TimeManagementData
      {
         bool runNetworkInThread = false;
         bool publishWhileTicking = false;
         bool timeManagementDataSet = false;
         int networkCallbackThreads = -1;
      };

      TimeManagementData myTimeManagementData;
#endif
      double myNextFrameSimTime;
      double myCurrentFrameSimTime;
      double myLastSetSimTime;
      std::atomic<bool> myStartNetworkThread;

#if DtDIS
      int myDefaultObjectTimeout;
      bool myDisableTimeoutProcessing = false;
#endif

      typedef DtOrderedEntityTypeList<DefaultNetworkInterfaceEntry*>  DefaultNetworkInterfaceEntries;
      DefaultNetworkInterfaceEntries myDefaultNetworkInterfaceEntries;

      DtReflectedObjectLists myReflectedObjectLists;

      std::vector<DtSimObjectNetInterface*> myInterfacesToDelete;
      double myNetworkFrameTime;

      bool mySendMessagesInNetworkProcess;
      tbb::spin_mutex myQueuedMessagesToSendMutex;
      std::vector<makVrfEvents::DtEvent*> myQueuedMessagesToSend;
      int myNumNetworkWorkerThreads; 

      bool myBulkCreateInProgress;
      unsigned int myBulkCreateTickCounter;
      bool myScenarioLoaded;

      bool myLimitSizeToMtu;
      DtVrfObjectIdGenerator* myVrfObjectIdGenerator;

      static DtRemoteObjectManagerCreatorFcn theRemoteObjectManagerCreatorFcn;

#if DtHLA
      bool myEnteredTimeManagedMode = false;
#endif
   };
}