vrlFederateAmbassador13.h

Go to the documentation of this file.

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


#ifndef DtVrlFederateAmbassador_H_
#define DtVrlFederateAmbassador_H_
 

#if DtHLA
#if !DtHLA_1516



#include "callbacks.h"

#include <RTI.hh>
#include "nullFederateAmbassador13.h"
#include <list>

typedef void (*DtFederateSaveCb)(
   const char* label,
   void* usr);

typedef void (*DtFederateRestoreCb)(
   const char* label,
   void* usr);

typedef void (*DtSynchPointCb)(
   const char* label,
   void* usr);

typedef void (*DtAnnounceSynchPointCb)(
   const char* label,
   const char* tag,
   void* usr);

class DT_DLL_VL DtInteractionManager;
class DT_DLL_VL DtHlaObjectManager;

class DT_DLL_VL DtVrlFederateAmbassador : public DtNullFederateAmbassador
{
   struct DtScopeChangeCallbackData
   {
      DtVrlFederateAmbassador* fedAmb;
      RTI::ObjectHandle        handle;
   };

public:
   DtVrlFederateAmbassador();

   virtual ~DtVrlFederateAmbassador()
      throw( RTI::FederateInternalError );

protected:
   DtVrlFederateAmbassador( const DtVrlFederateAmbassador& src );

   DtVrlFederateAmbassador& operator=(const DtVrlFederateAmbassador& src );

public:
   virtual void init( DtExerciseConn* exConn,
      DtHlaObjectManager* hlaObjMgr,
      DtInteractionManager* interMgr );

public:
   static DtVrlFederateAmbassador* create();

public:
   virtual void addReflectAttributeValuesCb( RTI::ObjectHandle id,
      DtReflectAttributeValuesCb cb, void* usr );
   virtual void removeReflectAttributeValuesCb( RTI::ObjectHandle id,
      DtReflectAttributeValuesCb cb, void* usr );

   virtual void addDiscoverObjectCb( RTI::ObjectClassHandle hand,
      DtDiscoverObjectCb cb, void* usr );
   virtual void removeDiscoverObjectCb( RTI::ObjectClassHandle hand,
      DtDiscoverObjectCb cb, void* usr );

   virtual void addRemoveObjectCb( RTI::ObjectHandle id,
      DtRemoveObjectCb cb, void* usr );
   virtual void removeRemoveObjectCb( RTI::ObjectHandle id,
      DtRemoveObjectCb cb, void* usr );

   virtual void addStartRegCb( RTI::ObjectClassHandle hand,
      DtStartRegCb cb, void* usr );
   virtual void removeStartRegCb( RTI::ObjectClassHandle hand,
      DtStartRegCb cb, void* usr );

   virtual void addStopRegCb( RTI::ObjectClassHandle hand,
      DtStopRegCb cb, void* usr );
   virtual void removeStopRegCb( RTI::ObjectClassHandle hand,
      DtStopRegCb cb, void* usr );

   virtual void addUpdatesOnCb( RTI::ObjectHandle hand,
      DtUpdatesOnCb cb, void* usr );
   virtual void removeUpdatesOnCb( RTI::ObjectHandle hand,
      DtUpdatesOnCb cb, void* usr );

   virtual void addUpdatesOffCb( RTI::ObjectHandle hand,
      DtUpdatesOffCb cb, void* usr );
   virtual void removeUpdatesOffCb( RTI::ObjectHandle hand,
      DtUpdatesOffCb cb, void* usr );

   virtual void addStartInteractionsCb( RTI::InteractionClassHandle hand,
      DtStartStopInterCb cb, void* usr );
   virtual void removeStartInteractionsCb( RTI::InteractionClassHandle hand,
      DtStartStopInterCb cb, void* usr );

   virtual void addStopInteractionsCb( RTI::InteractionClassHandle hand,
      DtStartStopInterCb cb, void* usr );
   virtual void removeStopInteractionsCb( RTI::InteractionClassHandle hand,
      DtStartStopInterCb cb, void* usr );

