bool TraCIServerAPI_VehicleType::processSet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { std::string warning = ""; // additional description for response // variable int variable = inputStorage.readUnsignedByte(); if (variable != VAR_LENGTH && variable != VAR_MAXSPEED && variable != VAR_VEHICLECLASS && variable != VAR_SPEED_FACTOR && variable != VAR_SPEED_DEVIATION && variable != VAR_EMISSIONCLASS && variable != VAR_WIDTH && variable != VAR_MINGAP && variable != VAR_SHAPECLASS && variable != VAR_ACCEL && variable != VAR_DECEL && variable != VAR_IMPERFECTION && variable != VAR_TAU && variable != VAR_COLOR ) { server.writeStatusCmd(CMD_SET_VEHICLETYPE_VARIABLE, RTYPE_ERR, "Change Vehicle Type State: unsupported variable specified", outputStorage); return false; } // id std::string id = inputStorage.readString(); MSVehicleType* v = MSNet::getInstance()->getVehicleControl().getVType(id); if (v == 0) { server.writeStatusCmd(CMD_SET_VEHICLETYPE_VARIABLE, RTYPE_ERR, "Vehicle type '" + id + "' is not known", outputStorage); return false; } // process try { if (setVariable(CMD_SET_VEHICLETYPE_VARIABLE, variable, inputStorage.readUnsignedByte(), *v, server, inputStorage, outputStorage)) { server.writeStatusCmd(CMD_SET_VEHICLETYPE_VARIABLE, RTYPE_OK, warning, outputStorage); return true; } } catch (ProcessError& e) { server.writeStatusCmd(CMD_SET_VEHICLETYPE_VARIABLE, RTYPE_ERR, e.what(), outputStorage); } return false; }
bool TraCIServer::readTypeCheckingUnsignedByte(tcpip::Storage& inputStorage, int& into) { if (inputStorage.readUnsignedByte() != TYPE_UBYTE) { return false; } into = inputStorage.readUnsignedByte(); return true; }
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 TraCIServer::readTypeCheckingColor(tcpip::Storage& inputStorage, RGBColor& into) { if (inputStorage.readUnsignedByte() != TYPE_COLOR) { return false; } unsigned char r = static_cast<unsigned char>(inputStorage.readUnsignedByte()); unsigned char g = static_cast<unsigned char>(inputStorage.readUnsignedByte()); unsigned char b = static_cast<unsigned char>(inputStorage.readUnsignedByte()); unsigned char a = static_cast<unsigned char>(inputStorage.readUnsignedByte()); into.set(r, g, b, a); return true; }
bool TraCIServer::readTypeCheckingPolygon(tcpip::Storage& inputStorage, PositionVector& into) { if (inputStorage.readUnsignedByte() != TYPE_POLYGON) { return false; } into.clear(); unsigned int noEntries = inputStorage.readUnsignedByte(); PositionVector shape; for (unsigned int i = 0; i < noEntries; ++i) { SUMOReal x = inputStorage.readDouble(); SUMOReal y = inputStorage.readDouble(); into.push_back(Position(x, y)); } return true; }
// =========================================================================== // method definitions // =========================================================================== bool TraCIServerAPI_GUI::processGet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { // variable & id int variable = inputStorage.readUnsignedByte(); std::string id = inputStorage.readString(); // check variable if (variable != ID_LIST && variable != VAR_VIEW_ZOOM && variable != VAR_VIEW_OFFSET && variable != VAR_VIEW_SCHEMA && variable != VAR_VIEW_BOUNDARY) { return server.writeErrorStatusCmd(CMD_GET_GUI_VARIABLE, "Get GUI Variable: unsupported variable specified", outputStorage); } // begin response building tcpip::Storage tempMsg; // response-code, variableID, objectID tempMsg.writeUnsignedByte(RESPONSE_GET_GUI_VARIABLE); tempMsg.writeUnsignedByte(variable); tempMsg.writeString(id); // process request if (variable == ID_LIST) { std::vector<std::string> ids = getMainWindow()->getViewIDs(); tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(ids); } else { GUISUMOAbstractView* v = getNamedView(id); if (v == 0) { return server.writeErrorStatusCmd(CMD_GET_GUI_VARIABLE, "View '" + id + "' is not known", outputStorage); } switch (variable) { case VAR_VIEW_ZOOM: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(v->getChanger().getZoom()); break; case VAR_VIEW_OFFSET: tempMsg.writeUnsignedByte(POSITION_2D); tempMsg.writeDouble(v->getChanger().getXPos()); tempMsg.writeDouble(v->getChanger().getYPos()); break; case VAR_VIEW_SCHEMA: { FXComboBox& c = v->getColoringSchemesCombo(); tempMsg.writeUnsignedByte(TYPE_STRING); tempMsg.writeString((std::string)c.getItem(c.getCurrentItem()).text()); break; } case VAR_VIEW_BOUNDARY: { tempMsg.writeUnsignedByte(TYPE_BOUNDINGBOX); Boundary b = v->getVisibleBoundary(); tempMsg.writeDouble(b.xmin()); tempMsg.writeDouble(b.ymin()); tempMsg.writeDouble(b.xmax()); tempMsg.writeDouble(b.ymax()); break; } default: break; } } server.writeStatusCmd(CMD_GET_GUI_VARIABLE, RTYPE_OK, "", outputStorage); server.writeResponseWithLength(outputStorage, tempMsg); return true; }
// =========================================================================== // method definitions // =========================================================================== bool TraCIServerAPI_POI::processGet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { const int variable = inputStorage.readUnsignedByte(); const std::string id = inputStorage.readString(); server.initWrapper(libsumo::RESPONSE_GET_POI_VARIABLE, variable, id); try { if (!libsumo::POI::handleVariable(id, variable, &server)) { switch (variable) { case libsumo::VAR_PARAMETER: { std::string paramName = ""; if (!server.readTypeCheckingString(inputStorage, paramName)) { return server.writeErrorStatusCmd(libsumo::CMD_GET_POI_VARIABLE, "Retrieval of a parameter requires its name.", outputStorage); } server.getWrapperStorage().writeUnsignedByte(libsumo::TYPE_STRING); server.getWrapperStorage().writeString(libsumo::POI::getParameter(id, paramName)); break; } default: return server.writeErrorStatusCmd(libsumo::CMD_GET_POI_VARIABLE, "Get PoI Variable: unsupported variable " + toHex(variable, 2) + " specified", outputStorage); } } } catch (libsumo::TraCIException& e) { return server.writeErrorStatusCmd(libsumo::CMD_GET_POI_VARIABLE, e.what(), outputStorage); } server.writeStatusCmd(libsumo::CMD_GET_POI_VARIABLE, libsumo::RTYPE_OK, "", outputStorage); server.writeResponseWithLength(outputStorage, server.getWrapperStorage()); return true; }
bool TraCIServerAPI_Simulation::processSet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { std::string warning = ""; // additional description for response // variable int variable = inputStorage.readUnsignedByte(); if (variable != CMD_CLEAR_PENDING_VEHICLES) { return server.writeErrorStatusCmd(CMD_SET_SIM_VARIABLE, "Set Simulation Variable: unsupported variable specified", outputStorage); } // id std::string id = inputStorage.readString(); // process switch (variable) { case CMD_CLEAR_PENDING_VEHICLES: { //clear any pending vehicle insertions std::string route; if (!server.readTypeCheckingString(inputStorage, route)) { return server.writeErrorStatusCmd(CMD_SET_SIM_VARIABLE, "A string is needed for clearing pending vehicles.", outputStorage); } MSNet::getInstance()->getInsertionControl().clearPendingVehicles(route); } break; default: break; } server.writeStatusCmd(CMD_SET_SIM_VARIABLE, RTYPE_OK, warning, outputStorage); return true; }
bool TraCIServer::readTypeCheckingStringList(tcpip::Storage& inputStorage, std::vector<std::string>& into) { if (inputStorage.readUnsignedByte() != TYPE_STRINGLIST) { return false; } into = inputStorage.readStringList(); return true; }
bool TraCIServer::readTypeCheckingDouble(tcpip::Storage& inputStorage, double& into) { if (inputStorage.readUnsignedByte() != TYPE_DOUBLE) { return false; } into = inputStorage.readDouble(); return true; }
// =========================================================================== // method definitions // =========================================================================== bool TraCIServerAPI_POI::processGet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { // variable & id int variable = inputStorage.readUnsignedByte(); std::string id = inputStorage.readString(); // check variable if (variable != ID_LIST && variable != VAR_TYPE && variable != VAR_COLOR && variable != VAR_POSITION && variable != ID_COUNT) { return server.writeErrorStatusCmd(CMD_GET_POI_VARIABLE, "Get PoI Variable: unsupported variable specified", outputStorage); } // begin response building tcpip::Storage tempMsg; // response-code, variableID, objectID tempMsg.writeUnsignedByte(RESPONSE_GET_POI_VARIABLE); tempMsg.writeUnsignedByte(variable); tempMsg.writeString(id); // process request if (variable == ID_LIST || variable == ID_COUNT) { std::vector<std::string> ids; ShapeContainer& shapeCont = MSNet::getInstance()->getShapeContainer(); shapeCont.getPOIs().insertIDs(ids); if (variable == ID_LIST) { tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(ids); } else { tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt((int) ids.size()); } } else { PointOfInterest* p = getPoI(id); if (p == 0) { return server.writeErrorStatusCmd(CMD_GET_POI_VARIABLE, "POI '" + id + "' is not known", outputStorage); } switch (variable) { case VAR_TYPE: tempMsg.writeUnsignedByte(TYPE_STRING); tempMsg.writeString(p->getType()); break; case VAR_COLOR: tempMsg.writeUnsignedByte(TYPE_COLOR); tempMsg.writeUnsignedByte(p->getColor().red()); tempMsg.writeUnsignedByte(p->getColor().green()); tempMsg.writeUnsignedByte(p->getColor().blue()); tempMsg.writeUnsignedByte(p->getColor().alpha()); break; case VAR_POSITION: tempMsg.writeUnsignedByte(POSITION_2D); tempMsg.writeDouble(p->x()); tempMsg.writeDouble(p->y()); break; default: break; } } server.writeStatusCmd(CMD_GET_POI_VARIABLE, RTYPE_OK, "", outputStorage); server.writeResponseWithLength(outputStorage, tempMsg); 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_Route::processGet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { // variable & id int variable = inputStorage.readUnsignedByte(); std::string id = inputStorage.readString(); // check variable if (variable != ID_LIST && variable != VAR_EDGES && variable != ID_COUNT && variable != VAR_PARAMETER) { return server.writeErrorStatusCmd(CMD_GET_ROUTE_VARIABLE, "Get Route Variable: unsupported variable " + toHex(variable, 2) + " specified", outputStorage); } // begin response building tcpip::Storage tempMsg; // response-code, variableID, objectID tempMsg.writeUnsignedByte(RESPONSE_GET_ROUTE_VARIABLE); tempMsg.writeUnsignedByte(variable); tempMsg.writeString(id); // process request if (variable == ID_LIST) { std::vector<std::string> ids; MSRoute::insertIDs(ids); tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(ids); } else if (variable == ID_COUNT) { std::vector<std::string> ids; MSRoute::insertIDs(ids); tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt((int) ids.size()); } else { const MSRoute* r = MSRoute::dictionary(id); if (r == 0) { return server.writeErrorStatusCmd(CMD_GET_ROUTE_VARIABLE, "Route '" + id + "' is not known", outputStorage); } switch (variable) { case VAR_EDGES: tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeInt(r->size()); for (MSRouteIterator i = r->begin(); i != r->end(); ++i) { tempMsg.writeString((*i)->getID()); } break; case VAR_PARAMETER: { std::string paramName = ""; if (!server.readTypeCheckingString(inputStorage, paramName)) { return server.writeErrorStatusCmd(CMD_GET_ROUTE_VARIABLE, "Retrieval of a parameter requires its name.", outputStorage); } tempMsg.writeUnsignedByte(TYPE_STRING); tempMsg.writeString(r->getParameter(paramName, "")); } break; default: break; } } server.writeStatusCmd(CMD_GET_ROUTE_VARIABLE, RTYPE_OK, "", outputStorage); server.writeResponseWithLength(outputStorage, tempMsg); return true; }
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; }
// =========================================================================== // method definitions // =========================================================================== bool TraCIServerAPI_Junction::processGet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { // variable int variable = inputStorage.readUnsignedByte(); std::string id = inputStorage.readString(); // check variable if (variable != ID_LIST && variable != VAR_POSITION && variable != ID_COUNT && variable != VAR_SHAPE) { return server.writeErrorStatusCmd(CMD_GET_JUNCTION_VARIABLE, "Get Junction Variable: unsupported variable specified", outputStorage); } // begin response building tcpip::Storage tempMsg; // response-code, variableID, objectID tempMsg.writeUnsignedByte(RESPONSE_GET_JUNCTION_VARIABLE); tempMsg.writeUnsignedByte(variable); tempMsg.writeString(id); if (variable == ID_LIST) { std::vector<std::string> ids; MSNet::getInstance()->getJunctionControl().insertIDs(ids); tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(ids); } else if (variable == ID_COUNT) { std::vector<std::string> ids; MSNet::getInstance()->getJunctionControl().insertIDs(ids); tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt((int) ids.size()); } else { MSJunction* j = MSNet::getInstance()->getJunctionControl().get(id); if (j == 0) { return server.writeErrorStatusCmd(CMD_GET_JUNCTION_VARIABLE, "Junction '" + id + "' is not known", outputStorage); } switch (variable) { case ID_LIST: break; case VAR_POSITION: tempMsg.writeUnsignedByte(POSITION_2D); tempMsg.writeDouble(j->getPosition().x()); tempMsg.writeDouble(j->getPosition().y()); break; case VAR_SHAPE: tempMsg.writeUnsignedByte(TYPE_POLYGON); tempMsg.writeUnsignedByte((int)MIN2(static_cast<size_t>(255), j->getShape().size())); for (unsigned int iPoint = 0; iPoint < MIN2(static_cast<size_t>(255), j->getShape().size()); ++iPoint) { tempMsg.writeDouble(j->getShape()[iPoint].x()); tempMsg.writeDouble(j->getShape()[iPoint].y()); } break; default: break; } } server.writeStatusCmd(CMD_GET_JUNCTION_VARIABLE, RTYPE_OK, "", outputStorage); server.writeResponseWithLength(outputStorage, tempMsg); return true; }
bool TraCIServer::readTypeCheckingPosition2D(tcpip::Storage& inputStorage, Position& into) { if (inputStorage.readUnsignedByte() != POSITION_2D) { return false; } SUMOReal x = inputStorage.readDouble(); SUMOReal y = inputStorage.readDouble(); into.set(x, y, 0); return true; }
bool TraCIServer::readTypeCheckingBoundary(tcpip::Storage& inputStorage, Boundary& into) { if (inputStorage.readUnsignedByte() != TYPE_BOUNDINGBOX) { return false; } const SUMOReal xmin = inputStorage.readDouble(); const SUMOReal ymin = inputStorage.readDouble(); const SUMOReal xmax = inputStorage.readDouble(); const SUMOReal ymax = inputStorage.readDouble(); into.set(xmin, ymin, xmax, ymax); return true; }
// =========================================================================== // method definitions // =========================================================================== bool TraCIServerAPI_MultiEntryExit::processGet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { const int variable = inputStorage.readUnsignedByte(); const std::string id = inputStorage.readString(); server.initWrapper(libsumo::RESPONSE_GET_MULTIENTRYEXIT_VARIABLE, variable, id); try { if (!libsumo::MultiEntryExit::handleVariable(id, variable, &server)) { return server.writeErrorStatusCmd(libsumo::CMD_GET_MULTIENTRYEXIT_VARIABLE, "Get Multi Entry Exit Detector Variable: unsupported variable " + toHex(variable, 2) + " specified", outputStorage); } } catch (libsumo::TraCIException& e) { return server.writeErrorStatusCmd(libsumo::CMD_GET_MULTIENTRYEXIT_VARIABLE, e.what(), outputStorage); } server.writeStatusCmd(libsumo::CMD_GET_MULTIENTRYEXIT_VARIABLE, libsumo::RTYPE_OK, "", outputStorage); server.writeResponseWithLength(outputStorage, server.getWrapperStorage()); return true; }
// =========================================================================== // method definitions // =========================================================================== bool TraCIServerAPI_VehicleType::processGet(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 != ID_LIST && variable != VAR_LENGTH && variable != VAR_MAXSPEED && variable != VAR_ACCEL && variable != VAR_DECEL && variable != VAR_TAU && variable != VAR_VEHICLECLASS && variable != VAR_EMISSIONCLASS && variable != VAR_SHAPECLASS && variable != VAR_SPEED_FACTOR && variable != VAR_SPEED_DEVIATION && variable != VAR_IMPERFECTION && variable != VAR_MINGAP && variable != VAR_WIDTH && variable != VAR_COLOR && variable != ID_COUNT) { server.writeStatusCmd(CMD_GET_VEHICLETYPE_VARIABLE, RTYPE_ERR, "Get Vehicle Type Variable: unsupported variable specified", outputStorage); return false; } // begin response building tcpip::Storage tempMsg; // response-code, variableID, objectID tempMsg.writeUnsignedByte(RESPONSE_GET_VEHICLETYPE_VARIABLE); tempMsg.writeUnsignedByte(variable); tempMsg.writeString(id); // process request if (variable == ID_LIST) { std::vector<std::string> ids; MSNet::getInstance()->getVehicleControl().insertVTypeIDs(ids); tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(ids); } else if (variable == ID_COUNT) { std::vector<std::string> ids; MSNet::getInstance()->getVehicleControl().insertVTypeIDs(ids); tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt((int) ids.size()); } else { MSVehicleType* v = MSNet::getInstance()->getVehicleControl().getVType(id); if (v == 0) { server.writeStatusCmd(CMD_GET_VEHICLETYPE_VARIABLE, RTYPE_ERR, "Vehicle type '" + id + "' is not known", outputStorage); return false; } getVariable(variable, *v, tempMsg); } server.writeStatusCmd(CMD_GET_VEHICLETYPE_VARIABLE, RTYPE_OK, warning, outputStorage); server.writeResponseWithLength(outputStorage, tempMsg); return true; }
bool TraCIServerAPI_Simulation::processSet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { std::string warning = ""; // additional description for response // variable int variable = inputStorage.readUnsignedByte(); if (variable != CMD_CLEAR_PENDING_VEHICLES && variable != CMD_SAVE_SIMSTATE) { return server.writeErrorStatusCmd(CMD_SET_SIM_VARIABLE, "Set Simulation Variable: unsupported variable " + toHex(variable, 2) + " specified", outputStorage); } // id std::string id = inputStorage.readString(); // process try { switch (variable) { case CMD_CLEAR_PENDING_VEHICLES: { //clear any pending vehicle insertions std::string route; if (!server.readTypeCheckingString(inputStorage, route)) { return server.writeErrorStatusCmd(CMD_SET_SIM_VARIABLE, "A string is needed for clearing pending vehicles.", outputStorage); } libsumo::Simulation::clearPending(route); } break; case CMD_SAVE_SIMSTATE: { //save current simulation state std::string file; if (!server.readTypeCheckingString(inputStorage, file)) { return server.writeErrorStatusCmd(CMD_SET_SIM_VARIABLE, "A string is needed for saving simulation state.", outputStorage); } libsumo::Simulation::saveState(file); } break; default: break; } } catch (libsumo::TraCIException& e) { return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, e.what(), outputStorage); } server.writeStatusCmd(CMD_SET_SIM_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) { return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "Change Route State: unsupported variable specified", outputStorage); } // id std::string id = inputStorage.readString(); // 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 MSEdgeVector 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, 1, 0, stops))) { return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "Could not add route.", outputStorage); } } 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_Simulation::commandDistanceRequest(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage, int commandId) { Position pos1; Position pos2; std::pair<const MSLane*, SUMOReal> roadPos1; std::pair<const MSLane*, SUMOReal> roadPos2; // read position 1 int posType = inputStorage.readUnsignedByte(); switch (posType) { case POSITION_ROADMAP: try { std::string roadID = inputStorage.readString(); roadPos1.second = inputStorage.readDouble(); roadPos1.first = getLaneChecking(roadID, inputStorage.readUnsignedByte(), roadPos1.second); pos1 = roadPos1.first->getShape().positionAtOffset(roadPos1.second); } catch (TraCIException& e) { server.writeStatusCmd(commandId, RTYPE_ERR, e.what()); return false; } break; case POSITION_2D: case POSITION_3D: { SUMOReal p1x = inputStorage.readDouble(); SUMOReal p1y = inputStorage.readDouble(); pos1.set(p1x, p1y); } if (posType == POSITION_3D) { inputStorage.readDouble(); // z value is ignored } roadPos1 = convertCartesianToRoadMap(pos1); break; default: server.writeStatusCmd(commandId, RTYPE_ERR, "Unknown position format used for distance request"); return false; } // read position 2 posType = inputStorage.readUnsignedByte(); switch (posType) { case POSITION_ROADMAP: try { std::string roadID = inputStorage.readString(); roadPos2.second = inputStorage.readDouble(); roadPos2.first = getLaneChecking(roadID, inputStorage.readUnsignedByte(), roadPos2.second); pos2 = roadPos2.first->getShape().positionAtOffset(roadPos2.second); } catch (TraCIException& e) { server.writeStatusCmd(commandId, RTYPE_ERR, e.what()); return false; } break; case POSITION_2D: case POSITION_3D: { SUMOReal p2x = inputStorage.readDouble(); SUMOReal p2y = inputStorage.readDouble(); pos2.set(p2x, p2y); } if (posType == POSITION_3D) { inputStorage.readDouble(); // z value is ignored } roadPos2 = convertCartesianToRoadMap(pos2); break; default: server.writeStatusCmd(commandId, RTYPE_ERR, "Unknown position format used for distance request"); return false; } // read distance type int distType = inputStorage.readUnsignedByte(); SUMOReal distance = 0.0; if (distType == REQUEST_DRIVINGDIST) { // compute driving distance if ((roadPos1.first == roadPos2.first) && (roadPos1.second <= roadPos2.second)) { // same edge distance = roadPos2.second - roadPos1.second; } else { MSEdgeVector newRoute; MSNet::getInstance()->getRouterTT().compute( &roadPos1.first->getEdge(), &roadPos2.first->getEdge(), 0, MSNet::getInstance()->getCurrentTimeStep(), newRoute); MSRoute route("", newRoute, false, 0, std::vector<SUMOVehicleParameter::Stop>()); distance = route.getDistanceBetween(roadPos1.second, roadPos2.second, &roadPos1.first->getEdge(), &roadPos2.first->getEdge()); } } else { // compute air distance (default) distance = pos1.distanceTo(pos2); } // write response command outputStorage.writeUnsignedByte(TYPE_DOUBLE); outputStorage.writeDouble(distance); return true; }
bool TraCIServerAPI_Simulation::commandPositionConversion(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage, int commandId) { std::pair<MSLane*, SUMOReal> roadPos; Position cartesianPos; Position geoPos; SUMOReal z = 0; // actual position type that will be converted int srcPosType = inputStorage.readUnsignedByte(); switch (srcPosType) { case POSITION_2D: case POSITION_3D: case POSITION_LON_LAT: case POSITION_LON_LAT_ALT: { SUMOReal x = inputStorage.readDouble(); SUMOReal y = inputStorage.readDouble(); if (srcPosType != POSITION_2D && srcPosType != POSITION_LON_LAT) { z = inputStorage.readDouble(); } geoPos.set(x, y); cartesianPos.set(x, y); if (srcPosType == POSITION_LON_LAT || srcPosType == POSITION_LON_LAT_ALT) { GeoConvHelper::getFinal().x2cartesian_const(cartesianPos); } else { GeoConvHelper::getFinal().cartesian2geo(geoPos); } } break; case POSITION_ROADMAP: { std::string roadID = inputStorage.readString(); SUMOReal pos = inputStorage.readDouble(); int laneIdx = inputStorage.readUnsignedByte(); try { // convert edge,offset,laneIdx to cartesian position cartesianPos = geoPos = getLaneChecking(roadID, laneIdx, pos)->getShape().positionAtOffset(pos); z = cartesianPos.z(); GeoConvHelper::getFinal().cartesian2geo(geoPos); } catch (TraCIException& e) { server.writeStatusCmd(commandId, RTYPE_ERR, e.what()); return false; } } break; default: server.writeStatusCmd(commandId, RTYPE_ERR, "Source position type not supported"); return false; } int destPosType = 0; if (!server.readTypeCheckingUnsignedByte(inputStorage, destPosType)) { server.writeStatusCmd(commandId, RTYPE_ERR, "Destination position type must be of type ubyte."); return false; } switch (destPosType) { case POSITION_ROADMAP: { // convert cartesion position to edge,offset,lane_index roadPos = convertCartesianToRoadMap(cartesianPos); // write result that is added to response msg outputStorage.writeUnsignedByte(POSITION_ROADMAP); outputStorage.writeString(roadPos.first->getEdge().getID()); outputStorage.writeDouble(roadPos.second); const std::vector<MSLane*> lanes = roadPos.first->getEdge().getLanes(); outputStorage.writeUnsignedByte((int)distance(lanes.begin(), find(lanes.begin(), lanes.end(), roadPos.first))); } break; case POSITION_2D: case POSITION_3D: case POSITION_LON_LAT: case POSITION_LON_LAT_ALT: outputStorage.writeUnsignedByte(destPosType); if (destPosType == POSITION_LON_LAT || destPosType == POSITION_LON_LAT_ALT) { outputStorage.writeDouble(geoPos.x()); outputStorage.writeDouble(geoPos.y()); } else { outputStorage.writeDouble(cartesianPos.x()); outputStorage.writeDouble(cartesianPos.y()); } if (destPosType != POSITION_2D && destPosType != POSITION_LON_LAT) { outputStorage.writeDouble(z); } break; default: server.writeStatusCmd(commandId, RTYPE_ERR, "Destination position type not supported"); return false; } return true; }
// =========================================================================== // method definitions // =========================================================================== bool TraCIServerAPI_MeMeDetector::processGet(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 != ID_LIST && variable != LAST_STEP_VEHICLE_NUMBER && variable != LAST_STEP_MEAN_SPEED && variable != LAST_STEP_VEHICLE_ID_LIST && variable != LAST_STEP_VEHICLE_HALTING_NUMBER && variable != ID_COUNT) { server.writeStatusCmd(CMD_GET_MULTI_ENTRY_EXIT_DETECTOR_VARIABLE, RTYPE_ERR, "Get MeMeDetector Variable: unsupported variable specified", outputStorage); return false; } // begin response building tcpip::Storage tempMsg; // response-code, variableID, objectID tempMsg.writeUnsignedByte(RESPONSE_GET_MULTI_ENTRY_EXIT_DETECTOR_VARIABLE); tempMsg.writeUnsignedByte(variable); tempMsg.writeString(id); if (variable == ID_LIST) { std::vector<std::string> ids; MSNet::getInstance()->getDetectorControl().getTypedDetectors(SUMO_TAG_ENTRY_EXIT_DETECTOR).insertIDs(ids); tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(ids); } else if (variable == ID_COUNT) { std::vector<std::string> ids; MSNet::getInstance()->getDetectorControl().getTypedDetectors(SUMO_TAG_ENTRY_EXIT_DETECTOR).insertIDs(ids); tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt((int) ids.size()); } else { MSE3Collector* e3 = static_cast<MSE3Collector*>(MSNet::getInstance()->getDetectorControl().getTypedDetectors(SUMO_TAG_ENTRY_EXIT_DETECTOR).get(id)); if (e3 == 0) { server.writeStatusCmd(CMD_GET_MULTI_ENTRY_EXIT_DETECTOR_VARIABLE, RTYPE_ERR, "Areal detector '" + id + "' is not known", outputStorage); return false; } switch (variable) { case ID_LIST: break; case LAST_STEP_VEHICLE_NUMBER: tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt((int) e3->getVehiclesWithin()); break; case LAST_STEP_MEAN_SPEED: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(e3->getCurrentMeanSpeed()); break; case LAST_STEP_VEHICLE_ID_LIST: { tempMsg.writeUnsignedByte(TYPE_STRINGLIST); std::vector<std::string> ids = e3->getCurrentVehicleIDs(); tempMsg.writeStringList(ids); } break; case LAST_STEP_VEHICLE_HALTING_NUMBER: tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt((int) e3->getCurrentHaltingNumber()); break; default: break; } } server.writeStatusCmd(CMD_GET_MULTI_ENTRY_EXIT_DETECTOR_VARIABLE, RTYPE_OK, warning, 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; }
// =========================================================================== // method definitions // =========================================================================== bool TraCIServerAPI_Edge::processGet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { // variable & id int variable = inputStorage.readUnsignedByte(); std::string id = inputStorage.readString(); // check variable if (variable != ID_LIST && variable != VAR_EDGE_TRAVELTIME && variable != VAR_EDGE_EFFORT && variable != VAR_CURRENT_TRAVELTIME && variable != VAR_CO2EMISSION && variable != VAR_COEMISSION && variable != VAR_HCEMISSION && variable != VAR_PMXEMISSION && variable != VAR_NOXEMISSION && variable != VAR_FUELCONSUMPTION && variable != VAR_NOISEEMISSION && variable != VAR_WAITING_TIME && variable != LAST_STEP_VEHICLE_NUMBER && variable != LAST_STEP_MEAN_SPEED && variable != LAST_STEP_OCCUPANCY && variable != LAST_STEP_VEHICLE_HALTING_NUMBER && variable != LAST_STEP_LENGTH && variable != LAST_STEP_PERSON_ID_LIST && variable != LAST_STEP_VEHICLE_ID_LIST && variable != ID_COUNT && variable != VAR_PARAMETER) { return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "Get Edge Variable: unsupported variable " + toHex(variable, 2) + " specified", outputStorage); } // begin response building tcpip::Storage tempMsg; // response-code, variableID, objectID tempMsg.writeUnsignedByte(RESPONSE_GET_EDGE_VARIABLE); tempMsg.writeUnsignedByte(variable); tempMsg.writeString(id); // process request if (variable == ID_LIST) { std::vector<std::string> ids; MSEdge::insertIDs(ids); tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(ids); } else if (variable == ID_COUNT) { std::vector<std::string> ids; MSEdge::insertIDs(ids); tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt((int) ids.size()); } else { MSEdge* e = MSEdge::dictionary(id); if (e == 0) { return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "Edge '" + id + "' is not known", outputStorage); } switch (variable) { case VAR_EDGE_TRAVELTIME: { // time int time = 0; if (!server.readTypeCheckingInt(inputStorage, time)) { return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "The message must contain the time definition.", outputStorage); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); SUMOReal value; if (!MSNet::getInstance()->getWeightsStorage().retrieveExistingTravelTime(e, time, value)) { tempMsg.writeDouble(-1); } else { tempMsg.writeDouble(value); } } break; case VAR_EDGE_EFFORT: { // time int time = 0; if (!server.readTypeCheckingInt(inputStorage, time)) { return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "The message must contain the time definition.", outputStorage); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); SUMOReal value; if (!MSNet::getInstance()->getWeightsStorage().retrieveExistingEffort(e, time, value)) { tempMsg.writeDouble(-1); } else { tempMsg.writeDouble(value); } } break; case VAR_CURRENT_TRAVELTIME: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(e->getCurrentTravelTime()); break; case VAR_WAITING_TIME: { SUMOReal wtime = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { wtime += (*i)->getWaitingSeconds(); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(wtime); } break; case LAST_STEP_PERSON_ID_LIST: { std::vector<std::string> personIDs; std::vector<MSTransportable*> persons = e->getSortedPersons(MSNet::getInstance()->getCurrentTimeStep()); for (std::vector<MSTransportable*>::iterator it = persons.begin(); it != persons.end(); ++it) { personIDs.push_back((*it)->getID()); } tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(personIDs); } break; case LAST_STEP_VEHICLE_ID_LIST: { std::vector<std::string> vehIDs; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { const MSLane::VehCont& vehs = (*i)->getVehiclesSecure(); for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) { vehIDs.push_back((*j)->getID()); } (*i)->releaseVehicles(); } tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(vehIDs); } break; case VAR_CO2EMISSION: { SUMOReal sum = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { sum += (*i)->getCO2Emissions(); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(sum); } break; case VAR_COEMISSION: { SUMOReal sum = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { sum += (*i)->getCOEmissions(); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(sum); } break; case VAR_HCEMISSION: { SUMOReal sum = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { sum += (*i)->getHCEmissions(); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(sum); } break; case VAR_PMXEMISSION: { SUMOReal sum = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { sum += (*i)->getPMxEmissions(); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(sum); } break; case VAR_NOXEMISSION: { SUMOReal sum = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { sum += (*i)->getNOxEmissions(); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(sum); } break; case VAR_FUELCONSUMPTION: { SUMOReal sum = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { sum += (*i)->getFuelConsumption(); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(sum); } break; case VAR_NOISEEMISSION: { SUMOReal sum = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { sum += (SUMOReal) pow(10., ((*i)->getHarmonoise_NoiseEmissions() / 10.)); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); if (sum != 0) { tempMsg.writeDouble(HelpersHarmonoise::sum(sum)); } else { tempMsg.writeDouble(0); } } break; case LAST_STEP_VEHICLE_NUMBER: { int sum = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { sum += (*i)->getVehicleNumber(); } tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt(sum); } break; case LAST_STEP_MEAN_SPEED: { SUMOReal sum = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { sum += (*i)->getMeanSpeed(); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(sum / (SUMOReal) lanes.size()); } break; case LAST_STEP_OCCUPANCY: { SUMOReal sum = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { sum += (*i)->getNettoOccupancy(); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(sum / (SUMOReal) lanes.size()); } break; case LAST_STEP_VEHICLE_HALTING_NUMBER: { int halting = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { const MSLane::VehCont& vehs = (*i)->getVehiclesSecure(); for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) { if ((*j)->getSpeed() < SUMO_const_haltingSpeed) { ++halting; } } (*i)->releaseVehicles(); } tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt(halting); } break; case LAST_STEP_LENGTH: { SUMOReal lengthSum = 0; int noVehicles = 0; const std::vector<MSLane*>& lanes = e->getLanes(); for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) { const MSLane::VehCont& vehs = (*i)->getVehiclesSecure(); for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) { lengthSum += (*j)->getVehicleType().getLength(); } noVehicles += (int) vehs.size(); (*i)->releaseVehicles(); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); if (noVehicles == 0) { tempMsg.writeDouble(0); } else { tempMsg.writeDouble(lengthSum / (SUMOReal) noVehicles); } } break; case VAR_PARAMETER: { std::string paramName = ""; if (!server.readTypeCheckingString(inputStorage, paramName)) { return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "Retrieval of a parameter requires its name.", outputStorage); } tempMsg.writeUnsignedByte(TYPE_STRING); tempMsg.writeString(e->getParameter(paramName, "")); } break; default: break; } } server.writeStatusCmd(CMD_GET_EDGE_VARIABLE, RTYPE_OK, "", outputStorage); server.writeResponseWithLength(outputStorage, tempMsg); 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 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; }
// =========================================================================== // method definitions // =========================================================================== bool TraCIServerAPI_Lane::processGet(TraCIServer& server, tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) { // variable int variable = inputStorage.readUnsignedByte(); std::string id = inputStorage.readString(); // check variable if (variable != ID_LIST && variable != LANE_LINK_NUMBER && variable != LANE_EDGE_ID && variable != VAR_LENGTH && variable != VAR_MAXSPEED && variable != LANE_LINKS && variable != VAR_SHAPE && variable != VAR_CO2EMISSION && variable != VAR_COEMISSION && variable != VAR_HCEMISSION && variable != VAR_PMXEMISSION && variable != VAR_NOXEMISSION && variable != VAR_FUELCONSUMPTION && variable != VAR_NOISEEMISSION && variable != VAR_WAITING_TIME && variable != LAST_STEP_MEAN_SPEED && variable != LAST_STEP_VEHICLE_NUMBER && variable != LAST_STEP_VEHICLE_ID_LIST && variable != LAST_STEP_OCCUPANCY && variable != LAST_STEP_VEHICLE_HALTING_NUMBER && variable != LAST_STEP_LENGTH && variable != VAR_CURRENT_TRAVELTIME && variable != LANE_ALLOWED && variable != LANE_DISALLOWED && variable != VAR_WIDTH && variable != ID_COUNT ) { return server.writeErrorStatusCmd(CMD_GET_LANE_VARIABLE, "Get Lane Variable: unsupported variable specified", outputStorage); } // begin response building tcpip::Storage tempMsg; // response-code, variableID, objectID tempMsg.writeUnsignedByte(RESPONSE_GET_LANE_VARIABLE); tempMsg.writeUnsignedByte(variable); tempMsg.writeString(id); if (variable == ID_LIST) { std::vector<std::string> ids; MSLane::insertIDs(ids); tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(ids); } else if (variable == ID_COUNT) { std::vector<std::string> ids; MSLane::insertIDs(ids); tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt((int) ids.size()); } else { MSLane* lane = MSLane::dictionary(id); if (lane == 0) { return server.writeErrorStatusCmd(CMD_GET_LANE_VARIABLE, "Lane '" + id + "' is not known", outputStorage); } switch (variable) { case LANE_LINK_NUMBER: tempMsg.writeUnsignedByte(TYPE_UBYTE); tempMsg.writeUnsignedByte((int) lane->getLinkCont().size()); break; case LANE_EDGE_ID: tempMsg.writeUnsignedByte(TYPE_STRING); tempMsg.writeString(lane->getEdge().getID()); break; case VAR_LENGTH: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getLength()); break; case VAR_MAXSPEED: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getSpeedLimit()); break; case LANE_LINKS: { tempMsg.writeUnsignedByte(TYPE_COMPOUND); tcpip::Storage tempContent; unsigned int cnt = 0; tempContent.writeUnsignedByte(TYPE_INTEGER); const MSLinkCont& links = lane->getLinkCont(); tempContent.writeInt((int) links.size()); ++cnt; const SUMOTime currTime = MSNet::getInstance()->getCurrentTimeStep(); for (MSLinkCont::const_iterator i = links.begin(); i != links.end(); ++i) { MSLink* link = (*i); // approached non-internal lane (if any) tempContent.writeUnsignedByte(TYPE_STRING); tempContent.writeString(link->getLane() != 0 ? link->getLane()->getID() : ""); ++cnt; // approached "via", internal lane (if any) tempContent.writeUnsignedByte(TYPE_STRING); #ifdef HAVE_INTERNAL_LANES tempContent.writeString(link->getViaLane() != 0 ? link->getViaLane()->getID() : ""); #else tempContent.writeString(""); #endif ++cnt; // priority tempContent.writeUnsignedByte(TYPE_UBYTE); tempContent.writeUnsignedByte(link->havePriority() ? 1 : 0); ++cnt; // opened tempContent.writeUnsignedByte(TYPE_UBYTE); const SUMOReal speed = MIN2(lane->getSpeedLimit(), link->getLane()->getSpeedLimit()); tempContent.writeUnsignedByte(link->opened(currTime, speed, speed, DEFAULT_VEH_LENGTH, 0.0, DEFAULT_VEH_DECEL, 0) ? 1 : 0); ++cnt; // approaching foe tempContent.writeUnsignedByte(TYPE_UBYTE); tempContent.writeUnsignedByte(link->hasApproachingFoe(currTime, currTime, 0) ? 1 : 0); ++cnt; // state (not implemented, yet) tempContent.writeUnsignedByte(TYPE_STRING); tempContent.writeString(SUMOXMLDefinitions::LinkStates.getString(link->getState())); ++cnt; // direction tempContent.writeUnsignedByte(TYPE_STRING); tempContent.writeString(SUMOXMLDefinitions::LinkDirections.getString(link->getDirection())); ++cnt; // length tempContent.writeUnsignedByte(TYPE_DOUBLE); tempContent.writeDouble(link->getLength()); ++cnt; } tempMsg.writeInt((int) cnt); tempMsg.writeStorage(tempContent); } break; case LANE_ALLOWED: { tempMsg.writeUnsignedByte(TYPE_STRINGLIST); SVCPermissions permissions = lane->getPermissions(); if (permissions == SVCFreeForAll) { // special case: write nothing permissions = 0; } tempMsg.writeStringList(getAllowedVehicleClassNamesList(permissions)); } case LANE_DISALLOWED: { tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(getAllowedVehicleClassNamesList(~(lane->getPermissions()))); // negation yields disallowed } break; case VAR_SHAPE: tempMsg.writeUnsignedByte(TYPE_POLYGON); tempMsg.writeUnsignedByte((int)MIN2(static_cast<size_t>(255), lane->getShape().size())); for (unsigned int iPoint = 0; iPoint < MIN2(static_cast<size_t>(255), lane->getShape().size()); ++iPoint) { tempMsg.writeDouble(lane->getShape()[iPoint].x()); tempMsg.writeDouble(lane->getShape()[iPoint].y()); } break; case VAR_CO2EMISSION: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getCO2Emissions()); break; case VAR_COEMISSION: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getCOEmissions()); break; case VAR_HCEMISSION: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getHCEmissions()); break; case VAR_PMXEMISSION: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getPMxEmissions()); break; case VAR_NOXEMISSION: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getNOxEmissions()); break; case VAR_FUELCONSUMPTION: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getFuelConsumption()); break; case VAR_NOISEEMISSION: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getHarmonoise_NoiseEmissions()); break; case LAST_STEP_VEHICLE_NUMBER: tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt((int) lane->getVehicleNumber()); break; case LAST_STEP_MEAN_SPEED: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getMeanSpeed()); break; case LAST_STEP_VEHICLE_ID_LIST: { std::vector<std::string> vehIDs; const MSLane::VehCont& vehs = lane->getVehiclesSecure(); for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) { vehIDs.push_back((*j)->getID()); } lane->releaseVehicles(); tempMsg.writeUnsignedByte(TYPE_STRINGLIST); tempMsg.writeStringList(vehIDs); } break; case LAST_STEP_OCCUPANCY: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getNettoOccupancy()); break; case LAST_STEP_VEHICLE_HALTING_NUMBER: { int halting = 0; const MSLane::VehCont& vehs = lane->getVehiclesSecure(); for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) { if ((*j)->getSpeed() < SUMO_const_haltingSpeed) { ++halting; } } lane->releaseVehicles(); tempMsg.writeUnsignedByte(TYPE_INTEGER); tempMsg.writeInt(halting); } break; case LAST_STEP_LENGTH: { SUMOReal lengthSum = 0; const MSLane::VehCont& vehs = lane->getVehiclesSecure(); for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) { lengthSum += (*j)->getVehicleType().getLength(); } tempMsg.writeUnsignedByte(TYPE_DOUBLE); if (vehs.size() == 0) { tempMsg.writeDouble(0); } else { tempMsg.writeDouble(lengthSum / (SUMOReal) vehs.size()); } lane->releaseVehicles(); } break; case VAR_WAITING_TIME: { tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getWaitingSeconds()); } break; case VAR_CURRENT_TRAVELTIME: { SUMOReal meanSpeed = lane->getMeanSpeed(); tempMsg.writeUnsignedByte(TYPE_DOUBLE); if (meanSpeed != 0) { tempMsg.writeDouble(lane->getLength() / meanSpeed); } else { tempMsg.writeDouble(1000000.); } } break; case VAR_WIDTH: tempMsg.writeUnsignedByte(TYPE_DOUBLE); tempMsg.writeDouble(lane->getWidth()); break; default: break; } } server.writeStatusCmd(CMD_GET_LANE_VARIABLE, RTYPE_OK, "", outputStorage); server.writeResponseWithLength(outputStorage, tempMsg); return true; }