federationslist.cc

分布式仿真 开放源码

    federation->acquireIfAvailable(federate, id, attributes, list_size);
}

// ----------------------------------------------------------------------------
// divest
void
FederationsList::divest(Handle handle,
                        FederateHandle federate,
                        ObjectHandle id,
                        AttributeHandle *attributes,
                        UShort list_size)
    throw (ObjectNotKnown,
           AttributeNotDefined,
           AttributeNotOwned,
           FederateNotExecutionMember,
           SaveInProgress,
           RestoreInProgress,
           RTIinternalError)
{
    Federation *federation = NULL ;

    // It may throw FederationExecutionDoesNotExist.
    searchFederation(handle, federation);

    // It may throw RTIinternalError.
    checkHandle(handle);
    checkHandle(federate);

    federation->divest(federate, id, attributes, list_size);
}

// ----------------------------------------------------------------------------
// acquire
void
FederationsList::acquire(Handle handle,
                         FederateHandle federate,
                         ObjectHandle id,
                         AttributeHandle *attributes,
                         UShort list_size,
                         const char *tag)
    throw (ObjectNotKnown,
           ObjectClassNotPublished,
           AttributeNotDefined,
           AttributeNotPublished,
           FederateOwnsAttributes,
           FederateNotExecutionMember,
           SaveInProgress,
           RestoreInProgress,
           RTIinternalError)
{
    Federation *federation = NULL ;

    // It may throw FederationExecutionDoesNotExist.
    searchFederation(handle, federation);

    // It may throw RTIinternalError.
    checkHandle(handle);
    checkHandle(federate);

    D.Out(pdDebug, "attributeOwnershipAcquisition of Object %u .", id);

    federation->acquire(federate, id, attributes, list_size, tag);
}

// ----------------------------------------------------------------------------
// cancelNegotiatedAttributeOwnershipDivestiture
void
FederationsList::cancelDivestiture(Handle handle,
                                   FederateHandle federate,
                                   ObjectHandle id,
                                   AttributeHandle *attributes,
                                   UShort list_size)
    throw (ObjectNotKnown, AttributeNotDefined, AttributeNotOwned,
           AttributeDivestitureWasNotRequested, FederateNotExecutionMember,
           SaveInProgress, RestoreInProgress, RTIinternalError)
{
    Federation *federation = NULL ;

    // It may throw FederationExecutionDoesNotExist.
    searchFederation(handle, federation);

    // It may throw RTIinternalError.
    checkHandle(handle);
    checkHandle(federate);

    D.Out(pdDebug,
          "cancelNegotiatedAttributeOwnershipDivestiture of Object %u .", id);

    federation->cancelDivestiture(federate, id, attributes, list_size);
}

// ----------------------------------------------------------------------------
// respondRelease
AttributeHandleSet*
FederationsList::respondRelease(Handle handle,
                                FederateHandle federate,
                                ObjectHandle id,
                                AttributeHandle *attributes,
                                UShort list_size)
    throw (ObjectNotKnown,
           AttributeNotDefined,
           AttributeNotOwned,
           FederateWasNotAskedToReleaseAttribute,
           FederateNotExecutionMember,
           SaveInProgress,
           RestoreInProgress,
           RTIinternalError)
{
    Federation *federation = NULL ;

    // It may throw FederationExecutionDoesNotExist.
    searchFederation(handle, federation);

    // It may throw RTIinternalError.
    checkHandle(handle);
    checkHandle(federate);

    D.Out(pdDebug, "AttributeOwnershipRealeaseResponse of Object %u .", id);

    return federation->respondRelease(federate, id, attributes, list_size);
}

