objMgr.h

Go to the documentation of this file.

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

#ifndef objMgr_H_
#define objMgr_H_


#include "timeMgr.h"
#include "fedMgr.h"
#include "rtiMsConfig.h"
#include "connection.h"
#include "objClassInfo.h"
#include "rtiObject.h"
#include <vlutil/vlHashlist.h>
#include <vlutil/vlFedTarget.h>
#include "connectMgr.h"
#include "RIDparams.h"
#include "addrMap.h"
#include "reqObjMsg.h"
#include "ownerMsg.h"
#include "aHandValSet.h"
#include <set>
#include <list>
#if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)
#include <RTI/Enums.h>
#include <RTI/Exception.h>
#else
#ifdef DtIFSPEC13DLC
#include "RTI13.h"
#define RTI rti13
#else
#include "RTI.hh"
#endif
#endif

#define DtHlaNamePrefix "HLA_"

class DtUpdateMsg;
class DtReserveNameMsg;
class DtNameReservedMsg;
class DtRegObjMsg;
class DtMultiRegObjMsg;
class DtDiscObjMsg;
class DtReqDiscObjMsg;
class DtDeleteRoMsg;
class DtDeleteTsoMsg;
class DtLocDelMsg;
class DtPubObjMsg;
class DtUnpubObjMsg;
class DtSubObjMsg;
class DtUnsubObjMsg;
class DtRequestMsg;
class DtOwnershipMsg;
class DtResignMsg;
class DtRegion13;
class DtRegionEntryListWithAttributes;
class DtRtiSaveFile;
class DtMomTallyList;
class DtObjectMgr;
class DtFomClassMgr;
class DtTimeMgr;

#ifdef DtIFSPEC1516E
class DtQueryTransportMsg;
class DtQueryInterTransportMsg;
class DtReserveMultiNameMsg;
class DtMultiNameReservedMsg;
class DtReleaseMultiNameMsg;
#endif

enum DtDivestCondition
{
   DtDivestUnconditional,
   DtDivestNegotiated,
   DtDivestOnlyIfWanted
};

typedef std::map<DtHandle,DtRtiObject*> DtRtiObjectMap;

class DT_DLL_LRC DtObjectMgr
{
public:

   typedef DtObjectMgr* (*DtObjectMgrCreator)(DtFederateMgr* fedMgr);

   typedef std::map<DtObjectInstanceHandle, DtAttributeHandleSet>
      DtPendingRequestAttrMap;

protected:
   typedef std::set< DtObjectClassHandle > DtObjectClassHandleSet;
   typedef std::set< DtObjectInstanceHandle > DtObjectInstanceHandleSet;
   typedef std::map< DtObjectClassHandle,DtBitMask*> DtObjectClassMaskMap;
   typedef std::map< DtObjectInstanceHandle,DtBitMask*> DtObjectInstanceMaskMap;
   typedef std::list< std::pair< DtObjectClassHandle, DtAttributeHandleSet > > DtObjClassAttrSetPairList;
   typedef std::list< std::pair< DtObjectInstanceHandle, DtAttributeHandleSet > > DtObjInstAttrSetPairList;
#ifdef DtTIME
#ifdef DtIFSPEC1516
   typedef std::map<DtObjectInstanceHandle, rti1516::LogicalTime const *> DtObjectHandleTimeMap;
   typedef std::map<DtRtiObject*, rti1516::LogicalTime const *> DtObjectPtrTimeMap;
#elif defined(DtIFSPEC1516E)
   typedef std::map<DtObjectInstanceHandle, rti1516e::LogicalTime const *> DtObjectHandleTimeMap;
   typedef std::map<DtRtiObject*, rti1516e::LogicalTime const *> DtObjectPtrTimeMap;
#else
   typedef std::map<DtObjectInstanceHandle, RTI::FedTime const *> DtObjectHandleTimeMap;
   typedef std::map<DtRtiObject*, RTI::FedTime const *> DtObjectPtrTimeMap;
#endif
#endif

protected:

   DtObjectMgr(DtFederateMgr* fedMgr);

public:

   virtual ~DtObjectMgr();

private:
   
   DtObjectMgr(DtObjectMgr const& );

   DtObjectMgr& operator= (DtObjectMgr const& );

public:

   virtual void postJoinInit();

   virtual bool isPostJoined() const;

   inline DtFederateMgr* federateMgr() {return myFederateMgr;}
   inline DtFederateMgr* federateMgr() const {return myFederateMgr;}

   inline DtConnectionMgr* connectMgr() {return federateMgr()->connectMgr();}
   inline DtConnectionMgr* connectMgr() const {return federateMgr()->connectMgr();}


   inline DtRIDParameters* params() {return federateMgr()->params();}
   inline DtRIDParameters* params() const {return federateMgr()->params();}


   inline DtFomClassMgr* fom() {return federateMgr()->fom();}
   inline DtFomClassMgr* fom() const {return federateMgr()->fom();}

#ifdef DtTIME

   inline DtTimeMgr* timeMgr() {return federateMgr()->timeMgr();}
   inline DtTimeMgr* timeMgr() const {return federateMgr()->timeMgr();}
#endif

   virtual bool useHlaNamePrefix();

   virtual DtObjectInstanceHandle objectHandle(const char* name);

   virtual const char* objectName(DtObjectInstanceHandle handle);

   virtual DtObjectClassHandle objectClass(DtObjectInstanceHandle handle);

   virtual int subscribed(DtObjectClassHandle handle);

   virtual int published(DtObjectClassHandle handle);

   virtual void publish(
      DtObjectClassHandle theObject,
      const DtAttributeHandleSet& attributeList);

   virtual void unpublishClass(
      DtObjectClassHandle theObject);

   virtual void unpublishAttributes(
      DtObjectClassHandle theClass,
      DtAttributeHandleSet const & attributeList);

   virtual void unpublishAttributes(
      DtObjectClassInfo& classDesc,
      DtAttributeHandleSet const & attributeList,
      bool implicitlyUnpublishPrivilegeToDelete);

   virtual void subscribe(
      DtObjectClassHandle theClass,
      const DtAttributeHandleSet& attributeList,
      bool active);

#ifdef DtIFSPEC1516E

   virtual void subscribe(
       DtObjectClassHandle theClass,
       const DtAttributeHandleSet& attributeList,
       bool active,
       MAKRti::DtString updateRateDesignator);
#endif

   virtual void unsubscribeClass(
      DtObjectClassHandle theClass);

