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/eventManager.h"
#include "vrfMsgTransport/events.h"
#include <vlutil/vlMachineTypes.h>
#include <vlpi/disEnums.h>
#include "vrfmsgs/messageExecutive.h"
#include <vrfmsgs/messageTypes.h>
#include <vlutil/vlUtil.h>

class DtSimInterfaceMessage;
class DtInterfaceMessageExecutive;
class DtCommunicationManager;
class DtSimInterfaceContent;
class DtInterfaceContentFactory;

class DtVrfMessageInterface;
typedef bool (*DtIsValidVrfMessageVersionFcn)(DtU32 version, const makVrfEvents::DtDataEvent* inter, void* user);
typedef DtVrfMessageInterface* (*DtVrfMessageInterfaceCreatorFcn)(DtCommunicationManager* exConn, bool useDefaultInterfaceFactory);

class DT_DLL_vrfMsgTransport DtVrfMessageInterface
{
public:
   DtVrfMessageInterface(DtCommunicationManager* exConn, 
      bool useDefaultInterfaceFactory = true);

   virtual ~DtVrfMessageInterface();

   virtual bool init();

   virtual bool createMessageExecutive();

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

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

   virtual bool getContentFromNet(const makVrfEvents::DtDataEvent* dataInter,
      DtSimInterfaceContent*& content) const;

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

   virtual bool setContentForNet(makVrfEvents::DtDataEvent* 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(const makVrfEvents::DtDataEvent*) 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);
   
   DtCommunicationManager* communicationManager() const;
   virtual void setConnectionManager(DtCommunicationManager* cm);

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

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

   virtual DtInterfaceMessageExecutive* messageExecutive() const;

   virtual const DtSimulationAddress& messageAddress() const;

   virtual bool receiveMessage(const makVrfEvents::DtDataEvent* dataInter);

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

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

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

   virtual void setCommunicationManager(DtCommunicationManager*);

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

public:
   static DtVrfMessageInterface* create(DtCommunicationManager* exConn, bool useDefaultInterfaceFactory = true);
   static DtVrfMessageInterfaceCreatorFcn setCreator(DtVrfMessageInterfaceCreatorFcn);
   static DtVrfMessageInterfaceCreatorFcn creator();

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

   virtual bool sendNormalMessage(const DtSimInterfaceMessage& message, bool overrideTimestampOrder, bool sendImmediately = false);

   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;
   DtCommunicationManager*       myCommunicationManager;

   bool myCreatedInterfaceFactory;
   DtU32 mySequenceNumber;
   DtU32 mySessionId;

   DtU32 myVrfMessageVersionSupported;
   DtList myCallbacks;

   static DtVrfMessageInterfaceCreatorFcn theCreatorFcn;
};

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 DtCommunicationManager* DtVrfMessageInterface::communicationManager() const
{
   return myCommunicationManager;
}

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