interMgr.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1998 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: interMgr.h,v $ $Revision: 1.64 $ $State: Exp $
*********************************************************************/

#ifndef interMgr_H_
#define interMgr_H_


#include <vlutil/vlList.h>
#include <vlutil/vlHashlist.h>
#include <vlutil/vlFedTarget.h>
#include "fomMgr.h"
#include "connectMgr.h"
#include "RIDparams.h"
#include "pHandValSet.h"
#ifdef DtMOM
#include "tallySet.h"
#endif

class DtRtiSaveFile;
class DtInteractionClassInfo;
class DtInteractionMgr;
class DtFomClassMgr;
class DtMomMgr;
class DtTimeMgr;
class DtInteractionMsg;
class DtPubInterMsg;
class DtUnpubInterMsg;
class DtSubInterMsg;
class DtUnsubInterMsg;
class DtResignMsg;
class DtRegion;
class DtPhvps;
class DtRtiObject;

class DT_DLL_LRC DtInteractionMgr
{
public:
   typedef DtInteractionMgr* (*DtInteractionMgrCreator)(DtFederateMgr* fedMgr);

protected:
   typedef std::map< DtInteractionClassHandle, DtBitMask*> DtInteractionClassMaskMap;

protected:

   DtInteractionMgr(DtFederateMgr* fedMgr);

public:

   virtual ~DtInteractionMgr();

private:

   DtInteractionMgr(DtInteractionMgr const& other);

   DtInteractionMgr& operator=(DtInteractionMgr const& other);

public:

   virtual void postJoinInit();

   virtual bool isPostJoined() const;

   virtual void publish(
      DtInteractionClassHandle theInteraction);

   virtual void unpublish(
      DtInteractionClassHandle theInteraction);

   virtual void subscribe(
      DtInteractionClassHandle theClass,
      bool active);

   virtual void unsubscribe(
      DtInteractionClassHandle theClass);

   virtual unsigned long send(DtInteractionClassHandle theInteraction, const DtPhvps& params, DtRtiApiTime const * theTime,
      DtRtiApiTagConstRef theTag, DtHandle channel, bool anonymous=false);

   virtual unsigned long sendDirected(DtInteractionClassHandle theInteraction, DtObjectInstanceHandle objectInstance,
      const DtPhvps& params, DtRtiApiTagConstRef theTag, DtRtiApiTime const* theTime = nullptr);

   virtual MAKRti::DtTransportType getTransport(DtInteractionClassHandle theClass);

   virtual void setTransport(
      DtInteractionClassHandle theClass,
      MAKRti::DtTransportType theType);

#if !defined(DtIFSPEC13) && !defined(DtIFSPEC1516)
   virtual void requestInteractionTransportationTypeChange(
      DtInteractionClassHandle theClass,
      MAKRti::DtTransportType theType );
#endif   

   virtual void setOrder(DtInteractionClassHandle theClass,
                         MAKRti::DtOrderType theType);

#if defined(DtIFSPEC13)
   virtual void subscribeInteractionClassWithRegion(
      DtInteractionClassHandle theClass,
      DtRegion &theRegion,
      bool active) {}

   virtual void unsubscribeInteractionClassWithRegion (
      DtInteractionClassHandle theClass,
      DtRegion &theRegion) {}

   virtual unsigned long send(
      DtInteractionClassHandle theClass,
      const DtPhvps& params,
      RTI::FedTime const * theTime,
      const char* theTag,
      DtRegion& theRegion,
      bool anonymous=false) {return 0;}

#else

   virtual void subscribeInteractionClassWithRegions (
      DtInteractionClassHandle theClass,
      RTI_API::RegionHandleSet const & theRegionHandleSet,
      bool active) {}

   virtual void unsubscribeInteractionClassWithRegions (
      DtInteractionClassHandle theClass,
      RTI_API::RegionHandleSet const & theRegionHandleSet) {}

   virtual unsigned long send(
      DtInteractionClassHandle theClass,
      const DtPhvps& params,
      RTI_API::RegionHandleSet const & theRegionHandleSet,
      RTI_API::LogicalTime const * theTime,
      RTI_API::VariableLengthData const & theTag,
      bool anonymous = false) {return 0;}

#endif 

