hlaObject.h

Go to the documentation of this file.

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

#if DtHLA


#include <vlutil/vlMachineTypes.h>
#include "removeObjectCbInfo.h"
#include "objectReflectAttributeValuesCbInfo.h"
#include "objClassDesc.h"


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



// ----------------------------------- DtParameterCbInfo -----------------------
// this class is only used by DtHlaObject for passing params to static
// callback fns. This is useed to make a copy of an AttributeHandleSet.
class DT_DLL_VL DtParameterCbInfo
{
public:
   DtParameterCbInfo( DtHlaObject* obj, const RTI::AttributeHandleSet& set );

   virtual ~DtParameterCbInfo();

public:
   DtHlaObject* myObj;
#if DtHLA_1516
   RTI::AttributeHandleSet mySet;
#else
   RTI::AttributeHandleSet* mySet;
#endif
};

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 divestAttributes( const RTI::AttributeHandleSet& attrs,
                                  bool ifAvailable = false );

   virtual void divestObject(bool ifAvailable = false);

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


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

   virtual void acquireObject( bool ifAvailable = false );

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

   virtual inline DtTime lastSimTimeUpdateReceived() const;

   virtual inline DtTime lastReceivedTimeStamp() const;

   virtual inline void setLastSimTimeUpdateReceived( DtTime tm );

   virtual inline void setLastReceivedTimeStamp( DtTime tm );

protected:

#if DtHLA_1516

   virtual void copyToLocalAndRemote(const RTI::AttributeHandleValueMap& sourceList,
      const RTI::AttributeHandleSet& neededByRemote, const RTI::AttributeHandleSet& neededByLocal,
      RTI::AttributeHandleValueMap& toRemoteList, RTI::AttributeHandleValueMap& toLocalList);

   virtual bool handlesMatch(const RTI::AttributeHandleValueMap& handleValueMap,
      const RTI::AttributeHandleSet& handleSet) const;

   virtual void clearUpdatedAttributes(const RTI::AttributeHandleValueMap& sourceList);

#else

   virtual bool handlesMatch(const RTI::AttributeHandleValuePairSet& handleValueSet,
      const RTI::AttributeHandleSet& handleSet) const;

   virtual void copyToLocalAndRemote(const RTI::AttributeHandleValuePairSet& sourceList,
      const RTI::AttributeHandleSet& neededByRemote, const RTI::AttributeHandleSet& neededByLocal,
      RTI::AttributeHandleValuePairSet& toRemoteList, RTI::AttributeHandleValuePairSet& toLocalList);

   virtual void clearUpdatedAttributes(const RTI::AttributeHandleValuePairSet& sourceList);

#endif

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


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

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

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

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



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,
      bool notifyOwnershipManagement = true );

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

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

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

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

   virtual void computeEligible();

   virtual void justRegistered();


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

   virtual void addHandlesToSet(RTI::AttributeHandleSet& destinationSet,
      const RTI::AttributeHandleSet& sourceSet);

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;

   enum SplitUpdateDiscriminant
   {
      UpdateBothLocalAndRemote,
      UpdateRemoteOnly,
      UpdateLocalOnly,
      UpdateSplit
   };
   SplitUpdateDiscriminant mySplitUpdate;

#if DtHLA_1516_EVOLVED
   DtString myLastProducingFederate;
#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;
   bool myUpdateRequiredAttributes;

   RTI::AttributeHandleSet* mySelfReflectSplitAttrs;

   RTI::AttributeHandleSet* myEligibleNeeded;

   RTI::AttributeHandleSet* myEligibleSubscribed;

   RTI::AttributeHandleSet* myScratchAttributes;

   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   

#endif