   virtual void unsubscribeAttributes(
      DtObjectClassHandle theClass,
      DtAttributeHandleSet const & attributeList);

   virtual void unsubscribeAttributes(
      DtObjectClassInfo& classDesc,
      DtAttributeHandleSet const & attributeList);

#ifdef DtIFSPEC1516E

   virtual void reserveMultipleObjectInstanceName(
      std::set<std::wstring> const & theObjectInstanceNames);
#endif

#if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)

   virtual void reserveObjectInstanceName (
      std::string const & theObjectInstanceName);

   virtual DtObjectInstanceHandle registerObj(
      DtObjectClassHandle theClass,
      std::string const & theObjectInstanceName);

#else

   virtual DtObjectInstanceHandle registerObj(
      DtObjectClassHandle theClass,
      const char* name);
#endif

#ifdef DtIFSPEC1516E

   virtual void releaseObjectInstanceName(
      std::string const & theObjectInstanceName)
      throw (rti1516e::ObjectInstanceNameNotReserved);
   virtual void releaseMultipleObjectInstanceNames( 
      std::set< std::wstring > const & theObjectInstanceNames )
      throw (rti1516e::ObjectInstanceNameNotReserved);
   virtual void queryAttributeTransportationType(
       DtObjectInstanceHandle theObject,
       DtAttributeHandle theAttribute);
   virtual void queryInteractionTransportationType(
       DtFederateHandle theFederate,
       DtInteractionClassHandle theInteraction);
   virtual void releaseDenied( DtObjectInstanceHandle objectHandle, 
       const DtAttributeHandleSet & attrs );
   virtual double getUpdateRateForAttribute( DtObjectInstanceHandle objHandle, 
       DtAttributeHandle attrHandle );
#endif

   virtual DtObjectInstanceHandle registerObj(
      DtObjectClassHandle theClass);

#ifdef DtIFSPEC1516E
   bool holdsPrivilegeToDelete( const DtObjectInstanceHandle & id );
#endif

#ifdef DtIFSPEC1516


   virtual unsigned long deleteObj(
      DtObjectInstanceHandle objectID,
      rti1516::LogicalTime const * theTime,
      rti1516::VariableLengthData const & theTag);
#elif defined(DtIFSPEC1516E)


   virtual unsigned long deleteObj(
       DtObjectInstanceHandle objectID,
       rti1516e::LogicalTime const * theTime,
       rti1516e::VariableLengthData const & theTag);
#else


   virtual unsigned long deleteObj(
      DtObjectInstanceHandle objectID,
      RTI::FedTime const * theTime,
      char const * theTag);
#endif

   virtual void localDeleteObj(DtObjectInstanceHandle obj);

#ifdef DtIFSPEC1516
   virtual void requestObjectUpdate (
      DtObjectInstanceHandle  theObject,
      const DtAttributeHandleSet& theAttributes,
      rti1516::VariableLengthData const & tag=DtRtiMsg::theDefaultTag);
#elif defined(DtIFSPEC1516E)
   virtual void requestObjectUpdate (
       DtObjectInstanceHandle  theObject,
       const DtAttributeHandleSet& theAttributes,
       rti1516e::VariableLengthData const & tag=DtRtiMsg::theDefaultTag);
#else
   virtual void requestObjectUpdate (
      DtObjectInstanceHandle  theObject,
      const DtAttributeHandleSet& theAttributes,
      char const * tag=DtRtiMsg::theDefaultTag);
#endif

#ifdef DtIFSPEC1516
   virtual void requestClassUpdate (
      DtObjectClassHandle   theClass,
      const DtAttributeHandleSet& theAttributes,
      rti1516::VariableLengthData const & tag=DtRtiMsg::theDefaultTag,
      DtHandle regionSetHandle=DtDefaultRegionSetHandle);
#elif defined(DtIFSPEC1516E)
   virtual void requestClassUpdate (
       DtObjectClassHandle   theClass,
       const DtAttributeHandleSet& theAttributes,
       rti1516e::VariableLengthData const & tag=DtRtiMsg::theDefaultTag,
       DtHandle regionSetHandle=DtDefaultRegionSetHandle);
#else
   virtual void requestClassUpdate (
      DtObjectClassHandle   theClass,
      const DtAttributeHandleSet& theAttributes,
      char const * tag=DtRtiMsg::theDefaultTag,
      DtHandle regionSetHandle=DtDefaultRegionSetHandle);
#endif

#ifdef DtIFSPEC1516
   virtual unsigned long sendUpdate(
      DtObjectInstanceHandle theObject,
      const DtAhvps& theAttrs,
      rti1516::LogicalTime const * theTime,
      rti1516::VariableLengthData const & tag);
#elif defined(DtIFSPEC1516E)
   virtual unsigned long sendUpdate(
       DtObjectInstanceHandle theObject,
       const DtAhvps& theAttrs,
       rti1516e::LogicalTime const * theTime,
       rti1516e::VariableLengthData const & tag);
#else
   virtual unsigned long sendUpdate(
      DtObjectInstanceHandle theObject,
      const DtAhvps& theAttrs,
      RTI::FedTime const * theTime,
      char const * tag);
#endif

#ifdef DtIFSPEC1516
   virtual unsigned long sendUpdate(
      DtRtiObject* theObject,
      const DtAhvps& theAttrs,
      rti1516::LogicalTime const * theTime,
      rti1516::VariableLengthData const & tag);
#elif defined(DtIFSPEC1516E)
   virtual unsigned long sendUpdate(
       DtRtiObject* theObject,
       const DtAhvps& theAttrs,
       rti1516e::LogicalTime const * theTime,
       rti1516e::VariableLengthData const & tag);
#else
   virtual unsigned long sendUpdate(
      DtRtiObject* theObject,
      const DtAhvps& theAttrs,
      RTI::FedTime const * theTime,
      char const * tag);
#endif

#ifdef DtIFSPEC1516
   virtual void acquireAttrs(
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& desiredAttributes,
      bool onlyIfAvail,
      rti1516::VariableLengthData const & tag=DtRtiMsg::theDefaultTag);
#elif defined(DtIFSPEC1516E)
   virtual void acquireAttrs(
       DtObjectInstanceHandle objHand,
       const DtAttributeHandleSet& desiredAttributes,
       bool onlyIfAvail,
       rti1516e::VariableLengthData const & tag=DtRtiMsg::theDefaultTag);
#else
   virtual void acquireAttrs(
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& desiredAttributes,
      bool onlyIfAvail,
      char const * tag=DtRtiMsg::theDefaultTag);
#endif

