void Query::ReadGetResponse(tcpip::Storage & content) { int position = 0; int length2 = 0; int extLength = 0; int length = 0; int commandId = 0; int varId = 0; string objectId = ""; int variableType = 0; try { position = content.position(); length2 = content.size(); extLength = content.readUnsignedByte(); if (extLength == 0) { length = content.readInt(); } commandId = content.readUnsignedByte(); varId = content.readUnsignedByte(); objectId = content.readString(); variableType = content.readUnsignedByte(); int listLen = 0; int count = 0; switch (variableType) { case TYPE_STRING: stringValue = content.readString(); break; case TYPE_INTEGER: intValue = content.readInt(); break; case TYPE_DOUBLE: doubleValue = content.readDouble(); break; case TYPE_STRINGLIST: listLen = content.readInt(); stringListValue.clear(); for (int i=0; i<listLen; i++) { stringListValue.push_back(content.readString()); } break; case POSITION_2D: positionValue.x = content.readDouble(); positionValue.y = content.readDouble(); break; case TYPE_BOUNDINGBOX: count = content.size()/sizeof(double); for (int i = 0; i < count-1; i++) { vectorValue.push_back(content.readDouble()); } break; default: break; } } catch (exception & ex) { cout << "can't read response for object " << objectId << ex.what() << endl; cout<<position<<" "<<length2 << " "<<extLength<<" "<<length<<" "<<commandId<<" "<<varId<<" "<<objectId<<" "<<variableType<< "\n"; } }
bool SUMO_CLIENT::validateSubscription(tcpip::Storage& inMsg) { try { int length = inMsg.readUnsignedByte(); if (length == 0) { length = inMsg.readInt(); } int cmdId = inMsg.readUnsignedByte(); if (cmdId >= RESPONSE_SUBSCRIBE_INDUCTIONLOOP_VARIABLE && cmdId <= RESPONSE_SUBSCRIBE_GUI_VARIABLE) { answerLog << " CommandID=" << cmdId; answerLog << " ObjectID=" << inMsg.readString(); unsigned int varNo = inMsg.readUnsignedByte(); answerLog << " #variables=" << varNo << std::endl; for (unsigned int i = 0; i < varNo; ++i) { answerLog << " VariableID=" << inMsg.readUnsignedByte(); bool ok = inMsg.readUnsignedByte() == RTYPE_OK; answerLog << " ok=" << ok; int valueDataType = inMsg.readUnsignedByte(); answerLog << " valueDataType=" << valueDataType; readAndReportTypeDependent(inMsg, valueDataType); } } else if (cmdId >= RESPONSE_SUBSCRIBE_INDUCTIONLOOP_CONTEXT && cmdId <= RESPONSE_SUBSCRIBE_GUI_CONTEXT) { answerLog << " CommandID=" << cmdId; answerLog << " ObjectID=" << inMsg.readString(); answerLog << " Domain=" << inMsg.readUnsignedByte(); unsigned int varNo = inMsg.readUnsignedByte(); answerLog << " #variables=" << varNo << std::endl; unsigned int objNo = inMsg.readInt(); answerLog << " #objects=" << objNo << std::endl; for (unsigned int j = 0; j < objNo; ++j) { answerLog << " ObjectID=" << inMsg.readString() << std::endl; for (unsigned int i = 0; i < varNo; ++i) { answerLog << " VariableID=" << inMsg.readUnsignedByte(); bool ok = inMsg.readUnsignedByte() == RTYPE_OK; answerLog << " ok=" << ok; int valueDataType = inMsg.readUnsignedByte(); answerLog << " valueDataType=" << valueDataType; readAndReportTypeDependent(inMsg, valueDataType); } } } else { answerLog << "#Error: received response with command id: " << cmdId << " but expected a subscription response (0xe0-0xef / 0x90-0x9f)" << std::endl; return false; } } catch (std::invalid_argument& e) { answerLog << "#Error while reading message:" << e.what() << std::endl; return false; } return true; }
bool TraCIServer::readTypeCheckingInt(tcpip::Storage& inputStorage, int& into) { if (inputStorage.readUnsignedByte() != TYPE_INTEGER) { return false; } into = inputStorage.readInt(); return true; }
bool SUMO_CLIENT::validateSimulationStep2(tcpip::Storage& inMsg) { try { int noSubscriptions = inMsg.readInt(); for (int s = 0; s < noSubscriptions; ++s) { if (!validateSubscription(inMsg)) { return false; } } } catch (std::invalid_argument& e) { answerLog << "#Error while reading message:" << e.what() << std::endl; return false; } return true; }
bool TraCIServerAPI_Route::processSet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { std::string warning = ""; // additional description for response // variable int variable = inputStorage.readUnsignedByte(); if (variable != ADD) { server.writeStatusCmd(CMD_SET_ROUTE_VARIABLE, RTYPE_ERR, "Change Route State: unsupported variable specified", outputStorage); return false; } // id std::string id = inputStorage.readString(); // process int valueDataType = inputStorage.readUnsignedByte(); switch (variable) { case ADD: { if (valueDataType != TYPE_STRINGLIST) { server.writeStatusCmd(CMD_SET_ROUTE_VARIABLE, RTYPE_ERR, "A string list is needed for adding a new route.", outputStorage); return false; } //read itemNo int numEdges = inputStorage.readInt(); MSEdgeVector edges; while (numEdges--) { std::string edgeID = inputStorage.readString(); MSEdge* edge = MSEdge::dictionary(edgeID); if (edge == 0) { server.writeStatusCmd(CMD_SET_ROUTE_VARIABLE, RTYPE_ERR, "Unknown edge '" + edgeID + "' in route.", outputStorage); return false; } edges.push_back(edge); } const std::vector<SUMOVehicleParameter::Stop> stops; if (!MSRoute::dictionary(id, new MSRoute(id, edges, 1, 0, stops))) { server.writeStatusCmd(CMD_SET_ROUTE_VARIABLE, RTYPE_ERR, "Could not add route.", outputStorage); return false; } } break; default: break; } server.writeStatusCmd(CMD_SET_ROUTE_VARIABLE, RTYPE_OK, warning, outputStorage); return true; }
// =========================================================================== // method definitions // =========================================================================== bool TraCIServerAPI_Simulation::processGet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { // variable & id int variable = inputStorage.readUnsignedByte(); std::string id = inputStorage.readString(); // check variable if (variable != VAR_TIME_STEP && variable != VAR_LOADED_VEHICLES_NUMBER && variable != VAR_LOADED_VEHICLES_IDS && variable != VAR_DEPARTED_VEHICLES_NUMBER && variable != VAR_DEPARTED_VEHICLES_IDS && variable != VAR_TELEPORT_STARTING_VEHICLES_NUMBER && variable != VAR_TELEPORT_STARTING_VEHICLES_IDS && variable != VAR_TELEPORT_ENDING_VEHICLES_NUMBER && variable != VAR_TELEPORT_ENDING_VEHICLES_IDS && variable != VAR_ARRIVED_VEHICLES_NUMBER && variable != VAR_ARRIVED_VEHICLES_IDS && variable != VAR_DELTA_T && variable != VAR_NET_BOUNDING_BOX && variable != VAR_MIN_EXPECTED_VEHICLES && variable != POSITION_CONVERSION && variable != DISTANCE_REQUEST && variable != VAR_BUS_STOP_WAITING && variable != VAR_PARKING_STARTING_VEHICLES_NUMBER && variable != VAR_PARKING_STARTING_VEHICLES_IDS && variable != VAR_PARKING_ENDING_VEHICLES_NUMBER && variable != VAR_PARKING_ENDING_VEHICLES_IDS && variable != VAR_STOP_STARTING_VEHICLES_NUMBER && variable != VAR_STOP_STARTING_VEHICLES_IDS && variable != VAR_STOP_ENDING_VEHICLES_NUMBER && variable != VAR_STOP_ENDING_VEHICLES_IDS ) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Get Simulation Variable: unsupported variable specified", outputStorage); } // begin response building tcpip::Storage tempMsg; // response-code, variableID, objectID tempMsg.writeUnsignedByte(RESPONSE_GET_SIM_VARIABLE); tempMsg.writeUnsignedByte(variable); tempMsg.writeString(id); // process request switch (variable) { case VAR_TIME_STEP: tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt(MSNet::getInstance()->getCurrentTimeStep()); break; case VAR_LOADED_VEHICLES_NUMBER: writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_BUILT); break; case VAR_LOADED_VEHICLES_IDS: { const std::vector<std::string>& ids = server.getVehicleStateChanges().find(MSNet::VEHICLE_STATE_BUILT)->second; tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(ids); } break; case VAR_DEPARTED_VEHICLES_NUMBER: writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_DEPARTED); break; case VAR_DEPARTED_VEHICLES_IDS: writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_DEPARTED); break; case VAR_TELEPORT_STARTING_VEHICLES_NUMBER: writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_STARTING_TELEPORT); break; case VAR_TELEPORT_STARTING_VEHICLES_IDS: writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_STARTING_TELEPORT); break; case VAR_TELEPORT_ENDING_VEHICLES_NUMBER: writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_ENDING_TELEPORT); break; case VAR_TELEPORT_ENDING_VEHICLES_IDS: writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_ENDING_TELEPORT); break; case VAR_ARRIVED_VEHICLES_NUMBER: writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_ARRIVED); break; case VAR_ARRIVED_VEHICLES_IDS: writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_ARRIVED); break; case VAR_PARKING_STARTING_VEHICLES_NUMBER: writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_STARTING_PARKING); break; case VAR_PARKING_STARTING_VEHICLES_IDS: writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_STARTING_PARKING); break; case VAR_PARKING_ENDING_VEHICLES_NUMBER: writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_ENDING_PARKING); break; case VAR_PARKING_ENDING_VEHICLES_IDS: writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_ENDING_PARKING); break; case VAR_STOP_STARTING_VEHICLES_NUMBER: writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_STARTING_STOP); break; case VAR_STOP_STARTING_VEHICLES_IDS: writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_STARTING_STOP); break; case VAR_STOP_ENDING_VEHICLES_NUMBER: writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_ENDING_STOP); break; case VAR_STOP_ENDING_VEHICLES_IDS: writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_ENDING_STOP); break; case VAR_DELTA_T: tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt(DELTA_T); break; case VAR_NET_BOUNDING_BOX: { tempMsg.writeUnsignedByte(TYPE_BOUNDINGBOX); Boundary b = GeoConvHelper::getFinal().getConvBoundary(); tempMsg.writeDouble(b.xmin()); tempMsg.writeDouble(b.ymin()); tempMsg.writeDouble(b.xmax()); tempMsg.writeDouble(b.ymax()); break; } break; case VAR_MIN_EXPECTED_VEHICLES: tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt(MSNet::getInstance()->getVehicleControl().getActiveVehicleCount() + MSNet::getInstance()->getInsertionControl().getPendingFlowCount()); break; case POSITION_CONVERSION: if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Position conversion requires a compound object.", outputStorage); } if (inputStorage.readInt() != 2) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Position conversion requires a source position and a position type as parameter.", outputStorage); } if (!commandPositionConversion(server, inputStorage, tempMsg, CMD_GET_SIM_VARIABLE)) { return false; } break; case DISTANCE_REQUEST: if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of distance requires a compound object.", outputStorage); } if (inputStorage.readInt() != 3) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of distance requires two positions and a distance type as parameter.", outputStorage); } if (!commandDistanceRequest(server, inputStorage, tempMsg, CMD_GET_SIM_VARIABLE)) { return false; } break; case VAR_BUS_STOP_WAITING: { std::string id; if (!server.readTypeCheckingString(inputStorage, id)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of persons at busstop requires a string.", outputStorage); } MSBusStop* s = MSNet::getInstance()->getBusStop(id); if (s == 0) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Unknown bus stop '" + id + "'.", outputStorage); } tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt(s->getPersonNumber()); break; } default: break; } server.writeStatusCmd(CMD_GET_SIM_VARIABLE, RTYPE_OK, "", outputStorage); server.writeResponseWithLength(outputStorage, tempMsg); return true; }
bool TraCIServerAPI_POI::processSet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { std::string warning = ""; // additional description for response // variable & id int variable = inputStorage.readUnsignedByte(); std::string id = inputStorage.readString(); // check variable if (variable != libsumo::VAR_TYPE && variable != libsumo::VAR_COLOR && variable != libsumo::VAR_POSITION && variable != libsumo::VAR_WIDTH && variable != libsumo::VAR_HEIGHT && variable != libsumo::VAR_ANGLE && variable != libsumo::VAR_IMAGEFILE && variable != libsumo::VAR_HIGHLIGHT && variable != libsumo::ADD && variable != libsumo::REMOVE && variable != libsumo::VAR_PARAMETER) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "Change PoI State: unsupported variable " + toHex(variable, 2) + " specified", outputStorage); } // process try { switch (variable) { case libsumo::VAR_TYPE: { std::string type; if (!server.readTypeCheckingString(inputStorage, type)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The type must be given as a string.", outputStorage); } libsumo::POI::setType(id, type); } break; case libsumo::VAR_COLOR: { libsumo::TraCIColor col; if (!server.readTypeCheckingColor(inputStorage, col)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The color must be given using an according type.", outputStorage); } libsumo::POI::setColor(id, col); } break; case libsumo::VAR_POSITION: { libsumo::TraCIPosition pos; if (!server.readTypeCheckingPosition2D(inputStorage, pos)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The position must be given using an according type.", outputStorage); } libsumo::POI::setPosition(id, pos.x, pos.y); } break; case libsumo::VAR_WIDTH: { double width; if (!server.readTypeCheckingDouble(inputStorage, width)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The width must be given using an according type.", outputStorage); } libsumo::POI::setWidth(id, width); } break; case libsumo::VAR_HEIGHT: { double height; if (!server.readTypeCheckingDouble(inputStorage, height)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The height must be given using an according type.", outputStorage); } libsumo::POI::setHeight(id, height); } break; case libsumo::VAR_ANGLE: { double angle; if (!server.readTypeCheckingDouble(inputStorage, angle)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The angle must be given using an according type.", outputStorage); } libsumo::POI::setAngle(id, angle); } break; case libsumo::VAR_IMAGEFILE: { std::string imageFile; if (!server.readTypeCheckingString(inputStorage, imageFile)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The type must be given as a string.", outputStorage); } libsumo::POI::setImageFile(id, imageFile); } break; case libsumo::VAR_HIGHLIGHT: { // Highlight the POI by adding a polygon (NOTE: duplicated code exists for vehicle domain) if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "A compound object is needed for highlighting an object.", outputStorage); } int itemNo = inputStorage.readUnsignedByte(); if (itemNo > 5) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "Highlighting an object needs zero to five parameters.", outputStorage); } libsumo::TraCIColor col = libsumo::TraCIColor(255, 0, 0); if (itemNo > 0) { if (!server.readTypeCheckingColor(inputStorage, col)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The first parameter for highlighting must be the highlight color.", outputStorage); } } double size = -1; if (itemNo > 1) { if (!server.readTypeCheckingDouble(inputStorage, size)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The second parameter for highlighting must be the highlight size.", outputStorage); } } int alphaMax = -1; if (itemNo > 2) { if (!server.readTypeCheckingUnsignedByte(inputStorage, alphaMax)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The third parameter for highlighting must be maximal alpha.", outputStorage); } } double duration = -1; if (itemNo > 3) { if (!server.readTypeCheckingDouble(inputStorage, duration)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The fourth parameter for highlighting must be the highlight duration.", outputStorage); } } int type = 0; if (itemNo > 4) { if (!server.readTypeCheckingUnsignedByte(inputStorage, type)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The fifth parameter for highlighting must be the highlight type id as ubyte.", outputStorage); } } libsumo::POI::highlight(id, col, size, alphaMax, duration, type); } break; case libsumo::ADD: { if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "A compound object is needed for setting a new PoI.", outputStorage); } //read itemNo const int parameterCount = inputStorage.readInt(); std::string type; if (!server.readTypeCheckingString(inputStorage, type)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The first PoI parameter must be the type encoded as a string.", outputStorage); } libsumo::TraCIColor col; if (!server.readTypeCheckingColor(inputStorage, col)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The second PoI parameter must be the color.", outputStorage); } int layer = 0; if (!server.readTypeCheckingInt(inputStorage, layer)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The third PoI parameter must be the layer encoded as int.", outputStorage); } libsumo::TraCIPosition pos; if (!server.readTypeCheckingPosition2D(inputStorage, pos)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The fourth PoI parameter must be the position.", outputStorage); } if (parameterCount == 4) { if (!libsumo::POI::add(id, pos.x, pos.y, col, type, layer)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "Could not add PoI.", outputStorage); } } else if (parameterCount == 8) { std::string imgFile; if (!server.readTypeCheckingString(inputStorage, imgFile)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The fifth PoI parameter must be the imgFile encoded as a string.", outputStorage); } double width; if (!server.readTypeCheckingDouble(inputStorage, width)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The sixth PoI parameter must be the width encoded as a double.", outputStorage); } double height; if (!server.readTypeCheckingDouble(inputStorage, height)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The seventh PoI parameter must be the height encoded as a double.", outputStorage); } double angle; if (!server.readTypeCheckingDouble(inputStorage, angle)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The eighth PoI parameter must be the angle encoded as a double.", outputStorage); } // if (!libsumo::POI::add(id, pos.x, pos.y, col, type, layer, imgFile, width, height, angle)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "Could not add PoI.", outputStorage); } } else { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "Adding a PoI requires either only type, color, layer and position parameters or these and imageFile, width, height and angle parameters.", outputStorage); } } break; case libsumo::REMOVE: { int layer = 0; // !!! layer not used yet (shouldn't the id be enough?) if (!server.readTypeCheckingInt(inputStorage, layer)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The layer must be given using an int.", outputStorage); } if (!libsumo::POI::remove(id, layer)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "Could not remove PoI '" + id + "'", outputStorage); } } break; case libsumo::VAR_PARAMETER: { if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "A compound object is needed for setting a parameter.", outputStorage); } //readt itemNo inputStorage.readInt(); std::string name; if (!server.readTypeCheckingString(inputStorage, name)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The name of the parameter must be given as a string.", outputStorage); } std::string value; if (!server.readTypeCheckingString(inputStorage, value)) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, "The value of the parameter must be given as a string.", outputStorage); } libsumo::POI::setParameter(id, name, value); } break; default: break; } } catch (libsumo::TraCIException& e) { return server.writeErrorStatusCmd(libsumo::CMD_SET_POI_VARIABLE, e.what(), outputStorage); } server.writeStatusCmd(libsumo::CMD_SET_POI_VARIABLE, libsumo::RTYPE_OK, warning, outputStorage); return true; }
bool TraCIServerAPI_Edge::processSet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { std::string warning = ""; // additional description for response // variable int variable = inputStorage.readUnsignedByte(); if (variable != VAR_EDGE_TRAVELTIME && variable != VAR_EDGE_EFFORT && variable != VAR_MAXSPEED && variable != VAR_PARAMETER) { return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "Change Edge State: unsupported variable " + toHex(variable, 2) + " specified", outputStorage); } // id std::string id = inputStorage.readString(); MSEdge* e = MSEdge::dictionary(id); if (e == 0) { return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "Edge '" + id + "' is not known", outputStorage); } // process switch (variable) { case LANE_ALLOWED: { // read and set allowed vehicle classes std::vector<std::string> classes; if (!server.readTypeCheckingStringList(inputStorage, classes)) { return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "Allowed vehicle classes must be given as a list of strings.", outputStorage); } SVCPermissions permissions = parseVehicleClasses(classes); const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { (*i)->setPermissions(permissions); } e->rebuildAllowedLanes(); } break; case LANE_DISALLOWED: { // read and set disallowed vehicle classes std::vector<std::string> classes; if (!server.readTypeCheckingStringList(inputStorage, classes)) { return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "Not allowed vehicle classes must be given as a list of strings.", outputStorage); } SVCPermissions permissions = ~parseVehicleClasses(classes); // negation yields allowed const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { (*i)->setPermissions(permissions); } e->rebuildAllowedLanes(); } break; case VAR_EDGE_TRAVELTIME: { // read and set travel time if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time requires a compound object.", outputStorage); } int parameterCount = inputStorage.readInt(); if (parameterCount == 3) { // bound by time int begTime = 0, endTime = 0; double value = 0; if (!server.readTypeCheckingInt(inputStorage, begTime)) { return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "The first variable must be the begin time given as int.", outputStorage); } if (!server.readTypeCheckingInt(inputStorage, endTime)) { return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "The second variable must be the end time given as int.", outputStorage); } if (!server.readTypeCheckingDouble(inputStorage, value)) { return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The third variable must be the value given as double", outputStorage); } MSNet::getInstance()->getWeightsStorage().addTravelTime(e, begTime, endTime, value); } else if (parameterCount == 1) { // unbound double value = 0; if (!server.readTypeCheckingDouble(inputStorage, value)) { return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The variable must be the value given as double", outputStorage); } MSNet::getInstance()->getWeightsStorage().addTravelTime(e, SUMOReal(0), SUMOReal(SUMOTime_MAX), value); } else { return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time requires either begin time, end time, and value, or only value as parameter.", outputStorage); } } break; case VAR_EDGE_EFFORT: { // read and set effort if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort requires a compound object.", outputStorage); } int parameterCount = inputStorage.readInt(); if (parameterCount == 3) { // bound by time int begTime = 0, endTime = 0; double value = 0; if (!server.readTypeCheckingInt(inputStorage, begTime)) { return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "The first variable must be the begin time given as int.", outputStorage); } if (!server.readTypeCheckingInt(inputStorage, endTime)) { return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "The second variable must be the end time given as int.", outputStorage); } if (!server.readTypeCheckingDouble(inputStorage, value)) { return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The third variable must be the value given as double", outputStorage); } MSNet::getInstance()->getWeightsStorage().addEffort(e, begTime, endTime, value); } else if (parameterCount == 1) { // unbound double value = 0; if (!server.readTypeCheckingDouble(inputStorage, value)) { return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The variable must be the value given as double", outputStorage); } MSNet::getInstance()->getWeightsStorage().addEffort(e, SUMOReal(0), SUMOReal(SUMOTime_MAX), value); } else { return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort requires either begin time, end time, and value, or only value as parameter.", outputStorage); } } break; case VAR_MAXSPEED: { // read and set max. speed double value = 0; if (!server.readTypeCheckingDouble(inputStorage, value)) { return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The speed must be given as a double.", outputStorage); } const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { (*i)->setMaxSpeed(value); } } break; case VAR_PARAMETER: { if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "A compound object is needed for setting a parameter.", outputStorage); } //readt itemNo inputStorage.readInt(); std::string name; if (!server.readTypeCheckingString(inputStorage, name)) { return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The name of the parameter must be given as a string.", outputStorage); } std::string value; if (!server.readTypeCheckingString(inputStorage, value)) { return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The value of the parameter must be given as a string.", outputStorage); } e->addParameter(name, value); } break; default: break; } server.writeStatusCmd(CMD_SET_EDGE_VARIABLE, RTYPE_OK, warning, outputStorage); return true; }
bool TraCIServerAPI_POI::processSet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { std::string warning = ""; // additional description for response // variable int variable = inputStorage.readUnsignedByte(); if (variable != VAR_TYPE && variable != VAR_COLOR && variable != VAR_POSITION && variable != ADD && variable != REMOVE) { return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "Change PoI State: unsupported variable specified", outputStorage); } // id std::string id = inputStorage.readString(); PointOfInterest* p = 0; ShapeContainer& shapeCont = MSNet::getInstance()->getShapeContainer(); if (variable != ADD && variable != REMOVE) { p = getPoI(id); if (p == 0) { return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "POI '" + id + "' is not known", outputStorage); } } // process switch (variable) { case VAR_TYPE: { std::string type; if (!server.readTypeCheckingString(inputStorage, type)) { return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The type must be given as a string.", outputStorage); } p->setType(type); } break; case VAR_COLOR: { RGBColor col; if (!server.readTypeCheckingColor(inputStorage, col)) { return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The color must be given using an according type.", outputStorage); } p->setColor(col); } break; case VAR_POSITION: { Position pos; if (!server.readTypeCheckingPosition2D(inputStorage, pos)) { return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The position must be given using an accoring type.", outputStorage); } shapeCont.movePOI(id, pos); } break; case ADD: { if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "A compound object is needed for setting a new PoI.", outputStorage); } //read itemNo inputStorage.readInt(); std::string type; if (!server.readTypeCheckingString(inputStorage, type)) { return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The first PoI parameter must be the type encoded as a string.", outputStorage); } RGBColor col; if (!server.readTypeCheckingColor(inputStorage, col)) { return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The second PoI parameter must be the color.", outputStorage); } int layer = 0; if (!server.readTypeCheckingInt(inputStorage, layer)) { return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The third PoI parameter must be the layer encoded as int.", outputStorage); } Position pos; if (!server.readTypeCheckingPosition2D(inputStorage, pos)) { return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The fourth PoI parameter must be the position.", outputStorage); } // if (!shapeCont.addPOI(id, type, col, (SUMOReal)layer, Shape::DEFAULT_ANGLE, Shape::DEFAULT_IMG_FILE, pos, Shape::DEFAULT_IMG_WIDTH, Shape::DEFAULT_IMG_HEIGHT)) { delete p; return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "Could not add PoI.", outputStorage); } } break; case REMOVE: { int layer = 0; // !!! layer not used yet (shouldn't the id be enough?) if (!server.readTypeCheckingInt(inputStorage, layer)) { return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The layer must be given using an int.", outputStorage); } if (!shapeCont.removePOI(id)) { return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "Could not remove PoI '" + id + "'", outputStorage); } } break; default: break; } server.writeStatusCmd(CMD_SET_POI_VARIABLE, RTYPE_OK, warning, outputStorage); return true; }
bool TraCIServerAPI_Route::processSet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { std::string warning = ""; // additional description for response // variable int variable = inputStorage.readUnsignedByte(); if (variable != ADD && variable != VAR_PARAMETER) { return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "Change Route State: unsupported variable " + toHex(variable, 2) + " specified", outputStorage); } // id std::string id = inputStorage.readString(); const MSRoute* r = 0; if (variable != ADD) { r = MSRoute::dictionary(id); if (r == 0) { return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "Route '" + id + "' is not known", outputStorage); } } // process switch (variable) { case ADD: { std::vector<std::string> edgeIDs; if (!server.readTypeCheckingStringList(inputStorage, edgeIDs)) { return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "A string list is needed for adding a new route.", outputStorage); } //read itemNo ConstMSEdgeVector edges; for (std::vector<std::string>::const_iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) { MSEdge* edge = MSEdge::dictionary(*i); if (edge == 0) { return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "Unknown edge '" + *i + "' in route.", outputStorage); } edges.push_back(edge); } const std::vector<SUMOVehicleParameter::Stop> stops; if (!MSRoute::dictionary(id, new MSRoute(id, edges, true, 0, stops))) { return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "Could not add route.", outputStorage); } } break; case VAR_PARAMETER: { if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "A compound object is needed for setting a parameter.", outputStorage); } //readt itemNo inputStorage.readInt(); std::string name; if (!server.readTypeCheckingString(inputStorage, name)) { return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "The name of the parameter must be given as a string.", outputStorage); } std::string value; if (!server.readTypeCheckingString(inputStorage, value)) { return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "The value of the parameter must be given as a string.", outputStorage); } ((MSRoute*) r)->addParameter(name, value); } break; default: break; } server.writeStatusCmd(CMD_SET_ROUTE_VARIABLE, RTYPE_OK, warning, outputStorage); return true; }
// =========================================================================== // method definitions // =========================================================================== bool TraCIServerAPI_Simulation::processGet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { const int variable = inputStorage.readUnsignedByte(); const std::string id = inputStorage.readString(); server.initWrapper(RESPONSE_GET_SIM_VARIABLE, variable, id); try { switch (variable) { case VAR_TIME: server.getWrapperStorage().writeUnsignedByte(TYPE_DOUBLE); server.getWrapperStorage().writeDouble(SIMTIME); break; case VAR_TIME_STEP: server.getWrapperStorage().writeUnsignedByte(TYPE_INTEGER); server.getWrapperStorage().writeInt((int)libsumo::Simulation::getCurrentTime()); break; case VAR_LOADED_VEHICLES_NUMBER: writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_BUILT); break; case VAR_LOADED_VEHICLES_IDS: writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_BUILT); break; case VAR_DEPARTED_VEHICLES_NUMBER: writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_DEPARTED); break; case VAR_DEPARTED_VEHICLES_IDS: writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_DEPARTED); break; case VAR_TELEPORT_STARTING_VEHICLES_NUMBER: writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_STARTING_TELEPORT); break; case VAR_TELEPORT_STARTING_VEHICLES_IDS: writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_STARTING_TELEPORT); break; case VAR_TELEPORT_ENDING_VEHICLES_NUMBER: writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ENDING_TELEPORT); break; case VAR_TELEPORT_ENDING_VEHICLES_IDS: writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ENDING_TELEPORT); break; case VAR_ARRIVED_VEHICLES_NUMBER: writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ARRIVED); break; case VAR_ARRIVED_VEHICLES_IDS: writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ARRIVED); break; case VAR_PARKING_STARTING_VEHICLES_NUMBER: writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_STARTING_PARKING); break; case VAR_PARKING_STARTING_VEHICLES_IDS: writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_STARTING_PARKING); break; case VAR_PARKING_ENDING_VEHICLES_NUMBER: writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ENDING_PARKING); break; case VAR_PARKING_ENDING_VEHICLES_IDS: writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ENDING_PARKING); break; case VAR_STOP_STARTING_VEHICLES_NUMBER: writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_STARTING_STOP); break; case VAR_STOP_STARTING_VEHICLES_IDS: writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_STARTING_STOP); break; case VAR_STOP_ENDING_VEHICLES_NUMBER: writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ENDING_STOP); break; case VAR_STOP_ENDING_VEHICLES_IDS: writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ENDING_STOP); break; case VAR_COLLIDING_VEHICLES_NUMBER: writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_COLLISION); break; case VAR_COLLIDING_VEHICLES_IDS: writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_COLLISION); break; case VAR_EMERGENCYSTOPPING_VEHICLES_NUMBER: writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_EMERGENCYSTOP); break; case VAR_EMERGENCYSTOPPING_VEHICLES_IDS: writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_EMERGENCYSTOP); break; case VAR_DELTA_T: server.getWrapperStorage().writeUnsignedByte(TYPE_INTEGER); server.getWrapperStorage().writeInt((int)libsumo::Simulation::getDeltaT()); break; case VAR_MIN_EXPECTED_VEHICLES: server.getWrapperStorage().writeUnsignedByte(TYPE_INTEGER); server.getWrapperStorage().writeInt(libsumo::Simulation::getMinExpectedNumber()); break; case VAR_BUS_STOP_WAITING: server.getWrapperStorage().writeUnsignedByte(TYPE_INTEGER); server.getWrapperStorage().writeInt(libsumo::Simulation::getBusStopWaiting(id)); break; case VAR_NET_BOUNDING_BOX: { server.getWrapperStorage().writeUnsignedByte(TYPE_POLYGON); libsumo::TraCIPositionVector tb = libsumo::Simulation::getNetBoundary(); server.getWrapperStorage().writeByte(2); server.getWrapperStorage().writeDouble(tb[0].x); server.getWrapperStorage().writeDouble(tb[0].y); server.getWrapperStorage().writeDouble(tb[1].x); server.getWrapperStorage().writeDouble(tb[1].y); break; } case POSITION_CONVERSION: if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Position conversion requires a compound object.", outputStorage); } if (inputStorage.readInt() != 2) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Position conversion requires a source position and a position type as parameter.", outputStorage); } if (!commandPositionConversion(server, inputStorage, server.getWrapperStorage(), CMD_GET_SIM_VARIABLE)) { return false; } break; case DISTANCE_REQUEST: if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of distance requires a compound object.", outputStorage); } if (inputStorage.readInt() != 3) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of distance requires two positions and a distance type as parameter.", outputStorage); } if (!commandDistanceRequest(server, inputStorage, server.getWrapperStorage(), CMD_GET_SIM_VARIABLE)) { return false; } break; case FIND_ROUTE: { if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a compound object.", outputStorage); } if (inputStorage.readInt() != 5) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires five parameter.", outputStorage); } std::string from, to, vtype; double depart; int routingMode; if (!server.readTypeCheckingString(inputStorage, from)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as first parameter.", outputStorage); } if (!server.readTypeCheckingString(inputStorage, to)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as second parameter.", outputStorage); } if (!server.readTypeCheckingString(inputStorage, vtype)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as third parameter.", outputStorage); } if (!server.readTypeCheckingDouble(inputStorage, depart)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as fourth parameter.", outputStorage); } if (!server.readTypeCheckingInt(inputStorage, routingMode)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires an integer as fifth parameter.", outputStorage); } writeStage(server.getWrapperStorage(), libsumo::Simulation::findRoute(from, to, vtype, TIME2STEPS(depart), routingMode)); break; } case FIND_INTERMODAL_ROUTE: { if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of an intermodal route requires a compound object.", outputStorage); } if (inputStorage.readInt() != 13) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of an intermodal route requires thirteen parameters.", outputStorage); } std::string from, to, modes, ptype, vtype, destStop; double depart, speed, walkFactor, departPos, arrivalPos, departPosLat; int routingMode; if (!server.readTypeCheckingString(inputStorage, from)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as first parameter.", outputStorage); } if (!server.readTypeCheckingString(inputStorage, to)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as second parameter.", outputStorage); } if (!server.readTypeCheckingString(inputStorage, modes)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as third parameter.", outputStorage); } if (!server.readTypeCheckingDouble(inputStorage, depart)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as fourth parameter.", outputStorage); } if (!server.readTypeCheckingInt(inputStorage, routingMode)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires an integer as fifth parameter.", outputStorage); } if (!server.readTypeCheckingDouble(inputStorage, speed)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as sixth parameter.", outputStorage); } if (!server.readTypeCheckingDouble(inputStorage, walkFactor)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as seventh parameter.", outputStorage); } if (!server.readTypeCheckingDouble(inputStorage, departPos)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as eigth parameter.", outputStorage); } if (!server.readTypeCheckingDouble(inputStorage, arrivalPos)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as nineth parameter.", outputStorage); } if (!server.readTypeCheckingDouble(inputStorage, departPosLat)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as tenth parameter.", outputStorage); } if (!server.readTypeCheckingString(inputStorage, ptype)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as eleventh parameter.", outputStorage); } if (!server.readTypeCheckingString(inputStorage, vtype)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as twelvth parameter.", outputStorage); } if (!server.readTypeCheckingString(inputStorage, destStop)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as thirteenth parameter.", outputStorage); } const std::vector<libsumo::TraCIStage> result = libsumo::Simulation::findIntermodalRoute(from, to, modes, TIME2STEPS(depart), routingMode, speed, walkFactor, departPos, arrivalPos, departPosLat, ptype, vtype, destStop); server.getWrapperStorage().writeUnsignedByte(TYPE_COMPOUND); server.getWrapperStorage().writeInt((int)result.size()); for (const libsumo::TraCIStage s : result) { writeStage(server.getWrapperStorage(), s); } break; } case VAR_PARAMETER: { std::string paramName = ""; if (!server.readTypeCheckingString(inputStorage, paramName)) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a parameter requires its name.", outputStorage); } server.getWrapperStorage().writeUnsignedByte(TYPE_STRING); server.getWrapperStorage().writeString(libsumo::Simulation::getParameter(id, paramName)); break; } default: return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Get Simulation Variable: unsupported variable " + toHex(variable, 2) + " specified", outputStorage); } } catch (libsumo::TraCIException& e) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, e.what(), outputStorage); } server.writeStatusCmd(CMD_GET_SIM_VARIABLE, RTYPE_OK, "", outputStorage); server.writeResponseWithLength(outputStorage, server.getWrapperStorage()); return true; }
bool TraCIServerAPI_Polygon::processSet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { std::string warning = ""; // additional description for response // variable int variable = inputStorage.readUnsignedByte(); if (variable != VAR_TYPE && variable != VAR_COLOR && variable != VAR_SHAPE && variable != VAR_FILL && variable != ADD && variable != REMOVE) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "Change Polygon State: unsupported variable specified", outputStorage); } // id std::string id = inputStorage.readString(); Polygon* p = 0; ShapeContainer& shapeCont = MSNet::getInstance()->getShapeContainer(); if (variable != ADD && variable != REMOVE) { p = getPolygon(id); if (p == 0) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "Polygon '" + id + "' is not known", outputStorage); } } // process switch (variable) { case VAR_TYPE: { std::string type; if (!server.readTypeCheckingString(inputStorage, type)) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The type must be given as a string.", outputStorage); } p->setType(type); } break; case VAR_COLOR: { RGBColor col; if (!server.readTypeCheckingColor(inputStorage, col)) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The color must be given using an according type.", outputStorage); } p->setColor(col); } break; case VAR_SHAPE: { PositionVector shape; if (!server.readTypeCheckingPolygon(inputStorage, shape)) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The shape must be given using an accoring type.", outputStorage); } shapeCont.reshapePolygon(id, shape); } break; case VAR_FILL: { int value = 0; if (!server.readTypeCheckingUnsignedByte(inputStorage, value)) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "'fill' must be defined using an unsigned byte.", outputStorage); } p->setFill(value != 0); } break; case ADD: { if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "A compound object is needed for setting a new polygon.", outputStorage); } //readt itemNo inputStorage.readInt(); std::string type; if (!server.readTypeCheckingString(inputStorage, type)) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The type must be given as a string.", outputStorage); } RGBColor col; if (!server.readTypeCheckingColor(inputStorage, col)) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The second polygon parameter must be the color.", outputStorage); } int value = 0; if (!server.readTypeCheckingUnsignedByte(inputStorage, value)) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The third polygon parameter must be 'fill' encoded as ubyte.", outputStorage); } bool fill = value != 0; int layer = 0; if (!server.readTypeCheckingInt(inputStorage, layer)) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The fourth polygon parameter must be the layer encoded as int.", outputStorage); } PositionVector shape; if (!server.readTypeCheckingPolygon(inputStorage, shape)) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The fifth polygon parameter must be the shape.", outputStorage); } // if (!shapeCont.addPolygon(id, type, col, (SUMOReal)layer, Shape::DEFAULT_ANGLE, Shape::DEFAULT_IMG_FILE, shape, fill)) { delete p; return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "Could not add polygon.", outputStorage); } } break; case REMOVE: { int layer = 0; // !!! layer not used yet (shouldn't the id be enough?) if (!server.readTypeCheckingInt(inputStorage, layer)) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The layer must be given using an int.", outputStorage); } if (!shapeCont.removePolygon(id)) { return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "Could not remove polygon '" + id + "'", outputStorage); } } break; default: break; } server.writeStatusCmd(CMD_SET_POLYGON_VARIABLE, RTYPE_OK, warning, outputStorage); return true; }
bool TraCIServerAPI_TLS::processSet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { std::string warning = ""; // additional description for response // variable int variable = inputStorage.readUnsignedByte(); if (variable != TL_PHASE_INDEX && variable != TL_PROGRAM && variable != TL_PHASE_DURATION && variable != TL_RED_YELLOW_GREEN_STATE && variable != TL_COMPLETE_PROGRAM_RYG) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "Change TLS State: unsupported variable specified", outputStorage); return false; } std::string id = inputStorage.readString(); if (!MSNet::getInstance()->getTLSControl().knows(id)) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "Traffic light '" + id + "' is not known", outputStorage); return false; } MSTLLogicControl& tlsControl = MSNet::getInstance()->getTLSControl(); SUMOTime cTime = MSNet::getInstance()->getCurrentTimeStep(); MSTLLogicControl::TLSLogicVariants& vars = tlsControl.get(id); int valueDataType = inputStorage.readUnsignedByte(); switch (variable) { case TL_PHASE_INDEX: { if (valueDataType != TYPE_INTEGER) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "The phase index must be given as an integer.", outputStorage); return false; } int index = inputStorage.readInt(); if (index < 0 || vars.getActive()->getPhaseNumber() <= (unsigned int)index) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "The phase index is not in the allowed range.", outputStorage); return false; } int duration = vars.getActive()->getPhase(index).duration; vars.getActive()->changeStepAndDuration(tlsControl, cTime, index, duration); } break; case TL_PROGRAM: { if (valueDataType != TYPE_STRING) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "The program must be given as a string.", outputStorage); return false; } std::string subID = inputStorage.readString(); try { vars.switchTo(tlsControl, subID); } catch (ProcessError& e) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, e.what(), outputStorage); return false; } } break; case TL_PHASE_DURATION: { if (valueDataType != TYPE_INTEGER) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "The phase duration must be given as an integer.", outputStorage); return false; } int duration = inputStorage.readInt(); int index = vars.getActive()->getCurrentPhaseIndex(); vars.getActive()->changeStepAndDuration(tlsControl, cTime, index, duration); } break; case TL_RED_YELLOW_GREEN_STATE: { if (valueDataType != TYPE_STRING) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "The phase must be given as a string.", outputStorage); return false; } // build only once... std::string state = inputStorage.readString(); if (vars.getLogic("online") == 0) { MSPhaseDefinition* phase = new MSPhaseDefinition(DELTA_T, state); std::vector<MSPhaseDefinition*> phases; phases.push_back(phase); MSTrafficLightLogic* logic = new MSSimpleTrafficLightLogic(tlsControl, id, "online", phases, 0, cTime + DELTA_T); vars.addLogic("online", logic, true, true); } else { MSPhaseDefinition nphase(DELTA_T, state); *(static_cast<MSSimpleTrafficLightLogic*>(vars.getLogic("online"))->getPhases()[0]) = nphase; } // @note: this assumes logic "online" is still active vars.getActive()->setTrafficLightSignals(MSNet::getInstance()->getCurrentTimeStep()); vars.executeOnSwitchActions(); } break; case TL_COMPLETE_PROGRAM_RYG: { if (valueDataType != TYPE_COMPOUND) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "A compound object is needed for setting a new program.", outputStorage); return false; } //read itemNo inputStorage.readInt(); if (inputStorage.readUnsignedByte() != TYPE_STRING) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 1. parameter (subid) must be a string.", outputStorage); return false; } std::string subid = inputStorage.readString(); if (inputStorage.readUnsignedByte() != TYPE_INTEGER) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 2. parameter (type) must be an int.", outputStorage); return false; } //read type inputStorage.readInt(); if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 3. parameter (subparams) must be a compound object.", outputStorage); return false; } //read sublength inputStorage.readInt(); if (inputStorage.readUnsignedByte() != TYPE_INTEGER) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 4. parameter (index) must be an int.", outputStorage); return false; } int index = inputStorage.readInt(); if (inputStorage.readUnsignedByte() != TYPE_INTEGER) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 5. parameter (phase number) must be an int.", outputStorage); return false; } int phaseNo = inputStorage.readInt(); // make sure index and phaseNo are consistent if (index >= phaseNo) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 4/5. parameter (index) must be less than parameter (phase number).", outputStorage); return false; } std::vector<MSPhaseDefinition*> phases; for (int j = 0; j < phaseNo; ++j) { if (inputStorage.readUnsignedByte() != TYPE_INTEGER) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 6.1. parameter (duration) must be an int.", outputStorage); return false; } int duration = inputStorage.readInt(); if (inputStorage.readUnsignedByte() != TYPE_INTEGER) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 6.2. parameter (min duration) must be an int.", outputStorage); return false; } int minDuration = inputStorage.readInt(); if (inputStorage.readUnsignedByte() != TYPE_INTEGER) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 6.3. parameter (max duration) must be an int.", outputStorage); return false; } int maxDuration = inputStorage.readInt(); if (inputStorage.readUnsignedByte() != TYPE_STRING) { server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 6.4. parameter (phase) must be a string.", outputStorage); return false; } std::string state = inputStorage.readString(); MSPhaseDefinition* phase = new MSPhaseDefinition(duration, minDuration, maxDuration, state); phases.push_back(phase); } if (vars.getLogic(subid) == 0) { MSTrafficLightLogic* logic = new MSSimpleTrafficLightLogic(tlsControl, id, subid, phases, index, 0); vars.addLogic(subid, logic, true, true); } else { static_cast<MSSimpleTrafficLightLogic*>(vars.getLogic(subid))->setPhases(phases, index); } vars.getActive()->setTrafficLightSignals(MSNet::getInstance()->getCurrentTimeStep()); vars.executeOnSwitchActions(); } break; default: break; } server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_OK, warning, outputStorage); return true; }