distributedDdmMgr.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2006 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: distributedDdmMgr.h,v $ $Revision: 1.9 $ $State: Exp $
*********************************************************************/
#ifndef distributedDdmMgr_H_
#define distributedDdmMgr_H_
#ifdef DDM


#include "rtiMsConfig.h"
#include <assert.h>
#include "ddmMgr.h"

class DtObjectDataDistMgr;
class DtInterDataDistMgr;
class DtDistributedRegion;
class DtRegionSet;
class DtNotifyRegMsg;
class DtDeleteRegMsg;
class DtRegionRealizationMsg;
class DtResignMsg;

class DT_DLL_LRC DtDistributedDataDistMgr : public DtDataDistMgr
{

public:
   typedef std::map<DtRegionHandle, DtRegionRealization*> DtRegionRealizationMap;

protected:

   DtDistributedDataDistMgr(DtFederateMgr* fedMgrPtr);

public:

   virtual ~DtDistributedDataDistMgr();

private:
   
   DtDistributedDataDistMgr(DtDistributedDataDistMgr const& );

   DtDistributedDataDistMgr& operator= (DtDistributedDataDistMgr const& );

public:

   virtual DtDistributedRegion& defaultRegion();

   virtual DtRegionRealization& defaultRegionRealization();

   virtual DtRegionEntryList const& defaultRegionList() const;

   virtual DtObjectDataDistMgr* objDdmMgr();

   virtual DtInterDataDistMgr* interDdmMgr();

   virtual bool active();

   virtual MAKRti::DtInetAddr freeChannel();

   virtual void processNotifyRegion(const DtNotifyRegMsg& msg);

   virtual void processDeleteRegion(const DtDeleteRegMsg& msg);

   virtual void processRegionRealization(const DtRegionRealizationMsg& msg);

   virtual void processResign(const DtResignMsg& msg);

   virtual void joinObjectRegionSet(const MAKRti::DtInetAddr& address,
      DtRegionHandle regionSetHandle);

   virtual void dropObjectRegionSet(const MAKRti::DtInetAddr& address,
      DtRegionHandle regionSetHandle);

   virtual void joinInteractionRegionSet(const MAKRti::DtInetAddr& address,
      DtInteractionClassHandle classHandle, DtRegionHandle regionSetHandle);

   virtual void dropInteractionRegionSet(const MAKRti::DtInetAddr& address,
      DtInteractionClassHandle classHandle, DtRegionHandle regionSetHandle);

   virtual DtRegion* localRegion(DtRegionHandle regionHandle);

   virtual DtDistributedRegion* localDistributedRegion(DtRegionHandle regionHandle);

   virtual bool isMemberLocalRegions(DtRegionHandle regionHandle);

   virtual DtRegion* remoteRegion(DtRegionHandle regionHandle);

   virtual DtDistributedRegion* remoteDistributedRegion(DtRegionHandle regionHandle);

   virtual DtRegionRealization* localRegionRealization(
      DtRegionHandle realizationHandle);

   virtual DtRegionRealization* remoteRegionRealization(
      DtRegionHandle realizationHandle);

   virtual bool isMemberRemoteRegions(DtRegionHandle regionHandle);

#if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E) || defined(DtIFSPEC1516_2025)
   virtual DtRegionHandle constructConveyedRegion(DtRegionRealization const& region,
      DtDimensionHandleStdSet const& availDim);

   virtual void destructConveyedRegions();

   virtual DtRegionRealization const* conveyedRegion(
      DtRegionHandle realizationHandle);
#endif

   virtual void addPendingNotifyRegion(DtRegionSet& regionSet);

   virtual void addPendingNotifyRegion(const DtRegionEntryList& regionList);

   virtual void sendPendingNotifyRegion(bool forceDualTransmit=false);

   virtual void sendNotifyRegionMsg(const DtDistributedRegion &region,
      bool forceDualTransmit=false);

   virtual void sendDeleteRegionMsg(DtRegionHandle handleValue);

   virtual void sendRegionRealizationMsg(
      DtRegionRealization const& regionRealization, bool forceDualTransmit=false);

#if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E) || defined(DtIFSPEC1516_2025)
   virtual DtRegionHandle createRegion(DtDimensionHandleStdSet const & dimHandles);
#else
   virtual DtRegion* createRegion(DtSpaceHandle spaceHandleValue, unsigned long numberOfExtents);
   virtual DtDistributedRegion* createDistributedRegion(DtSpaceHandle spaceHandleValue, unsigned long numberOfExtents);
#endif

   virtual void deleteRegion(DtRegion *regionPtr);

   virtual void deleteDistributedRegion(DtDistributedRegion *regionPtr);

   virtual void deleteRegion(DtRegionHandle regionHandle);

   virtual void notifyAboutRegionModification(DtRegion* theRegion);

   virtual void notifyAboutDistributedRegionModification(DtDistributedRegion* theRegion);

   virtual void notifyAboutRegionModification(DtRegionHandle regionHandle);

   virtual DtRegionRealization* getRegionRealization(DtDistributedRegion* region,
      DtDimensionHandleStdSet* defaultDimensions = NULL);

   virtual DtSpaceHandle getAttributeRoutingSpaceHandle(
     DtAttributeHandle   theHandle,
     DtObjectClassHandle whichClass);

   virtual DtSpaceHandle getInteractionRoutingSpaceHandle(
      DtInteractionClassHandle   theHandle);

#if !defined(DtIFSPEC13)
   virtual void setRangeBounds(DtRegionHandle regionHandle, DtExtentIndex extentIndex, DtDimensionHandle dimHandle,
      unsigned long lower, unsigned long upper);
   virtual void setRangeBounds(DtRegionHandle regionHandle, DtExtentIndex extentIndex, DtDimBounds const & dimBounds);
   virtual DtDimBounds getRangeBounds(DtRegionHandle regionHandle, DtExtentIndex extentIndex, DtDimensionHandle dimHandle);

   virtual bool getDimensionHandleSet(DtRegionHandle theRegionHandle, RTI_API::DimensionHandleSet& dimSet) const;
#endif

   virtual void postTick();

   virtual bool save(DtRtiSaveFile& file);

   virtual void prepareToRestore();

   virtual bool restore( DtRtiSaveFile& file );

public:

   static void processNotifyRegion(const DtNotifyRegMsg& msg, void* usr);

   static void processDeleteRegion(const DtDeleteRegMsg& msg, void* usr);

   static void processRegionRealization(const DtRegionRealizationMsg& msg,
      void* usr);

   static DtDataDistMgr* create(DtFederateMgr* fedMgrPtr);

protected:

   virtual DtRegionHandle uniqueRegionHandle();

   virtual DtRegionHandle uniqueRegionRealizationHandle();

   virtual void addLocalRegion(DtDistributedRegion* region);
   virtual void removeLocalRegion(DtRegionHandle regionHandle);
   
   virtual void addRemoteRegion(DtDistributedRegion* region,
      DtFederateHandle fedHandle);
   virtual void removeRemoteRegion(DtRegionHandle regionHandle,
      DtFederateHandle fedHandle);

   virtual void addLocalRegionRealization(DtRegionRealization* realization);
   virtual void removeLocalRegionRealization(DtRegionHandle handle);

   virtual void addRemoteRegionRealization(DtRegionRealization* realization,
      DtFederateHandle fedHandle);
   virtual void removeRemoteRegionRealization(DtRegionHandle handle,
      DtFederateHandle fedHandle);

   virtual void destroyLists();

protected:
   
   DtDistributedRegion* myDefaultRegion;
   DtRegionRealization* myDefaultRegionRealization;
   DtRegionEntryList myDefaultRegionList;
   
   MAKRti::DtInetAddr myFreeChannel;

   bool myFreeChannelInitialized;

   std::map<DtInetAddr, MAKRti::DtList*> myObjRegSetChannels;
   std::map<DtInetAddr, MAKRti::DtHashlist*> myInterRegSetChannels;

   MAKRti::DtHashlist myLocalRegions;
   MAKRti::DtHashlist myRemoteRegions;
   MAKRti::DtHashlist myRemoteRegionsByFederate;
   MAKRti::DtHashlist myLocalRegionRealizations;
   MAKRti::DtHashlist myLocalRegionRealizationsByRegion;
   std::map<DtRegionHandle, DtRegionRealization*> myRemoteRegionRealizations;
   MAKRti::DtHashlist myRemoteRegionRealizationsByRegion;
   MAKRti::DtHashlist myRemoteRegionRealizationsByFederate;
   DtRegionRealizationMap myConveyedRegions;

   DtRegionHandle myNextRegionHandle;
   DtRegionHandle myNextRegionRealizationHandle;
   DtRegionHandle myNextConveyedRegionHandle;

   DtRegionHandleStdSet myPendingNotifyRegions;

   DtRegionHandleStdSet myNotifyRegionsSentThisTick;

};

#endif
#endif