   virtual void cancelAcquire(
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs);

#ifdef DtIFSPEC1516

   virtual void divestOwnership(
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs,
      DtDivestCondition condition,
      DtAttributeHandleSet& divestedSet,
      rti1516::VariableLengthData const & tag=DtRtiMsg::theDefaultTag);

   virtual void confirmDivestiture (
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs,
      rti1516::VariableLengthData const & theUserSuppliedTag);

#elif defined(DtIFSPEC1516E)

   virtual void divestOwnership(
       DtObjectInstanceHandle objHand,
       const DtAttributeHandleSet& attrs,
       DtDivestCondition condition,
       DtAttributeHandleSet& divestedSet,
       rti1516e::VariableLengthData const & tag=DtRtiMsg::theDefaultTag);

   virtual void confirmDivestiture (
       DtObjectInstanceHandle objHand,
       const DtAttributeHandleSet& attrs,
       rti1516e::VariableLengthData const & theUserSuppliedTag);

#else

   virtual void divestOwnership(
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs,
      DtDivestCondition condition,
      char const * tag=DtRtiMsg::theDefaultTag);
#endif

   virtual void cancelDivest(
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs);

   virtual DtAttributeHandleSet* releaseResponse(
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs);



   virtual void addAllObj(DtRtiObject* obj);
   virtual void removeAllObj(DtObjectInstanceHandle obj);
   virtual const DtRtiObjectMap& allObjects() const;
   virtual DtRtiObject* allObj(DtObjectInstanceHandle id);
   virtual DtRtiObject* allObj(const char* name);



   virtual void addKnownObj(DtRtiObject* obj);
   virtual void removeKnownObj(DtObjectInstanceHandle obj);
   virtual const DtRtiObjectMap& knownObjects() const;
   virtual DtRtiObject* knownObj(DtObjectInstanceHandle id);
   virtual DtRtiObject* knownObj(const char* name);



   virtual void addOwnedObj(DtRtiObject* obj);
   virtual void removeOwnedObj(DtObjectInstanceHandle obj);
   virtual const DtRtiObjectMap& ownedObjects() const;
   virtual DtRtiObject* ownedObj(DtObjectInstanceHandle id);
   virtual DtRtiObject* ownedObj(const char* name);



   virtual void addLrcManagedObj(DtRtiObject* obj);
   virtual void removeLrcManagedObj(DtObjectInstanceHandle obj);
   virtual const DtRtiObjectMap& lrcManagedObjects() const;
   virtual DtRtiObject* lrcManagedObj(DtObjectInstanceHandle id);
   virtual DtRtiObject* lrcManagedObj(const char* name);

   virtual void removeFromAllLists(DtRtiObject* object);

   virtual void queryOwnership(
      DtObjectInstanceHandle obj, DtAttributeHandle attr);

   virtual bool isAcquistionPending();

   virtual int evaluateSubscription(DtRtiMsg const& msg);

   virtual void autoProvideAttrValueUpdate();

   virtual void sendRegister(DtRtiObject* obj);

   virtual void resendRegister(DtRtiObject* obj, DtBitMask* sendMask = 0);
   
   virtual void resendMultiRegister( DtObjectClassHandle classHandle );

#ifdef DtIFSPEC1516


   virtual void sendRequestMsg(
      DtRequestType type, unsigned long idOrClass,
      const DtAttributeHandleSet& theSet,
      rti1516::VariableLengthData const & tag,
      bool anonymous,
      DtHandle regionSetHandle = DtRtiMsg::theDefaultRegionSetHandle,
      DtFederateHandle fedHandle = 0);
#elif defined(DtIFSPEC1516E)


   virtual void sendRequestMsg(
       DtRequestType type, unsigned long idOrClass,
       const DtAttributeHandleSet& theSet,
       rti1516e::VariableLengthData const & tag,
       bool anonymous,
       DtHandle regionSetHandle = DtRtiMsg::theDefaultRegionSetHandle,
       DtFederateHandle fedHandle = 0);
#endif

   virtual void addPendingStartUpdates(
      DtObjectInstanceHandle obj,
      const DtAttributeHandleSet& attributeList);

   virtual void addPendingStopUpdates(
      DtObjectClassHandle theClass,
      const DtAttributeHandleSet& attributeList);

   virtual void addPendingStartReg(DtObjectClassHandle theClass);

   virtual void addPendingStopReg(DtObjectClassHandle theClass);

   virtual void addPendingRegister(DtObjectClassHandle theClass, DtFederateHandle fedHandle = 0);

   virtual void addPendingSubscription(DtObjectClassHandle theClass, DtFederateHandle fedHandle = 0);

   virtual void addPendingRegisterForObject(DtObjectInstanceHandle objHandle);

   virtual void addPendingRemoval(DtObjectInstanceHandle id);

   virtual void addPendingRequestAttrs(DtObjectInstanceHandle objectHandle,
      DtAttributeHandleSet attributes);

   virtual void addPendingDivestNotification(DtObjectInstanceHandle objectHandle,
      DtAttributeHandleSet attributes);

   virtual void addPendingDiscovery(DtObjectInstanceHandle objectHandle,
      DtObjectClassHandle classHandle, DtFederateHandle federate,
      bool isNonDiscovery);

   virtual void processResign(const DtResignMsg& msg);



#ifdef DtIFSPEC1516
   void testResign(rti1516::ResignAction const & theAction);
   void prepareToResign(rti1516::ResignAction const & theAction);
#elif defined(DtIFSPEC1516E)
   void testResign(rti1516e::ResignAction const & theAction);
   void prepareToResign(rti1516e::ResignAction const & theAction);
#else
   void testResign(RTI::ResignAction const & theAction);
   void prepareToResign(RTI::ResignAction const & theAction);
#endif


   virtual void preTick();

   virtual void postTick();



   virtual void setRestoreInProgress(bool isRestore);
   virtual bool restoreInProgress() const;



   virtual void enableClassRelevanceSwitch();
   virtual void disableClassRelevanceSwitch();

   virtual void setClassRelevanceSwitch(bool enableSwitch);
   virtual bool classRelevanceSwitch();



   virtual void enableAttributeRelevanceSwitch();
   virtual void disableAttributeRelevanceSwitch();

   virtual void setAttributeRelevanceSwitch(bool enableSwitch);
   virtual bool attributeRelevanceSwitch();



