vrfMessageInterface.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1999-2001 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: vrfMsgIf.h,v $ $Revision: 1.3 $ $State: Exp $
*******************************************************************************/



#ifndef DtVrfMessageInterface_H_
#define DtVrfMessageInterface_H_

#include <vlutil/vlMachineTypes.h>
#include <vlpi/disEnums.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 DtExerciseConn;
class DtSplitMessageHandle;
class DtSplitMessageCollector;

#include "vrfMsgTransport/vrfMsgTransportDefines.h"

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

class DT_DLL_vrfMsgTransport DtVrfMessageInterface
{
public:

   DtVrfMessageInterface(DtExerciseConn* exConn, 
      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);
   virtual bool receiveMessage(const DtSimInterfaceMessage& msg);

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

#if XXX

   virtual bool createAndDeliverMessage(const DtSimulationAddress& sender,
    const DtSimulationAddress& recipient, 
    const DtSimInterfaceContent & content);
#endif

   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);
   
   virtual DtExerciseConn* exerciseConn();

   virtual void clearExerciseConn();

   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);

   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);

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

#ifdef DtHLA

   virtual bool isQueuedMessage(const DtSimInterfaceMessage& message);
   
   virtual void processReceiveMessageQueue();

   virtual void setQueueMessages(bool);
   virtual bool queueMessages() const;

   virtual void setTransportTypeReliable(int contentType);

   virtual void setTransportTypeBestEffort(int contentType);

   virtual void updateTransportTypeForMsg(const DtSimInterfaceMessage& message);

#endif

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

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

   virtual bool receiveMessage(const DtSimInterfaceContent& content);

protected:
   
   bool sendNormalMessage(const DtSimInterfaceMessage& message);

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

#ifdef DtHLA

   static void postDrainCallback(void* usr);

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

protected:

   DtVrfMessageInterface(const DtVrfMessageInterface& orig);

   DtVrfMessageInterface& operator=(
      const DtVrfMessageInterface& orig);

   DtVrfMessageInterface();

protected:

   DtInterfaceContentFactory*    myContentFactory;
   DtInterfaceMessageExecutive*  myMessageExecutive;
   DtExerciseConn*               myExerciseConnection;

   bool myCreatedInterfaceFactory;
   DtU32 mySequenceNumber;
   DtU32 mySessionId;

   DtSplitMessageCollector*      mySplitMessageCollector;

   DtU32 myVrfMessageVersionSupported;
   DtList myCallbacks;

#ifdef DtHLA



   DtList myReceiveMessageQueue;

   bool myQueueMessages;

   bool myUseReliableTransport;

   bool myAllowReliableDataInteractions;
    
   std::set<int> myContentTypesToSendReliable;


#endif
};

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::clearExerciseConn()
{
   myExerciseConnection = 0;
}

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

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;
}

#endif