events.h

Go to the documentation of this file.

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

#include "vrfMsgTransport/vrfMsgTransportDefines.h"
#include "vrfExtProtocol/simInterfaceContent.h"
#include <vl/detonationInteraction.h>
#include <vl/fireInteraction.h>
#include <vl/dataInteraction.h>
#include "vrfExtObjects/sensorFieldOfViewControlInter.h"
#include <vl/signalInteraction.h>
#include <vrfmsgs/vrfObjectMessage.h>
#include <vrfmsgs/simInterfaceMessage.h>
#include <vrfmsgs/reportMessage.h>
#include <vl/commentInteraction.h>
#include <vl/acknowledgeInteraction.h>
#include <vl/startResumeInteraction.h>
#include <vl/stopFreezeInteraction.h>
#include <vl/serviceRequestInteraction.h>
#include <vl/resupplyCancelInteraction.h>

#if DtHLA
#include <vrfExtObjects/influenceInteractionHLA.h>
#include <vrfExtObjects/endGestureInterHLA.h>
#include <vrfExtObjects/executeGestureInterHLA.h>
#endif

#if DtDIS
#include <vl/diGuyCustomPdu.h>
#endif

#if DtHLA
class DtDataInteractionWithTransportType : public DtDataInteraction
{
public:

   DtDataInteractionWithTransportType() : DtDataInteraction(), mySendReliable(false) {};
   DtDataInteractionWithTransportType(const DtDataInteractionWithTransportType& orig) : DtDataInteraction(orig), mySendReliable(orig.mySendReliable) {};
   virtual ~DtDataInteractionWithTransportType() {};

   bool mySendReliable;
};
#endif

class DT_DLL_vrfMsgTransport DtEvent
{
public:
   enum EventType
   {
      Unknown = 0,
      DetonationEvent = 1,
      FireEvent = 2,
      SimInterfaceContentMessageEvent = 3,
      DataInteractionEvent = 4,
      SignalInteractionEvent = 5,
#if DtHLA
      InfluenceInteractionEvent = 6,
#endif
      SensorFieldOfViewControlEvent = 7,
      CommentInteractionEvent = 8,
      AcknowledgeInteractionEvent = 9,
      StartResumeInteractionEvent = 10,
      StopFreezeInteractionEvent = 11,
      DIGuyActionEvent = 12,
#if DtHLA
      DIGuyEndActionEvent = 13,
#endif
      ServiceRequestEvent = 14,
      ResupplyOfferEvent = 15,
      ResupplyReceivedEvent = 16,
      ResupplyCancelEvent = 17,
      UserEvent = 1024
   };

public:
   DtEvent() : myEventType(Unknown) {};
   DtEvent(EventType t) : myEventType(t) {};
   DtEvent(const DtEvent& orig) : myEventType(orig.myEventType) {};
   virtual~ DtEvent() {};

   EventType eventType() const { return myEventType; };

   virtual void* contents() const = 0;
   virtual DtEvent* clone() const = 0;

   virtual bool isNetworkEvent() const = 0;

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

protected:
   EventType myEventType;
};

template <typename T>
class DtTypedEvent : public DtEvent
{
public:
   DtTypedEvent() : DtEvent(Unknown), myEvent(0) {};
   DtTypedEvent(EventType t) : DtEvent(t), myEvent(0) {};
   DtTypedEvent(EventType t, const T& e) : DtEvent(t), myEvent(new T(e)) {};
   DtTypedEvent(const DtTypedEvent& orig) : DtEvent(orig), myEvent(new T(*orig.myEvent)) {};
   virtual ~DtTypedEvent()
   {
      delete myEvent;
   }

   void* contents() const { return myEvent; };
   bool isNetworkEvent() const { return true; };

   void setEvent(const T& ev) { delete myEvent; myEvent = new T(ev); };

   virtual DtEvent* clone() const { return new DtTypedEvent<T>(*this); };

protected:
   T* myEvent;
};

#if DtHLA
class DT_DLL_vrfMsgTransport DtDataInteractionWithTransportEvent : public DtTypedEvent<DtDataInteractionWithTransportType>
{
public:
   DtDataInteractionWithTransportEvent() : DtTypedEvent(DataInteractionEvent), myOverrideTimestampOrder(true) {};
   DtDataInteractionWithTransportEvent(const DtDataInteractionWithTransportType& interaction, bool myOverrideTimestampOrder = true) : DtTypedEvent(DataInteractionEvent, interaction),
   myOverrideTimestampOrder(myOverrideTimestampOrder) {};
   DtDataInteractionWithTransportEvent(const DtDataInteractionWithTransportEvent& orig) :
      DtTypedEvent<DtDataInteractionWithTransportType>(orig), myOverrideTimestampOrder(orig.myOverrideTimestampOrder) {};

