rtia_federate.cc

分布式仿真 开放源码

              "Receiving Message from Federate, type ChangeInterOrder.");

        om->changeInteractionOrderType(req->getInteractionClass(),
                                       req->getOrderType(), e);
        break ;

      case Message::REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE:
        e = e_UnimplementedService ;
        break ;

      case Message::REQUEST_CLASS_ATTRIBUTE_VALUE_UPDATE:
        e = e_UnimplementedService ;
        break ;

      case Message::RETRACT:
        e = e_UnimplementedService ;
        break ;

      case Message::UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type unconditionalAttributeOwnershipDivestiture.");
        D.Out(pdTrace, "Object %u number of attributes %u ",
              req->getObject(), req->handleArraySize);
        owm->unconditionalAttributeOwnershipDivestiture(req->getObject(),
                                                        req->handleArray,
                                                        req->handleArraySize,
                                                        e);
        break ;

      case Message::NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type negotiatedAttributeOwnershipDivestiture.");
        D.Out(pdTrace, "Object %u ; %u nb Attribute ", req->getObject(),
              req->handleArraySize);
        owm->negotiatedAttributeOwnershipDivestiture(req->getObject(),
                                                     req->handleArray,
                                                     req->handleArraySize,
                                                     req->getTag(),
                                                     e);
        break ;

      case Message::ATTRIBUTE_OWNERSHIP_ACQUISITION:
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type attributeOwnershipAcquisition.");
        D.Out(pdTrace, "Object %u ; Nb d'Attributs ", req->getObject(),
              req->handleArraySize);
        owm->attributeOwnershipAcquisition(req->getObject(),
                                           req->handleArray,
                                           req->handleArraySize,
                                           req->getTag(), e);
        break ;

      case Message::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE:
      {
          D.Out(pdTrace, "Receiving Message from Federate, "
                "type attributeOwnershipRealeaseResponse.");
          D.Out(pdTrace, "Object %u nb Attribute %u ",
                req->getObject(), req->handleArraySize);

          AttributeHandleSet* theAttributes =
              owm->attributeOwnershipRealeaseResponse(req->getObject(),
                                                      req->handleArray,
                                                      req->handleArraySize,
                                                      e);
          if (e == e_NO_EXCEPTION) {
              rep.handleArraySize = theAttributes->size();

              for (unsigned int i=0 ; i<theAttributes->size(); i++) {
                  rep.handleArray[i] = theAttributes->getHandle(i);
              }
          }
      }
      break ;

      case Message::CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type cancelNegociatedAttributeOwnershipDivestiture.");
        D.Out(pdTrace, "Object %u nb Attribute %u ",
              req->getObject(), req->handleArraySize);
        owm->cancelnegotiatedAttributeOwnershipDivestiture(req->getObject(),
                                                           req->handleArray,
                                                           req->handleArraySize,
                                                           e);
        break ;


      case Message::CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION:
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type cancelAttributeOwnershipAcquisition.");
        D.Out(pdTrace, "Object %u nb Attribute %u ",
              req->getObject(), req->handleArraySize);
        owm->cancelattributeOwnershipAcquisition(req->getObject(),
                                                 req->handleArray,
                                                 req->handleArraySize,
                                                 e);
        break ;

      case Message::ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE:
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type attributeOwnershipAcquisitionIfAvailable.");
        D.Out(pdTrace, "Object %u nb Attribute %u ",
              req->getObject(), req->handleArraySize);
        owm->attributeOwnershipAcquisitionIfAvailable(req->getObject(),
                                                      req->handleArray,
                                                      req->handleArraySize,
                                                      e);
        break ;

      case Message::QUERY_ATTRIBUTE_OWNERSHIP:
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type queryAttributeOwnership.");
        D.Out(pdTrace, "Object %u Attribute %u ",
              req->getObject(), req->getAttribute());
        owm->queryAttributeOwnership(req->getObject(), req->getAttribute(), e);

        break ;

      case Message::IS_ATTRIBUTE_OWNED_BY_FEDERATE:
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type isAttributeOwnedByFederate.");
        D.Out(pdTrace, "Object %u Attribute %u ",
              req->getObject(), req->getAttribute());
        rep.setTag(owm->attributeOwnedByFederate(req->getObject(),
                                                 req->getAttribute(), e));
        break ;

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

        rep.setFederationTime(tm->requestLBTS());
        break ;

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

        rep.setFederationTime(tm->requestFederateTime());
        break ;

      case Message::QUERY_MIN_NEXT_EVENT_TIME:
        e = e_UnimplementedService ;
        break ;

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

        tm->setLookahead(req->getFederationTimeDelta(), e);
        break ;

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

        rep.setFederationTimeDelta(tm->requestLookahead());
        break ;

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

        tm->timeAdvanceRequest(req->getFederationTime(), e);
        break ;

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

        tm->nextEventRequest(req->getFederationTime(), e);
        break ;

      case Message::FLUSH_QUEUE_REQUEST:
        e = e_UnimplementedService ;
        break ;

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

        rep.setObjectClass(om->getObjectClassHandle(req->getName()));
        break ;

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

        try {
            rep.setName(om->getObjectClassName(req->getObjectClass()));
        }
        catch (ObjectClassNotDefined) {
            rep.setException(e_ObjectClassNotDefined);
        }
        catch (RTIinternalError) {
            rep.setException(e_RTIinternalError);
        }
        break ;

      case Message::GET_OBJECT_INSTANCE_HANDLE:
        D.Out(pdTrace,
              "Receiving Message from Federate, type getObjectInstanceHandle.");
        rep.setObject(om->getObjectInstanceHandle(req->getName()));
        break ;

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

        rep.setName(om->getObjectInstanceName(req->getObject()));
        break ;

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

        rep.setAttribute(om->getAttributeHandle(req->getName(),
                                                req->getObjectClass()));
        break ;

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

        rep.setName(om->getAttributeName(req->getAttribute(),
                                         req->getObjectClass()));
        break ;

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

        rep.setInteractionClass(om->getInteractionClassHandle(req->getName()));
        break ;

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

        rep.setName(om->getInteractionClassName(req->getInteractionClass()));
        break ;

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

        rep.setParameter(om->getParameterHandle(req->getName(),
                                                req->getInteractionClass()));
        break ;

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

        rep.setName(om->getParameterName(req->getParameter(),
                                         req->getInteractionClass()));
        break ;

      case Message::GET_SPACE_HANDLE:
        D.Out(pdTrace, "Receiving Message from Federate, type GetSpaceHandle.");
        rep.setSpace(ddm->getRoutingSpaceHandle(req->getName()));
        break ;

      case Message::GET_SPACE_NAME:
        D.Out(pdTrace, "Receiving Message from Federate, type GetSpaceName.");
        rep.setName(ddm->getRoutingSpaceName(req->getSpace()).c_str());
        break ;

      case Message::GET_DIMENSION_HANDLE:
        D.Out(pdTrace,
              "Receiving Message from Federate, type GetDimensionHandle");
        rep.setDimension(ddm->getDimensionHandle(string(req->getName()),
                                                 req->getSpace()));
        break ;

      case Message::GET_DIMENSION_NAME:
        D.Out(pdTrace,
              "Receiving Message from Federate, type GetDimensionName");
        rep.setName(ddm->getDimensionName(req->getDimension(),
                                          req->getSpace()).c_str());
        break ;

      case Message::GET_ATTRIBUTE_SPACE_HANDLE:
        D.Out(pdTrace,
              "Receiving Message from Federate, type GetAttributeSpaceHandle");
        rep.setSpace(ddm->getAttributeSpace(req->getAttribute(),
                                            req->getObjectClass()));
        break ;

      case Message::GET_INTERACTION_SPACE_HANDLE:
        D.Out(pdTrace,
              "Receiving Message from Federate: GetInteractionSpaceHandle");
        rep.setSpace(ddm->getInteractionSpace(req->getInteractionClass()));
        break ;

      case Message::GET_OBJECT_CLASS:
        D[pdTrace] << "Message from Federate: getObjectClass" << endl ;
	rep.setObjectClass(om->getObjectClass(req->getObject()));
	break ;	

      case Message::DDM_CREATE_REGION:
        D[pdTrace] << "Receiving Message from Federate: CreateRegion" << endl ;
        rep.setRegion(ddm->createRegion(req->getSpace(), req->getNumber(), e));
	rep.setNumber(rootObject->getRoutingSpace(req->getSpace()).size());
        break ;

      case Message::DDM_MODIFY_REGION:
	D[pdTrace] << "Receiving Message from Federate: Modify Region" << endl ;
	ddm->modifyRegion(req->getRegion(), req->getExtents(), e);
	break ;

      case Message::DDM_DELETE_REGION:
        D[pdTrace] << "Receiving Message from Federate: DeleteRegion" << endl ;
        ddm->deleteRegion(req->getRegion(), e);
        break ;

      case Message::DDM_ASSOCIATE_REGION:
	D[pdTrace] << "Receiving Message from Federate: Associate Region"
		   << endl ;
	ddm->associateRegion(req->getObject(), req->getRegion(),
			     req->handleArray, req->handleArraySize, e);
	break ;

      case Message::DDM_UNASSOCIATE_REGION:
	D[pdTrace] << "Receiving Message from Federate: Associate Region"
		   << endl ;
	ddm->unassociateRegion(req->getObject(), req->getRegion(), e);
	break ;

      case Message::DDM_SUBSCRIBE_ATTRIBUTES:
	D[pdTrace] << "Receiving Message from Federate: Subscribe Attributes"
		   << endl ;
	ddm->subscribe(req->getObjectClass(), req->getRegion(),
		       req->handleArray, req->handleArraySize, e);
	break ;

      case Message::DDM_UNSUBSCRIBE_ATTRIBUTES:
	D[pdTrace] << "Receiving Message from Federate: Unsubscribe Attributes"
		   << endl ;
	ddm->unsubscribeAttributes(req->getObjectClass(), req->getRegion(), e);
	break ;

      case Message::DDM_SUBSCRIBE_INTERACTION:
	D[pdTrace] << "Receiving Message from Federate: Subscribe Interaction"
		   << endl ;
	ddm->subscribe(req->getInteractionClass(), req->getRegion(), e);
	break ;

      case Message::DDM_UNSUBSCRIBE_INTERACTION:
	D[pdTrace] << "Receiving Message from Federate: Unsubscribe Interaction"
		   << endl ;
	ddm->unsubscribeInteraction(req->getInteractionClass(),
				    req->getRegion(), e);
	break ;
	
      case Message::ENABLE_TIME_REGULATION:
      case Message::DISABLE_TIME_REGULATION:
        D.Out(pdTrace,
              "Receiving Message from Federate, type SetTimeRegulating.");

        tm->setTimeRegulating(req->getBoolean(), e);
        break ;

      case Message::ENABLE_TIME_CONSTRAINED:
      case Message::DISABLE_TIME_CONSTRAINED:
        D.Out(pdTrace,
              "Receiving Message from Federate, type SetTimeConstrained.");