   virtual void enableAttributeScopeSwitch();
   virtual void disableAttributeScopeSwitch();

   virtual void setAttributeScopeSwitch(bool enableSwitch);
   virtual bool attributeScopeSwitch();

   virtual void turnUpdatesOn(DtRtiObject const& object, DtAttributeHandleSet const& oldOnSet);

   virtual void turnUpdatesOff(DtRtiObject const& object, DtAttributeHandleSet const& oldOnSet);

   virtual DtObjectInstanceHandle uniqueHandle();

   virtual void getUniqueName(DtObjectInstanceHandle handle,
      MAKRti::DtString& objectName);

   virtual bool objectWasCreatedByFederate( DtRtiObject const& obj, DtFederateHandle const& fedHandle );

   virtual DtRtiObject* processNewObj(DtObjectInstanceHandle objHand,
      DtObjectClassHandle realClass, const char* name,
      const DtAttributeHandleSet& inSet,
      DtHandle regSetHandle,
      DtFederateHandle sourceFederate);

   virtual DtObjectClassInfo* firstSubscribedClass(
      DtObjectClassInfo* classDesc,
      DtHandle regSetHandle);

#ifdef DtMOM


   virtual void getObjectsOwned(DtMomTallyList& list);
   virtual void getObjectsReflected(DtMomTallyList& list);
   virtual void getObjectsUpdated(DtMomTallyList& list);
#endif
 
   virtual int numObjectsOwned();

   virtual void setAttributeTransportType (DtObjectInstanceHandle theObject, 
                                       const DtAttributeHandleSet& theAttributes,
                                       MAKRti::DtTransportType theType);

   virtual void setAttributeOrderType (DtObjectInstanceHandle theObject, 
                                       const DtAttributeHandleSet& theAttributes,
                                       MAKRti::DtOrderType theType);


#ifdef DDM





   virtual void registerAssociateRegionForUpdates(DtRtiObject& object,
      DtAttributeHandleSet const& attributes, DtRegion& region) {};

#ifdef DtIFSPEC1516

   virtual DtObjectInstanceHandle registerObjectInstanceWithRegions (
      DtObjectClassHandle theClass,
      rti1516::AttributeHandleSetRegionHandleSetPairVector const &
         theAttributeRegionPairs,
      const char * theObjectInstanceName=NULL) { return 0;}

   virtual void associateRegionsForUpdates (
      DtObjectInstanceHandle theObject, 
      rti1516::AttributeHandleSetRegionHandleSetPairVector const &
         theAttributeRegionPairs) {}

   virtual void unassociateRegionsForUpdates (
      DtObjectInstanceHandle theObject,
      rti1516::AttributeHandleSetRegionHandleSetPairVector const &
         theAttributeRegionPairs) {}

   virtual void subscribeObjectClassAttributesWithRegions (
      DtObjectClassHandle theClass,
      rti1516::AttributeHandleSetRegionHandleSetPairVector const &
         theAttributeRegionPairs,
         bool active) {}

   virtual void unsubscribeObjectClassAttributesWithRegions (
      DtObjectClassHandle theClass,
      rti1516::AttributeHandleSetRegionHandleSetPairVector const &
         theAttributeHandleSetRegionHandleSetPairVector) {}

   virtual void requestAttributeValueUpdateWithRegions (
      DtObjectClassHandle theClass,
      rti1516::AttributeHandleSetRegionHandleSetPairVector const &
         theAttributeRegionPairs,
      rti1516::VariableLengthData const & theUserSuppliedTag) {}

#elif defined(DtIFSPEC1516E)

   virtual DtObjectInstanceHandle registerObjectInstanceWithRegions (
       DtObjectClassHandle theClass,
       rti1516e::AttributeHandleSetRegionHandleSetPairVector const &
       theAttributeRegionPairs,
       const char * theObjectInstanceName=NULL) { return 0;}

   virtual void associateRegionsForUpdates (
       DtObjectInstanceHandle theObject, 
       rti1516e::AttributeHandleSetRegionHandleSetPairVector const &
       theAttributeRegionPairs) {}

   virtual void unassociateRegionsForUpdates (
       DtObjectInstanceHandle theObject,
       rti1516e::AttributeHandleSetRegionHandleSetPairVector const &
       theAttributeRegionPairs) {}

   virtual void subscribeObjectClassAttributesWithRegions (
       DtObjectClassHandle theClass,
       rti1516e::AttributeHandleSetRegionHandleSetPairVector const &
       theAttributeRegionPairs,
       bool active,
       MAKRti::DtString updateRateDesignator ) {}

   virtual void unsubscribeObjectClassAttributesWithRegions (
       DtObjectClassHandle theClass,
       rti1516e::AttributeHandleSetRegionHandleSetPairVector const &
       theAttributeHandleSetRegionHandleSetPairVector) {}

   virtual void requestAttributeValueUpdateWithRegions (
       DtObjectClassHandle theClass,
       rti1516e::AttributeHandleSetRegionHandleSetPairVector const &
       theAttributeRegionPairs,
       rti1516e::VariableLengthData const & theUserSuppliedTag) {}

#else

   virtual DtObjectInstanceHandle registerObjectInstanceWithRegion(
      DtObjectClassHandle objectClass,
      DtAttributeHandle attributes[],
      DtRegion13 *regions[],
      unsigned long numberOfHandles,
      const char *objectName=NULL) { return 0; }

   virtual void associateRegionForUpdates(
      DtRegion& theRegion,
      DtObjectInstanceHandle theObject, 
      const DtAttributeHandleSet& theAttributes) {}

   virtual void unassociateRegionForUpdates(
      DtRegion& theRegion, DtObjectInstanceHandle theObject) {}

   virtual void subscribeObjectClassAttributesWithRegion(
      DtObjectClassHandle theClass,
      DtRegion &theRegion,
      const DtAttributeHandleSet &attributeList,
      bool active) {}

   virtual void unsubscribeObjectClassWithRegion(
      DtObjectClassHandle theClass, DtRegion &theRegion) {}

   virtual void requestClassAttributeValueUpdateWithRegion (
      DtObjectClassHandle theClass,
      const DtAttributeHandleSet &theAttributes,
      const DtRegion &theRegion) {}

#endif 



#endif 

#ifdef DtTIME



   virtual void checkPendingTsoRemoveObject();

   virtual bool retractTsoRemoveObject(DtMessageRetractionHandle const& retractionHandle);
#endif

   virtual bool save(DtRtiSaveFile& file);

