rtiambassador.hh

分布式仿真 开放源码

// ----------------------------------------------------------------------------
// CERTI - HLA RunTime Infrastructure
// Copyright (C) 2002, 2003  ONERA
//
// This file is part of CERTI-libRTI
//
// CERTI-libRTI is free software ; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation ; either version 2 of
// the License, or (at your option) any later version.
//
// CERTI-libRTI is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY ; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this program ; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
//
// $Id: RTIambassador.hh,v 3.17 2003/10/06 16:19:43 breholee Exp $
// ----------------------------------------------------------------------------

#ifndef _CERTI_RTI_AMBASSADOR_HH
#define _CERTI_RTI_AMBASSADOR_HH

#include "RTItypes.hh"
#include "fedtime.hh"
#include "SocketUN.hh"

namespace certi {

class FederateAmbassador ;
class RootObject ;
class Message ;
class CAttributeHandleValuePairSet ;
class AttributeHandleSet ;

/*! This class is used by applications for calls to RTI.
  RTIambassador is separated into two parts. This part uses an UNIX socket
  for sending and receiving data to/from rtia.
*/
class RTIambassador : private SocketUN
{
public:
    RTIambassador(void) throw (MemoryExhausted, RTIinternalError);
    ~RTIambassador(void);

    // Federation Management -------------------------------------------------
    void
    createFederationExecution(const char *executionName,
                              const char *FED)
        throw (FederationExecutionAlreadyExists,
               ConcurrentAccessAttempted,
               CouldNotOpenFED,
               ErrorReadingFED,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError);

    void
    destroyFederationExecution(const char *executionName)
        throw (FederatesCurrentlyJoined,
               FederationExecutionDoesNotExist,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError);

    FederateHandle
    joinFederationExecution(const char *yourName,
                            const char *executionName,
                            FederateAmbassadorPtr federateAmbassadorReference)
        throw (FederateAlreadyExecutionMember,
               FederationExecutionDoesNotExist,
               CouldNotOpenRID, //CERTI
               ErrorReadingRID, //CERTI
               CouldNotOpenFED, //not implemented
               ErrorReadingFED, //not implemented
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError);

    void
    resignFederationExecution(ResignAction theAction)
        throw (FederateOwnsAttributes,
               FederateNotExecutionMember,
               InvalidResignAction,
               ConcurrentAccessAttempted,
               RTIinternalError);

    void
    registerFederationSynchronizationPoint(const char *label,
                                           const char *theTag)
        throw (
            FederateNotExecutionMember,
            ConcurrentAccessAttempted,
            SaveInProgress,
            RestoreInProgress,
            RTIinternalError);

    void
    registerFederationSynchronizationPoint(const char *label,
                                           const char *theTag,
                                           const FederateHandleSet& syncSet)
        throw (FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError,
               UnimplementedService); //CERTI

    void
    synchronizationPointAchieved(const char *label)
        throw (SynchronizationPointLabelWasNotAnnounced,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError);

    void
    requestFederationSave(const char *label,
                          const FedTime& theTime)
        throw (FederationTimeAlreadyPassed,
               InvalidFederationTime,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError);

    void
    requestFederationSave(const char *label)
        throw (FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError);

    void
    federateSaveBegun()
        throw (SaveNotInitiated,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               RestoreInProgress,
               RTIinternalError);

    void
    federateSaveComplete()
        throw (SaveNotInitiated,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               RestoreInProgress,
               RTIinternalError);

    void
    federateSaveNotComplete()
        throw (SaveNotInitiated,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               RestoreInProgress,
               RTIinternalError);

    void
    requestFederationRestore(const char *label)
        throw (SpecifiedSaveLabelDoesNotExist, //CERTI
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError,
               UnimplementedService); //CERTI

    void
    federateRestoreComplete()
        throw (UnknownLabel,
               RestoreNotRequested,
               RTICannotRestore,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RTIinternalError,
               UnimplementedService); //CERTI

    void
    federateRestoreNotComplete()
        throw (UnknownLabel,
               RestoreNotRequested,
               FederateNotExecutionMember,
               RTICannotRestore,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RTIinternalError,
               UnimplementedService); //CERTI

    // Declaration Management ------------------------------------------------

    void
    publishObjectClass(ObjectClassHandle theClass,
                       const AttributeHandleSet& attributeList)
        throw (ObjectClassNotDefined,
               AttributeNotDefined,
               OwnershipAcquisitionPending, //not implemented
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               SecurityError, //CERTI
               RTIinternalError);

    void
    unpublishObjectClass(ObjectClassHandle theClass)
        throw (ObjectClassNotDefined,
               ObjectClassNotPublished, //not implemented
               OwnershipAcquisitionPending, //not implemented
               FederateOwnsAttributes, //CERTI
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               SecurityError, //CERTI
               RTIinternalError);

