ambObserver.h

Go to the documentation of this file.

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


#ifndef DtRtiAmbassadorObserver_H_
#define DtRtiAmbassadorObserver_H_

#ifdef DtIFSPEC13

#include "rtiMsConfig.h"
#include <vlutil/vlList.h>
#include <vlutil/vlString.h>

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

class DtRtiAmbassadorImplementor;

class DT_DLL_LRC DtRtiAmbassadorObserver : public MAKRti::DtListedObj
{
public:

   DtRtiAmbassadorObserver() : MAKRti::DtListedObj() {}

   virtual ~DtRtiAmbassadorObserver() {}

   virtual DtRtiAmbassadorObserver* next() const;

   virtual DtRtiAmbassadorObserver* prev() const;

   virtual DtRtiAmbassadorObserver* wrapNext() const;

   virtual DtRtiAmbassadorObserver* wrapPrev() const;

   virtual void createFederationExecution (
      const char *executionName, 
      const char *FED, 
      RTI::Exception* except = NULL)  {} 

   virtual void destroyFederationExecution (
      const char *executionName, 
      RTI::Exception* except = NULL)  {} 

   virtual void joinFederationExecution (
      const char *yourName, 
      const char *executionName, 
      RTI::FederateAmbassador* federateAmbassadorReference, 
      RTI::FederateHandle& handle, 
      RTI::Exception* except = NULL)  {} 

   virtual void resignFederationExecution (
      RTI::ResignAction theAction, 
      RTI::Exception* except = NULL)  {} 

   virtual void registerFederationSynchronizationPoint (       
      const char *label,  
      const char *theTag, 
      RTI::Exception* except = NULL)  {} 

   virtual void registerFederationSynchronizationPoint (       
      const char *label,
      const char *theTag,
      const RTI::FederateHandleSet& syncSet, 
      RTI::Exception* except = NULL)  {}

   virtual void synchronizationPointAchieved (      
      const char *label, 
      RTI::Exception* except = NULL)  {}

   virtual void requestFederationSave (    
      const char *label,  
      const RTI::FedTime& theTime, 
      RTI::Exception* except = NULL)  {}

   virtual void requestFederationSave ( 
      const char *label, 
      RTI::Exception* except = NULL)  {} 

   virtual void federateSaveBegun ( 
      RTI::Exception* except = NULL)  {}

   virtual void federateSaveComplete ( 
      RTI::Exception* except = NULL)  {}

   virtual void federateSaveNotComplete ( 
      RTI::Exception* except = NULL)  {}

   virtual void requestFederationRestore (    
      const char *label, 
      RTI::Exception* except = NULL)  {} 

   virtual void federateRestoreComplete ( 
      RTI::Exception* except = NULL)  {}

   virtual void federateRestoreNotComplete ( 
      RTI::Exception* except = NULL)  {}

//-----------------------------------
//----------------------------------

   virtual void publishObjectClass (
      RTI::ObjectClassHandle   theClass,  
      const RTI::AttributeHandleSet& attributeList, 
      RTI::Exception* except = NULL)  {}

   virtual void unpublishObjectClass (
      RTI::ObjectClassHandle theClass, 
      RTI::Exception* except = NULL)  {}

   virtual void publishInteractionClass (
      RTI::InteractionClassHandle theInteraction, 
      RTI::Exception* except = NULL)  {}

   virtual void unpublishInteractionClass (
      RTI::InteractionClassHandle theInteraction, 
      RTI::Exception* except = NULL)  {}

   virtual void subscribeObjectClassAttributes (
      RTI::ObjectClassHandle theClass,  
      const RTI::AttributeHandleSet& attributeList,
      RTI::Boolean active = RTI::RTI_TRUE, 
      RTI::Exception* except = NULL)  {}

   virtual void unsubscribeObjectClass (
      RTI::ObjectClassHandle theClass, 
      RTI::Exception* except = NULL)  {}

   virtual void subscribeInteractionClass (
      RTI::InteractionClassHandle theClass, 
      RTI::Boolean active = RTI::RTI_TRUE, 
      RTI::Exception* except = NULL)  {}

   virtual void unsubscribeInteractionClass (
      RTI::InteractionClassHandle theClass, 
      RTI::Exception* except = NULL)  {}

//-------------------------------
//-------------------------------

   virtual void registerObjectInstance (
      RTI::ObjectClassHandle  theClass, 
      const char *theObject, 
      RTI::ObjectHandle& handle,
      RTI::Exception* except = NULL)  {}

   virtual void registerObjectInstance (
      RTI::ObjectClassHandle theClass, 
      RTI::ObjectHandle& handle,
      RTI::Exception* except = NULL)  {}

   virtual void updateAttributeValues (
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleValuePairSet& theAttributes,
      const RTI::FedTime& theTime, 
      const char *theTag, 
      RTI::EventRetractionHandle& handle,
      RTI::Exception* except = NULL)  {} 

   virtual void updateAttributeValues (
        RTI::ObjectHandle theObject, 
        const RTI::AttributeHandleValuePairSet& theAttributes,
        const char *theTag, 
      RTI::Exception* except = NULL)  {}

   virtual void sendInteraction (
      RTI::InteractionClassHandle theInteraction,
      const RTI::ParameterHandleValuePairSet& theParameters,
      const RTI::FedTime& theTime,
      const char *theTag, 
      RTI::EventRetractionHandle& handle,
      RTI::Exception* except = NULL)  {}

   virtual void sendInteraction (
      RTI::InteractionClassHandle theInteraction,
      const RTI::ParameterHandleValuePairSet& theParameters,
      const char *theTag, 
      RTI::Exception* except = NULL)  {} 

   virtual void deleteObjectInstance (
      RTI::ObjectHandle theObject, 
      const RTI::FedTime& theTime, 
      const char *theTag, 
      RTI::EventRetractionHandle& handle,
      RTI::Exception* except = NULL)  {}

   virtual void deleteObjectInstance (
      RTI::ObjectHandle theObject,
      const char *theTag, 
      RTI::Exception* except = NULL)  {}

   virtual void localDeleteObjectInstance (
      RTI::ObjectHandle theObject, 
      RTI::Exception* except = NULL)  {} 

   virtual void changeAttributeTransportationType (
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& theAttributes,
      RTI::TransportationHandle theType, 
      RTI::Exception* except = NULL)  {}
        
   virtual void changeInteractionTransportationType (
      RTI::InteractionClassHandle theClass,
      RTI::TransportationHandle theType, 
      RTI::Exception* except = NULL)  {}

   virtual void requestObjectAttributeValueUpdate (
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& theAttributes, 
      RTI::Exception* except = NULL)  {}

   virtual void requestClassAttributeValueUpdate (
      RTI::ObjectClassHandle theClass,
      const RTI::AttributeHandleSet& theAttributes, 
      RTI::Exception* except = NULL)  {}

//---------------------------------
//---------------------------------

   virtual void unconditionalAttributeOwnershipDivestiture (
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& theAttributes, 
      RTI::Exception* except = NULL)  {}

   virtual void negotiatedAttributeOwnershipDivestiture (
      RTI::ObjectHandle theObject, 
      const RTI::AttributeHandleSet& theAttributes,
      const char *theTag, 
      RTI::Exception* except = NULL)  {}

   virtual void attributeOwnershipAcquisition (
      RTI::ObjectHandle theObject, 
      const RTI::AttributeHandleSet& desiredAttributes,
      const char *theTag, 
      RTI::Exception* except = NULL)  {}

   virtual void attributeOwnershipAcquisitionIfAvailable (
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& desiredAttributes, 
      RTI::Exception* except = NULL)  {}

   virtual void attributeOwnershipReleaseResponse (
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& theAttributes, 
      RTI::AttributeHandleSet* set,
      RTI::Exception* except = NULL)  {}

   virtual void cancelNegotiatedAttributeOwnershipDivestiture (
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet& theAttributes, 
      RTI::Exception* except = NULL)  {}

   virtual void cancelAttributeOwnershipAcquisition (
      RTI::ObjectHandle theObject, 
      const RTI::AttributeHandleSet& theAttributes, 
      RTI::Exception* except = NULL)  {}

   virtual void queryAttributeOwnership (
      RTI::ObjectHandle theObject,
      RTI::AttributeHandle theAttribute, 
      RTI::Exception* except = NULL)  {}
        
   virtual void isAttributeOwnedByFederate (
      RTI::ObjectHandle theObject,
      RTI::AttributeHandle theAttribute, 
      RTI::Boolean boolean,
      RTI::Exception* except = NULL)  {}
        
//----------------------------
//----------------------------

   virtual void enableTimeRegulation (
      const RTI::FedTime& theFederateTime, 
      const RTI::FedTime& theLookahead, 
      RTI::Exception* except = NULL)  {}

   virtual void disableTimeRegulation (
      RTI::Exception* except = NULL)  {}

   virtual void enableTimeConstrained (
      RTI::Exception* except = NULL)  {}

   virtual void disableTimeConstrained (
      RTI::Exception* except = NULL)  {}

   virtual void timeAdvanceRequest (
     const  RTI::FedTime& theTime, 
     RTI::Exception* except = NULL)  {}

   virtual void timeAdvanceRequestAvailable (
    const RTI::FedTime& theTime, 
      RTI::Exception* except = NULL)  {}

   virtual void nextEventRequest (
      const RTI::FedTime& theTime, 
      RTI::Exception* except = NULL)  {}

   virtual void nextEventRequestAvailable (
      const RTI::FedTime& theTime, 
      RTI::Exception* except = NULL)  {}

   virtual void flushQueueRequest (
      const RTI::FedTime& theTime, 
      RTI::Exception* except = NULL)  {}

   virtual void enableAsynchronousDelivery(
      RTI::Exception* except = NULL)  {}

   virtual void disableAsynchronousDelivery(
      RTI::Exception* except = NULL)  {}
    
   virtual void queryLBTS (
      RTI::FedTime& theTime, 
      RTI::Exception* except = NULL)  {} 

   virtual void queryFederateTime (
      RTI::FedTime& theTime, 
      RTI::Exception* except = NULL)  {} 

   virtual void queryMinNextEventTime (
      RTI::FedTime& theTime, 
      RTI::Exception* except = NULL)  {} 

   virtual void modifyLookahead (
      const RTI::FedTime& theLookahead, 
      RTI::Exception* except = NULL)  {}

   virtual void queryLookahead (
       RTI::FedTime& theTime, 
      RTI::Exception* except = NULL)  {} 

   virtual void retract (
      RTI::EventRetractionHandle theHandle, 
      RTI::Exception* except = NULL)  {}

   virtual void changeAttributeOrderType (
      RTI::ObjectHandle theObject, 
      const RTI::AttributeHandleSet& theAttributes,
      RTI::OrderingHandle theType, 
      RTI::Exception* except = NULL)  {} 

   virtual void changeInteractionOrderType (
      RTI::InteractionClassHandle theClass,
      RTI::OrderingHandle theType, 
      RTI::Exception* except = NULL)  {}

//--------------------------------
//--------------------------------

   virtual void createRegion (
      RTI::SpaceHandle theSpace,
      RTI::ULong numberOfExtents, 
      RTI::Region* region,
      RTI::Exception* except = NULL)  {}

   virtual void notifyAboutRegionModification (
      RTI::Region &theRegion, 
      RTI::Exception* except = NULL)  {}

   virtual void deleteRegion (
      RTI::Region *theRegion, 
      RTI::Exception* except = NULL)  {}

   virtual void registerObjectInstanceWithRegion (
      RTI::ObjectClassHandle theClass,
      const char *theObject,
      RTI::AttributeHandle theAttributes[],
      RTI::Region *theRegions[],
      RTI::ULong theNumberOfHandles, 
      RTI::ObjectHandle& handle,
      RTI::Exception* except = NULL)  {}

   virtual void registerObjectInstanceWithRegion (
      RTI::ObjectClassHandle theClass,
      RTI::AttributeHandle theAttributes[],
      RTI::Region *theRegions[],
      RTI::ULong theNumberOfHandles, 
      RTI::ObjectHandle& handle,
      RTI::Exception* except = NULL)  {}

