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 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,
#ifdef DtIFSPEC1516
      rti1516::LogicalTime const * theTime,
      rti1516::VariableLengthData const & theTag,
#elif defined(DtIFSPEC1516E)
      rti1516e::LogicalTime const * theTime,
      rti1516e::VariableLengthData const & theTag,
#else
      RTI::FedTime const * theTime,
      const char* theTag,
#endif
      DtHandle channel,
      bool anonymous=false);

   virtual MAKRti::DtTransportType getTransport(DtInteractionClassHandle theClass);

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

#ifdef DtIFSPEC1516E


   virtual void requestInteractionTransportationTypeChange( DtInteractionClassHandle theClass,
                                                            MAKRti::DtTransportType theType );
#endif   

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

#ifdef DDM
#ifdef DtIFSPEC1516

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

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

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

#elif defined(DtIFSPEC1516E)

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

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

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

   virtual void subscribeInteractionClassWithRegion(
      DtInteractionClassHandle theClass,
      DtRegion &theRegion,
      bool active) {}

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

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

#endif 
#endif 


   virtual int acceptInteraction(const DtInteractionMsg& msg);

   virtual int subscribed(DtInteractionClassHandle handle);

   virtual int published(DtInteractionClassHandle handle);

   virtual int subscribed(DtInteractionClassInfo* classDesc);

   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,
#ifdef DtIFSPEC1516
      rti1516::LogicalTime const * theTime,
      rti1516::VariableLengthData const & theTag,
#elif defined(DtIFSPEC1516E)
      rti1516e::LogicalTime const * theTime,
      rti1516e::VariableLengthData const & theTag,
#else
      RTI::FedTime const * theTime,
      const char* theTag,
#endif
      unsigned long serialNumber, DtHandle channel, bool anonymous=false);

   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 void enableRelevanceAdvisorySwitch();
   virtual void disableRelevanceAdvisorySwitch();

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

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

#ifdef DDM



   virtual void checkForRegionalSubscribe(DtInteractionClassInfo& info) {}

   virtual void checkForRegionalPublish(DtInteractionClassInfo& info) {}

#endif

   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

#ifdef DtTIME

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


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

   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

#ifdef DDM
#ifdef DtIFSPEC1516

   virtual void calculateRegionSet(
      DtInteractionClassInfo const& sentClassInfo,
      DtInteractionClassInfo const& receivedClassInfo,
      unsigned long channel,
      rti1516::RegionHandleSet & regionHandles) {}
#elif defined(DtIFSPEC1516E)

   virtual void calculateRegionSet(
       DtInteractionClassInfo const& sentClassInfo,
       DtInteractionClassInfo const& receivedClassInfo,
       unsigned long channel,
       rti1516e::RegionHandleSet & regionHandles) {}
#else
   virtual void calculateRegionSet(
      DtInteractionClassInfo const& sentClassInfo,
      unsigned long channel, DtPhvps& paramSet) {};
#endif
#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;

   std::set<DtInteractionClassHandle> myRetransmitSubClass;
   DtInteractionClassMaskMap          myRetransmitSubClassMask;
   std::set<DtInteractionClassHandle> myRetransmitPassiveSubClass;

   std::set<DtInteractionClassHandle> myRetransmitUnsubClass;
   std::set<DtInteractionClassHandle> myRetransmitUnsubClassForSmartForwarding;

protected:

   static DtInteractionMgrCreator theCreator;

   static DtInteractionMgrCreator theInternalCreator;
};

#endif