   virtual void addReceiveInteractionCb( RTI::InteractionClassHandle hand,
      DtReceiveInteractionCb cb, void* usr, DtDDMRegionSP region = DtDDMRegionSP() );
   virtual void removeReceiveInteractionCb( RTI::InteractionClassHandle hand,
      DtReceiveInteractionCb cb, void* usr, DtDDMRegionSP region = DtDDMRegionSP() );
   
   virtual void addTimeAdvanceGrantCb( DtFedTimeCb cb, void* usr );
   virtual void removeTimeAdvanceGrantCb( DtFedTimeCb cb, void* usr );

   virtual void addTimeRegulationEnabledCb( DtFedTimeCb cb, void* usr );
   virtual void removeTimeRegulationEnabledCb( DtFedTimeCb cb, void* usr );

   virtual void addTimeConstrainedEnabledCb( DtFedTimeCb cb, void* usr );
   virtual void removeTimeConstrainedEnabledCb( DtFedTimeCb cb, void* usr );

   virtual void setRemoveObjectOnAttOutOfScope(bool remove);
   virtual bool removeObjectOnAttOutOfScope() const;




   virtual void addFederateSaveCb(const DtString& label,
      DtFederateSaveCb func, void* usr);
   virtual void addFederateSaveCb(DtFederateSaveCb func, 
      void* usr);

   virtual void removeFederateSaveCb(const DtString& label,
      DtFederateSaveCb func, void* usr);
   virtual void removeFederateSaveCb(DtFederateSaveCb func, 
      void* usr);


   virtual void addFederateRestoreCb(const DtString& label,
      DtFederateRestoreCb func, void* usr);
   virtual void addFederateRestoreCb(DtFederateRestoreCb func, 
      void* usr);

   virtual void removeFederateRestoreCb(const DtString& label,
      DtFederateRestoreCb func, void* usr);
   virtual void removeFederateRestoreCb(DtFederateRestoreCb func, 
      void* usr);

   virtual bool waitingForSaveOrRestore() const;

public:

   virtual void timeAdvanceGrant( const RTI::FedTime& theTime )
      throw( RTI::InvalidFederationTime,
             RTI::TimeAdvanceWasNotInProgress,
             RTI::FederateInternalError );

   virtual void timeRegulationEnabled( const RTI::FedTime& theTime )
      throw( RTI::InvalidFederationTime,
             RTI::EnableTimeRegulationWasNotPending,
             RTI::FederateInternalError );

   virtual void timeConstrainedEnabled( const RTI::FedTime& theTime )
      throw( RTI::InvalidFederationTime,
             RTI::EnableTimeConstrainedWasNotPending,
             RTI::FederateInternalError );

   virtual void startRegistrationForObjectClass(
      RTI::ObjectClassHandle theClass )
      throw( RTI::ObjectClassNotPublished,
             RTI::FederateInternalError );

   virtual void stopRegistrationForObjectClass(
      RTI::ObjectClassHandle theClass )
      throw( RTI::ObjectClassNotPublished,
             RTI::FederateInternalError );

   virtual void turnInteractionsOn(
      RTI::InteractionClassHandle theHandle )
      throw( RTI::InteractionClassNotPublished,
             RTI::FederateInternalError );
   
   virtual void turnInteractionsOff(
      RTI::InteractionClassHandle theHandle )
      throw( RTI::InteractionClassNotPublished,
             RTI::FederateInternalError );

   virtual void discoverObjectInstance(
      RTI::ObjectHandle theObject,
      RTI::ObjectClassHandle theObjectClass,
      const char* theObjectName )
      throw( RTI::CouldNotDiscover,
             RTI::ObjectClassNotKnown,
             RTI::FederateInternalError );

