rtia_federate.cc

certi-SHM-3.0.tar 不错的开源的分布式方针软件 大家多多支持 他是linux

// -*- mode:C++ ; tab-width:4 ; c-basic-offset:4 ; indent-tabs-mode:nil -*-
// ----------------------------------------------------------------------------
// CERTI - HLA RunTime Infrastructure
// Copyright (C) 2002, 2003  ONERA
//
// This file is part of CERTI
//
// CERTI is free software ; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation ; either version 2 of the License, or
// (at your option) any later version.
//
// CERTI 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 General Public License for more details.
//
// You should have received a copy of the GNU 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: RTIA_federate.cc,v 3.8 2003/03/21 15:06:46 breholee Exp $
// ----------------------------------------------------------------------------

#include "RTIA.hh"

namespace certi {
namespace rtia {

static pdCDebug D("RTIA", "(RTIA fed) ");

// ----------------------------------------------------------------------------
//! Choose federate processing.
void
RTIA::chooseFederateProcessing(Message *req, Message &rep, TypeException &e)
{
    e = e_NO_EXCEPTION ;

    switch(req->type) {

        // 2.1
    case CREATE_FEDERATION_EXECUTION:
        nb_requetes[0]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type CreateFederation.");

        fm->createFederationExecution(req->getFederationName(), e);
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type CreateFederation done.");

        break ;

        // 2.2
    case DESTROY_FEDERATION_EXECUTION:
        nb_requetes[1]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type DestroyFederation.");

        fm->destroyFederationExecution(req->getFederationName(), e);
        break ;

        // 2.3
    case JOIN_FEDERATION_EXECUTION: {
        nb_requetes[2]++ ;

        D.Out(pdTrace, "Receiving Message from Federate, type JoinFederation.");

        rep.federate =
            fm->joinFederationExecution(req->getFederateName(),
                                        req->getFederationName(), e);

        D.Out(pdTrace, "Trying to use a .fed file");
        string filename = string(req->getFederationName()) + ".fed" ;
        ifstream *fdd = new ifstream(filename.c_str());
        if (fdd->is_open()) {
            fedparser::FedParser *parser = new fedparser::FedParser(rootObject);
            if (parser == 0)
                throw MemoryExhausted("No memory left to read FED file.");
            parser->readFile(filename.c_str());
            delete parser ;
        }
        else {
            if (XmlParser::exists()) {
                D.Out(pdTrace, "Trying to use a .xml file");
                filename = string(req->getFederationName()) + ".xml" ;
                fdd = new ifstream(filename.c_str());
                if (fdd->is_open()) {
                    XmlParser *parser = new XmlParser(rootObject);
                    parser->parse(filename);
                    delete fdd ;
                    delete parser ;
                }
            }
        }
        break ;
    }
        // 2.4
    case RESIGN_FEDERATION_EXECUTION:
        nb_requetes[3]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type ResignFederation.");

        fm->resignFederationExecution(req->resignAction, e);
        break ;

        // 2.5
    case REGISTER_FEDERATION_SYNCHRONIZATION_POINT:
        nb_requetes[4]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, type RequestPause.");

        fm->registerSynchronization(req->getLabel(), req->getTag(), e);
        break ;

        // 2.7
    case SYNCHRONIZATION_POINT_ACHIEVED:
        nb_requetes[5]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, type PauseAchieved.");

        fm->unregisterSynchronization(req->getLabel(), e);
        break ;

        // 2.11
    case REQUEST_FEDERATION_SAVE:
        // unimplemented
        break ;

        // 2.13
    case FEDERATE_SAVE_BEGUN:
        // unimplemented
        break ;

        // 2.14(1)
    case FEDERATE_SAVE_ACHIEVED:
        // unimplemented
        break ;

        // 2.14(2)
    case FEDERATE_SAVE_NOT_ACHIEVED:
        // unimplemented
        break ;

        // 2.15
    case REQUEST_RESTORE:
        // unimplemented
        break ;

        // 2.17(1)
    case RESTORE_ACHIEVED:
        // unimplemented
        break ;

        // 2.17(2)
    case RESTORE_NOT_ACHIEVED:
        // unimplemented
        break ;

        // 3.1(1)
    case PUBLISH_OBJECT_CLASS:
        nb_requetes[8]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type PublishObjectClass.");

        dm->publishObjectClass(req->objectClass,
                               req->handleArray,
                               req->handleArraySize,
                               e);
        break ;

        // 3.1(2)
    case UNPUBLISH_OBJECT_CLASS:
        nb_requetes[9]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type UnpublishObjectClass.");

        dm->unpublishObjectClass(req->objectClass, e);
        break ;

        // 3.2(1)
    case PUBLISH_INTERACTION_CLASS:
        nb_requetes[10]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type PublishInteractionClass.");

        dm->publishInteractionClass(req->interactionClass, e);
        break ;

        // 3.2(2)
    case UNPUBLISH_INTERACTION_CLASS:
        nb_requetes[11]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, "
              "type UnpublishInteractionClass");

        dm->unpublishInteractionClass(req->interactionClass, e);
        break ;

        // 3.3.(1)
    case SUBSCRIBE_OBJECT_CLASS_ATTRIBUTE:
        nb_requetes[12]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type SubscribeObjectClass.");
        dm->subscribeObjectClassAttribute(req->objectClass,
                                          req->handleArray,
                                          req->handleArraySize,
                                          e);
        break ;

        // 3.3(2)
    case UNSUBSCRIBE_OBJECT_CLASS_ATTRIBUTE:
        nb_requetes[13]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type UnsubscribeObjectClass.");

        // BUG: Why attributes are not transmitted ?
        dm->unsubscribeObjectClassAttribute(req->objectClass, e);
        break ;

        // 3.4(1)
    case SUBSCRIBE_INTERACTION_CLASS:
        nb_requetes[14]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type SubscribeInteraction.");

        dm->subscribeInteractionClass(req->interactionClass, e);
        break ;

        // 3.4(2)
    case UNSUBSCRIBE_INTERACTION_CLASS:
        nb_requetes[15]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type UnsubscribeInteraction.");

        dm->unsubscribeInteractionClass(req->interactionClass, e);
        break ;

        // 4.1
    case REQUEST_ID:
        nb_requetes[16]++ ;

        D.Out(pdTrace, "Receiving Message from Federate, type RequestIDs.");

        ObjectHandle first ;
        ObjectHandle last ;
        om->requestID(req->idCount, first, last, e);

        rep.firstId = first ;
        rep.lastId = last ;
        break ;

        // 4.2
    case REGISTER_OBJECT: {
        nb_requetes[17]++ ;

        FederationTime date = tm->requestFederateTime();
        FederationTime heure = date + tm->requestLookahead();

        D.Out(pdTrace, "Receiving Message from Federate, type RegisterObject.");

        rep.object = om->registerObject(req->objectClass,
                                        req->getName(),
                                        date, heure, e);
        break ; /*FAYET 25.07.01*/
    }

        // 4.3
    case UPDATE_ATTRIBUTE_VALUES: {
        nb_requetes[18]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type UpdateAttribValues.");

        AttributeValue *ValueArray = req->getValueArray();

        try {
            rep.eventRetraction = om->updateAttributeValues(req->object,
                                                            req->handleArray,
                                                            ValueArray,
                                                            req->handleArraySize,
                                                            req->date,
                                                            req->getTag(),
                                                            e);
            free(ValueArray);
        } catch (Exception *e) {
            free(ValueArray);
            throw e ;
        }
    }
        break ;

        // 4.6
    case SEND_INTERACTION: {
        nb_requetes[19]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type SendInteraction.");

        ParameterValue *ValueArray = (ParameterValue *) req->getValueArray();

        try {
            rep.eventRetraction = om->sendInteraction(req->interactionClass,
                                                      req->handleArray,
                                                      ValueArray,
                                                      req->handleArraySize,
                                                      req->date,
                                                      req->getTag(),
                                                      e);
            free(ValueArray);
        } catch (Exception *e) {
            free(ValueArray);
            throw e ;
        }
    }
        break ;

        // 4.8
    case DELETE_OBJECT:
        nb_requetes[20]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, type DeleteObject.");
        rep.eventRetraction = om->deleteObject(req->object, req->getTag(), e);
        break ;

        // 4.10
    case CHANGE_ATTRIBUTE_TRANSPORT_TYPE:
        nb_requetes[21]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type ChangeAttribTransport.");

        om->changeAttributeTransportType(req->object,
                                         req->handleArray,
                                         req->handleArraySize,
                                         req->transport,
                                         e);
        break ;

        // 4.11
    case CHANGE_ATTRIBUTE_ORDER_TYPE:
        nb_requetes[22]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type ChangeAttribOrder.");

        om->changeAttributeOrderType(req->object,
                                     req->handleArray,
                                     req->handleArraySize,
                                     req->order,
                                     e);
        break ;

        // 4.12
    case CHANGE_INTERACTION_TRANSPORT_TYPE:
        nb_requetes[23]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type ChangeInterTransport.");

        om->changeInteractionTransportType(req->interactionClass,
                                           req->transport,
                                           e);
        break ;

        // 4.13
    case CHANGE_INTERACTION_ORDER_TYPE:
        nb_requetes[24]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type ChangeInterOrder.");

        om->changeInteractionOrderType(req->interactionClass, req->order, e);
        break ;

        // 4.14(1)
    case REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE: