fedAmbWrap.h

Go to the documentation of this file.

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

#ifndef DtFedAmbWrapper_H_
#define DtFedAmbWrapper_H_

#ifdef DtIFSPEC13

#include "rtiMsConfig.h"

#ifdef DtIFSPEC13DLC
#include "NullFederateAmbassador13.h" 
#define RTI rti13
#else
#include "NullFederateAmbassador.hh" 
#endif

class DtFedAmbWrapper; 
 
typedef DtFedAmbWrapper* (*DtFedAmbWrapperCreator) 
   (RTI::FederateAmbassador* fedAmb); 
 

#ifdef DtIFSPEC13DLC
class DT_DLL_LRC DtFedAmbWrapper : public rti13::NullFederateAmbassador 
#else
class DT_DLL_LRC DtFedAmbWrapper : public NullFederateAmbassador 
#endif
{
public: 
   DtFedAmbWrapper(RTI::FederateAmbassador* fedAmb);
 
   virtual ~DtFedAmbWrapper() throw (RTI::FederateInternalError);
 
   virtual RTI::FederateAmbassador* fedAmb(); 
   virtual void setFedAmb(RTI::FederateAmbassador* f); 
 
protected: 
   RTI::FederateAmbassador* myFedAmb; 
 
public: 
 

 
   virtual void synchronizationPointRegistrationSucceeded ( 
     const char *label)  
   throw ( 
     RTI::FederateInternalError); 
 
   virtual void synchronizationPointRegistrationFailed ( 
     const char *label)  
   throw ( 
     RTI::FederateInternalError); 
 
   virtual void announceSynchronizationPoint ( 
     const char *label,  
     const char *tag)    
   throw ( 
     RTI::FederateInternalError); 
 
   virtual void federationSynchronized ( 
     const char *label)  
   throw ( 
     RTI::FederateInternalError); 
 
   virtual void initiateFederateSave ( 
     const char *label)  
   throw ( 
     RTI::UnableToPerformSave, 
     RTI::FederateInternalError); 
 
   virtual void federationSaved () 
   throw ( 
     RTI::FederateInternalError); 
 
   virtual void federationNotSaved () 
   throw ( 
     RTI::FederateInternalError); 
 
   virtual void requestFederationRestoreSucceeded ( 
     const char *label)  
   throw ( 
     RTI::FederateInternalError); 
 
   virtual void requestFederationRestoreFailed ( 
     const char *label, 
     const char *reason)  
   throw ( 
     RTI::FederateInternalError); 
 
   virtual void federationRestoreBegun () 
   throw ( 
     RTI::FederateInternalError); 
 
   virtual void initiateFederateRestore ( 
     const char               *label,    
     RTI::FederateHandle handle)   
   throw ( 
     RTI::SpecifiedSaveLabelDoesNotExist, 
     RTI::CouldNotRestore, 
     RTI::FederateInternalError); 
 
   virtual void federationRestored () 
   throw ( 
     RTI::FederateInternalError); 
 
   virtual void federationNotRestored () 
   throw ( 
     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); 
 


 
   virtual void timeRegulationEnabled ( 
    const  RTI::FedTime& theFederateTime)  
   throw ( 
     RTI::InvalidFederationTime, 
     RTI::EnableTimeRegulationWasNotPending, 
     RTI::FederateInternalError); 
 
   virtual void timeConstrainedEnabled ( 
     const RTI::FedTime& theFederateTime)  
   throw ( 
     RTI::InvalidFederationTime, 
     RTI::EnableTimeConstrainedWasNotPending, 
     RTI::FederateInternalError); 
 
   virtual void timeAdvanceGrant ( 
     const RTI::FedTime& theTime)  
   throw ( 
     RTI::InvalidFederationTime, 
     RTI::TimeAdvanceWasNotInProgress, 
     RTI::FederateInternalError); 
 
   virtual void requestRetraction ( 
     RTI::EventRetractionHandle theHandle)  
   throw ( 
     RTI::EventNotKnown, 
     RTI::FederateInternalError); 

}; 