// ----------------------------------------------------------------------------
// cancelAcquisition
void
FederationsList::cancelAcquisition(Handle handle,
                                   FederateHandle federate,
                                   ObjectHandle id,
                                   AttributeHandle *attributes,
                                   UShort list_size)
    throw (ObjectNotKnown,
           AttributeNotDefined,
           AttributeAlreadyOwned,
           AttributeAcquisitionWasNotRequested,
           FederateNotExecutionMember,
           SaveInProgress,
           RestoreInProgress,
           RTIinternalError)
{
    Federation *federation = NULL ;

    // It may throw FederationExecutionDoesNotExist.
    searchFederation(handle, federation);

    // It may throw RTIinternalError.
    checkHandle(handle);
    checkHandle(federate);

    D.Out(pdDebug, "cancelAttributeOwnershipAcquisition of Object %u .", id);

    federation->cancelAcquisition(federate, id, attributes, list_size);
}

// ----------------------------------------------------------------------------
long
FederationsList::createRegion(Handle federation,
                              FederateHandle federate,
                              SpaceHandle space,
                              long nb_extents)
    throw (SpaceNotDefined, InvalidExtents, FederateNotExecutionMember,
           SaveInProgress, RestoreInProgress, RTIinternalError)
{
    Federation *f = 0 ;

    searchFederation(federation, f);
    checkHandle(federation);
    checkHandle(federate);

    D[pdDebug] << "Create " << nb_extents << "-extent Region "
               << "in space " << space << endl ;

    return f->createRegion(federate, space, nb_extents);
}

// ----------------------------------------------------------------------------
void
FederationsList::modifyRegion(Handle federation,
			      FederateHandle federate,
			      RegionHandle region,
			      const std::vector<Extent> &extents)
    throw (InvalidExtents, SaveInProgress, RestoreInProgress, RTIinternalError)
{
    Federation *f = 0 ;

    searchFederation(federation, f);
    checkHandle(federation);
    checkHandle(federate);

    D[pdDebug] << "Modify region #" << region << endl ;
    f->modifyRegion(federate, region, extents);
}

// ----------------------------------------------------------------------------
void
FederationsList::deleteRegion(Handle federation,
                              FederateHandle federate,
                              long region)
    throw (RegionNotKnown, RegionInUse, FederateNotExecutionMember,
           SaveInProgress, RestoreInProgress, RTIinternalError)
{
    Federation *f = 0 ;

    searchFederation(federation, f);
    checkHandle(federation);
    checkHandle(federate);

    D[pdDebug] << "Delete region " << region << endl ;

    f->deleteRegion(federate, region);
}

// ----------------------------------------------------------------------------
void
FederationsList::associateRegion(Handle federation,
				 FederateHandle federate,
				 ObjectHandle object,
				 RegionHandle region,
				 unsigned short nb_attributes,
				 AttributeHandle *attributes)
	throw (RegionInUse, FederateNotExecutionMember, SaveInProgress,
	       RestoreInProgress, RTIinternalError)
{
    Federation *f = 0 ;

    searchFederation(federation, f);
    checkHandle(federation);
    checkHandle(federate);

    D[pdDebug] << "Associate region for updates " << region << endl ;

    f->associateRegion(federate, object, region, nb_attributes, attributes);
}

// ----------------------------------------------------------------------------
void
FederationsList::unassociateRegion(Handle federation, 
				   FederateHandle federate,
				   ObjectHandle object,
				   RegionHandle region)
	throw (RegionInUse, FederateNotExecutionMember, SaveInProgress,
	       RestoreInProgress, RTIinternalError)
{
    Federation *f = 0 ;

    searchFederation(federation, f);
    checkHandle(federation);
    checkHandle(federate);

    D[pdDebug] << "Unassociate region for updates " << region << endl ;

    f->unassociateRegion(federate, object, region);
}

// ----------------------------------------------------------------------------
void
FederationsList::subscribeAttributesWR(Handle federation,
				       FederateHandle federate,
				       ObjectClassHandle object_class,
				       RegionHandle region,
				       unsigned short nb,
				       AttributeHandle *attributes)
    throw (FederateNotExecutionMember, SaveInProgress, RestoreInProgress,
	   RTIinternalError)
{
    Federation *f = 0 ;

    searchFederation(federation, f);
    checkHandle(federation);
    checkHandle(federate);

    D[pdDebug] << " Subscribe attributes with region " << region << endl ;

    f->subscribeAttributesWR(federate, object_class, region, nb, attributes);
}