   virtual void reflectAttributeValues(
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleValuePairSet& theAttributes,
      const RTI::FedTime& theTime,
      const char* theTag,
      RTI::EventRetractionHandle theHandle )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotKnown,
             RTI::FederateOwnsAttributes,
             RTI::InvalidFederationTime,
             RTI::FederateInternalError );

   virtual void reflectAttributeValues(
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleValuePairSet& theAttributes,
      const char* theTag )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotKnown,
             RTI::FederateOwnsAttributes,
             RTI::FederateInternalError);

   virtual void receiveInteraction(
      RTI::InteractionClassHandle theInteraction,
      const RTI::ParameterHandleValuePairSet& theParameters,
      const RTI::FedTime& theTime,
      const char* theTag,
      RTI::EventRetractionHandle theHandle )
      throw( RTI::InteractionClassNotKnown,
             RTI::InteractionParameterNotKnown,
             RTI::InvalidFederationTime,
             RTI::FederateInternalError );

   virtual void receiveInteraction(
      RTI::InteractionClassHandle theInteraction,
      const RTI::ParameterHandleValuePairSet& theParameters,
      const char* theTag )
      throw( RTI::InteractionClassNotKnown,
             RTI::InteractionParameterNotKnown,
             RTI::FederateInternalError );

   virtual void removeObjectInstance(
      RTI::ObjectHandle theObject,
      const RTI::FedTime& theTime,
      const char* theTag,
      RTI::EventRetractionHandle theHandle )
      throw( RTI::ObjectNotKnown,
             RTI::InvalidFederationTime,
             RTI::FederateInternalError );
   
   virtual void removeObjectInstance(
      RTI::ObjectHandle theObject,
      const char* theTag )
      throw( RTI::ObjectNotKnown,
             RTI::FederateInternalError );

   virtual void attributesInScope (
      RTI::ObjectHandle theObject,     
      const RTI::AttributeHandleSet& theAttributes) 
      throw ( RTI::ObjectNotKnown,
              RTI::AttributeNotKnown,
              RTI::FederateInternalError);

   virtual void attributesOutOfScope (
      RTI::ObjectHandle theObject,     
      const RTI::AttributeHandleSet& theAttributes) 
      throw ( RTI::ObjectNotKnown,
              RTI::AttributeNotKnown,
              RTI::FederateInternalError);

   
   virtual void provideAttributeValueUpdate(
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& theAttributes )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotKnown,
             RTI::AttributeNotOwned,
             RTI::FederateInternalError );

   virtual void turnUpdatesOnForObjectInstance(
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& theAttributes )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotOwned,
             RTI::FederateInternalError );

   virtual void turnUpdatesOffForObjectInstance(
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& theAttributes )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotOwned,
             RTI::FederateInternalError );

   virtual void requestAttributeOwnershipAssumption(
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& offeredAttributes,
      const char* theTag )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotKnown,
             RTI::AttributeAlreadyOwned,
             RTI::AttributeNotPublished,
             RTI::FederateInternalError );
   
   virtual void attributeOwnershipDivestitureNotification(
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& releasedAttributes )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotKnown,
             RTI::AttributeNotOwned,
             RTI::AttributeDivestitureWasNotRequested,
             RTI::FederateInternalError );
   
   virtual void attributeOwnershipAcquisitionNotification(
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& securedAttributes )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotKnown,
             RTI::AttributeAcquisitionWasNotRequested,
             RTI::AttributeAlreadyOwned,
             RTI::AttributeNotPublished,
             RTI::FederateInternalError );
   
   virtual void attributeOwnershipUnavailable(
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& theAttributes )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotKnown,
             RTI::AttributeAlreadyOwned,
             RTI::AttributeAcquisitionWasNotRequested,
             RTI::FederateInternalError );
   
   virtual void requestAttributeOwnershipRelease(
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& candidateAttributes,
      const char* theTag )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotKnown,
             RTI::AttributeNotOwned,
             RTI::FederateInternalError );
   
   virtual void confirmAttributeOwnershipAcquisitionCancellation(
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& theAttributes )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotKnown,
             RTI::AttributeAlreadyOwned,
             RTI::AttributeAcquisitionWasNotCanceled,
             RTI::FederateInternalError );
   
   virtual void informAttributeOwnership(
      RTI::ObjectHandle theObject,
      RTI::AttributeHandle theAttribute,
      RTI::FederateHandle theOwner )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotKnown,
             RTI::FederateInternalError );
   
   virtual void attributeIsNotOwned(
      RTI::ObjectHandle theObject,
      RTI::AttributeHandle theAttribute )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotKnown,
             RTI::FederateInternalError );
   
   virtual void attributeOwnedByRTI(
      RTI::ObjectHandle theObject,
      RTI::AttributeHandle theAttribute )
      throw( RTI::ObjectNotKnown,
             RTI::AttributeNotKnown,
             RTI::FederateInternalError);

   // Ignores federation saves, and immediately responds with 
   // "Federation Save Complete".
   virtual void initiateFederateSave(
      const char* label )
      throw( RTI::UnableToPerformSave,
      RTI::FederateInternalError );

   virtual void federationSaved()
      throw( RTI::FederateInternalError);

   virtual void federationNotSaved()
      throw( RTI::FederateInternalError );

   // Ignores federation restores, and immediately responds with 
   // "Federation Restore Complete".
   virtual void initiateFederateRestore (
      const char *label,   // supplied C4
      RTI::FederateHandle handle)  // supplied C1
      throw (
      RTI::SpecifiedSaveLabelDoesNotExist,
      RTI::CouldNotRestore,
      RTI::FederateInternalError);

   virtual void federationRestored ()
      throw (
      RTI::FederateInternalError);

   virtual void synchronizationPointRegistrationSucceeded( const char* label )
      throw( RTI::FederateInternalError );

   virtual void synchronizationPointRegistrationFailed( const char* label )
      throw( RTI::FederateInternalError );

   virtual void federationSynchronized( const char* label )
      throw( RTI::FederateInternalError );

   virtual void announceSynchronizationPoint(
      const char* label, const char* tag )
      throw( RTI::FederateInternalError );

   virtual void addSynchPointRegSucceededCb(const DtString& label,
      DtSynchPointCb func, void* usr);
   virtual void addSynchPointRegSucceededCb(DtSynchPointCb func, 
      void* usr);

   virtual void removeSynchPointRegSucceededCb(const DtString& label,
      DtSynchPointCb func, void* usr);
   virtual void removeSynchPointRegSucceededCb(DtSynchPointCb func, 
      void* usr);

   virtual void addSynchPointRegFailedCb(const DtString& label,
      DtSynchPointCb func, void* usr);
   virtual void addSynchPointRegFailedCb(DtSynchPointCb func, 
      void* usr);

   virtual void removeSynchPointRegFailedCb(const DtString& label,
      DtSynchPointCb func, void* usr);
   virtual void removeSynchPointRegFailedCb(DtSynchPointCb func, 
      void* usr);

   virtual void addFederationSynchedCb(const DtString& label,
      DtSynchPointCb func, void* usr);
   virtual void addFederationSynchedCb(DtSynchPointCb func, 
      void* usr);

   virtual void removeFederationSynchedCb(const DtString& label,
      DtSynchPointCb func, void* usr);
   virtual void removeFederationSynchedCb(DtSynchPointCb func, 
      void* usr);

   virtual void addAnnounceSynchPointCb(const DtString& label,
      DtAnnounceSynchPointCb func, void* usr);
   virtual void addAnnounceSynchPointCb(DtAnnounceSynchPointCb func, 
      void* usr);

   virtual void removeAnnounceSynchPointCb(const DtString& label,
      DtAnnounceSynchPointCb func, void* usr);
   virtual void removeAnnounceSynchPointCb(DtAnnounceSynchPointCb func, 
      void* usr);