   virtual void prepareToRestore();

   virtual bool restore( DtRtiSaveFile& file );

   virtual void sendNotDiscoveredMsgForSmartForwarding(
      DtObjectInstanceHandle handle,
      const DtObjectClassInfo& classInfo,
      DtFederateHandle federate,
      const DtAttributeHandleSet* attributes = 0);
   virtual void sendNotDiscoveredMsgForSmartForwarding(
      DtObjectInstanceHandle handle,
      const DtObjectClassInfo& classInfo,
      DtFederateHandle federate,
      const DtAhvps* attributes);

public:

   static DtObjectMgr* create(DtFederateMgr* fedMgr);

   static void setCreatorFunction(DtObjectMgrCreator creator);

   static void setInternalCreatorFunction(DtObjectMgrCreator fn);

   virtual void ignoreNextUpdate(DtObjectInstanceHandle hdl);

protected:

   virtual void insertRegBitMask( DtObjectClassHandle classHandle, DtFederateHandle fedHandle );
   virtual void insertSubBitMask( DtObjectClassHandle classHandle, DtFederateHandle fedHandle );
   virtual void insertDiscBitMask( DtObjectClassHandle classHandle, DtFederateHandle fedHandle );
   virtual void insertNonDiscBitMask( DtObjectClassHandle classHandle, DtFederateHandle fedHandle );

#ifdef DtIFSPEC1516
   virtual void provideAttrValueUpdate(const DtRtiObject* obj,
      const DtAttributeHandleSet& attrHandles,
      rti1516::VariableLengthData const & tag);
#elif defined(DtIFSPEC1516E)
    virtual void provideAttrValueUpdate(const DtRtiObject* obj,
        const DtAttributeHandleSet& attrHandles,
        rti1516e::VariableLengthData const & tag);
#else
   virtual void provideAttrValueUpdate(const DtRtiObject* obj,
      const DtAttributeHandleSet& attrHandles,
      char const * tag);
#endif

   virtual void remoteSubscribe(
      DtObjectClassInfo& classDesc,
      const DtAttributeHandleSet& attrs,
      DtFederateHandle fedHandle,
      bool isReplacement);

   virtual void remotePassiveSubscribe(
      DtObjectClassInfo& classDesc,
      const DtAttributeHandleSet& attrs,
      DtFederateHandle fedHandle,
      bool isReplacement);

   virtual void remoteUnsubscribe(
      DtObjectClassHandle classHandle,
      const DtAttributeHandleSet& attrs,
      DtFederateHandle fedHandle);

   virtual void setDiscoveredClass(DtRtiObject& object,
      DtFederateHandle federateHandle, DtObjectClassHandle classHandle);


   virtual void processUpdate(const DtUpdateMsg& msg);
#if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)
   virtual void processReserveName(DtReserveNameMsg const& msg);
   virtual void processNameReserved(DtNameReservedMsg const& msg);
#ifdef DtIFSPEC1516E
   virtual void processMultiNameReserved( DtMultiNameReservedMsg const& msg );
#endif
#endif
   virtual void processRegister(const DtRegObjMsg& msg);
   virtual void processMultiRegister(const DtMultiRegObjMsg& msg);
   virtual void processDiscover(const DtDiscObjMsg& msg);
   virtual void processRequestDiscover(const DtReqDiscObjMsg& msg);
   virtual void processDelete(const DtDeleteRoMsg& msg);
#ifdef DtTIME
   virtual void processDeleteTso(const DtDeleteTsoMsg& msg);
#endif
   virtual void processLocDelete(const DtLocDelMsg& msg);
   virtual void processPub(const DtPubObjMsg& msg);
   virtual void processUnpub(const DtUnpubObjMsg& msg);
   virtual void processSub(const DtSubObjMsg& msg);
   virtual void processUnsub(const DtUnsubObjMsg& msg);
   virtual void processRequest(const DtRequestMsg& msg);
   virtual void processOwnership(const DtOwnershipMsg& msg);
#ifdef DtIFSPEC1516E
   virtual void processQueryTransport(const DtQueryTransportMsg& msg);
   virtual void processQueryInterTransport(const DtQueryInterTransportMsg& msg);
#endif


#ifdef DtIFSPEC1516
   virtual void processAcquire(
      DtObjectInstanceHandle objHand, const DtAttributeHandleSet& attrs,
      DtFederateHandle fed, bool onlyIfAvail,
      rti1516::VariableLengthData const & tag);
#elif defined(DtIFSPEC1516E)
   virtual void processAcquire(
       DtObjectInstanceHandle objHand, const DtAttributeHandleSet& attrs,
       DtFederateHandle fed, bool onlyIfAvail,
       rti1516e::VariableLengthData const & tag);
#else
   virtual void processAcquire(
      DtObjectInstanceHandle objHand, const DtAttributeHandleSet& attrs,
      DtFederateHandle fed, bool onlyIfAvail,
      char const * tag);
#endif

   virtual void processCancelAcquire(
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs,
      DtFederateHandle fed);

   virtual void processConfirmCancelAcquire(
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs);

#ifdef DtIFSPEC1516
   virtual void processDivest(DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs, DtFederateHandle fed,
      bool negotiated, 
      rti1516::VariableLengthData const & tag=DtRtiMsg::theDefaultTag);
#elif defined(DtIFSPEC1516E)
   virtual void processDivest(DtObjectInstanceHandle objHand,
       const DtAttributeHandleSet& attrs, DtFederateHandle fed,
       bool negotiated, 
       rti1516e::VariableLengthData const & tag=DtRtiMsg::theDefaultTag);
#else
   virtual void processDivest(DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs, DtFederateHandle fed,
      bool negotiated, 
      char const * tag=DtRtiMsg::theDefaultTag);
#endif

   virtual void notifyDivestedAttributes(DtObjectClassHandle objectClass,
      DtAttributeHandleSet const& attrs);

   virtual void processQueryOwner(DtObjectInstanceHandle objHand,
      DtAttributeHandle attr, DtFederateHandle requestor);

#ifdef DtIFSPEC1516
   virtual void processNotifyAcquire(
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs,
      rti1516::VariableLengthData const & tag=DtRtiMsg::theDefaultTag,
      bool forceAcquire=false);
#elif defined(DtIFSPEC1516E)
   virtual void processNotifyAcquire(
       DtObjectInstanceHandle objHand,
       const DtAttributeHandleSet& attrs,
       rti1516e::VariableLengthData const & tag=DtRtiMsg::theDefaultTag,
       bool forceAcquire=false);
#else
   virtual void processNotifyAcquire(
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs,
      char const * tag=DtRtiMsg::theDefaultTag,
      bool forceAcquire=false);
#endif

