eventManager.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/events.h>
#include <tbb/spin_mutex.h>
#include <map>
#include <boost/signals2.hpp>



class DtNetworkInterfaceManager;

namespace makVrfEvents
{
   class DtEvent;
   class DtEventManager;
   class DtSimControlEvent;

   typedef DtEventManager* (*DtEventManagerCreatorFcn)();

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

   public:
      DtEventManager();
      virtual ~DtEventManager();

      virtual void tick();

      virtual void addEvent(const DtEvent&);

      virtual void sendEvent(const DtEvent&);

      static void setEventManagerCreatorFcn(DtEventManagerCreatorFcn fcn);
      static DtEventManager* createEventManager();

      virtual void setProcessEventsImmediately(bool b);
      bool processEventsImmediately() const
      {
         return myProcessEventsImmediately;
      }

      virtual void setNetworkManager(DtNetworkInterfaceManager*);
      DtNetworkInterfaceManager* networkInterfaceManager() const
      {
         return myNetworkManager;
      }

      virtual void resetSimulation();

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

   public:

      typedef boost::signals2::signal<void (const DtEvent&)> EventSignal;


      virtual EventSignal& signalForEvent(DtEvent::EventType type);


      virtual void cleanupSignals();
      EventSignal& signalForFireEvent();
      EventSignal& signalForDetonationEvent();
      EventSignal& signalForDataEvent();
      EventSignal& signalForCommentEvent();
      EventSignal& signalForRawSignalEvent();
      EventSignal& signalForVrfSignalEvent();
      EventSignal& signalForExternalCommsSignalEvent();
      EventSignal& signalForSensorFieldOfViewControlEvent();
      EventSignal& signalForSimControlEvent();
      EventSignal& signalDiGuyActionEvent();
      EventSignal& signalForInfluenceEvent();
      EventSignal& signalForInitiateTakeEvent();
      EventSignal& signalForTransferRequestEvent();
      EventSignal& signalForTransferResponseEvent();
      EventSignal& signalForOwnershipAcquisitionRejectedEvent();
      EventSignal& signalForOwnershipAcquisitionAcquiredEvent();
      EventSignal& signalForTransferAcquisitionRequestEvent();
      EventSignal& signalForTransferAcquisitionResponseEvent();
      EventSignal& signalForCollisionEvent();
      EventSignal& signalForServiceRequestEvent();
      EventSignal& signalForResupplyOfferEvent();
      EventSignal& signalForResupplyReceivedEvent();
      EventSignal& signalForResupplyCancelEvent();
      EventSignal& signalForInterrogatorEvent();
      EventSignal& signalForInterrogatorResponseEvent();

   public:

      virtual void selfReflect(unsigned int i);
      virtual void doNotSelfReflect(unsigned int i);

      virtual bool wantsToSelfReflect(unsigned int) const;

      virtual void postEvent(const DtEvent&);

   protected:

      virtual void processEvent(const DtEvent&);

      virtual bool wantsToProcessEvent(const DtEvent&) const;

      virtual void addEvent(const DtEvent&, bool& selfReflecting);

   protected:
      tbb::spin_mutex myMutex;
      std::vector<DtEvent*> myEvents;

      tbb::spin_mutex myCallbackMutex;
      typedef std::map<DtEvent::EventType, EventSignal*> EventCallbackMap;
      EventCallbackMap myEventCallbackMap;

      static DtEventManagerCreatorFcn theEventManagerCreatorFcn;

      bool myProcessEventsImmediately;

      std::set<unsigned int> myDoNotSelfReflect;


      DtNetworkInterfaceManager* myNetworkManager;
      bool myProcessNetworkEventsLocally;
   };
}