inline DtFedAmbWrapper::DtFedAmbWrapper(RTI::FederateAmbassador* fedAmb)
   : NullFederateAmbassador()
   , myFedAmb(fedAmb)
{
}

inline DtFedAmbWrapper::~DtFedAmbWrapper()
   throw (RTI::FederateInternalError)
{
}

inline RTI::FederateAmbassador* DtFedAmbWrapper::fedAmb() 
{ 
   return myFedAmb; 
} 
 
inline void DtFedAmbWrapper::setFedAmb(RTI::FederateAmbassador* f) 
{ 
   myFedAmb = f; 
} 
 
inline void DtFedAmbWrapper::synchronizationPointRegistrationSucceeded ( 
   const char *label) 
   throw ( 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb->synchronizationPointRegistrationSucceeded(label); 
   }  
} 
 
inline void DtFedAmbWrapper::synchronizationPointRegistrationFailed ( 
   const char *label)   
   throw ( 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> synchronizationPointRegistrationFailed(label); 
   }  
} 
 
inline void DtFedAmbWrapper::announceSynchronizationPoint ( 
   const char *label,   
   const char *tag)     
   throw ( 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> announceSynchronizationPoint(label, tag); 
   }  
} 
 
inline void DtFedAmbWrapper::federationSynchronized ( 
   const char *label)   
   throw ( 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> federationSynchronized(label); 
   }  
} 
 
inline void DtFedAmbWrapper::initiateFederateSave ( 
   const char *label)   
   throw ( 
     RTI::UnableToPerformSave, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> initiateFederateSave(label); 
   }  
} 
 
inline void DtFedAmbWrapper::federationSaved () 
   throw ( 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> federationSaved(); 
   }  
} 
 
inline void DtFedAmbWrapper::federationNotSaved () 
   throw ( 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> federationNotSaved(); 
   }  
} 
 
inline void DtFedAmbWrapper::requestFederationRestoreSucceeded ( 
   const char *label)   
   throw ( 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> requestFederationRestoreSucceeded(label); 
   }  
} 
 
inline void DtFedAmbWrapper::requestFederationRestoreFailed ( 
   const char *label, const char *reason)   
   throw ( 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> requestFederationRestoreFailed(label, reason); 
   }  
} 
 
inline void DtFedAmbWrapper::federationRestoreBegun () 
   throw ( 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> federationRestoreBegun(); 
   }  
} 
 
inline void DtFedAmbWrapper::initiateFederateRestore ( 
   const char *label, RTI::FederateHandle handle)    
   throw ( 
     RTI::SpecifiedSaveLabelDoesNotExist, 
     RTI::CouldNotRestore, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> initiateFederateRestore(label, handle); 
   }  
} 
 
 
inline void DtFedAmbWrapper::federationRestored () 
   throw ( 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> federationRestored(); 
   }  
} 
 
inline void DtFedAmbWrapper::federationNotRestored () 
   throw ( 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> federationNotRestored(); 
   }  
} 
 
inline void DtFedAmbWrapper::startRegistrationForObjectClass ( 
   RTI::ObjectClassHandle  theClass)        
   throw ( 
     RTI::ObjectClassNotPublished, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> startRegistrationForObjectClass(theClass); 
   }  
} 
 
inline void DtFedAmbWrapper::stopRegistrationForObjectClass ( 
   RTI::ObjectClassHandle   theClass)        
   throw ( 
     RTI::ObjectClassNotPublished, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> stopRegistrationForObjectClass(theClass); 
   }  
} 
 
inline void DtFedAmbWrapper::turnInteractionsOn ( 
   RTI::InteractionClassHandle theHandle)   
   throw ( 
     RTI::InteractionClassNotPublished, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> turnInteractionsOn(theHandle); 
   }  
} 
 
 
inline void DtFedAmbWrapper::turnInteractionsOff ( 
   RTI::InteractionClassHandle theHandle)   
   throw ( 
     RTI::InteractionClassNotPublished, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> turnInteractionsOff(theHandle); 
   }  
} 
 
 
inline void DtFedAmbWrapper::discoverObjectInstance ( 
   RTI::ObjectHandle theObject,  
   RTI::ObjectClassHandle theObjectClass,  
   const char * theObjectName)    
   throw ( 
     RTI::CouldNotDiscover, 
     RTI::ObjectClassNotKnown, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> discoverObjectInstance( 
  theObject, theObjectClass, theObjectName); 
   }  
} 
 
 
inline void DtFedAmbWrapper::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) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> reflectAttributeValues( 
        theObject, theAttributes, theTime, theTag, theHandle); 
   }  
} 
 
