federationShadow.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2022 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include <rtiMsConfig.h>

#include <federationShadowHandshakeMsg.h>
#include <internalTypes.h>

#include <vlutil/vlPrint.h>
#include <vlutil/vlSmartPointers.h>
#include <vlutil/vlTime.h>
#include <vlutil/vlFedTarget.h>

#include <queue>

class DtFederationShadowHandshakeMsg;
class DtFederationShadowShutdownMsg;
class DtCreateResponseMsg;
class DtJoinMsg;
class DtJoinResponseMsg;
class DtJoinConfirmMsg;
class DtResignMsg;
class DtResignDirectiveMsg;
class DtRegObjMsg;
class DtMultiRegObjMsg;
class DtAssocPubRegMsg;
class DtDeleteRoMsg;
class DtDeleteTsoMsg;
class DtOwnershipMsg;

class DtFederationShadow;
class DtFederateShadow;
class DtSynchronousFileDistributor;
class DtConnectionMgr;
class DtFomModuleManager;
class DtRIDParameters;

typedef DtFederationShadow* (*DtFederationShadowCreator)(DtHandle federationHandle, const MAKRti::DtString& federationName,
   DtRIDParameters* p, std::shared_ptr<DtFilePrinter> logPrinter);


class DT_DLL_FEDSHDW DtFederationShadow
{
protected:

   DtFederationShadow(DtHandle federationHandle, const MAKRti::DtString& federationName, DtRIDParameters* p,
      std::shared_ptr<DtFilePrinter> logPrinter);

public:

   virtual ~DtFederationShadow();

   virtual DtHandle federationHandle() const;

   virtual const MAKRti::DtString& name() const;

   DtConnectionMgr* connectMgr();

   virtual DtFomModuleManager* fomManager();

   const DtRIDParameters& params() const;

   virtual void checkVersion(const MAKRti::DtString& version) const;

   virtual void processUpdateNotifyLevel(DtNotifyLevelType level);

   virtual void exit();

   int processQuit();

   virtual DtResignAction resignAction() const;

   virtual void run();

public:

   static DtFederationShadow* create(DtHandle federationHandle, const MAKRti::DtString& federationName, DtRIDParameters* p,
      std::shared_ptr<DtFilePrinter> logPrinter);

   static void setCreatorFunction(DtFederationShadowCreator fn);

   static bool shutdownSignalCaught();
   static void caughtShutdownSignal();

   static const MAKRti::DtString& shutDownStatement();

   static const MAKRti::DtString& readyStatement();

protected:

   virtual DtFederateShadow* federateShadow(DtHandle federateHandle);

   virtual void cleanupConstructorException();

   virtual void wait(DtTime intervalInSeconds);

   virtual bool tick(bool noCallbacks = false);

   virtual bool processJoinFoms(const DtJoinResponseMsg& msg);

   virtual void sendFederationShadowHandshakeMsg(DtHandle destinationId,
      DtFederationShadowHandshakeMsg::HandshakeStatus status);

   virtual void federationShadowToForwarderHandshake();


   virtual bool queueMessage(const DtRtiMsg& msg);
   virtual DtRtiMsg* popMessageQueue();
   virtual void processQueuedMessages(DtRtiMsg* nextMessage);


   static  void processFederationShadowHandshakeMsg(const DtFederationShadowHandshakeMsg& msg, void* usr);
   virtual void processFederationShadowHandshakeMsg(const DtFederationShadowHandshakeMsg& msg);

   virtual void processFederationShadowShutdownMsg(const DtFederationShadowShutdownMsg& msg);
   static  void processFederationShadowShutdownMsg(const DtFederationShadowShutdownMsg& msg, void* usr);

   virtual void processCreateResponseMsg(const DtCreateResponseMsg& msg);
   static  void processCreateResponseMsg(const DtCreateResponseMsg& msg, void* usr);

   virtual void processJoinMsg(const DtJoinMsg& msg);
   static  void processJoinMsg(const DtJoinMsg& msg, void* usr);

   virtual void processJoinResponseMsg(const DtJoinResponseMsg& msg);
   virtual void doProcessJoinResponseMsg(const DtJoinResponseMsg& msg);
   static  void processJoinResponseMsg(const DtJoinResponseMsg& msg, void* usr);

   virtual void processJoinConfirmMsg(const DtJoinConfirmMsg& msg);
   static  void processJoinConfirmMsg(const DtJoinConfirmMsg& msg, void* usr);

   virtual void processResignMsg(const DtResignMsg& msg);
   static  void processResignMsg(const DtResignMsg& msg, void* usr);

   virtual void processResignDirectiveMsg(const DtResignDirectiveMsg& msg);
   static  void processResignDirectiveMsg(const DtResignDirectiveMsg& msg, void* usr);

   virtual void processRegObjMsg(const DtRegObjMsg& msg);
   static  void processRegObjMsg(const DtRegObjMsg& msg, void* usr);

   virtual void processMultiRegObjMsg(const DtMultiRegObjMsg& msg);
   static  void processMultiRegObjMsg(const DtMultiRegObjMsg& msg, void* usr);

   virtual void processAssocPubRegMsg(const DtAssocPubRegMsg& msg);
   static  void processAssocPubRegMsg(const DtAssocPubRegMsg& msg, void* usr);

   virtual void processDeleteRoMsg(const DtDeleteRoMsg& msg);
   static  void processDeleteRoMsg(const DtDeleteRoMsg& msg, void* usr);

   virtual void processDeleteTsoMsg(const DtDeleteTsoMsg& msg);
   static  void processDeleteTsoMsg(const DtDeleteTsoMsg& msg, void* usr);

   virtual void processOwnershipMsg(const DtOwnershipMsg& msg);
   static  void processOwnershipMsg(const DtOwnershipMsg& msg, void* usr);

   inline DtFederateShadow* federate(DtFederateHandle federateHandle);

protected:

   typedef std::map<DtHandle, DtFederateShadow*> FederateShadowByHandleMap;
   DtRIDParameters* myParams;

   std::shared_ptr<DtFilePrinter> myLogPrinter;

   DtConnectionMgr* myConnectionMgr;

   DtFomModuleManager* myFomManager;

   DtResignAction myResignAction;

   DtSynchronousFileDistributor* myFomDistributor;

   DtClock myClock;
   MAKRti::DtString myFederationName;
   DtFederationHandle myFederationHandle;
   DtFederateHandle myFederateHandle;
   DtFederationShadowHandshakeMsg::HandshakeStatus myHandshakeStatus;

   FederateShadowByHandleMap myFederatesByConnection;
   FederateShadowByHandleMap myFederatesByHandle;
   std::set<DtFederateHandle> myJoinedFederates;

   bool myExitCommanded;
   bool myPendingQuit;


   std::queue<DtRtiMsg*> myBufferedMessages;
   bool myProcessingJoinResponse;

protected:

   static DtFederationShadowCreator theCreator;
   static bool theShutdownSignalCaught;
   static const MAKRti::DtString theShutDownStatement;
   static const MAKRti::DtString theReadyStatement;

};

inline DtConnectionMgr* DtFederationShadow::connectMgr()
{
   return myConnectionMgr;
}

inline const DtRIDParameters& DtFederationShadow::params() const
{
   return *myParams;
}

inline DtFederateShadow* DtFederationShadow::federate(DtFederateHandle federateHandle)
{
   FederateShadowByHandleMap::iterator findFed = myFederatesByHandle.find(federateHandle);
   return findFed != myFederatesByHandle.end() ? findFed->second : nullptr;
}