hlaObjectManager.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2025 MAK Technologies, Inc
** All rights reserved.
*********************************************************************/


#ifndef DtHlaObjectManager_H_
#define DtHlaObjectManager_H_

#if DtHLA 

#include "callbacks.h"
#include "vlutil/vlHashlist.h"
#include "hlaObjectFactory.h"
#include "region.h"
#include "objectId.h"
#include <map>

typedef std::map<DtObjectId, DtHlaObject*> DtHlaObjectMap;



class DT_DLL_VL DtHlaObjectManager
{
public:
   
   DtHlaObjectManager(DtHlaObjectFactory* factory,
      DtExerciseConn* conn);

   virtual ~DtHlaObjectManager();

   virtual const DtHlaObjectMap& allHlaObjects() const;

   virtual const DtHlaObjectMap& registeredObjects() const;

   virtual const DtHlaObjectMap& discoveredObjects() const;

   virtual DtHlaObject* hlaObject(
#if DtHLA_1516
       RTI::ObjectInstanceHandle id
#else
       RTI::ObjectHandle id
#endif
                                 ) ;

   virtual DtHlaObject* hlaObject(const char* name) const;

   virtual void addDiscoverObjectCallback(
      RTI::ObjectClassHandle handle, DtDiscoverObjectCb cb, void* usr);
   virtual void removeDiscoverObjectCallback(
      RTI::ObjectClassHandle handle, DtDiscoverObjectCb cb, void* usr);

   virtual void addRemoveObjectCallback(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id,
#else
      RTI::ObjectHandle id,
#endif
      DtRemoveObjectCb cb, void* usr);
   virtual void removeRemoveObjectCallback(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id,
#else
      RTI::ObjectHandle id,
#endif
      DtRemoveObjectCb cb, void* usr);

   virtual const DtHlaObject* processDiscoverObject(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id,
      RTI::ObjectClassHandle handle, 
      const std::wstring &name);
#else
      RTI::ObjectHandle id,
      RTI::ObjectClassHandle handle, 
      const char* name);
#endif
  
#if DtHLA_1516_EVOLVED
   virtual const DtHlaObject* processDiscoverObject(
      RTI::ObjectInstanceHandle id,
      RTI::ObjectClassHandle handle, 
      const std::wstring &name,
      RTI::FederateHandle registeringFederate );
#endif

//#if DtHLA_4
//   //! This form of processDiscoverObject takes the additional argument
//   //! registeringFederate, indicating the Federate Handle of the federate
//   //! that registered the object.
//   //! This form of processDiscoverObject is called in HLA Evolved
//   //! Returns the added instance.
//   virtual const DtHlaObject* processDiscoverObject(
//      RTI::ObjectInstanceHandle id,
//      RTI::ObjectClassHandle handle,
//      const std::wstring& name,
//      RTI::FederateHandle registeringFederate);
//#endif

   virtual const DtHlaObject* processDiscoverObject(DtHlaObject* hlaObj);

   virtual const DtHlaObject* processDiscoverObjectAsClass(DtHlaObject* hlaObj,
      RTI::ObjectClassHandle classHandle);

   virtual void processRemoveObject(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id
#else
      RTI::ObjectHandle id
#endif
     );

   virtual void processRemoveObject(DtHlaObject* obj);

   virtual void processReflectAttributeValues(const DtStateMsg &msg);

   virtual void processProvideUpdate(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id,
#else
      RTI::ObjectHandle id,
#endif
      const RTI::AttributeHandleSet& theAttributes);

   virtual void processLocalUpdateRequest(
      RTI::ObjectClassHandle hand,
      const RTI::AttributeHandleSet& set);

   virtual void localSubscriptionChanged(RTI::ObjectClassHandle handle);

   virtual void publicationChanged(RTI::ObjectClassHandle handle);

   virtual void processAttributeAcquisition(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id,
#else
      RTI::ObjectHandle id,
#endif
     const RTI::AttributeHandleSet& attrs);

   virtual void processAttributeDivestiture(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id,
#else
      RTI::ObjectHandle id,
#endif
      const RTI::AttributeHandleSet& attrs);

   virtual void processRequestAssumption(
#if DtHLA_1516
     RTI::ObjectInstanceHandle id,
     const RTI::AttributeHandleSet& attrs, 
     const RTI::VariableLengthData &tag);
#else
     RTI::ObjectHandle id,
     const RTI::AttributeHandleSet& attrs, 
     const char* tag);
#endif

   virtual void processRequestRelease(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id,
      const RTI::AttributeHandleSet& attrs, 
      const RTI::VariableLengthData &tag);
#else
      RTI::ObjectHandle id,
      const RTI::AttributeHandleSet& attrs, 
      const char* tag);
#endif

   virtual void processConfirmAcquisitionCancellation(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id,
#else
      RTI::ObjectHandle id,
#endif
      const RTI::AttributeHandleSet& attrs);

   virtual DtHlaObject* registerHlaObject( RTI::ObjectClassHandle classHand, 
      const char* name, const DtDDMRegionSet* regionSet = 0);

   virtual void registerHlaObjectWithRegion(
      RTI::ObjectClassHandle classHand,
      const char* name, const DtDDMRegionSet& regionSet,
#if DtHLA_1516
      RTI::ObjectInstanceHandle& id);