inline void DtFedAmbWrapper::reflectAttributeValues ( 
   RTI::ObjectHandle theObject,       
   const RTI::AttributeHandleValuePairSet& theAttributes,   
   const char* theTag)          
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::FederateOwnsAttributes, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> reflectAttributeValues(theObject, theAttributes, theTag); 
   }  
} 
 
 
inline void DtFedAmbWrapper::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) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> receiveInteraction( 
        theInteraction, theParameters, theTime, theTag, theHandle); 
   }  
} 
 
inline void DtFedAmbWrapper::receiveInteraction ( 
   RTI::InteractionClassHandle theInteraction,   
   const RTI::ParameterHandleValuePairSet& theParameters,    
   const char *theTag)           
   throw ( 
     RTI::InteractionClassNotKnown, 
     RTI::InteractionParameterNotKnown, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> receiveInteraction(theInteraction, theParameters, theTag); 
   }  
} 
 
 
inline void DtFedAmbWrapper::removeObjectInstance ( 
   RTI::ObjectHandle theObject,   
   const RTI::FedTime& theTime,     
   const char *theTag,      
   RTI::EventRetractionHandle theHandle)   
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::InvalidFederationTime, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> removeObjectInstance( 
        theObject, theTime, theTag, theHandle); 
   }  
} 
 
inline void DtFedAmbWrapper::removeObjectInstance ( 
   RTI::ObjectHandle theObject,  const char *theTag)      
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> removeObjectInstance(theObject, theTag); 
   }  
} 
 
 
inline void DtFedAmbWrapper::attributesInScope ( 
   RTI::ObjectHandle theObject,       
   const RTI::AttributeHandleSet& theAttributes)   
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> attributesInScope( 
        theObject, theAttributes); 
   }  
} 
 
 
inline void DtFedAmbWrapper::attributesOutOfScope ( 
   RTI::ObjectHandle theObject,       
   const RTI::AttributeHandleSet& theAttributes)   
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> attributesOutOfScope( 
        theObject, theAttributes); 
   }  
} 
 
 
inline void DtFedAmbWrapper::provideAttributeValueUpdate ( 
   RTI::ObjectHandle theObject,       
   const RTI::AttributeHandleSet& theAttributes)   
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::AttributeNotOwned, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> provideAttributeValueUpdate( 
        theObject, theAttributes); 
   }  
} 
 
 
inline void DtFedAmbWrapper::turnUpdatesOnForObjectInstance ( 
   RTI::ObjectHandle theObject,       
   const RTI::AttributeHandleSet& theAttributes)   
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotOwned, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> turnUpdatesOnForObjectInstance( 
        theObject, theAttributes); 
   }  
} 
 
 
inline void DtFedAmbWrapper::turnUpdatesOffForObjectInstance ( 
   RTI::ObjectHandle theObject,        
   const RTI::AttributeHandleSet& theAttributes)   
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotOwned, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> turnUpdatesOffForObjectInstance( 
       theObject, theAttributes); 
   }  
} 
 
inline void DtFedAmbWrapper::requestAttributeOwnershipAssumption ( 
   RTI::ObjectHandle theObject,           
   const RTI::AttributeHandleSet& offeredAttributes,   
   const char *theTag)              
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::AttributeAlreadyOwned, 
     RTI::AttributeNotPublished, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> requestAttributeOwnershipAssumption( 
        theObject, offeredAttributes, theTag); 
   }  
} 
 