   virtual DtEvent* clone() const { return new DtDataInteractionWithTransportEvent(*this); };

   bool myOverrideTimestampOrder;
};
#endif
class DT_DLL_vrfMsgTransport DtDataInteractionEvent : public DtTypedEvent<DtDataInteraction>
{
public:
   DtDataInteractionEvent() : DtTypedEvent(DataInteractionEvent) {};
   DtDataInteractionEvent(const DtDataInteraction& interaction) : DtTypedEvent(DataInteractionEvent, interaction) {};
};


class DT_DLL_vrfMsgTransport DtSignalInteractionEvent : public DtTypedEvent<DtSignalInteraction>
{
public:
   DtSignalInteractionEvent() : DtTypedEvent(SignalInteractionEvent) {};
   DtSignalInteractionEvent(const DtSignalInteraction& interaction) : DtTypedEvent(SignalInteractionEvent, interaction) {};
};


class DT_DLL_vrfMsgTransport DtDetonationEvent : public DtTypedEvent<DtDetonationInteraction>
{
public:
   DtDetonationEvent() : DtTypedEvent(DetonationEvent) {};
   DtDetonationEvent(const DtDetonationInteraction& interaction) : DtTypedEvent(DetonationEvent, interaction) {};
};

class DT_DLL_vrfMsgTransport DtSensorFieldOfViewControlEvent : public DtTypedEvent<DtSensorFieldOfViewControlInter>
{
public:
   DtSensorFieldOfViewControlEvent() : DtTypedEvent(SensorFieldOfViewControlEvent) {};
   DtSensorFieldOfViewControlEvent(const DtSensorFieldOfViewControlInter& interaction) : DtTypedEvent(SensorFieldOfViewControlEvent, interaction) {};
};

class DT_DLL_vrfMsgTransport DtCommentInteractionEvent : public DtTypedEvent<DtCommentInteraction>
{
public:
   DtCommentInteractionEvent() : DtTypedEvent(CommentInteractionEvent) {};
   DtCommentInteractionEvent(const DtCommentInteraction& interaction) : DtTypedEvent(CommentInteractionEvent, interaction) {};
};

#if DtHLA
class DT_DLL_vrfMsgTransport DtInfluenceInteractionEvent : public DtTypedEvent<DtInfluenceInteraction>
{
public:
   DtInfluenceInteractionEvent() : DtTypedEvent(InfluenceInteractionEvent) {};
   DtInfluenceInteractionEvent(const DtInfluenceInteraction& interaction) : DtTypedEvent(InfluenceInteractionEvent, interaction) {};
};

class DT_DLL_vrfMsgTransport DtDIGuyEndActionEvent : public DtTypedEvent<DtEndGestureInter>
{
public:
   DtDIGuyEndActionEvent() : DtTypedEvent(DIGuyEndActionEvent) {};
   DtDIGuyEndActionEvent(const DtEndGestureInter& interaction) : DtTypedEvent(DIGuyEndActionEvent, interaction) {};
};

class DT_DLL_vrfMsgTransport DtDIGuyActionEvent : public DtTypedEvent<DtExecuteGestureInter>
{
public:
   DtDIGuyActionEvent() : DtTypedEvent(DIGuyEndActionEvent) {};
   DtDIGuyActionEvent(const DtExecuteGestureInter& interaction) : DtTypedEvent(DIGuyEndActionEvent, interaction) {};
};
#else

class DT_DLL_vrfMsgTransport DtDIGuyActionEvent : public DtTypedEvent<DtDIGuyCustomPdu>
{
public:
   DtDIGuyActionEvent() : DtTypedEvent(DIGuyActionEvent) {};
   DtDIGuyActionEvent(const DtDIGuyCustomPdu& interaction) : DtTypedEvent(DIGuyActionEvent, interaction) {};
};
#endif

class DT_DLL_vrfMsgTransport DtFireEvent : public DtTypedEvent<DtFireInteraction>
{
public:
   DtFireEvent() : DtTypedEvent(FireEvent) {};
   DtFireEvent(const DtFireInteraction& interaction) : DtTypedEvent(FireEvent, interaction) {};
};

