rtia_federate.cc

分布式仿真 开放源码

// ----------------------------------------------------------------------------
// 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.27 2003/11/13 10:52:20 breholee Exp $
// ----------------------------------------------------------------------------

#include <config.h>
#include "RTIA.hh"

#include "fed.hh"
#include "XmlParser.hh"

using std::string ;
using std::ifstream ;

namespace certi {
namespace rtia {

static pdCDebug D("RTIA", __FILE__);

// ----------------------------------------------------------------------------
//! Verify that federate is not in saving or restoring state.
void
RTIA::saveAndRestoreStatus(Message::Type type)
    throw (SaveInProgress, RestoreInProgress)
{
    switch (type) {
      case Message::RESIGN_FEDERATION_EXECUTION:
      case Message::TICK_REQUEST:
      case Message::GET_OBJECT_CLASS_HANDLE:
      case Message::GET_OBJECT_CLASS_NAME:
      case Message::GET_ATTRIBUTE_HANDLE:
      case Message::GET_ATTRIBUTE_NAME:
      case Message::GET_INTERACTION_CLASS_HANDLE:
      case Message::GET_INTERACTION_CLASS_NAME:
      case Message::GET_PARAMETER_HANDLE:
      case Message::GET_PARAMETER_NAME:
      case Message::GET_OBJECT_INSTANCE_HANDLE:
      case Message::GET_OBJECT_INSTANCE_NAME:
      case Message::GET_SPACE_HANDLE:
      case Message::GET_SPACE_NAME:
      case Message::GET_DIMENSION_HANDLE:
      case Message::GET_DIMENSION_NAME:
      case Message::GET_ATTRIBUTE_SPACE_HANDLE:
      case Message::GET_OBJECT_CLASS:
      case Message::GET_INTERACTION_SPACE_HANDLE:
      case Message::GET_TRANSPORTATION_HANDLE:
      case Message::GET_TRANSPORTATION_NAME:
      case Message::GET_ORDERING_HANDLE:
      case Message::GET_ORDERING_NAME:
        break ;
      case Message::FEDERATE_SAVE_BEGUN:
      case Message::FEDERATE_SAVE_COMPLETE:
      case Message::FEDERATE_SAVE_NOT_COMPLETE:
        fm->checkFederationRestoring();
        break ;
      case Message::FEDERATE_RESTORE_COMPLETE:
      case Message::FEDERATE_RESTORE_NOT_COMPLETE:
        fm->checkFederationSaving();
      default:
        fm->checkFederationSaving();
        fm->checkFederationRestoring();
    }
}

// ----------------------------------------------------------------------------
//! Choose federate processing.
void
RTIA::chooseFederateProcessing(Message *req, Message &rep, TypeException &e)
{
    // Verify not in saving or restoring state.
    saveAndRestoreStatus(req->type);

    e = e_NO_EXCEPTION ;

    switch(req->type) {

      case Message::CREATE_FEDERATION_EXECUTION:
        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 ;

      case Message::DESTROY_FEDERATION_EXECUTION:
        D.Out(pdTrace,
              "Receiving Message from Federate, type DestroyFederation.");

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

      case Message::JOIN_FEDERATION_EXECUTION: {
          D.Out(pdTrace,
                "Receiving Message from Federate, type JoinFederation.");

          rep.setFederate(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()) {
	      int result = certi::fedparser::build(filename.c_str(),
						   rootObject, true);
	      if (result) throw ErrorReadingFED();
          }
          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 ;
                  }
		  else throw CouldNotOpenFED();
              }
          }
          break ;
      }
      case Message::RESIGN_FEDERATION_EXECUTION:
        D.Out(pdTrace,
              "Receiving Message from Federate, type ResignFederation.");

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

      case Message::REGISTER_FEDERATION_SYNCHRONIZATION_POINT:
        D.Out(pdTrace, "Receiving Message from Federate, type RequestPause.");

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

      case Message::SYNCHRONIZATION_POINT_ACHIEVED:
        D.Out(pdTrace, "Receiving Message from Federate, type PauseAchieved.");

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

      case Message::REQUEST_FEDERATION_SAVE:
        D.Out(pdTrace, "Receiving Message from Federate, type"
              " RequestFederationSave.");

        fm->requestFederationSave(req->getLabel(), req->getFederationTime(), e);
        break ;

      case Message::FEDERATE_SAVE_BEGUN:
        D.Out(pdTrace, "Receiving Message from Federate, type"
              " FederateSaveBegun.");

        fm->federateSaveBegun(e);
        break ;

      case Message::FEDERATE_SAVE_COMPLETE:
      case Message::FEDERATE_SAVE_NOT_COMPLETE: {
          D.Out(pdTrace, "Receiving Message from Federate, type"
                " FederateSave(Not)Complete.");

          bool result = req->type == Message::FEDERATE_SAVE_COMPLETE ;
          fm->federateSaveStatus(result, e);
      }
        break ;

