vrfMessageInterface.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 <vlutil/vlMachineTypes.h>
#include <vlpi/disEnums.h>

#include <vrfMsgTransport/eventManager.h>
#include "vrfmsgs/messageExecutive.h"
#include <vrfmsgs/messageTypes.h>
#include <vlutil/vlUtil.h>
#include <vl/dataInteraction.h>
#include <vl/interClassDesc.h>
#include <vl/rtiCompatibility.h>

class DtSimInterfaceMessage;
class DtInterfaceMessageExecutive;
class DtSimInterfaceContent;
class DtInterfaceContentFactory;
class DtSplitMessageHandle;
class DtSplitMessageCollector;
class DtExerciseConn;

typedef bool (*DtIsValidVrfMessageVersionFcn)(DtU32 version, DtDataInteraction* inter, void* user);

class DT_DLL_vrfMsgTransport DtVrfMessageInterface
{
public:
   DtVrfMessageInterface(DtEventManager* eventManager, 
      bool useDefaultInterfaceFactory = true);

   virtual ~DtVrfMessageInterface();

   virtual bool init();

   virtual bool createMessageExecutive();

   virtual void createSplitMessageCollector();
   
   virtual DtSplitMessageCollector* splitMessageCollector();
   virtual const DtSplitMessageCollector* splitMessageCollector() const;

   virtual bool deliverMessage(const DtSimInterfaceMessage& msg,
      bool overrideTimestampOrder = true);
   virtual bool receiveMessage(const DtSimInterfaceMessage& msg);

   virtual bool createAndDeliverMessage(
      const DtSimulationAddress& recipient, 
      const DtSimInterfaceContent & content,
      bool overrideTimestampOrder = true);

   virtual bool getContentFromNet(DtDataInteraction* dataInter,
      DtSimInterfaceContent*& content) const;

   virtual bool getContentFromNet(unsigned nBufferSize,
      int nContentType,
      const char* pContentBuffer,
      DtSimInterfaceContent*& content) const;

   virtual bool setContentForNet(DtDataInteraction* dataInter,
      DtSimInterfaceContent* content) const;

   virtual void setSequence(DtU32 num);
   virtual DtU32 sequence() const;

   virtual void setSessionId(DtU32 num);
   virtual DtU32 sessionId() const;

   virtual void setVrfMessageVersionSupported(DtU32 num);
   virtual DtU32 vrfMessageVersionSupported() const;

   virtual bool isMessageVrfVersionSupported(DtDataInteraction*) const;

   virtual void addVrfMessageVersionValidCallback(DtIsValidVrfMessageVersionFcn fcn, void* usr);
   virtual void removeVrfMessageVersionValidCallback(DtIsValidVrfMessageVersionFcn fcn, void* usr);

   virtual bool isVrfMessageVersionTransparentMessageType(int messageType) const;

   virtual bool isSessionTransparentMessageType(int messageType);
   
   DtEventManager* eventManager();

   virtual void addEvent(const DtEvent&);

   virtual void addEvent(const DtDetonationInteraction&);
   virtual void addEvent(const DtFireInteraction&);
   virtual void addEvent(const DtAcknowledgeInteraction&);
   virtual void addEvent(const DtStopFreezeInteraction&);
   virtual void addEvent(const DtStartResumeInteraction&);
   virtual void addEvent(const DtDataInteraction&);
   virtual void addEvent(const DtSignalInteraction&);
   virtual void addEvent(const DtCommentInteraction&);
   virtual void addEvent(const DtSensorFieldOfViewControlInter&);
   virtual void addevent(const DtSimInterfaceContent&);

#if DtHLA
   virtual void addEvent(const DtDataInteractionWithTransportType&);
   virtual void addEvent(const DtInfluenceInteraction&);
   virtual void addEvent(const DtEndGestureInter&);
   virtual void addEvent(const DtExecuteGestureInter&);
#else
   virtual void addEvent(const DtDIGuyCustomPdu&);
#endif

   virtual void clearEventManager();

   virtual DtInterfaceContentFactory* factory() const;
   virtual void setFactory(DtInterfaceContentFactory* fact);

   virtual DtInterfaceMessageExecutive* messageExecutive() const;

