rtia_federate.cc

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

        // unimplemented
        break ;

        // 4.14(2)
    case REQUEST_CLASS_ATTRIBUTE_VALUE_UPDATE:
        // unimplemented
        break ;

        // 4.16
    case RETRACT:
        // unimplemented
        break ;

        // 5.1
    case UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
        nb_requetes[47]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type unconditionalAttributeOwnershipDivestiture.");
        D.Out(pdTrace, "Object %u number of attributes %u ",
              req->object, req->handleArraySize);
        owm->unconditionalAttributeOwnershipDivestiture(req->object,
                                                        req->handleArray,
                                                        req->handleArraySize,
                                                        e);
        break ;


        // 5.2
    case NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
        nb_requetes[45]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type negotiatedAttributeOwnershipDivestiture.");
        D.Out(pdTrace, "Object %u ; %u nb Attribute ", req->object,
              req->handleArraySize);
        owm->negotiatedAttributeOwnershipDivestiture(req->object,
                                                     req->handleArray,
                                                     req->handleArraySize,
                                                     req->getTag(),
                                                     e);
        break ;


        // 5.6
    case ATTRIBUTE_OWNERSHIP_ACQUISITION:
        nb_requetes[48]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type attributeOwnershipAcquisition.");
        D.Out(pdTrace, "Object %u ; Nb d'Attributs ", req->object,
              req->handleArraySize);
        owm->attributeOwnershipAcquisition(req->object,
                                           req->handleArray,
                                           req->handleArraySize,
                                           req->getTag(), e);
        break ;

        // 5.8
    case ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE:
        {
            nb_requetes[50]++ ;
            D.Out(pdTrace, "Receiving Message from Federate, "
                  "type attributeOwnershipRealeaseResponse.");
            D.Out(pdTrace, "Object %u nb Attribute %u ",
                  req->object, req->handleArraySize);

            AttributeHandleSet* theAttributes=
                owm->attributeOwnershipRealeaseResponse(req->object,
                                                        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 ;

        // 5.9
    case CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
        nb_requetes[49]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type cancelNegociatedAttributeOwnershipDivestiture.");
        D.Out(pdTrace, "Object %u nb Attribute %u ",
              req->object, req->handleArraySize);
        owm->cancelnegotiatedAttributeOwnershipDivestiture(req->object,
                                                           req->handleArray,
                                                           req->handleArraySize,
                                                           e);
        break ;


        // 5.10
    case CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION:
        nb_requetes[51]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type cancelAttributeOwnershipAcquisition.");
        D.Out(pdTrace, "Object %u nb Attribute %u ",
              req->object, req->handleArraySize);
        owm->cancelattributeOwnershipAcquisition(req->object,
                                                 req->handleArray,
                                                 req->handleArraySize,
                                                 e);
        break ;
        // 5.12
    case ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE:
        nb_requetes[46]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type attributeOwnershipAcquisitionIfAvailable.");
        D.Out(pdTrace, "Object %u nb Attribute %u ",
              req->object, req->handleArraySize);
        owm->attributeOwnershipAcquisitionIfAvailable(req->object,
                                                      req->handleArray,
                                                      req->handleArraySize,
                                                      e);
        break ;

        // 5.14
    case QUERY_ATTRIBUTE_OWNERSHIP:
        nb_requetes[44]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type queryAttributeOwnership.");
        D.Out(pdTrace, "Object %u Attribute %u ",
              req->object, req->attribute);
        owm->queryAttributeOwnership(req->object, req->attribute, e);

        break ;

        // 5.16
    case IS_ATTRIBUTE_OWNED_BY_FEDERATE:
        nb_requetes[43]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, "
              "type isAttributeOwnedByFederate.");
        D.Out(pdTrace, "Object %u Attribute %u ",
              req->object, req->attribute);
        rep.setTag(owm->attributeOwnedByFederate(req->object,
                                                 req->attribute, e));
        break ;

        // 6.1
    case REQUEST_FEDERATION_TIME:
        nb_requetes[25]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type RequestFederationTime.");

        rep.date = tm->requestFederationTime();
        break ;

        // 6.2
    case REQUEST_LBTS:
        nb_requetes[26]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, type RequestLBTS.");

        rep.date = tm->requestLBTS();
        break ;

        // 6.3
    case REQUEST_FEDERATE_TIME:
        nb_requetes[27]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type RequestFederateTime.");

        rep.date = tm->requestFederateTime();
        break ;

        // 6.4
    case REQUEST_MIN_NEXT_EVENT_TIME:
        // unimplemented
        break ;

        // 6.5
    case SET_LOOKAHEAD:
        nb_requetes[28]++ ;
        D.Out(pdTrace, "Receiving Message from Federate, type SetLookAhead.");

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

        // 6.6
    case REQUEST_LOOKAHEAD:
        nb_requetes[29]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type RequestLookAhead.");

        rep.lookahead = tm->requestLookahead();
        break ;

        // 6.7
    case TIME_ADVANCE_REQUEST:
        nb_requetes[30]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type TimeAdvanceRequest.");

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

        // 6.8
    case NEXT_EVENT_REQUEST:
        nb_requetes[31]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type NestEventRequest.");

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

        // 6.9
    case FLUSH_QUEUE_REQUEST:
        // unimplemented
        break ;

        // 7.1
    case CREATE_UPDATE_REGION:
        // unimplemented
        break ;

        // 7.2
    case CREATE_SUBSCRIPTION_REGION:
        // unimplemented
        break ;

        // 7.3(1)
    case ASSOCIATE_UPDATE_REGION:
        // unimplemented
        break ;

        // 7.3(2)
    case DISASSOCIATE_UPDATE_REGION:
        // unimplemented
        break ;

        // 7.5
    case MODIFY_REGION:
        // unimplemented
        break ;

        // 7.6
    case DELETE_REGION:
        // unimplemented
        break ;

        // 8.1
    case GET_OBJECT_CLASS_HANDLE:
        nb_requetes[32]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type GetObjectClassHandle.");

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

        // 8.2
    case GET_OBJECT_CLASS_NAME:
        nb_requetes[33]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type GetObjectClassName.");

        rep.setName(om->getObjectClassName(req->objectClass));
        break ;

        // 8.3
    case GET_ATTRIBUTE_HANDLE:
        nb_requetes[34]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type GetAttributeHandle.");

        rep.attribute = om->getAttributeHandle(req->getName(),
                                               req->objectClass);
        break ;

        // 8.4
    case GET_ATTRIBUTE_NAME:
        nb_requetes[35]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type GetAttributeName.");

        rep.setName(om->getAttributeName(req->attribute,
                                         req->objectClass));
        break ;

        // 8.5
    case GET_INTERACTION_CLASS_HANDLE:
        nb_requetes[36]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type GetInteractionHandle.");

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

        // 8.6
    case GET_INTERACTION_CLASS_NAME:
        nb_requetes[37]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type GetInteractionName.");

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

        // 8.7
    case GET_PARAMETER_HANDLE:
        nb_requetes[38]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type GetParameterHandle.");

        rep.parameter = om->getParameterHandle(req->getName(),
                                               req->interactionClass);
        break ;

        // 8.8
    case GET_PARAMETER_NAME:
        nb_requetes[39]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type GetParameterName.");

        rep.setName(om->getParameterName(req->parameter,
                                         req->interactionClass));
        break ;

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

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

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

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

        // 8.11
    case GET_FEDERATE_HANDLE:
        // unimplemented
        break ;

        // 8.12
    case GET_FEDERATE_NAME:
        // unimplemented
        break ;

        // 8.13
    case SET_TIME_REGULATING:
        nb_requetes[40]++ ;
        D.Out(pdTrace,
              "Receiving Message from Federate, type SetTimeRegulating.");

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

        // 8.14