   virtual int acceptInteraction(const DtInteractionMsg& msg);

   virtual int subscribed(DtInteractionClassHandle handle);

   virtual int published(DtInteractionClassHandle handle);

   virtual int subscribed(DtInteractionClassInfo const* classDesc);

   virtual bool subscribed(DtObjectClassInfo const* objectClassInfo, DtInteractionClassInfo const* interactionClassInfo);

   virtual int evaluateSubscription(DtRtiMsg const& msg);

   virtual void sendSubscribeMsg(DtInteractionClassHandle theInter, bool isPassive, 
      DtFederateHandle fedHandle);
   virtual void sendSubscribeMsg(DtInteractionClassHandle theInter,
      bool isPassive,  DtBitMask* sendMask = 0);

   virtual void sendPublishMsg(DtInteractionClassHandle theInter);

   virtual void sendUnsubscribeMsg(DtInteractionClassHandle theInter,
      bool forSmartForwarding=false);

   virtual void sendUnpublishMsg(DtInteractionClassHandle theInter);

   virtual void sendInteractionMsg(DtInteractionClassHandle theClass, const DtPhvps& theParams,
      MAKRti::DtTransportType transportType, MAKRti::DtOrderType orderType, DtRtiApiTime const * theTime,
      DtRtiApiTagConstRef theTag, unsigned long serialNumber, DtHandle channel, bool anonymous = false);

   virtual void sendDirectedInteractionMsg(DtInteractionClassHandle interactionClass, DtRtiObject const& objectHandle,
      const DtPhvps& parameters, MAKRti::DtOrderType orderType, DtRtiApiTime const* time, DtRtiApiTagConstRef userTag,
      unsigned long serialNumber);

   virtual void checkParameterHandles(DtInteractionClassInfo* classDesc, const DtPhvps& paramValues);

   virtual void addPendingStartInters(
      DtInteractionClassHandle theClass);
   virtual void addPendingStopInters(
      DtInteractionClassHandle theClass);

   virtual void sendPendingStartInters();
   virtual void sendPendingStopInters();

   virtual void sendPendingSubscription();
   virtual void addPendingSubscription(DtInteractionClassHandle theClass,
      bool isPassive, DtFederateHandle fedHandle = 0);

   virtual void sendPendingUnsubscription();
   virtual void addPendingUnsubscription(DtInteractionClassHandle theClass,
      bool forSmartForwarding);

   virtual void preTick();

   virtual void postTick();

   virtual void processResign(const DtResignMsg& msg);

   virtual DtInteractionClassInfo* firstSubscribedClass(DtInteractionClassInfo* classDesc);

   virtual DtInteractionClassInfo* firstSubscribedDirectedClass(DtObjectClassInfo const* knownObjectClass, bool attributesOwned,
      DtInteractionClassInfo* classDesc);

   virtual void enableRelevanceAdvisorySwitch();
   virtual void disableRelevanceAdvisorySwitch();

   virtual void setRelevanceAdvisorySwitch(bool enableSwitch);
   virtual bool relevanceAdvisorySwitch() const;

   virtual MAKRti::DtInetAddr localAddrMap(
      DtInteractionClassHandle theClass, DtHandle theChannel);


   virtual void checkForRegionalSubscribe(DtInteractionClassInfo& info) {}

   virtual void checkForRegionalPublish(DtInteractionClassInfo& info) {}

   virtual bool save(DtRtiSaveFile& file);

   virtual void prepareToRestore();

   virtual bool restore( DtRtiSaveFile& file );

   virtual DtFederateMgr* federateMgr();
   virtual DtFederateMgr* federateMgr() const;

   virtual DtConnectionMgr* connectMgr();
   virtual DtConnectionMgr* connectMgr() const;

   virtual DtRIDParameters* params();
   virtual DtRIDParameters* params() const;
 