    void
    publishInteractionClass(InteractionClassHandle theInteraction)
        throw (InteractionClassNotDefined,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               SecurityError, //RTI
               RTIinternalError);

    void
    unpublishInteractionClass(InteractionClassHandle theInteraction)
        throw (InteractionClassNotDefined,
               InteractionClassNotPublished, //not implemented
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               SecurityError, //RTI
               RTIinternalError);

    void
    subscribeObjectClassAttributes(ObjectClassHandle theClass,
                                   const AttributeHandleSet& attributeList,
                                   Boolean active = RTI_TRUE)
        throw (ObjectClassNotDefined,
               AttributeNotDefined,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               SecurityError, //RTI
               RTIinternalError);

    void
    unsubscribeObjectClass(ObjectClassHandle theClass)
        throw (ObjectClassNotDefined,
               ObjectClassNotSubscribed, //not implemented
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               SecurityError, //RTI
               RTIinternalError);

    void
    subscribeInteractionClass(InteractionClassHandle theClass,
                              Boolean active = RTI_TRUE)
        throw (InteractionClassNotDefined,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               FederateLoggingServiceCalls, //not implemented
               SaveInProgress,
               RestoreInProgress,
               SecurityError, //RTI
               RTIinternalError);

    void
    unsubscribeInteractionClass(InteractionClassHandle theClass)
        throw (InteractionClassNotDefined,
               InteractionClassNotSubscribed, //not implemented
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               SecurityError, //RTI
               RTIinternalError);

    // Object Management -----------------------------------------------------

    ObjectHandle
    registerObjectInstance(ObjectClassHandle theClass,
                           const char *theObjectName)
        throw (ObjectClassNotDefined,
               ObjectClassNotPublished,
               InvalidObjectHandle, //RTI
               ObjectAlreadyRegistered,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError);

    ObjectHandle
    registerObjectInstance(ObjectClassHandle theClass)
        throw (ObjectClassNotDefined,
               ObjectClassNotPublished,
               InvalidObjectHandle, //RTI
               ObjectAlreadyRegistered,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError);

    EventRetractionHandle
    updateAttributeValues(ObjectHandle theObject,
                          const AttributeHandleValuePairSet& theAttributes,
                          const FedTime& theTime,
                          const char *theTag)
        throw (ObjectNotKnown,
               AttributeNotDefined,
               AttributeNotOwned,
               InvalidFederationTime,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError);

    void
    updateAttributeValues(ObjectHandle theObject,
                          const AttributeHandleValuePairSet& theAttributes,
                          const char *theTag)
        throw (ObjectNotKnown,
               AttributeNotDefined,
               AttributeNotOwned,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError,
               UnimplementedService); //CERTI

    EventRetractionHandle
    sendInteraction(InteractionClassHandle theInteraction,
                    const ParameterHandleValuePairSet& theParameters,
                    const FedTime& theTime,
                    const char *theTag)
        throw (InteractionClassNotDefined,
               InteractionClassNotPublished,
               InteractionParameterNotDefined,
               InvalidFederationTime,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError);

    void
    sendInteraction(InteractionClassHandle theInteraction,
                    const ParameterHandleValuePairSet& theParameters,
                    const char *theTag)
        throw (InteractionClassNotDefined,
               InteractionClassNotPublished,
               InteractionParameterNotDefined,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError,
               UnimplementedService); //CERTI

    EventRetractionHandle
    deleteObjectInstance(ObjectHandle theObject,
                         const FedTime& theTime,
                         const char *theTag)
        throw (ObjectNotKnown,
               DeletePrivilegeNotHeld,
               InvalidFederationTime,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError);

    void
    deleteObjectInstance(ObjectHandle theObject,
                         const char *theTag)
        throw (ObjectNotKnown,
               DeletePrivilegeNotHeld,
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError,
               UnimplementedService); //CERTI

    void
    localDeleteObjectInstance(ObjectHandle theObject)
        throw (ObjectNotKnown,
               FederateOwnsAttributes, //not implemented
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,
               SaveInProgress,
               RestoreInProgress,
               RTIinternalError,
               UnimplementedService); //CERTI

    void
    changeAttributeTransportationType(ObjectHandle theObject,
                                      const AttributeHandleSet& theAttributes,
                                      TransportationHandle theType)
        throw (ObjectNotKnown,
               AttributeNotDefined,
               AttributeNotOwned,
               InvalidTransportType, //CERTI
               InvalidTransportationHandle, //not implemented
               FederateNotExecutionMember,
               ConcurrentAccessAttempted,