vrfTDLMessageInterface.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2017 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma once

#include "vrfMsgTransport/vrfMsgTransportDefines.h"

#include <vlutil/vlMachineTypes.h>

#include <vlutil/vlUtil.h>
#include <vl/dataInteraction.h>
#include <vl/interClassDesc.h>
#include <vl/rtiCompatibility.h>

class DtVrfTDLMessage;
class DtVrfTDLMessageFactory;

typedef void (*DtVrfTDLMessageCallbackFcn)(DtVrfTDLMessage*, void* usr);

class DT_DLL_vrfMsgTransport DtVrfTDLMessageInterface
{
public:

   DtVrfTDLMessageInterface(DtExerciseConn* exConn, 
      bool useDefaultInterfaceFactory = true);

   virtual ~DtVrfTDLMessageInterface();

   virtual bool init();

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

   virtual const DtSimulationAddress& messageAddress() const;

   virtual bool sendMessage(DtVrfTDLMessage& message);
   
   virtual DtExerciseConn* exerciseConn();

   virtual void clearExerciseConn();

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

   virtual void addVrfTDLMessageCallback(DtVrfTDLMessageCallbackFcn fcn, void* usr);
   virtual void removeVrfTDLMessageCallback(DtVrfTDLMessageCallbackFcn fcn, void* usr);

#ifdef DtHLA

   virtual void setTransportTypeReliable(int contentType);

   virtual void setTransportTypeBestEffort(int contentType);

   virtual void updateTransportTypeForMsg(const DtVrfTDLMessage& message);

   static char* dataInteractionChooser(
      DtExerciseConn* exConn, const DtInteraction& inter);
#endif

   virtual bool receiveMessage(DtVrfTDLMessage* content);

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

protected:
   virtual bool setContentForNet(
      DtDataInteraction* dataInter, DtVrfTDLMessage& content) const;

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

   virtual void receiveMessage(DtDataInteraction* dataInter);

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

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

   virtual bool getContentFromNet(unsigned nBufferSize,
      const char* pContentBuffer,
      DtVrfTDLMessage*& content) const;

   virtual void invokeCallbacks(DtVrfTDLMessage*);

private:

   DtVrfTDLMessageInterface(const DtVrfTDLMessageInterface& orig);

   DtVrfTDLMessageInterface& operator=(
      const DtVrfTDLMessageInterface& orig);

   DtVrfTDLMessageInterface();

protected:
   DtExerciseConn*               myExerciseConnection;
   DtU32 mySequenceNumber;
   bool myAllowReliableDataInteractions;
   bool myUseReliableTransport;
   DtVrfTDLMessageFactory* myFactory;
   bool myCreatedInterfaceFactory;
    
   typedef std::vector<std::pair<DtVrfTDLMessageCallbackFcn, void*> > CallbackData;
   CallbackData myCallbacks;

   DtVrfTDLMessage* myVrfTDLMessageTranslator;

#ifdef DtHLA

   std::set<int> myContentTypesToSendReliable;
#endif
};

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

inline void DtVrfTDLMessageInterface::clearExerciseConn()
{
   myExerciseConnection = 0;
}

inline DtExerciseConn* DtVrfTDLMessageInterface::exerciseConn()
{
  return myExerciseConnection;
}