interaction.cc

分布式仿真 开放源码

}

// ----------------------------------------------------------------------------
//! Returns the parameter handle obtained by its name.
ParameterHandle
Interaction::getParameterHandle(const char *the_name) const
    throw (NameNotFound, RTIinternalError)
{
    list<Parameter *>::const_iterator p ;
    for (p = parameterSet.begin(); p != parameterSet.end(); p++) {
        if (strcmp((*p)->getName(), the_name) == 0)
            return (*p)->getHandle();
    }

    throw NameNotFound();
}

// ----------------------------------------------------------------------------
//! Returns the parameter name obtained by its handle.
const char *
Interaction::getParameterName(ParameterHandle the_handle) const
    throw (InteractionParameterNotDefined,
           RTIinternalError)
{
    return getParameterByHandle(the_handle)->getName();
}

// ----------------------------------------------------------------------------
//! Return true if federate has subscribed to this attribute w/ region
bool
Interaction::isSubscribed(FederateHandle fed, RegionImp *region)
{
    list<Subscriber *>::iterator s ;
    for (s = subscribers.begin(); s != subscribers.end(); ++s) {
        if ((*s)->match(fed, region)) {
	    return true ;
        }
    }
    return false ;
}

// ----------------------------------------------------------------------------
//! Return true if federate has subscribed to this attribute w/ default region
bool
Interaction::isSubscribed(FederateHandle fed)
{
    return isSubscribed(fed, 0);
}

// ----------------------------------------------------------------------------
//! Return true if federate is publishing the attribute.
bool
Interaction::isPublishing(FederateHandle fed)
{
    list<Publisher *>::iterator p ;
    for (p = publishers.begin(); p != publishers.end(); ++p) {
        if ((*p)->getHandle() == fed) {
	    return true ;
        }
    }
    return false ;
}

// ----------------------------------------------------------------------------
/*! Check a SendInteractionOrder to see if it's OK for sending, but
  without sending it(to be called on the RTIA only).
*/
void
Interaction::isReady(FederateHandle federate_handle,
                     ParameterHandle *parameter_list,
                     UShort list_size)
    throw (FederateNotPublishing,
           InteractionParameterNotDefined,
           RTIinternalError)
{
    // Is Federate Publishing Interaction?
    if (!isPublishing(federate_handle))
        throw FederateNotPublishing();

    // Are Parameters Defined?
    for (UShort i = 0 ; i < list_size ; i++)
        getParameterByHandle(parameter_list[i]);
}

// ----------------------------------------------------------------------------
//! killFederate.
void
Interaction::killFederate(FederateHandle the_federate)
    throw ()
{
    try {
        // Is federate publishing something ? (not important)
        if (isPublishing(the_federate))
            unpublish(the_federate);

        // Does federate subscribed to something ?
        if (isSubscribed(the_federate))
            unsubscribe(the_federate);
    }
    catch (SecurityError &e) {}
}

// ----------------------------------------------------------------------------
//! publish
void
Interaction::publish(FederateHandle the_handle)
    throw (FederateNotPublishing, RTIinternalError, SecurityError)
{
    checkFederateAccess(the_handle, (char *) "Publish");
    
    if (!isPublishing(the_handle)) {
	D.Out(pdInit,
	      "Interaction %d: Added Federate %d to publishers list.",
	      handle, the_handle);
	publishers.push_front(new Publisher(the_handle));
    }
    else
	D.Out(pdError,
	      "Interaction %d: Inconsistent publish request from"
	      " Federate %d.", handle, the_handle);
}

// ----------------------------------------------------------------------------
//! publish
void
Interaction::unpublish(FederateHandle the_handle)
    throw (FederateNotPublishing, RTIinternalError, SecurityError)
{
    if (isPublishing(the_handle)) {
	D.Out(pdTerm,
	      "Interaction %d: Removed Federate %d from publishers list.",
	      handle, the_handle);
	deletePublisher(the_handle);
    }
    else {
	throw FederateNotPublishing();
    }
}