   virtual void processNotifyAcquireForDirectedMessaging(
      DtFederateHandle fedHandle,
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs);


#ifdef DtIFSPEC1516
   virtual void processGiveToLrc(DtObjectInstanceHandle objHand, 
      const DtAttributeHandleSet& attrs,
      rti1516::VariableLengthData const & tag,
      DtHandle hand);
#elif defined(DtIFSPEC1516E)
   virtual void processGiveToLrc(DtObjectInstanceHandle objHand, 
       const DtAttributeHandleSet& attrs,
       rti1516e::VariableLengthData const & tag,
       DtHandle hand);
#else
   virtual void processGiveToLrc(DtObjectInstanceHandle objHand, 
      const DtAttributeHandleSet& attrs,
      char const * tag,
      DtHandle hand);
#endif
   
   virtual void resetOwner(DtFederateHandle fedHandle, DtObjectInstanceHandle objHandle);


   virtual void sendPublishMsg(DtObjectClassHandle handle,
      const DtAttributeHandleSet& theSet);
   virtual void sendUnpublishMsg(DtObjectInstanceHandle handle,
      const DtAttributeHandleSet& theSet);
   virtual void sendUnsubscribeMsg(DtObjectClassHandle handle,
      const DtAttributeHandleSet& theSet);
   virtual void sendSubscribeMsg(DtObjectClassHandle theObj,
      bool isPassive, bool replacement,
      const DtAttributeHandleSet& theSet, DtFederateHandle fedHandle);
   virtual void sendSubscribeMsg(DtObjectClassHandle theObj,
      bool isPassive, bool replacement,
      const DtAttributeHandleSet& theSet, DtBitMask* sendMask = 0);
   virtual void sendRegisterMsg(DtRtiObject* object, DtBitMask* sendMask = 0);
   virtual void sendRegisterMsg( DtRtiMsg* msg, DtRtiObject* object, DtBitMask* sendMask = 0);

   virtual void sendLocalDeleteMsg(DtObjectInstanceHandle handle);
   virtual void sendDiscoverMsg(DtObjectInstanceHandle objHandle,
      DtObjectClassHandle classHandle, DtFederateHandle owner);
   virtual void sendDiscoverMsg(DtObjectInstanceHandle objHandle,
      DtObjectClassHandle classHandle, DtFederateHandle owner, DtBitMask* fedHandles);
   virtual void sendRequestDiscoverMsg(DtObjectInstanceHandle objHandle,
      DtObjectClassHandle classHandle);
   virtual void sendRemoveDiscoverMsg(DtObjectInstanceHandle objHandle,
      DtObjectClassHandle classHandle, DtFederateHandle fedHandle);

#if defined (DtIFSPEC1516) || defined(DtIFSPEC1516E)

   virtual void sendBestEffortUpdateMsg(
      DtRtiObject* obj, const DtAhvpBase& theAttrs, DtOrderHandle orderType,
      RTI_IFSPEC::LogicalTime const * theTime,
      RTI_IFSPEC::VariableLengthData const & tag,
      unsigned long serialNumber, const MAKRti::DtInetAddr& destAddr,
      unsigned int offset=0);

   virtual void sendReliableUpdateMsg(
      DtRtiObject* obj, const DtAhvpBase& theAttrs,
      DtOrderHandle orderType,
      RTI_IFSPEC::LogicalTime const * theTime,
      RTI_IFSPEC::VariableLengthData const & tag,
      unsigned long serialNumber);

   virtual void sendReserveNameMsg(std::string const & theObjectInstanceName);

   virtual unsigned long sendDeleteMsg(DtObjectInstanceHandle handle,
      DtOrderHandle orderType,
      RTI_IFSPEC::LogicalTime const * theTime,
      RTI_IFSPEC::VariableLengthData const & tag);

   virtual void sendOwnershipMsg(
      DtOwnerMsgKind kind, DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs,
      DtFederateHandle targetFed = 0,
      RTI_IFSPEC::VariableLengthData const & tag = DtRtiMsg::theDefaultTag);

   virtual void sendOwnershipMsg(
      DtOwnerMsgKind kind, DtObjectInstanceHandle objHand,
      const DtAttributeHandle attr,
      DtFederateHandle targetFed = 0,
      RTI_IFSPEC::VariableLengthData const & tag = DtRtiMsg::theDefaultTag);
#endif

#if defined(DtIFSPEC1516E)

   virtual void sendAttrQueryFoundMsg( 
       DtFederateHandle targetFed, 
       DtObjectInstanceHandle objHand, 
       const DtAttributeHandle attr, 
       DtTransportType transType );

   virtual void sendInterQueryFoundMsg(
       DtFederateHandle targetFed,
       DtObjectInstanceHandle objHand, 
       const DtInteractionClassHandle handle,
       DtTransportType transType );

   void sendInterQueryMsg(
       DtFederateHandle targetFed,
       DtInteractionClassHandle handle,
       DtFederateHandle sendingFed );

#elif defined(DtIFSPEC13)
   virtual void sendBestEffortUpdateMsg(
      DtRtiObject* obj, const DtAhvpBase& theAttrs, DtOrderHandle orderType,
      RTI::FedTime const * theTime,
      char const * tag,
      unsigned long serialNumber, const MAKRti::DtInetAddr& destAddr,
      unsigned int offset=0);

   virtual void sendReliableUpdateMsg(
      DtRtiObject* obj, const DtAhvpBase& theAttrs,
      DtOrderHandle orderType,
      RTI::FedTime const * theTime,
      char const * tag,
      unsigned long serialNumber);

   virtual void sendRequestMsg(
      DtRequestType type, unsigned long idOrClass,
      const DtAttributeHandleSet& theSet,
      char const * tag,
      bool anonymous,
      DtHandle regionSetHandle = DtRtiMsg::theDefaultRegionSetHandle,
      DtFederateHandle fedHandle = 0);

   virtual unsigned long sendDeleteMsg(DtObjectInstanceHandle handle,
      DtOrderHandle orderType,
      RTI::FedTime const * theTime,
      char const * tag);

   virtual void sendOwnershipMsg(
      DtOwnerMsgKind kind, DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs,
      DtFederateHandle targetFed = 0,
      char const * tag = DtRtiMsg::theDefaultTag);