   virtual void associateRegionForUpdates (
      RTI::Region &theRegion,
      RTI::ObjectHandle theObject,
      const RTI::AttributeHandleSet &theAttributes, 
      RTI::Exception* except = NULL)  {}

   virtual void unassociateRegionForUpdates (
      RTI::Region &theRegion,
      RTI::ObjectHandle theObject, 
      RTI::Exception* except = NULL)  {}

   virtual void subscribeObjectClassAttributesWithRegion (
      RTI::ObjectClassHandle theClass,
      RTI::Region &theRegion,
      const RTI::AttributeHandleSet &attributeList,
      RTI::Boolean active = RTI::RTI_TRUE, 
      RTI::Exception* except = NULL)  {}

   virtual void unsubscribeObjectClassWithRegion (
      RTI::ObjectClassHandle theClass,
      RTI::Region &theRegion, 
      RTI::Exception* except = NULL)  {}

   virtual void subscribeInteractionClassWithRegion (
      RTI::InteractionClassHandle theClass,
      RTI::Region &theRegion,
      RTI::Boolean active = RTI::RTI_TRUE, 
      RTI::Exception* except = NULL)  {}

   virtual void unsubscribeInteractionClassWithRegion (
      RTI::InteractionClassHandle theClass,
      RTI::Region &theRegion, 
      RTI::Exception* except = NULL)  {}

   virtual void sendInteractionWithRegion (
      RTI::InteractionClassHandle theInteraction,
      const RTI::ParameterHandleValuePairSet &theParameters,
      const RTI::FedTime& theTime,
      const char *theTag, 
      const RTI::Region &theRegion, 
      RTI::EventRetractionHandle& handle,
      RTI::Exception* except = NULL)  {}

   virtual void sendInteractionWithRegion (
      RTI::InteractionClassHandle theInteraction,
      const RTI::ParameterHandleValuePairSet &theParameters,
      const char *theTag,
      const RTI::Region &theRegion, 
      RTI::Exception* except = NULL)  {} 

   virtual void requestClassAttributeValueUpdateWithRegion (
     RTI::ObjectClassHandle theClass,
     const RTI::AttributeHandleSet &theAttributes,
     const RTI::Region &theRegion, 
      RTI::Exception* except = NULL)  {}

//------------------------
//------------------------

   virtual void getObjectClassHandle (
      const char *theName, 
      RTI::ObjectClassHandle& handle,
      RTI::Exception* except = NULL)  {}

   virtual void getObjectClassName (
      RTI::ObjectClassHandle theHandle, 
      char* className,
      RTI::Exception* except = NULL)  {} 

   virtual void getAttributeHandle (
      const char *theName, 
      RTI::ObjectClassHandle whichClass, 
      RTI::AttributeHandle& handle,
      RTI::Exception* except = NULL)  {} 

   virtual void getAttributeName (
      RTI::AttributeHandle theHandle,
      RTI::ObjectClassHandle whichClass, 
      char* attributeName,
      RTI::Exception* except = NULL)  {} 

   virtual void getInteractionClassHandle (
      const char *theName, 
      RTI::InteractionClassHandle& handle,
      RTI::Exception* except = NULL)  {}

   virtual void getInteractionClassName (
     RTI::InteractionClassHandle theHandle, 
     char* className,
     RTI::Exception* except = NULL)  {} 

   virtual void getParameterHandle (
      const char *theName,
      RTI::InteractionClassHandle whichClass,
      RTI::ParameterHandle& handle,
      RTI::Exception* except = NULL)  {} 
    
   virtual void getParameterName (
      RTI::ParameterHandle theHandle,  
      RTI::InteractionClassHandle whichClass, 
      char* paramName,
      RTI::Exception* except = NULL)  {}

   virtual void getObjectInstanceHandle (
      const char *theName, 
      RTI::ObjectHandle& handle,
      RTI::Exception* except = NULL)  {}

   virtual void getObjectInstanceName (
     RTI::ObjectHandle theHandle, 
     char* objectInstanceName,
     RTI::Exception* except = NULL)  {}

   virtual void getRoutingSpaceHandle (
     const char *theName, 
     RTI::SpaceHandle& handle,
     RTI::Exception* except = NULL)  {}
        