protected:

   virtual const RTI::Region* getRegionFromAttributes(
      const RTI::AttributeHandleValuePairSet& theAttributes ) const;

   virtual const RTI::Region* getRegionFromParameters(
      const RTI::ParameterHandleValuePairSet& theAttributes ) const;

   struct DtFederateSaveCbInfo
   {
      DtFederateSaveCb cbFunction;
      void* userData;
   };

   struct DtFederateRestoreCbInfo
   {
      DtFederateRestoreCb cbFunction;
      void* userData;
   };

   struct DtLabelledFederateSaveCbInfo
   {
      DtString label;
      DtFederateSaveCb cbFunction;
      void* userData;
   };

   struct DtLabelledFederateRestoreCbInfo
   {
      DtString label;
      DtFederateRestoreCb cbFunction;
      void* userData;
   };

   struct DtGeneralSynchPointCbInfo
   {
      DtSynchPointCb cbFunction;
      void* userData;
   };

   struct DtLabelledSynchPointCbInfo
   {
      DtString label;
      DtSynchPointCb cbFunction;
      void* userData;
   };

   struct DtGeneralAnnounceCbInfo
   {
      DtAnnounceSynchPointCb cbFunction;
      void* userData;
   };

   struct DtLabelledAnnounceCbInfo
   {
      DtString label;
      DtAnnounceSynchPointCb cbFunction;
      void* userData;
   };

   static void attributesOutOfScopeCb(void* usr);

   virtual void processAttributesOutOfScope(RTI::ObjectHandle handle);

   DtExerciseConn*       myExConn;
   DtInteractionManager* myInteractionManager;
   DtHlaObjectManager*   myHlaObjectManager;

   DtReflectAttributeValuesCbList myRavCbList;
   DtUpdatesOnCbList              myUpdatesOnCbList;
   DtUpdatesOffCbList             myUpdatesOffCbList;
   DtStartRegCbList               myStartRegCbList;
   DtStopRegCbList                myStopRegCbList;
   DtStartStopInterCbList         myStartIntCbList;
   DtStartStopInterCbList         myStopIntCbList;
   DtFedTimeCbList                myTimeAdvanceGrantCbList;
   DtFedTimeCbList                myRegulationEnabledCbList;
   DtFedTimeCbList                myConstrainedEnabledCbList;
   
   std::list<DtFederateSaveCbInfo> myFederateSaveCbList;
   std::list<DtLabelledFederateSaveCbInfo> myLabFederateSaveCbList;
   std::list<DtFederateRestoreCbInfo> myFederateRestoreCbList;
   std::list<DtLabelledFederateRestoreCbInfo> myLabFederateRestoreCbList;

   std::list<DtLabelledSynchPointCbInfo> myLabSynchPtRegSucceededCbList;
   std::list<DtLabelledSynchPointCbInfo> myLabSynchPtRegFailedCbList;
   std::list<DtLabelledSynchPointCbInfo> myLabFederationSynchedCbList;
   std::list<DtLabelledAnnounceCbInfo>   myLabAnnounceSynchPointCbList;

   std::list<DtGeneralSynchPointCbInfo> mySynchPtRegSucceededCbList;
   std::list<DtGeneralSynchPointCbInfo> mySynchPtRegFailedCbList;
   std::list<DtGeneralSynchPointCbInfo> myFederationSynchedCbList;
   std::list<DtGeneralAnnounceCbInfo>     myAnnounceSynchPointCbList;

   bool myRemoveObjectOnAttOutOfScope;

   virtual void applyFedsSynchedCallbacks(const char* label);
   virtual void applyRegistrationSucceededCallbacks(const char* label);
   virtual void applyRegistrationFailedCallbacks(const char* label);

   virtual bool applyAnnounceCallbacks(const char* label, const char* tag);

protected:

   bool myWaitingForSave;
   bool myWaitingForRestore;
};

#endif   
#endif
#endif