hlaObj.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*******************************************************************************/
#ifndef hlaObj_H_
#define hlaObj_H_

#if DtHLA


#include <vlutil/vlMachineTypes.h>
#include "remObjCbInfo.h"
#include "objRefCbInfo.h"
#include "objClassDesc.h"


class DT_DLL_VL DtExerciseConn;
class DT_DLL_VL DtStateMsg;
class DT_DLL_VL DtVrlRtiAmbassador;
class DT_DLL_VL DtOwnershipHandler;



class DT_DLL_VL DtHlaObject
{
public:
   DtHlaObject( DtExerciseConn* conn, 
#if DtHLA_1516
                RTI::ObjectInstanceHandle id,
#else 
                RTI::ObjectHandle id,
#endif
                const char* name, 
                DtObjClassDesc& classDesc,
                bool reflecting = false);

   DtHlaObject( DtExerciseConn* conn, 
                const char* name, 
                DtObjClassDesc& classDesc,
                bool reflecting = false);

   virtual ~DtHlaObject();

protected:

   DtHlaObject();

   DtHlaObject( const DtHlaObject& src );

   DtHlaObject& operator=( const DtHlaObject& src );

public:
#if DtHLA_1516
   virtual inline const RTI::ObjectInstanceHandle& objectId() const;
#else
   virtual inline const RTI::ObjectHandle& objectId() const;
#endif

   virtual inline const RTI::AttributeHandleSet& attrHandleSet();

   virtual inline const RTI::AttributeHandleSet& requestedAttributes();

   virtual inline RTI::ObjectClassHandle objectClassHandle() const;
   
   virtual inline const char* name() const;

   inline int numAttributes() const;

   virtual inline DtExerciseConn* exerciseConn() const;

   virtual inline DtObjClassDesc& classDesc() const;


   virtual void setupUpdating();

   virtual void update();
   
   virtual void generateUpdate(
      const RTI::AttributeHandleSet& eligibileAttrs,
      const RTI::AttributeHandleSet& requiredAttrs,
      DtStateMsg* msg );

   virtual void cleanupFromUpdating();

   virtual void processProvideUpdate(
      const RTI::AttributeHandleSet& set );


   virtual void clearRequestedAttributes();

   virtual inline const RTI::AttributeHandleSet& ownedAttributes();

   virtual void forceUpdate();
   virtual void forceUpdate( const RTI::AttributeHandleSet& set );

   virtual void clearForcedAttributes();

   virtual const RTI::AttributeHandleSet& attributesNeededByFederation();

   virtual const RTI::AttributeHandleSet& eligibleAttributes();

   virtual const RTI::AttributeHandleSet& requiredAttributes();

   bool classNeededByFederation();

   void setupClassForUpdating();


   virtual void setupReflecting();

   virtual void callReflect( const DtStateMsg& msg );

   virtual void callReflectLocal( const DtStateMsg& msg );
   
   virtual void reflectLocal( const DtStateMsg& msg ) = 0;

   virtual void cleanupFromReflecting();

   virtual void requestUpdate( RTI::AttributeHandleSet* attrs = 0 );

   virtual void addRemoveObjectCb( DtRemoveObjectCb cb, void* usr );

   virtual void removeRemoveObjectCb( DtRemoveObjectCb cb, void* usr );
   
   virtual void addPostReflectCb( DtObjectReflectAttributeValuesCb cb, 
                                  void* usr );

   virtual void removePostReflectCb( DtObjectReflectAttributeValuesCb cb, 
                                     void* usr );
   
   virtual void processRemoveObject();

   
   virtual DtOwnershipHandler* setOwnershipHandler( DtOwnershipHandler* handler );

   virtual void unconditionalDivest( const RTI::AttributeHandleSet& attrs );

   virtual void negotiatedDivest( const RTI::AttributeHandleSet& attrs );

   virtual void cancelNegotiatedDivest( const RTI::AttributeHandleSet& attrs );
   
   virtual void acquireAttributes( const RTI::AttributeHandleSet& attrs,
                                   bool ifAvailable = false );

   virtual void cancelAcquireAttributes( const RTI::AttributeHandleSet& attrs );

   virtual inline DtTime lastSimTimeUpdateReceived() const;

   virtual inline DtTime lastReceivedTimeStamp() const;

protected:
   virtual inline void setLastSimTimeUpdateReceived( DtTime tm );

   virtual inline void setLastReceivedTimeStamp( DtTime tm );

public:
   virtual void printMsg( const DtStateMsg& msg,
                          bool fullReport = false ) const;

   virtual void localSubscriptionChanged();
   
   virtual void publicationChanged();


#if DtHLA_1516_EVOLVED


   virtual const DtString& lastProducingFederate() const;
#endif

#if DtHLA_1516

   virtual const std::set<DtDDMRegion>& lastRegionInformation() const;
#endif


protected:

   friend class DtHlaObjectManager;

   virtual void reflect( const DtStateMsg& msg ) = 0;

   void wipeRemoveList();

   virtual void clearRemoveList();

   void wipeReflectList();

   virtual void applyPostReflectCallbacks( const DtStateMsg& msg );