#else
      RTI::ObjectHandle& id);
#endif

   virtual void deleteHlaObject(
#if DtHLA_1516
      RTI::ObjectInstanceHandle objHand);
#else
      RTI::ObjectHandle objHand);
#endif

#if !DtHLA_1516
   virtual void setRegionsForRegister(int numAttrs,
      RTI::AttributeHandle* attrs, RTI::Region** regions);
   virtual void setNoRegionsForRegister();
#endif
   
#if DtHLA_1516
   virtual bool reserveName(const std::wstring &theName, bool pushRti);

   virtual bool isNameReserved(const std::wstring &theName)const;

   #if DtHLA_1516_EVOLVED
   virtual void releaseObjectInstanceName( const std::wstring& name);

   virtual bool reserveNames(
      std::set<std::wstring> const& objectNames, bool pushRti);

   #endif
#endif

public:
#if DtHLA_1516
   static double requestNameTickMinTime();
   static void setRequestNameTickMinTime(double time);

   static double requestNameTickMaxTime();
   static void setRequestNameTickMaxTime(double time);

   static int numberOfRequestNameTries();
   static void setNumberOfRequestNameTries(int tries);
#endif

   virtual void removeAllObjects();

protected:

#if DtHLA_1516
   static void nameReservationSuceededCb(const std::wstring &theName, void *theUserData);
   static void nameReservationFailedCb(const std::wstring &theName, void *theUserData);

   #if DtHLA_1516_EVOLVED
   static void nameSetReservationSucceededCb(const std::set<std::wstring>& nameSet, 
                                             void* userData );
   static void nameSetReservationFailedCb(const std::set<std::wstring>& nameSet,
                                              void* userData );
   #endif
#endif

protected:


   DtHlaObjectManager(const DtHlaObjectManager& orig);

   DtHlaObjectManager& operator=( const DtHlaObjectManager& orig);

   virtual void objectProcessRemoveObject(DtHlaObject* hlaObj);

   virtual void objectProcessReflect(DtHlaObject* hlaObj,
      const DtStateMsg &msg);

   virtual DtHlaObject* addKnownObject(
#if DtHLA_1516
      RTI::ObjectInstanceHandle id,
      RTI::ObjectClassHandle hand, 
      const std::wstring &name,
      bool reflecting);
#else
      RTI::ObjectHandle id,
      RTI::ObjectClassHandle hand, 
      const char* name,
      bool reflecting);
#endif

   virtual void removeKnownObject(
      DtHlaObject* hlaObj);

   virtual DtList* discoverCbList(RTI::ObjectClassHandle handle);


#if DtHLA_1516
   virtual void reservedNameSuceeded(const std::wstring &theName);

   virtual void reservedNameFailed(const std::wstring &theName);

#if DtHLA_1516_EVOLVED
   virtual void reservedNameSuceeded(const std::set<std::wstring>& theNames);

   virtual void reservedNameFailed(const std::set<std::wstring>& theNames);

   virtual const std::map<DtObjectId, RTI::FederateHandle>& registeredFederateHandleMap() const;
#endif

#endif
   
protected:
#if DtHLA_1516
   static double theRequestNameTickMinTime;
   static double theRequestNameTickMaxTime;
   static int theNumberOfRequestNameTries;
#endif

protected:

   DtHashlist myDiscoverCbLists;

   DtHlaObjectFactory* myFactory;

   DtHlaObjectMap myObjectList;

   DtHashlist myObjectListByName;

   DtHlaObjectMap myRegObjectList;

   DtHlaObjectMap myDiscObjectList;

   DtExerciseConn* myExConn;

#if DtHLA_1516
   std::set<std::wstring> myReservedObjectInstanceNameSet;

   bool myPendingNameReservationPassedFlag;
   bool myPendingNameReservationFailedFlag;
   int myReportedNameReservationCount;
   std::wstring myPendingNameReservationName;
   std::set<std::wstring> myPendingNameReservationNameSet;

#if DtHLA_1516_EVOLVED
   std::map<DtObjectId, RTI::FederateHandle> myRegisteringFederateMap;
#endif
#endif

#if !DtHLA_1516
   RTI::AttributeHandle* myAttrsForDDMRegister;
   RTI::Region** myRegionsForDDMRegister;
#endif
   int myNumAttrsForDDMRegister;
};

inline const DtHlaObjectMap& DtHlaObjectManager::allHlaObjects() const
{
   return myObjectList;
}

inline const DtHlaObjectMap& DtHlaObjectManager::registeredObjects() const
{
   return myRegObjectList;
}

inline const std::map<DtObjectId, DtHlaObject*>& DtHlaObjectManager::discoveredObjects() const
{
   return myDiscObjectList;
}

#endif
#endif