   virtual void sendOwnershipMsg(
      DtOwnerMsgKind kind, DtObjectInstanceHandle objHand,
      const DtAttributeHandle attr,
      DtFederateHandle targetFed = 0,
      char const * tag = DtRtiMsg::theDefaultTag);
#endif


   virtual void sendPendingStartUpdates();

   virtual void sendPendingStopUpdates();

   virtual void sendPendingStartReg();

   virtual void sendPendingStopReg();

   virtual void sendPendingRegister();

   virtual void sendPendingSubscription();

   virtual void sendPendingRemovals();

   virtual void sendPendingRequestAttributes();

   virtual void sendPendingDiscoveries();

   virtual void invokePendingDivestNotification();

   virtual void purgeDeletedObjects();

#if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)

   virtual void resetNameReservation(std::string objectName);

   virtual void resetNameUsed(std::string objectName);
#endif

   virtual void throwIfAcquisitionPending(
      DtObjectClassHandle classHand,
      const DtAttributeHandleSet& attrs);

#if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)


   virtual void confirmAllInstancesPendingDivestitures(
      DtObjectClassHandle classHand,
      const DtAttributeHandleSet& attrs );

   virtual void confirmPendingDivestitures(
      DtObjectInstanceHandle objHand,
      const DtAttributeHandleSet& attrs,
      DtAttributeHandleSet& divestedSet );

   virtual void cancelPendingConfirms(
      DtRtiObject* obj,
      const DtAttributeHandleSet& attrs );
#endif

   virtual void divestAllInstances(
      DtObjectClassHandle classHand,
      const DtAttributeHandleSet& attrs);

   virtual void divestAllInstances();

   virtual void releaseAllAttributes(DtRtiObject* object);

   virtual void releaseOwnership(
      DtRtiObject* obj,
      const DtAttributeHandleSet& attrs);

   virtual void sendUpdateMessage( DtUpdateMsg* update,
      DtObjectClassInfo* classDesc, DtUpdateType updateType,
      MAKRti::DtTransportType trans, unsigned int numberAttrs,
      MAKRti::DtInetAddr destAddr = DtInetAddr::inaddrAny(),
      unsigned int offset = 0);

#ifdef DtMOM


   virtual void incrementUpdateTally(DtHandle objectClass);
   virtual void incrementSentAttributesTally(DtHandle objectClass,
      MAKRti::DtTransportType transport, unsigned int numberAttrs);
   virtual void incrementReceivedTally(DtHandle objectClass,
      MAKRti::DtTransportType transport, unsigned int numberAttrs);
#endif
   
   virtual void deleteAllOwnedObjects();

   virtual void deleteObj(DtRtiObject* obj, bool isLocalDelete=false);

#ifdef DtIFSPEC1516


   virtual void retainTsoDeletedObj(DtRtiObject* obj,
      rti1516::LogicalTime const & time);

   virtual void retainTsoRemovedObj(DtRtiObject* obj,
      rti1516::LogicalTime const & time);
#elif defined(DtIFSPEC1516E)


   virtual void retainTsoDeletedObj(DtRtiObject* obj,
       rti1516e::LogicalTime const & time);

   virtual void retainTsoRemovedObj(DtRtiObject* obj,
       rti1516e::LogicalTime const & time);
#else


   virtual void retainTsoDeletedObj(DtRtiObject* obj, RTI::FedTime const & time);

   virtual void retainTsoRemovedObj(DtRtiObject* obj,
      RTI::FedTime const & time);
#endif

   virtual bool removedObjectIsRetained(DtObjectInstanceHandle objectHandle);

   virtual void removeObjectAssociations(DtRtiObject& object);

   virtual void collectRemoteSubscriptions(DtRtiObject& object);

   virtual DtFederateHandle federateHandleFromObjectID(DtObjectInstanceHandle id) const;

   virtual unsigned long nextOffsetId();

   virtual DtObjectInstanceHandle findReusableHandle();

   virtual DtRtiObject* registerObj(
      DtObjectClassHandle theClass,
      DtObjectInstanceHandle objHandle,
      const char* name);

   virtual DtRtiObject* processNewObj(DtObjectInstanceHandle objHand,
      DtObjectClassInfo* actualClass,
      DtObjectClassInfo* subscribedClass,
      const char* name,
      const DtAhvps& inSet,
      DtHandle regSetHandle,
      DtFederateHandle sourceFederate);

   virtual DtRtiObject* discoverObject(DtObjectInstanceHandle objHandle, 
      const char* objName, 
      DtObjectClassInfo* actualClass,
      DtObjectClassInfo* discoveredClass,
      const DtAttributeHandleSet& attrSet,
      DtFederateHandle federateHandle,
      bool federateOwnsPrivilegeToDelete);

#ifdef DDM





#ifdef DtIFSPEC1516
   virtual void calculateRegionSet(
      unsigned long channel, rti1516::RegionHandleSet & regionHandles) {}
#elif defined(DtIFSPEC1516E)
   virtual void calculateRegionSet(
       unsigned long channel, rti1516e::RegionHandleSet & regionHandles) {}
#else
   virtual void calculateRegionSet(
      unsigned long channel, const DtAhvps& reflectSet) {}
#endif

   virtual void checkForRegionalSubscribe(DtObjectClassInfo& info, DtFederateHandle fedHandle = 0) {}

   virtual void acquireAssociateRegionForUpdates(
      DtObjectInstanceHandle theObject, 
      const DtAttributeHandleSet& theAttributes) {}

   virtual void unassociateRegionForDivested(
      DtRtiObject& obj, const DtAttributeHandleSet& set, bool atomic){}


#endif

#ifdef DtIFSPEC1516
   virtual void invokeReflect(DtFederateHandle federateHandle,
      rti1516::ObjectInstanceHandle objectHandle,
      rti1516::AttributeHandleValueMap const& reflectedValues,
      rti1516::TransportationType transportType,
      rti1516::OrderType sentOrder,
      rti1516::OrderType receivedOrder,
      rti1516::VariableLengthData const & theTag,
      rti1516::LogicalTime const * time=0,
      unsigned long serialNumber=0,
      rti1516::RegionHandleSet const* regionHandles=0);
#elif defined(DtIFSPEC1516E)
   virtual void invokeReflect(DtFederateHandle federateHandle,
       rti1516e::ObjectInstanceHandle objectHandle,
       rti1516e::AttributeHandleValueMap const& reflectedValues,
       rti1516e::TransportationType transportType,
       rti1516e::OrderType sentOrder,
       rti1516e::OrderType receivedOrder,
       rti1516e::VariableLengthData const & theTag,
       rti1516e::LogicalTime const * time=0,
       unsigned long serialNumber=0,
       rti1516e::RegionHandleSet const* regionHandles=0);
#else
   virtual void invokeReflect(DtFederateHandle federateHandle,
      DtObjectInstanceHandle objectHandle,
      DtAhvps const& reflectedValues,
      DtTransportHandle transportType,
      DtOrderHandle sentOrder,
      char const * tag = 0,
      RTI::FedTime const * time=0,
      unsigned long serialNumber=0);
#endif

