networkEventManager.h

Go to the documentation of this file.

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

#include "vrfMsgTransport/vrfMsgTransportDefines.h"
#include "vrfMsgTransport/eventManager.h"
#include <boost/signals2.hpp>

#include <tbb/spin_rw_mutex.h>


class DtExerciseConn;
class DtInterfaceMessageExecutive;
class DtVrfTDLMessage;
class DtSimInterfaceMessage;

class DT_DLL_vrfMsgTransport DtNetworkEventManager : public DtEventManager
{
private:
   DtNetworkEventManager(const DtNetworkEventManager&);
   DtNetworkEventManager& operator=(const DtNetworkEventManager&);

public:
   DtNetworkEventManager();
   virtual ~DtNetworkEventManager();

   virtual void addEvent(const DtEvent&);

   DtExerciseConn* exerciseConnection() const
   {
      return myExerciseConnection;
   }

   virtual void setExerciseConnection(DtExerciseConn*);

   virtual const DtSimulationAddress& messageAddress() const;

#if DtHLA
   virtual void setTransportTypeReliable(int contentType);

   virtual void setTransportTypeBestEffort(int contentType);

   virtual bool sendReliable(const DtVrfTDLMessage& message) const;
   virtual bool sendReliable(const DtSimInterfaceMessage& message) const;
#endif

   virtual void setProcessNetworkEventsLocally(bool);
   bool processNetworkEventsLocally() const
   {
      return myProcessNetworkEventsLocally;
   }

public:
   boost::signals2::signal<void (const DtEvent&)> signal_sendingEventOnNetwork;

   virtual bool selfReflecting(const DtEvent&) const;
   virtual bool selfReflecting() const;

   static DtEventManager* creator();

protected:
   virtual void removeExerciseConnectionCallbacks();
   virtual void installExerciseConnectionCallbacks();

#if DtHLA
   static void influenceCallback(DtInfluenceInteraction*, void*);
   virtual void processInfluence(DtInfluenceInteraction*);

   static char* dataInteractionChooser(
      DtExerciseConn* exConn, const DtInteraction& inter);
#endif
   static void commentInteractionCallback(DtCommentInteraction *inter, void* usr);
   virtual void processCommentInteraction(DtCommentInteraction* ctrlInter);

   static void fireCallback(DtFireInteraction*, void*);
   virtual void processFireCallback(DtFireInteraction*);

   static void setGimbalControlCallback(DtSensorFieldOfViewControlInter* ctrlInter, void* usr);
   virtual void processGimbalControl(DtSensorFieldOfViewControlInter* ctrlInter);

   static void detonationCallback(DtDetonationInteraction*, void*);
   virtual void processDetonationCallback(DtDetonationInteraction*);

   static void startResumeInterationCallback(DtStartResumeInteraction* d, void* u);
   virtual void processStartResumeInteractionCallback(DtStartResumeInteraction* d);

   static void stopFreezeInterationCallback(DtStopFreezeInteraction* d, void* u);
   virtual void processStopFreezeInteractionCallback(DtStopFreezeInteraction* d);

   virtual bool isNetworkEvent(const DtEvent&) const;

   virtual bool sendNetworkEvent(const DtEvent&);

   static void netMessageCallback(DtDataInteraction* dataInter, void * usr);
   virtual void processNetMessage(DtDataInteraction* dataInter);

   static void signalInteractionCallback(DtSignalInteraction* dataInter, void * usr);
   virtual void processSignalInteraction(DtSignalInteraction* dataInter);

   static void serviceRequestCallback(DtServiceRequestInteraction*, void*);
   virtual void processServiceRequestCallback(DtServiceRequestInteraction*);

   static void resupplyOfferCallback(DtResupplyOfferInteraction*, void*);
   virtual void processResupplyOfferCallback(DtResupplyOfferInteraction*);

   static void resupplyReceivedCallback(DtResupplyRecInteraction*, void*);
   virtual void processResupplyReceivedCallback(DtResupplyRecInteraction*);

   static void resupplyCancelCallback(DtResupplyCancelInteraction*, void*);
   virtual void processResupplyCancelCallback(DtResupplyCancelInteraction*);

   virtual void initializeProtocolSpecific();

protected:
   DtExerciseConn* myExerciseConnection;
   bool myCallbacksInstalled;
   bool myDataCallbackInstalled;
   bool myProcessNetworkEventsLocally;

#ifdef DtHLA

   bool myAllowReliableDataInteractions;

   std::set<int> myContentTypesToSendReliable;
   tbb::spin_rw_mutex myFedTimeMutex;
#endif
};