inline void DtFedAmbWrapper::attributeOwnershipDivestitureNotification ( 
   RTI::ObjectHandle theObject,            
   const RTI::AttributeHandleSet& releasedAttributes)   
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::AttributeNotOwned, 
     RTI::AttributeDivestitureWasNotRequested, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> attributeOwnershipDivestitureNotification( 
        theObject, releasedAttributes); 
   }  
} 
 
 
inline void DtFedAmbWrapper::attributeOwnershipAcquisitionNotification ( 
   RTI::ObjectHandle theObject,           
   const RTI::AttributeHandleSet& securedAttributes)   
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::AttributeAcquisitionWasNotRequested, 
     RTI::AttributeAlreadyOwned, 
     RTI::AttributeNotPublished, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> attributeOwnershipAcquisitionNotification( 
        theObject, securedAttributes); 
   }  
} 
 
 
inline void DtFedAmbWrapper::attributeOwnershipUnavailable ( 
   RTI::ObjectHandle theObject,           
   const RTI::AttributeHandleSet& theAttributes)   
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::AttributeAlreadyOwned, 
     RTI::AttributeAcquisitionWasNotRequested, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> attributeOwnershipUnavailable( 
        theObject, theAttributes); 
   }  
} 
 
 
inline void DtFedAmbWrapper::requestAttributeOwnershipRelease ( 
   RTI::ObjectHandle theObject,             
   const RTI::AttributeHandleSet& candidateAttributes,   
   const char *theTag)                
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::AttributeNotOwned, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> requestAttributeOwnershipRelease( 
        theObject, candidateAttributes, theTag); 
   }  
} 
 
 
inline void DtFedAmbWrapper::confirmAttributeOwnershipAcquisitionCancellation ( 
   RTI::ObjectHandle theObject,           
   const RTI::AttributeHandleSet& theAttributes)   
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::AttributeAlreadyOwned, 
     RTI::AttributeAcquisitionWasNotCanceled, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> confirmAttributeOwnershipAcquisitionCancellation( 
        theObject, theAttributes); 
   }  
} 
 
 
inline void DtFedAmbWrapper::informAttributeOwnership ( 
   RTI::ObjectHandle theObject,      
   RTI::AttributeHandle theAttribute,   
   RTI::FederateHandle theOwner)       
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> informAttributeOwnership(theObject, theAttribute, theOwner); 
   }  
} 
 
inline void DtFedAmbWrapper::attributeIsNotOwned ( 
   RTI::ObjectHandle    theObject,      
   RTI::AttributeHandle theAttribute)   
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> attributeIsNotOwned(theObject, theAttribute); 
   }  
} 
 
inline void DtFedAmbWrapper::attributeOwnedByRTI ( 
   RTI::ObjectHandle    theObject,      
   RTI::AttributeHandle theAttribute)   
   throw ( 
     RTI::ObjectNotKnown, 
     RTI::AttributeNotKnown, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> attributeOwnedByRTI(theObject, theAttribute); 
   }  
} 
 
inline void DtFedAmbWrapper::timeRegulationEnabled ( 
   const  RTI::FedTime& theFederateTime)   
   throw ( 
     RTI::InvalidFederationTime, 
     RTI::EnableTimeRegulationWasNotPending, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> timeRegulationEnabled(theFederateTime); 
   }  
} 
 
inline void DtFedAmbWrapper::timeConstrainedEnabled ( 
   const RTI::FedTime& theFederateTime)   
   throw ( 
     RTI::InvalidFederationTime, 
     RTI::EnableTimeConstrainedWasNotPending, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> timeConstrainedEnabled(theFederateTime); 
   }  
} 
 
inline void DtFedAmbWrapper::timeAdvanceGrant ( 
   const RTI::FedTime& theTime)   
   throw ( 
     RTI::InvalidFederationTime, 
     RTI::TimeAdvanceWasNotInProgress, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> timeAdvanceGrant(theTime); 
   }  
} 
 
inline void DtFedAmbWrapper::requestRetraction ( 
   RTI::EventRetractionHandle theHandle)   
   throw ( 
     RTI::EventNotKnown, 
     RTI::FederateInternalError) 
{  
   if (myFedAmb)  
   {  
     myFedAmb-> requestRetraction(theHandle); 
   }  
} 
 
#endif 
#endif