   virtual bool acceptObjectChannel(unsigned long channel);

   virtual bool acceptRequestChannel(unsigned long channel);






   virtual void addClassMulticast(DtObjectClassInfo* classDesc, float rate=-1.0);
   virtual void removeClassMulticast(DtObjectClassInfo* classDesc, float rate=-1.0);

   virtual bool saveObjectList( DtRtiSaveFile& file );

   virtual bool restoreObjectList(DtRtiSaveFile& file);

   virtual void destroyObjectLists();

   virtual unsigned long savePacketLength();

   virtual void removeFromNotifiedDivestitures(DtObjectInstanceHandle objHdl,
      const DtAttributeHandleSet& attrs);

protected:


   static void processUpdate(const DtUpdateMsg& msg, void* usr);
#if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)
   static void processReserveName(DtReserveNameMsg const& msg, void* usr);
   static void processNameReserved(DtNameReservedMsg const& msg, void* usr);
#ifdef DtIFSPEC1516E
   static void processMultiNameReserved( DtMultiNameReservedMsg const& msg, void* usr );
#endif
#endif
   static void processRegister(const DtRegObjMsg& msg, void* usr);
   static void processMultiRegister(const DtMultiRegObjMsg& msg, void* usr);
   static void processDiscover(const DtDiscObjMsg& msg, void* usr);
   static void processRequestDiscover(const DtReqDiscObjMsg& msg, void* usr);
   static void processDelete(const DtDeleteRoMsg& msg, void* usr);
#ifdef DtTIME
   static void processDeleteTso(const DtDeleteTsoMsg& msg, void* usr);
#endif
   static void processLocDelete(const DtLocDelMsg& msg, void* usr);
   static void processPub(const DtPubObjMsg& msg, void* usr);
   static void processUnpub(const DtUnpubObjMsg& msg, void* usr);
   static void processSub(const DtSubObjMsg& msg, void* usr);
   static void processUnsub(const DtUnsubObjMsg& msg, void* usr);
   static void processRequest(const DtRequestMsg& msg, void* usr);
   static void processOwnership(const DtOwnershipMsg& msg, void* usr);
#ifdef DtIFSPEC1516E
   static void processQueryTransport(const DtQueryTransportMsg& msg, void* usr);
   static void processQueryInterTransport(const DtQueryInterTransportMsg& msg, void* usr);
#endif


protected:
   
   DtFederateMgr* myFederateMgr;

#if defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)

   std::set<std::string> myReservedNames;
   std::set<std::string> myUsedNames;
   std::set<std::string> myFailedNames;
#endif

   MAKRti::DtString myHlaNamePrefix;

   DtRtiObjectMap myObjects;
   
   MAKRti::DtHashList myObjectsByName;

   DtRtiObjectMap myKnownObjs;

   MAKRti::DtHashList myKnownObjsByName;

   DtRtiObjectMap myOwnedObjs;

   MAKRti::DtHashList myOwnedObjsByName;

   DtRtiObjectMap myLrcManagedObjs;

   MAKRti::DtHashList myLrcManagedObjsByName;

   DtAddrMap myAddrMap;

   std::map<DtObjectInstanceHandle, MAKRti::DtTime> myDeletedObjects;

#ifdef DtTIME


   DtRtiMsgQueue* myTsoRemoveQueue;
   DtObjectHandleTimeMap myTsoDeletedObjects;
   DtObjectPtrTimeMap myTsoDeletedObjectCache;
   DtObjectPtrTimeMap myTsoRemovedObjectCache;
#endif


   DtObjectClassHandleSet    myRetransmitSubClass;
   DtObjectClassMaskMap      myRetransmitSubClassMask;
   DtObjectInstanceHandleSet myLocalDeletedObjects;
   DtObjInstAttrSetPairList  myPendingStartUpdatesList;
   DtObjClassAttrSetPairList myPendingStopUpdatesList;
   DtObjectClassHandleSet    myPendingStartRegList;
   DtObjectClassHandleSet    myPendingStopRegList;
   DtObjectClassHandleSet    myPendingRegisterList;
   DtObjectClassMaskMap      myPendingRegisterMaskList;
   DtObjectInstanceHandleSet myPendingInstRegisterList;
   MAKRti::DtList myPendingRemovals;
   DtPendingRequestAttrMap myPendingRequestAttrs;
   DtPendingRequestAttrMap myPendingDivestNotifications;
   DtPendingRequestAttrMap myNotifiedDivestitures;
   
   DtHandle myFreeObjHandle;


   bool myClassRelevanceSwitch;
   bool myAttributeRelevanceSwitch;
   bool myAttributeScopeSwitch;

   bool myIsJoined;

   bool myRestoreInProgress;

   bool myReuseIds;

   MAKRti::DtClock myClock;

   typedef std::set<DtObjectInstanceHandle> DtObjHandleSet;
   typedef std::map<DtObjectClassHandle, DtObjHandleSet> DtClassToPendingObjDiscMap;
   typedef std::map<DtFederateHandle, DtClassToPendingObjDiscMap> DtFederateToPendingObjDiscMap;
   DtFederateToPendingObjDiscMap myPendingDiscoveries;
   DtObjectClassMaskMap       myPendingDiscoveriesMaskList;
   DtFederateToPendingObjDiscMap myPendingNonDiscoveries;
   DtObjectClassMaskMap       myPendingNonDiscoveriesMaskList;

   DtTime myNextPendingDiscTime;

   DtObjHandleSet myIgnoreObjects;

   bool myForceBestEffort;

   std::set<DtRtiMsgKind> myConstrainedUpdateKinds;
   std::set<DtRtiMsgKind> myConstrainedDeleteKinds;

protected:

   static DtObjectMgrCreator theCreator;

   static DtObjectMgrCreator theInternalCreator;
};

#endif