   virtual DtFomClassMgr* fom();
   virtual DtFomClassMgr* fom() const;

#ifdef DtMOM
   virtual DtMomMgr* momMgr();
   virtual DtMomMgr* momMgr() const;
#endif

   virtual DtTimeMgr* timeMgr();
   virtual DtTimeMgr* timeMgr() const;

public:

   static DtInteractionMgr* create(DtFederateMgr* fedMgrPtr);

   static void setCreatorFunction(DtInteractionMgrCreator fn);
   
   static void setInternalCreatorFunction(DtInteractionMgrCreator fn);


protected:

   //Increment MOM tally
   virtual void fastIncrementSentTally(DtInteractionClassHandle classHandle,
      MAKRti::DtTransportType transport);
   virtual void fastIncrementReceivedTally(DtInteractionClassHandle classHandle,
      MAKRti::DtTransportType transport);

   virtual void insertBitMask(DtInteractionClassMaskMap& classMaskMap, DtObjectClassHandle classHandle,
      DtFederateHandle fedHandle);

#if defined(DtIFSPEC13)
   virtual DtPhvps* getParameterValuesAndRegionHandles(const DtInteractionMsg& inter, DtObjectInstanceHandle objectHandle,
      DtPhvps& msgParams, DtInteractionClassInfo const** receiveClassDesc);
#else
   virtual DtPhvps* getParameterValuesAndRegionHandles(const DtInteractionMsg& inter, DtObjectInstanceHandle objectHandle,
      DtPhvps& msgParams, DtInteractionClassInfo const** receiveClassDesc, RTI_API::RegionHandleSet& regionHandles);
#endif

   virtual void processInteraction(const DtInteractionMsg& msg);
   virtual void processPub(const DtPubInterMsg& msg);
   virtual void processUnpub(const DtUnpubInterMsg& msg);
   virtual void processSub(const DtSubInterMsg& msg);
   virtual void processUnsub(const DtUnsubInterMsg& msg);

   virtual void addClassMulticast(DtInteractionClassInfo* classDesc);
   virtual void removeClassMulticast(DtInteractionClassInfo* classDesc);

#ifdef DtMOM
   //Increment MOM tally
   virtual void incrementSentTally(DtInteractionClassHandle classHandle,
      MAKRti::DtTransportType transport);
   virtual void incrementReceivedTally(DtInteractionClassHandle classHandle,
      MAKRti::DtTransportType transport);
#endif

#if defined(DtIFSPEC13)
   virtual void calculateRegionSet(
      DtInteractionClassInfo const& sentClassInfo,
      unsigned long channel, DtPhvps& paramSet) {};
#else
   virtual void calculateRegionSet(
      DtInteractionClassInfo const& sentClassInfo,
      DtInteractionClassInfo const& receivedClassInfo,
      unsigned long channel,
      RTI_API::RegionHandleSet & regionHandles) {}
#endif

   virtual void destroyInteractionLists();

protected:

   static void processInteraction(const DtInteractionMsg& msg, void* usr);
   static void processPub(const DtPubInterMsg& msg, void* usr);
   static void processUnpub(const DtUnpubInterMsg& msg, void* usr);
   static void processSub(const DtSubInterMsg& msg, void* usr);
   static void processUnsub(const DtUnsubInterMsg& msg, void* usr);

protected:

   DtFederateMgr* myFederateMgr;

   bool myIsJoined;

   MAKRti::DtList myPendingStartIntersList;
   MAKRti::DtList myPendingStopIntersList;

   std::set<DtRtiMsgKind> myConstrainedInteractionKinds;

   bool myRelevanceSwitch;

   DtInteractionClassHandleStdSet myRetransmitSubClass;
   DtInteractionClassMaskMap myRetransmitSubClassMask;
   DtInteractionClassHandleStdSet myRetransmitPassiveSubClass;

   DtInteractionClassHandleStdSet myRetransmitUnsubClass;
   DtInteractionClassHandleStdSet myRetransmitUnsubClassForSmartForwarding;

protected:

   static DtInteractionMgrCreator theCreator;

   static DtInteractionMgrCreator theInternalCreator;
};

#endif