bool TraCIServerAPI_Lane::processSet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { std::string warning = ""; // additional description for response // variable int variable = inputStorage.readUnsignedByte(); if (variable != VAR_MAXSPEED && variable != VAR_LENGTH && variable != LANE_ALLOWED && variable != LANE_DISALLOWED) { return server.writeErrorStatusCmd(CMD_SET_LANE_VARIABLE, "Change Lane State: unsupported variable specified", outputStorage); } // id std::string id = inputStorage.readString(); MSLane* l = MSLane::dictionary(id); if (l == 0) { return server.writeErrorStatusCmd(CMD_SET_LANE_VARIABLE, "Lane '" + id + "' is not known", outputStorage); } // process switch (variable) { case VAR_MAXSPEED: { double value = 0; if (!server.readTypeCheckingDouble(inputStorage, value)) { return server.writeErrorStatusCmd(CMD_SET_LANE_VARIABLE, "The speed must be given as a double.", outputStorage); } l->setMaxSpeed(value); } break; case VAR_LENGTH: { double value = 0; if (!server.readTypeCheckingDouble(inputStorage, value)) { return server.writeErrorStatusCmd(CMD_SET_LANE_VARIABLE, "The length must be given as a double.", outputStorage); } l->setLength(value); } break; case LANE_ALLOWED: { std::vector<std::string> classes; if (!server.readTypeCheckingStringList(inputStorage, classes)) { return server.writeErrorStatusCmd(CMD_SET_LANE_VARIABLE, "Allowed classes must be given as a list of strings.", outputStorage); } l->setPermissions(parseVehicleClasses(classes)); l->getEdge().rebuildAllowedLanes(); } break; case LANE_DISALLOWED: { std::vector<std::string> classes; if (!server.readTypeCheckingStringList(inputStorage, classes)) { return server.writeErrorStatusCmd(CMD_SET_LANE_VARIABLE, "Not allowed classes must be given as a list of strings.", outputStorage); } l->setPermissions(~parseVehicleClasses(classes)); // negation yields allowed l->getEdge().rebuildAllowedLanes(); } break; default: break; } server.writeStatusCmd(CMD_SET_LANE_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 & 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; }
// =========================================================================== // 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_GUI::processSet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { std::string warning = ""; // additional description for response // variable int variable = inputStorage.readUnsignedByte(); if (variable != VAR_VIEW_ZOOM && variable != VAR_VIEW_OFFSET && variable != VAR_VIEW_SCHEMA && variable != VAR_VIEW_BOUNDARY && variable != VAR_SCREENSHOT && variable != VAR_TRACK_VEHICLE ) { return server.writeErrorStatusCmd(CMD_SET_GUI_VARIABLE, "Change GUI State: unsupported variable specified", outputStorage); } // id std::string id = inputStorage.readString(); GUISUMOAbstractView* v = getNamedView(id); if (v == 0) { return server.writeErrorStatusCmd(CMD_SET_GUI_VARIABLE, "View '" + id + "' is not known", outputStorage); } // process switch (variable) { case VAR_VIEW_ZOOM: { Position off, p; double zoom = 1; if (!server.readTypeCheckingDouble(inputStorage, zoom)) { return server.writeErrorStatusCmd(CMD_SET_GUI_VARIABLE, "The zoom must be given as a double.", outputStorage); } off.set(v->getChanger().getXPos(), v->getChanger().getYPos(), zoom); v->setViewport(off, p); } break; case VAR_VIEW_OFFSET: { Position off, p; if (!server.readTypeCheckingPosition2D(inputStorage, off)) { return server.writeErrorStatusCmd(CMD_SET_GUI_VARIABLE, "The view port must be given as a position.", outputStorage); } off.set(off.x(), off.y(), v->getChanger().getZoom()); v->setViewport(off, p); } break; case VAR_VIEW_SCHEMA: { std::string schema; if (!server.readTypeCheckingString(inputStorage, schema)) { return server.writeErrorStatusCmd(CMD_SET_GUI_VARIABLE, "The scheme must be specified by a string.", outputStorage); } if (!v->setColorScheme(schema)) { return server.writeErrorStatusCmd(CMD_SET_GUI_VARIABLE, "The scheme is not known.", outputStorage); } } break; case VAR_VIEW_BOUNDARY: { Boundary b; if (!server.readTypeCheckingBoundary(inputStorage, b)) { return server.writeErrorStatusCmd(CMD_SET_GUI_VARIABLE, "The boundary must be specified by a bounding box.", outputStorage); } v->centerTo(b); break; } case VAR_SCREENSHOT: { std::string filename; if (!server.readTypeCheckingString(inputStorage, filename)) { return server.writeErrorStatusCmd(CMD_SET_GUI_VARIABLE, "Making a snapshot requires a file name.", outputStorage); } std::string error = v->makeSnapshot(filename); if (error != "") { return server.writeErrorStatusCmd(CMD_SET_GUI_VARIABLE, error, outputStorage); } } break; case VAR_TRACK_VEHICLE: { std::string id; if (!server.readTypeCheckingString(inputStorage, id)) { return server.writeErrorStatusCmd(CMD_SET_GUI_VARIABLE, "Tracking requires a string vehicle ID.", outputStorage); } if (id == "") { v->stopTrack(); } else { SUMOVehicle* veh = MSNet::getInstance()->getVehicleControl().getVehicle(id); if (veh == 0) { return server.writeErrorStatusCmd(CMD_SET_GUI_VARIABLE, "Could not find vehicle '" + id + "'.", outputStorage); } if (!static_cast<GUIVehicle*>(veh)->hasActiveAddVisualisation(v, GUIVehicle::VO_TRACKED)) { v->startTrack(static_cast<GUIVehicle*>(veh)->getGlID()); static_cast<GUIVehicle*>(veh)->addActiveAddVisualisation(v, GUIVehicle::VO_TRACKED); } } } default: break; } server.writeStatusCmd(CMD_SET_GUI_VARIABLE, RTYPE_OK, warning, outputStorage); return true; }