   virtual const DtSimulationAddress& messageAddress() const;

   virtual void receiveMessage(DtDataInteraction* dataInter);

   virtual bool sendMessage(const DtSimInterfaceMessage& message,
      bool overrideTimestampOrder);

   virtual void addMessageCallback(int type, DtMessageCallbackFcn fcn, 
      void* usrData);

   virtual void removeMessageCallback(int type, DtMessageCallbackFcn fcn, 
      void* usrData);

   virtual bool sendSplitContent(const char* pContentBuffer,
      unsigned int nBufferSize,
      int nContentType,
      const DtSimulationAddress& sender,
      const DtSimulationAddress& recipient,
      DtSplitMessageHandle& msgHandleReturn,
      bool overrideTimestampOrder);

   virtual bool sendSplitContent(const char* pContentBuffer,
      unsigned int nBufferSize,
      int nContentType,
      const DtSimulationAddress& sender,
      const DtSimulationAddress& recipient,
      bool overrideTimestampOrder);

   virtual void processReassembledContent(const char* pContent,
      int nContentSize,
      int nContentType,
      const DtSimulationAddress& messageIdSender,
      int messageIdNumber,
      const DtSimulationAddress& recipient);

   virtual void setEventManager(DtEventManager*);

public:
   virtual void netMessageCallback(const DtEvent&);
   virtual void simInterfaceContentMessageEvent(const DtEvent& c);
      
   virtual bool receiveMessage(const DtSimInterfaceContent& content);

   virtual DtExerciseConn* exerciseConnection() const;

protected:
   virtual void removeConnections();
   virtual void initializeConnections();

   bool sendNormalMessage(const DtSimInterfaceMessage& message, bool overrideTimestampOrder);

   static bool matchPattern(const DtSimulationAddress& address,
                            const DtSimulationAddress& pattern);

private:

   DtVrfMessageInterface(const DtVrfMessageInterface& orig);

   DtVrfMessageInterface& operator=(
      const DtVrfMessageInterface& orig);

   DtVrfMessageInterface();

protected:

   DtInterfaceContentFactory*    myContentFactory;
   DtInterfaceMessageExecutive*  myMessageExecutive;
   DtEventManager*               myEventManager;
   bool myOwnsEventManager;

   bool myCreatedInterfaceFactory;
   DtU32 mySequenceNumber;
   DtU32 mySessionId;

   DtSplitMessageCollector*      mySplitMessageCollector;

   DtU32 myVrfMessageVersionSupported;
   DtList myCallbacks;
};

inline DtU32 DtVrfMessageInterface::sequence() const
{
  return mySequenceNumber;
}

inline void DtVrfMessageInterface::setSessionId(DtU32 num)
{
  DtInfo("Setting SessionId to %d\n", num);
  mySessionId = num;
}

inline DtU32 DtVrfMessageInterface::sessionId() const
{
  return mySessionId;
}

inline bool DtVrfMessageInterface::isSessionTransparentMessageType(
   int messageType)
{
   if (messageType == DtVrfObjectDataMessageType)
   {
      return true;
   }
   
   return false;
}

inline bool DtVrfMessageInterface::isVrfMessageVersionTransparentMessageType(
   int messageType) const
{
   if (messageType == DtVrfObjectDataMessageType)
   {
      return true;
   }
   
   return false;
}

inline void DtVrfMessageInterface::clearEventManager()
{
   if (myOwnsEventManager)
   {
      delete myEventManager;
   }

   myEventManager = 0;
}

inline DtEventManager* DtVrfMessageInterface::eventManager()
{
   return myEventManager;
}

inline DtSplitMessageCollector* DtVrfMessageInterface::splitMessageCollector()
{
   return (mySplitMessageCollector);
}

inline const DtSplitMessageCollector* DtVrfMessageInterface::splitMessageCollector() const
{
   return (mySplitMessageCollector);
}

inline void DtVrfMessageInterface::setVrfMessageVersionSupported(DtU32 num)
{
   myVrfMessageVersionSupported = num;
}

inline DtU32 DtVrfMessageInterface::vrfMessageVersionSupported() const
{
   return myVrfMessageVersionSupported;
}