class DT_DLL_vrfMsgTransport DtServiceRequestEvent : public DtTypedEvent<DtServiceRequestInteraction>
{
public:
   DtServiceRequestEvent() : DtTypedEvent(ServiceRequestEvent) {};
   DtServiceRequestEvent(const DtServiceRequestInteraction& interaction) : DtTypedEvent(ServiceRequestEvent, interaction) {};
};

class DT_DLL_vrfMsgTransport DtResupplyOfferEvent : public DtTypedEvent<DtResupplyOfferInteraction>
{
public:
   DtResupplyOfferEvent() : DtTypedEvent(ResupplyOfferEvent) {};
   DtResupplyOfferEvent(const DtResupplyOfferInteraction& interaction) : DtTypedEvent(ResupplyOfferEvent, interaction) {};
};

class DT_DLL_vrfMsgTransport DtResupplyReceivedEvent : public DtTypedEvent<DtResupplyRecInteraction>
{
public:
   DtResupplyReceivedEvent() : DtTypedEvent(ResupplyReceivedEvent) {};
   DtResupplyReceivedEvent(const DtResupplyRecInteraction& interaction) : DtTypedEvent(ResupplyReceivedEvent, interaction) {};
};

class DT_DLL_vrfMsgTransport DtResupplyCancelEvent : public DtTypedEvent<DtResupplyCancelInteraction>
{
public:
   DtResupplyCancelEvent() : DtTypedEvent(ResupplyCancelEvent) {};
   DtResupplyCancelEvent(const DtResupplyCancelInteraction& interaction) : DtTypedEvent(ResupplyCancelEvent, interaction) {};
};

class DT_DLL_vrfMsgTransport DtAcknowledgeInteractionEvent : public DtTypedEvent<DtAcknowledgeInteraction>
{
public:
   DtAcknowledgeInteractionEvent() : DtTypedEvent(AcknowledgeInteractionEvent) {};
   DtAcknowledgeInteractionEvent(const DtAcknowledgeInteraction& interaction) : DtTypedEvent(AcknowledgeInteractionEvent, interaction) {};
   virtual bool processLocally() const { return false; };
};

class DT_DLL_vrfMsgTransport DtStopFreezeInteractionEvent : public DtTypedEvent<DtStopFreezeInteraction>
{
public:
   DtStopFreezeInteractionEvent() : DtTypedEvent(StopFreezeInteractionEvent) {};
   DtStopFreezeInteractionEvent(const DtStopFreezeInteraction& interaction) : DtTypedEvent(StopFreezeInteractionEvent, interaction) {};
};

class DT_DLL_vrfMsgTransport DtStartResumeInteractionEvent : public DtTypedEvent<DtStartResumeInteraction>
{
public:
   DtStartResumeInteractionEvent() : DtTypedEvent(StartResumeInteractionEvent) {};
   DtStartResumeInteractionEvent(const DtStartResumeInteraction& interaction) : DtTypedEvent(StartResumeInteractionEvent, interaction) {};
};

template <typename T>
class DtTypedVrfMessageEvent : public DtEvent
{
public:
   DtTypedVrfMessageEvent() : DtEvent(Unknown), myEvent(0) {};
   DtTypedVrfMessageEvent(EventType t) : DtEvent(t), myEvent(0) {};
   DtTypedVrfMessageEvent(EventType t, const T& interaction) : DtEvent(t), myEvent(static_cast<T*>(interaction.clone())) {};
   DtTypedVrfMessageEvent(const DtTypedVrfMessageEvent& orig) : DtEvent(orig), myEvent(static_cast<T*>(orig.myEvent->clone())) {};
   virtual ~DtTypedVrfMessageEvent()
   {
      delete myEvent;
   }

   void* contents() const { return myEvent; };
   bool isNetworkEvent() const { return true; };

   void setEvent(const T& ev) { delete myEvent; myEvent = static_cast<T*>(ev.clone()); };

   DtEvent* clone() const { return new DtTypedVrfMessageEvent<T>(*this); };

protected:
   T* myEvent;
};

class DT_DLL_vrfMsgTransport DtSimInterfaceContentMessageEvent : public DtTypedVrfMessageEvent<DtSimInterfaceContent>
{
public:
   DtSimInterfaceContentMessageEvent() : DtTypedVrfMessageEvent(SimInterfaceContentMessageEvent) {};
   DtSimInterfaceContentMessageEvent(const DtSimInterfaceContent& interaction) : DtTypedVrfMessageEvent(SimInterfaceContentMessageEvent, interaction) {};
};