communicationManager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2016 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once

#include "vrfMsgTransport/vrfMsgTransportDefines.h"
#include <vlpi/simulationAddress.h>
#include <vlutil/vlTime.h>
#include <boost/signals2.hpp>
#include <boost/function.hpp>



namespace makVrfEvents
{
   class DtEventManager;
   class DtEvent;
}

namespace makVrf
{
   class DtStateDataManager;
}

class DtScenario;
class DtExerciseClock;
class DtNetworkInterfaceManager;
class DtCommunicationManager;
class DtNetworkManagerInterface;
class Coordinate_System;
class DtVrfParameterDb;

typedef DtCommunicationManager* (*DtCommunicationManagerCreatorFcn)(const DtSimulationAddress&, makVrf::DtStateDataManager*, int);

struct DT_DLL_vrfMsgTransport DtCommunicationManagerPerformanceTimerInformation
{
   DtCommunicationManagerPerformanceTimerInformation() : preAdvanceFrameTime(0.), networkFrameTime(0.) {};
   double preAdvanceFrameTime;
   double networkFrameTime;
};

class DT_DLL_vrfMsgTransport DtCommunicationManager
{
public:
   typedef boost::function<double (double& dt)> SimTimeProvideFcn;
   DtCommunicationManager(const DtSimulationAddress&, makVrf::DtStateDataManager* sm = 0, int threadPoolSize = -1);

   virtual ~DtCommunicationManager();

   static void setCommunicationManagerCreatorFcn(DtCommunicationManagerCreatorFcn fcn);
   static DtCommunicationManager* createCommunicationManager(const DtSimulationAddress&, makVrf::DtStateDataManager* sm = 0, int threadPoolSize = -1);

   virtual void setNetworkInterfaceManager(DtNetworkInterfaceManager*);
   DtNetworkInterfaceManager* networkInterfaceManager()
   {
      return myNetworkInterfaceManager;
   }

   virtual void setSimulationAddress(const DtSimulationAddress&);
   const DtSimulationAddress& simulationAddress() const;
   const DtSimulationAddress& applicationId() const { return simulationAddress(); };

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

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

   virtual void setNumCallbackThreads(unsigned);

   virtual bool typeIsPublishable(const DtEntityType&) const;

   virtual void setCoordinateSystem(const Coordinate_System*);

   virtual double beginFrame(double& dt);

   virtual bool advanceFrame(DtCommunicationManagerPerformanceTimerInformation* performanceTimerInformation = nullptr);

   virtual bool insertManagerAtBeginning(DtNetworkManagerInterface*);

   virtual bool addManager(DtNetworkManagerInterface*);

   virtual DtNetworkManagerInterface* networkManagerInterface(const char*) const;

   virtual void removeManager(const char*);

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

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

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

   virtual void setUsePerfCounter(bool);

   virtual void setSessionId(int);
   int sessionId() const
   {
      return mySessionId;
   }

   virtual double elapsedRealTime() const;

   virtual void run();

   virtual void pause();

   virtual void rewindScenario();

   virtual void resetSimulation();

   virtual void setSimTime(double);

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

   virtual void setTimeMultiplier(double);

   virtual void setExerciseStartTime(double);

   virtual bool isPaused() const;
   virtual double approximateElapsedRealTime() const;
   virtual double absRealTime() const;
   virtual double timeMultiplier() const;
   virtual double exerciseStartTime() const;
   virtual bool isRunToCompleteFrameMode() const;
   virtual void setSimTimeProviderFunction(SimTimeProvideFcn f);

   virtual double simTime() const
   {
      return mySimTime;
   }


   DtExerciseClock* clock() const
   {
      return myExerciseClock;
   }

   bool inFame() const
   {
      return myInFrame;
   }

   virtual bool isConnectionless() const;

   virtual void removeAndDeleteAll();

   virtual void reserve(unsigned int);

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

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

   virtual void beginBulkCreate();
   virtual void endBulkCreate();
   makVrf::DtStateDataManager* stateDataManager() const
   {
      return myStateDataManager;
   }

   virtual bool rediscoverObjects();

public:
   boost::signals2::signal<void ()> signal_aboutToAdvanceFrame;
   
   boost::signals2::signal<void (makVrf::DtStateDataManager*)> signal_stateDataManagerChanged;

   boost::signals2::signal<void ()> signal_frameAdvanced;

   boost::signals2::signal<void (double simTime, double dT)> signal_beginFrame;

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

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

protected:
   virtual void slot_interfaceAdded(DtNetworkManagerInterface*);
   virtual void slot_interfaceRemoved(DtNetworkManagerInterface*);

   void initialize();

protected:
   DtNetworkInterfaceManager* myNetworkInterfaceManager;
   makVrf::DtStateDataManager* myStateDataManager;
   makVrfEvents::DtEventManager* myEventManager;
   static DtCommunicationManagerCreatorFcn theCommunicationManagerCreatorFcn;
   DtSimulationAddress mySimulationAddress;

   DtExerciseClock* myExerciseClock;
   bool myOwnsStateDataManager;
   int mySessionId;
   double mySimTime;
   double myLastDt;
   SimTimeProvideFcn mySimTimeProviderFunction;
   int myInFrame;
   DtVrfParameterDb* myParameterDatabase;
};