   virtual void loseOwnership( const RTI::AttributeHandleSet& attrs) ;

   virtual void gainOwnership( const RTI::AttributeHandleSet& attrs );

   virtual void processUpdatesOff( const RTI::AttributeHandleSet& set );

   void processUpdatesOn( const RTI::AttributeHandleSet& set );

#if !DtHLA_1516
   virtual bool  known() const;
#endif

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

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

   void dumpRtiException(const char *functionName, 
         const RTI::Exception *exc) const;

   virtual void processAttributeAcquisition(
      const RTI::AttributeHandleSet& attrs );

   virtual void processAttributeDivestiture(
      const RTI::AttributeHandleSet& attrs );

   virtual void processConfirmAcquisitionCancellation(
      const RTI::AttributeHandleSet& attrs );


   virtual void computeEligible();

   virtual void justRegistered();


#if DtHLA_1516_EVOLVED


   virtual void setLastProducingFederate(const DtString& fedName);
#endif

#if DtHLA_1516

   virtual void setRegionInformation(const std::set<DtDDMRegion>& regions);
#endif


   
public:
   static void ownerAcquisitionIfAvailableCb( void* usr );
   static void ownerAcquisitionCb( void* usr );
   static void negotiatedDivestitureCb( void* usr );
   static void unconditionalDivestitureCb( void* usr );

protected:
   static void reflectAttributeValuesCb( const DtStateMsg& stateMsg, 
                                         void* hlaObj );
   
   static void updatesOnCb( 
#if DtHLA_1516
      RTI::ObjectInstanceHandle handle,
#else
      RTI::ObjectHandle handle,
#endif
      const RTI::AttributeHandleSet& attributeSet, 
      void* usr );

   static void updatesOffCb( 
#if DtHLA_1516
      RTI::ObjectInstanceHandle handle,
#else
      RTI::ObjectHandle handle,
#endif
      const RTI::AttributeHandleSet& attributeSet, 
      void* usr );


protected:

   char* myName;

   DtExerciseConn*   myExConn;
   bool              myReflecting;
   bool              myUpdating;
   DtList            myRemoveCbList;
   DtList            myReflectCbList;
   DtListItem*       myRemoveCbListNextPtr;
   DtListItem*       myReflectCbListNextPtr;
   DtTime            myLastSimTimeUpdateReceived;
   DtTime            myLastReceivedTimeStamp;
   DtObjClassDesc   &myClassDesc;

#if DtHLA_1516_EVOLVED
   DtString myLastProducingFederate;   
#endif

#if DtHLA_1516

   std::set<DtDDMRegion> myLastRegionInformation;
#endif


#if DtHLA_1516
   RTI::ObjectInstanceHandle myObjectId;
#else
   RTI::ObjectHandle myObjectId;
#endif





   RTI::AttributeHandleSet* myEligibleAttrs;

   RTI::AttributeHandleSet* myNeededAttrs;
   
   RTI::AttributeHandleSet* myOwnedAttributes;

   RTI::AttributeHandleSet* myRequestedAttributes;

   RTI::AttributeHandleSet* myForcedAttributes;

   RTI::AttributeHandleSet* myRequiredAttributes;

   DtOwnershipHandler* myOwnershipHandler;
};

#if DtHLA_1516
inline const RTI::ObjectInstanceHandle& DtHlaObject::objectId() const
#else
inline const RTI::ObjectHandle& DtHlaObject::objectId() const
#endif
{ 
   return myObjectId; 
}

inline const RTI::AttributeHandleSet& DtHlaObject::attrHandleSet()
{ 
   return myClassDesc.attrHandleSet(); 
}

inline const RTI::AttributeHandleSet& DtHlaObject::requestedAttributes()
{ 
   return *myRequestedAttributes; 
}
inline RTI::ObjectClassHandle DtHlaObject::objectClassHandle() const
{ 
   return  myClassDesc.handle(); 
}

inline const char* DtHlaObject::name() const 
{ 
   return myName; 
}

inline int DtHlaObject::numAttributes() const
{ 
   return  myClassDesc.numAttributes() ; 
}

inline DtExerciseConn* DtHlaObject::exerciseConn() const 
{ 
   return myExConn; 
}

inline DtObjClassDesc& DtHlaObject::classDesc() const 
{ 
   return myClassDesc; 
}

inline const RTI::AttributeHandleSet& DtHlaObject::ownedAttributes()
{ 
   return *myOwnedAttributes; 
}

inline DtTime DtHlaObject::lastSimTimeUpdateReceived() const
{ 
   return myLastSimTimeUpdateReceived; 
}

inline void DtHlaObject::setLastSimTimeUpdateReceived( DtTime a_tm )
{ 
   myLastSimTimeUpdateReceived = a_tm; 
}

inline DtTime DtHlaObject::lastReceivedTimeStamp() const
{ 
   return myLastReceivedTimeStamp; 
}

inline void DtHlaObject::setLastReceivedTimeStamp( DtTime a_tm )
{ 
   myLastReceivedTimeStamp = a_tm; 
}


#endif   //! DtHLA

#endif   //! DtHlaObject_H_