      case Message::REQUEST_FEDERATION_RESTORE:
        D.Out(pdTrace, "Receiving Message from Federate, type"
              " RequestFederationRestore.");

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

      case Message::FEDERATE_RESTORE_COMPLETE:
      case Message::FEDERATE_RESTORE_NOT_COMPLETE: {
          D.Out(pdTrace, "Receiving Message from Federate, type"
                " FederateRestore(Not)Complete.");

          bool result = req->type == Message::FEDERATE_SAVE_COMPLETE ;
          fm->federateRestoreStatus(result, e);
      }
        break ;

      case Message::PUBLISH_OBJECT_CLASS:
        D.Out(pdTrace,
              "Receiving Message from Federate, type PublishObjectClass.");

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

      case Message::UNPUBLISH_OBJECT_CLASS:
        D.Out(pdTrace,
              "Receiving Message from Federate, type UnpublishObjectClass.");

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

      case Message::PUBLISH_INTERACTION_CLASS:
        D.Out(pdTrace,
              "Receiving Message from Federate, type PublishInteractionClass.");

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

      case Message::UNPUBLISH_INTERACTION_CLASS:
        D.Out(pdTrace,
              "Receiving Message from Federate, "
              "type UnpublishInteractionClass");

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

      case Message::SUBSCRIBE_OBJECT_CLASS_ATTRIBUTES:
        D.Out(pdTrace,
              "Receiving Message from Federate, type SubscribeObjectClass.");
        dm->subscribeObjectClassAttribute(req->getObjectClass(),
                                          req->handleArray,
                                          req->handleArraySize,
                                          e);
        break ;

      case Message::UNSUBSCRIBE_OBJECT_CLASS:
        D.Out(pdTrace,
              "Receiving Message from Federate, type UnsubscribeObjectClass.");

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

      case Message::SUBSCRIBE_INTERACTION_CLASS:
        D.Out(pdTrace,
              "Receiving Message from Federate, type SubscribeInteraction.");

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

      case Message::UNSUBSCRIBE_INTERACTION_CLASS:
        D.Out(pdTrace,
              "Receiving Message from Federate, type UnsubscribeInteraction.");

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

      case Message::REGISTER_OBJECT_INSTANCE: {
          FederationTime date = tm->requestFederateTime();
          FederationTime heure = date + tm->requestLookahead();

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

          rep.setObject(om->registerObject(req->getObjectClass(),
                                           req->getName(),
                                           date, heure, e));
          break ;
      }

      case Message::UPDATE_ATTRIBUTE_VALUES: {
          D.Out(pdTrace,
                "Receiving Message from Federate, type UpdateAttribValues.");

          AttributeValue *ValueArray = req->getValueArray();

          try {
              rep.setEventRetraction(
		  om->updateAttributeValues(req->getObject(),
                                            req->handleArray,
                                            ValueArray,
                                            req->handleArraySize,
                                            req->getFederationTime(),
                                            req->getTag(),
                                            e));
              free(ValueArray);
          } catch (Exception *e) {
              free(ValueArray);
              throw e ;
          }
      }
        break ;

      case Message::SEND_INTERACTION: {
          D.Out(pdTrace,
                "Receiving Message from Federate, type SendInteraction.");

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

          try {
              rep.setEventRetraction(
                  om->sendInteraction(req->getInteractionClass(),
                                      req->handleArray,
                                      ValueArray,
                                      req->handleArraySize,
                                      req->getFederationTime(),
                                      req->getTag(),
                                      e));
              free(ValueArray);
          } catch (Exception *e) {
              free(ValueArray);
              throw e ;
          }
      }
        break ;

      case Message::DELETE_OBJECT_INSTANCE:
        D.Out(pdTrace, "Receiving Message from Federate, type DeleteObject.");
        rep.setEventRetraction(om->deleteObject(req->getObject(), req->getTag(),
                                                e));
        break ;

      case Message::CHANGE_ATTRIBUTE_TRANSPORTATION_TYPE:
        D.Out(pdTrace,
              "Receiving Message from Federate, type ChangeAttribTransport.");

        om->changeAttributeTransportType(req->getObject(),
                                         req->handleArray,
                                         req->handleArraySize,
                                         req->getTransportType(),
                                         e);
        break ;

      case Message::CHANGE_ATTRIBUTE_ORDER_TYPE:
        D.Out(pdTrace,
              "Receiving Message from Federate, type ChangeAttribOrder.");

        om->changeAttributeOrderType(req->getObject(),
                                     req->handleArray,
                                     req->handleArraySize,
                                     req->getOrderType(),
                                     e);
        break ;

      case Message::CHANGE_INTERACTION_TRANSPORTATION_TYPE:
        D.Out(pdTrace,
              "Receiving Message from Federate, type ChangeInterTransport.");

        om->changeInteractionTransportType(req->getInteractionClass(),
                                           req->getTransportType(),
                                           e);
        break ;

      case Message::CHANGE_INTERACTION_ORDER_TYPE:
        D.Out(pdTrace,