   virtual void getRoutingSpaceName (
      RTI::SpaceHandle theHandle, 
      char* spaceName,
      RTI::Exception* except = NULL)  {} 

   virtual void getDimensionHandle (
     const char *theName,
     RTI::SpaceHandle whichSpace, 
     RTI::DimensionHandle& handle,
     RTI::Exception* except = NULL)  {}
    
   virtual void getDimensionName (
      RTI::DimensionHandle theHandle,
      RTI::SpaceHandle whichSpace, 
      char* dimensionName,
      RTI::Exception* except = NULL)  {}

   virtual void getAttributeRoutingSpaceHandle (
      RTI::AttributeHandle theHandle,
      RTI::ObjectClassHandle whichClass, 
      RTI::SpaceHandle& handle, 
      RTI::Exception* except = NULL)  {}

   virtual void getObjectClass (
      RTI::ObjectHandle theObject, 
      RTI::ObjectClassHandle& handle,
      RTI::Exception* except = NULL)  {}

   virtual void getInteractionRoutingSpaceHandle (
     RTI::InteractionClassHandle theHandle, 
     RTI::SpaceHandle& handle, 
     RTI::Exception* except = NULL)  {}

   virtual void getTransportationHandle (
     const char *theName, 
     RTI::TransportationHandle& handle,
     RTI::Exception* except = NULL)  {}

   virtual void getTransportationName (
     RTI::TransportationHandle theHandle, 
     char* transportationName,
     RTI::Exception* except = NULL)  {}

   virtual void getOrderingHandle (
     const char *theName, 
     RTI::OrderingHandle& handle,
     RTI::Exception* except = NULL)  {}

   virtual void getOrderingName (
     RTI::OrderingHandle theHandle, 
     char* orderingName,
     RTI::Exception* except = NULL)  {} 

   virtual void enableClassRelevanceAdvisorySwitch(
      RTI::Exception* except = NULL)  {}

   virtual void disableClassRelevanceAdvisorySwitch(
      RTI::Exception* except = NULL)  {}

   virtual void enableAttributeRelevanceAdvisorySwitch(
      RTI::Exception* except = NULL)  {}

   virtual void disableAttributeRelevanceAdvisorySwitch(
      RTI::Exception* except = NULL)  {}

   virtual void enableAttributeScopeAdvisorySwitch(
      RTI::Exception* except = NULL)  {}

   virtual void disableAttributeScopeAdvisorySwitch(
      RTI::Exception* except = NULL)  {}

   virtual void enableInteractionRelevanceAdvisorySwitch(
      RTI::Exception* except = NULL)  {}

   virtual void disableInteractionRelevanceAdvisorySwitch(
      RTI::Exception* except = NULL)  {}

   virtual void tick (
       RTI::Boolean result,
       RTI::Exception* except = NULL)  {}
        
   virtual void tick (
      RTI::TickTime minimum,
      RTI::TickTime maximum, 
      RTI::Boolean result,
      RTI::Exception* except = NULL)  {}

   virtual void getRegionToken(
     RTI::Region *, 
     RTI::RegionToken& token,
     RTI::Exception* except = NULL)  {}

   virtual void getRegion(
      RTI::RegionToken, 
      RTI::Region* region,
      RTI::Exception* except = NULL)  {}
};

inline DtRtiAmbassadorObserver* DtRtiAmbassadorObserver::next() const
{
   return (DtRtiAmbassadorObserver*) MAKRti::DtListedObj::next();
}

inline DtRtiAmbassadorObserver* DtRtiAmbassadorObserver::prev() const
{
   return (DtRtiAmbassadorObserver*) MAKRti::DtListedObj::prev();
}

inline DtRtiAmbassadorObserver* DtRtiAmbassadorObserver::wrapNext() const
{
   return (DtRtiAmbassadorObserver*) MAKRti::DtListedObj::wrapNext();
}

inline DtRtiAmbassadorObserver* DtRtiAmbassadorObserver::wrapPrev() const
{
   return (DtRtiAmbassadorObserver*) MAKRti::DtListedObj::wrapPrev();
}

#endif 
#endif