// ----------------------------------------------------------------------------
/*! Called by RTIG in order to start the broadcasting of an Interaction
  Message(to all federates who subscribed to this Interaction Class).
*/
InteractionBroadcastList *
Interaction::sendInteraction(FederateHandle federate_handle,
                             ParameterHandle *parameter_list,
                             ParameterValue *value_list,
                             UShort list_size,
                             FederationTime time,
                             const char *the_tag)
    throw (FederateNotPublishing,
           InteractionClassNotDefined,
           InteractionParameterNotDefined,
           RTIinternalError)
{
    // Pre-conditions checking
    if (!isPublishing(federate_handle))
        throw FederateNotPublishing();

    // Prepare and Broadcast message for this class
    InteractionBroadcastList *ibList = NULL ;
    if (server != NULL) {
        NetworkMessage *answer = new NetworkMessage ;
        answer->type = NetworkMessage::RECEIVE_INTERACTION ;
        answer->exception = e_NO_EXCEPTION ;
        answer->federation = server->federation();
        answer->federate = federate_handle ;
        answer->interactionClass = handle ; // Interaction Class Handle
	answer->date = time ;

        strcpy(answer->label, the_tag);

        answer->handleArraySize = list_size ;
        for (int i = 0 ; i < list_size ; i++) {
            answer->handleArray[i] = parameter_list[i] ;
            answer->setValue(i, value_list[i]);
        }

        D.Out(pdProtocol, "Preparing broadcast list.");
        ibList = new InteractionBroadcastList(answer);

        broadcastInteractionMessage(ibList);
    }
    else
        // SendInteraction should not be called on the RTIA.
        throw RTIinternalError("SendInteraction called by RTIA.");

    // Return the BroadcastList in case it had to be passed to the
    // parent class.
    return ibList ;
}

// ----------------------------------------------------------------------------
/*! Name attribute access(GetName reference must be considered READ-ONLY).
  NewName length must be lower or equal to MAX_USER_TAG_LENGTH.
*/
const char *
Interaction::getName() const
{
    return name.c_str();
}

// ----------------------------------------------------------------------------
//! Change the interaction name.
void
Interaction::setName(const char *new_name)
    throw (ValueLengthExceeded, RTIinternalError)
{
    name = new_name == 0 ? "" : new_name ;
}

// ----------------------------------------------------------------------------
//! Change the level ID.
/*! A class' LevelID can only be increased.
 */
void
Interaction::setLevelId(SecurityLevelID new_levelID)
{
    if (server->dominates(new_levelID, id) == RTI_FALSE)
        throw SecurityError("Attempt to lower interaction class level.");

    id = new_levelID ;
}

// ----------------------------------------------------------------------------
//! subscribe
void
Interaction::subscribe(FederateHandle fed, RegionImp *region)
    throw (FederateNotSubscribing, RTIinternalError, SecurityError)
{
    checkFederateAccess(fed, "Subscribe");

    if (!isSubscribed(fed, region)) {
	subscribers.push_front(new Subscriber(fed, region));
	D.Out(pdInit,
	      "Parameter %d: Added Federate %d to subscribers list.",
	      handle, fed);
    }
    else
	D.Out(pdError,
	      "Parameter %d: Unconsistent subscribe request from "
	      "federate %d.", handle, fed);    
}

// ----------------------------------------------------------------------------
//! subscribe
void
Interaction::subscribe(FederateHandle fed)
    throw (FederateNotSubscribing, RTIinternalError, SecurityError)
{
    subscribe(fed, 0);
}

// ----------------------------------------------------------------------------
//! unsubscribe
void
Interaction::unsubscribe(FederateHandle fed, RegionImp *region)
    throw (FederateNotSubscribing, RTIinternalError, SecurityError)
{
    if (isSubscribed(fed)) {
	deleteSubscriber(fed, region);
	D.Out(pdTerm,
	      "Parameter %d: Removed Federate %d from subscribers list.",
	      handle, fed);
    }
    else
	throw FederateNotSubscribing();
}

// ----------------------------------------------------------------------------
//! unsubscribe
void
Interaction::unsubscribe(FederateHandle fed)
    throw (FederateNotSubscribing, RTIinternalError, SecurityError)
{
    unsubscribe(fed, 0);
}

// ----------------------------------------------------------------------------
// setSpace
void
Interaction::setSpace(SpaceHandle h)
{
    space = h ;
}

// ----------------------------------------------------------------------------
// getSpace
SpaceHandle
Interaction::getSpace()
{
    return space ;
}

} // namespace certi

// $Id: Interaction.cc,v 3.19 2004/03/04 20:19:05 breholee Exp $