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 <vl/globalObjectDesignator.h>
#include <vl/dataInteraction.h>
#include "vrfmsgs/vrfObjectMessage.h"
#include "vrfMsgTransport/vrfMsgTransportDefines.h"
#include <vl/signalInteraction.h>
#include <vrfmsgs/splitMessageHandle.h>
#include <vrfutil/splitContentTimer.h>
#include <vlutil/vlTime.h>

class DtEventManager;
class DtEvent;
class DtSplitMessageKey;
class DtSignalMessageHeader;

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

struct DtExternalCommsMessageParams
{
   DtU32 messageId;
   DtGlobalObjectDesignator transmitterDesignator; 
   DtU32 radioIndex;
   DtU32 messageSize;
   DtEntityIdentifier receiverID;
   float timeout;
   double sampleRate;
};

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(DtEventManager*);
   virtual bool init();

public:
   static DtExternalCommsMessageTransporter* create(DtEventManager*);

   virtual ~DtExternalCommsMessageTransporter();

public:
   typedef DtCallbackList<const DtExternalCommsProcessMessageData&> DtProcessMessageCallbackList;
   typedef DtCallbackList<const DtExternalCommsTimeoutData&> DtTimeoutCallbackList;
   typedef std::pair<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 void addTimeoutCallback(DtTimeoutCallbackList::DtCallbackFunctionType fcn,
      void* usr);
   virtual void removeTimeoutCallback(DtTimeoutCallbackList::DtCallbackFunctionType fcn,
      void* usr);


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


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

   virtual void clearSplitContent();

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

   virtual void processSplitContentTimeout(const DtSplitMessageKey& key);

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

   virtual bool reassembleVrfObjectMessage(const DtExternalCommsMessageParams& params,
      const DtSignalMessageHeader& msgHdr);

   virtual void removeSplitContent(const DtSplitMessageKey& key);

   virtual void sendInteraction(const DtExternalCommsMessageParams& params,
      const DtSignalMessageHeader& msgHdr,
      const char* pContent);

   virtual void sendMessage(const DtExternalCommsMessageParams& params, DtVrfObjectMessage* message);

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

protected:

   virtual DtString entityIdToString(const DtEntityIdentifier& id) const;

   virtual void dataInteractionCallback(const DtEvent&);

   virtual void processDataInteraction(DtDataInteraction* interaction);

   virtual void processExternalCommsProcessMessage(DtDataInteraction* processMessageInteraction);

   virtual void processExternalCommsTimout(DtDataInteraction* timeoutInteraction);

   virtual void processExternalCommsReadyToSend(DtDataInteraction* readyToSendInteraction);

   virtual void signalInteractionCallback(const DtEvent&);
   virtual void processSignalInteraction(DtSignalInteraction* inter);

   virtual void sendSignalInteraction(DtSignalInteraction& signalInteraction);

public:

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

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