// ----------------------------------------------------------------------------
void
FederationsList::unsubscribeAttributesWR(Handle federation,
					 FederateHandle federate,
					 ObjectClassHandle object_class,
					 RegionHandle region)
    throw (FederateNotExecutionMember, SaveInProgress, RestoreInProgress,
	   RTIinternalError)
{
    Federation *f = 0 ;

    searchFederation(federation, f);
    checkHandle(federation);
    checkHandle(federate);

    D[pdDebug] << "Unsubscribe attributes with region " << region << endl ;

    f->unsubscribeAttributesWR(federate, object_class, region);
}

// ----------------------------------------------------------------------------
void
FederationsList::subscribeInteractionWR(Handle federation,
					FederateHandle federate,
					InteractionClassHandle ic,
					RegionHandle region)
    throw (FederateNotExecutionMember, SaveInProgress, RestoreInProgress,
	   RTIinternalError)
{
    Federation *f = 0 ;

    searchFederation(federation, f);
    checkHandle(federation);
    checkHandle(federate);

    D[pdDebug] << "Subscribe interaction with region " << region << endl ;

    f->subscribeInteractionWR(federate, ic, region);
}
    
// ----------------------------------------------------------------------------
void
FederationsList::unsubscribeInteractionWR(Handle federation,
					  FederateHandle federate,
					  InteractionClassHandle ic,
					  RegionHandle region)
    throw (FederateNotExecutionMember, SaveInProgress, RestoreInProgress,
	   RTIinternalError)
{
    Federation *f = 0 ;

    searchFederation(federation, f);
    checkHandle(federation);
    checkHandle(federate);

    D[pdDebug] << "Unsubscribe interaction with region " << region << endl ;

    f->unsubscribeInteractionWR(federate, ic, region);
}

// ----------------------------------------------------------------------------
void
FederationsList::requestFederationSave(Handle the_federation,
                                       FederateHandle the_federate,
                                       const char *the_label,
                                       FederationTime the_time)
{
    checkHandle(the_federation);

    // It may throw FederationExecutionDoesNotExist
    Federation *federation = 0 ;
    searchFederation(the_federation, federation);

    federation->requestFederationSave(the_federate, the_label, the_time);
}

// ----------------------------------------------------------------------------
void
FederationsList::federateSaveBegun(Handle the_federation,
                                   FederateHandle the_federate)
{
    checkHandle(the_federation);

    // It may throw FederationExecutionDoesNotExist
    Federation *federation = 0 ;
    searchFederation(the_federation, federation);

    federation->federateSaveBegun(the_federate);
}

// ----------------------------------------------------------------------------
void
FederationsList::federateSaveStatus(Handle the_federation,
                                    FederateHandle the_federate,
                                    bool the_status)
{
    checkHandle(the_federation);

    // It may throw FederationExecutionDoesNotExist
    Federation *federation = 0 ;
    searchFederation(the_federation, federation);

    federation->federateSaveStatus(the_federate, the_status);
}

// ----------------------------------------------------------------------------
void
FederationsList::requestFederationRestore(Handle the_federation,
                                          FederateHandle the_federate,
                                          const char *the_label)
{
    checkHandle(the_federation);

    // It may throw FederationExecutionDoesNotExist
    Federation *federation = NULL ;
    searchFederation(the_federation, federation);

    federation->requestFederationRestore(the_federate, the_label);
}

// ----------------------------------------------------------------------------
void
FederationsList::federateRestoreStatus(Handle the_federation,
                                       FederateHandle the_federate,
                                       bool the_status)
{
    checkHandle(the_federation);

    // It may throw FederationExecutionDoesNotExist
    Federation *federation = NULL ;
    searchFederation(the_federation, federation);

    federation->federateRestoreStatus(the_federate, the_status);
}

}} // certi::rtig

// EOF $Id: FederationsList.cc,v 3.23 2004/01/09 16:29:50 breholee Exp $