externalCommsMessageTransporter.h

Go to the documentation of this file.

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

#pragma once

#include <readerWriter/noArgumentCallbackList.h>
#include <vlutil/vlMachineTypes.h>
#include <vlpi/entityIdentifier.h>
#include "vrfmsgs/vrfObjectMessage.h"
#include "vrfMsgTransport/vrfMsgTransportDefines.h"
#include <vrfmsgs/splitMessageHandle.h>
#include <vrfutil/splitContentTimer.h>

class DtEventManager;
class DtSignalMessageHeader;

const DtUserProtocol DtQualnetSignalUserProtocol = (DtUserProtocol) 10000;
const DtUserProtocol DtExtendedContentSignalUserProtocol = (DtUserProtocol) 11060;

namespace makVrfEvents
{
   class DtEvent;
   class DtDataEvent;
   class DtExternalCommsSignalEvent;
   struct DtExternalCommsMessageParams;
}

struct DtExternalCommsProcessMessageData
{
   DtU32 myMessageId;
   DtEntityIdentifier mySender;
   DtEntityIdentifier myReceiver;
   DtU32 myTransmitterRadioIndex;
   double myDelay;
};

struct DtExternalCommsTimeoutData
{
   DtU32 myMessageId;
   DtEntityIdentifier mySender;
   DtU32 myTransmitterRadioIndex;
};

struct DtExternalCommsReadyToSendData
{
   DtEntityIdentifier myEntityId;
   DtU32 myRadioIndex;
};

class DtCommunicationManager;

class DT_DLL_vrfMsgTransport DtExternalCommsMessageTransporter
{
public:

   typedef struct _tSplitContentEntry{unsigned nSize; char* pBuffer;} SplitContentEntry;
   typedef std::map<DtSplitMessageKey, std::map<unsigned, SplitContentEntry> > SplitContentMap;

private:

   DtExternalCommsMessageTransporter();
   DtExternalCommsMessageTransporter(const DtExternalCommsMessageTransporter& orig);
   DtExternalCommsMessageTransporter& operator=(const DtExternalCommsMessageTransporter& orig);

protected:
   DtExternalCommsMessageTransporter(DtCommunicationManager*);
   virtual bool init();

public:
   static DtExternalCommsMessageTransporter* create(DtCommunicationManager*);

   virtual ~DtExternalCommsMessageTransporter();

public:
   typedef DtCallbackList<const DtExternalCommsProcessMessageData&> DtProcessMessageCallbackList;
   typedef DtCallbackList<const DtExternalCommsTimeoutData&> DtTimeoutCallbackList;
   typedef std::pair<makVrfEvents::DtExternalCommsMessageParams, DtVrfObjectMessageConstPtr> DtExternalCommsMessageCallbackParams;
   typedef DtCallbackList<const DtExternalCommsMessageCallbackParams&> DtNewMessageCallbackList;
   typedef DtCallbackList<const DtExternalCommsReadyToSendData&> DtReadyToSendCallbackList;


   virtual void addProcessMessageCallback(DtProcessMessageCallbackList::DtCallbackFunctionType fcn,
      void* usr);
   virtual void removeProcessMessageCallback(DtProcessMessageCallbackList::DtCallbackFunctionType fcn,
      void* usr);

   virtual bool processVrfObjectMessageReceived(const makVrfEvents::DtExternalCommsMessageParams& params,
      const char *pVrfObjectMessageBuffer);


   virtual void addReadyToSendCallback(DtReadyToSendCallbackList::DtCallbackFunctionType fcn,
      void* usr);
   virtual void removeReadyToSendCallback(DtReadyToSendCallbackList::DtCallbackFunctionType fcn,
      void* usr);


   virtual void addTimeoutCallback(DtTimeoutCallbackList::DtCallbackFunctionType fcn,
      void* usr);
   virtual void removeTimeoutCallback(DtTimeoutCallbackList::DtCallbackFunctionType fcn,
      void* usr);


   virtual void addNewMessageCallback(DtNewMessageCallbackList::DtCallbackFunctionType fcn,
      void* usr);
   virtual void removeNewMessageCallback(DtNewMessageCallbackList::DtCallbackFunctionType fcn,
      void* usr);

   bool enabled() const;
   virtual void setEnabled(bool bEnabled);
   virtual bool processSplitContent(const makVrfEvents::DtExternalCommsMessageParams& params,
      const DtSignalMessageHeader& msgHdr, const char *pContent);

   virtual void processSplitContentTimeout(const DtSplitMessageKey& key);

   virtual void sendMessage(const makVrfEvents::DtExternalCommsMessageParams& params, DtVrfObjectMessage* message);
   virtual bool reassembleVrfObjectMessage(const makVrfEvents::DtExternalCommsMessageParams& params,
      const DtSignalMessageHeader& msgHdr);

   virtual void removeSplitContent(const DtSplitMessageKey& key);

   static void splitContentTimeoutCbk(const DtSplitMessageKey& key, void *pUsr);

protected:

   virtual DtString entityIdToString(const DtEntityIdentifier& id) const;

   virtual void dataInteractionCallback(const makVrfEvents::DtEvent&);

   virtual void processDataInteraction(const makVrfEvents::DtDataEvent* interaction);

   virtual void processExternalCommsProcessMessage(const makVrfEvents::DtDataEvent* processMessageInteraction);

   virtual void processExternalCommsTimout(const makVrfEvents::DtDataEvent* timeoutInteraction);

   virtual void processExternalCommsReadyToSend(const makVrfEvents::DtDataEvent* readyToSendInteraction);

   virtual void signalInteractionCallback(const makVrfEvents::DtEvent&);
   virtual void processSignalInteraction(const makVrfEvents::DtExternalCommsSignalEvent* inter);
   virtual void sendInteraction(const makVrfEvents::DtExternalCommsMessageParams& params,
      const DtSignalMessageHeader& msgHdr, const char* pContent);

   virtual void sendSignalInteraction(const makVrfEvents::DtExternalCommsSignalEvent& signalInteraction);
   virtual void clearSplitContent();

public:

protected:
   bool myEnabled;
   DtCommunicationManager* myCommunicationManager;
   DtProcessMessageCallbackList myProcessMessageCallbackList;
   DtNewMessageCallbackList myNewMessageCallbackList;
   DtReadyToSendCallbackList myReadyToSendCallbackList;
   DtTimeoutCallbackList myTimeoutCallbackList;
   SplitContentMap mySplitContentMap;
   DtSplitContentTimer mySplitContentTimer;
   DtClock myClock;
};

inline bool DtExternalCommsMessageTransporter::enabled() const
{
   return myEnabled;
}