networkInterfaceManager.h

Go to the documentation of this file.

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

#pragma once

#include "vrfMsgTransport/vrfMsgTransportDefines.h"
#include <vrfStateData/stateDataTypes.h>
#include "vlpi/simulationAddress.h"
#include <boost/signals2.hpp>
#include <vlutil/vlPrint.h>

class DtNetworkManagerInterface;
class DtCommunicationManager;
class DtEntityType;
class Coordinate_System;
class DtVrfParameterDb;
class DtScenario;
class DtObjectType;

namespace makVrf
{
   class DtStateData;
   class DtStateDataManager;
}

namespace makVrfEvents
{
   class DtEvent;
   class DtEventManager;
}

class DtUUID;
class DtNetworkInterfaceManager;
typedef DtNetworkInterfaceManager* (*DtNetworkInterfaceManagerCreatorFcn)(makVrf::DtStateDataManager*);

class DT_DLL_vrfMsgTransport DtNetworkInterfaceManager
{
public:

   DtNetworkInterfaceManager(makVrf::DtStateDataManager*);

   virtual ~DtNetworkInterfaceManager();

   static void setNetworkInterfaceManagerCreatorFcn(DtNetworkInterfaceManagerCreatorFcn fcn);
   static DtNetworkInterfaceManager* createNetworkInterfaceManager(makVrf::DtStateDataManager*);

   makVrf::DtStateDataManager* stateDataManager() const
   {
      return myStateDataManager;
   }

   virtual void beginFrame(double simTime, double dt);

   double simTime() const
   {
      return mySimTime;
   }

   double dT() const
   {
      return myDt;
   }

   virtual bool isConnectionless() const;

   virtual bool preAdvanceFrame();

   virtual void advanceFrame(double* networkFrameTime = nullptr);

   virtual bool insertManagerAtBeginning(DtNetworkManagerInterface*);

   virtual void setNumCallbackThreads(unsigned);

   virtual std::string protocol() const;

   virtual bool addManager(DtNetworkManagerInterface*);

   virtual void removeManager(const char*);

   virtual bool hasNetworkManager(const char*) const;

   virtual bool typeIsPublishable(const DtEntityType&) const;

   virtual DtNetworkManagerInterface* networkManagerInterface(const char*) const;

   virtual void printDataToStream(const DtUUID&, DtOutputStream&) const;

   virtual void setInterest(const DtVector& geocentricCenter, double radius);

   virtual void reserve(unsigned numToReserve);

   virtual void printReflectedObjectCounts() const;

   virtual void requestUpdatesForRemoteNonVrfObjects() const;

   virtual void setCommunicationManager(DtCommunicationManager*);
   DtCommunicationManager* communicationManager()
   {
      return myCommunicationManager;
   }

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

   virtual const makVrf::DtStateData* stateDataForGlobalId(const DtString&) const;

   virtual void setRunFullyThreaded(bool);
   bool runFullyThreaded() const { return myRunFullyThreaded; };

   virtual void setCoordinateSystem(const Coordinate_System*);

   virtual void setParameterDatabase(DtVrfParameterDb*);

   virtual unsigned int maxNameLengthForType(const DtObjectType&) const;

   virtual void setVrfSessionId(int);

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

   virtual void startScenarioLoad(bool);

   virtual void endScenarioLoad(bool);

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

   virtual void rewindScenario();

   virtual void run();

   virtual void pause();

   virtual void setExerciseStartTime(double);

   virtual void setSimTime(double);

   virtual void setTimeMultiplier(double);

   virtual void setSiteAppId(int, int);
   const DtSimulationAddress& simulationAddress() const
   {
      return mySimulationAddress;
   }

   int numManagers() const
   {
      return myNetworkManagers.size();
   }

   virtual double determineSimTime(double& dt);

   virtual void addEvent(const makVrfEvents::DtEvent&, bool& selfReflected);

   virtual void sendEvent(const makVrfEvents::DtEvent&);

   virtual void setEventManager(makVrfEvents::DtEventManager*);

   virtual void resetSimulation();

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

   virtual void removeAndDeleteAll();

   virtual bool needsUnpublishedDatabase() const;

   virtual bool publishingOnLegionNetwork() const;

   virtual bool selfReflecting() const;
   
   virtual void setSelfReflecting(bool);

   virtual bool rediscoverObjects();

   virtual void beginBulkCreate();
   virtual void endBulkCreate();

public:
   boost::signals2::signal<void (DtNetworkManagerInterface*)> signal_interfaceAdded;

   boost::signals2::signal<void (DtNetworkManagerInterface*)> signal_interfaceRemoved;

protected:
   virtual void slot_stateDataAdded(makVrf::DtStateData*);

   virtual void slot_stateDataAboutToBeRemoved(const makVrf::DtStateData*);

   virtual void initialize(DtNetworkManagerInterface*);

protected:
   std::vector<DtNetworkManagerInterface*> myNetworkManagers;
   makVrf::DtStateDataManager* myStateDataManager;
   bool myRunFullyThreaded;
   bool myEnabled;
   const Coordinate_System* myCoordinateSystem;
   bool myOwnsCoordinateSystem;
   DtVrfParameterDb* myParameterDb;
   int myVrfSessionId;
   int myVrfMessageVersionSupported;
   DtSimulationAddress mySimulationAddress;
   int myNumberOfCallbackThreads;

   double mySimTime;
   double myDt;

   DtString myFrameRateMode;
   double myFrameDeltaTime;

   makVrfEvents::DtEventManager* myEventManager;
   static DtNetworkInterfaceManagerCreatorFcn theNetworkInterfaceManagerCreatorFcn;
   DtCommunicationManager* myCommunicationManager;

   boost::signals2::scoped_connection myStateDataAddedConnection;
   boost::signals2::scoped_connection myStateDataRemovedConnection;
};