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; }
// =========================================================================== // 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; }
// =========================================================================== // 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; }
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::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; }
bool TraCIServer::readTypeCheckingUnsignedByte(tcpip::Storage& inputStorage, int& into) { if (inputStorage.readUnsignedByte() != TYPE_UBYTE) { return false; } into = inputStorage.readUnsignedByte(); 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; }
// =========================================================================== // 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; }
void TraCIServer::writeStatusCmd(int commandId, int status, const std::string& description, tcpip::Storage& outputStorage) { if (status == RTYPE_ERR) { WRITE_ERROR("Answered with error to command " + toString(commandId) + ": " + description); } else if (status == RTYPE_NOTIMPLEMENTED) { WRITE_ERROR("Requested command not implemented (" + toString(commandId) + "): " + description); } outputStorage.writeUnsignedByte(1 + 1 + 1 + 4 + static_cast<int>(description.length())); // command length outputStorage.writeUnsignedByte(commandId); // command type outputStorage.writeUnsignedByte(status); // status outputStorage.writeString(description); // description }
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::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; }
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_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; }
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_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; }
void Query::ReadSetResponse(tcpip::Storage & content) { // cout << endl << "Response to vehicle query: " << endl; int pos = content.position(); cout << "pos: " << pos << endl; int length = content.size(); cout << "length: " << length << endl; // int length2 = content.readUnsignedByte(); // cout << "length: " << length2 << endl; // int commandId = content.readUnsignedByte(); // cout << "command id : " << hex << commandId << endl; // int varId = content.readUnsignedByte(); // cout << "variable id: " << hex << varId << endl; // string vehicleId = content.readString(); // cout << "vehicle id: " << vehicleId << endl; // int variableType = content.readUnsignedByte(); // cout << "type: " << variableType << endl; // string variableStr; // int variableInt; // cout << "cmdid " << commandId; // double variableDouble; // switch (variableType) { // case TYPE_STRING: // variableStr = content.readString(); // break; // case TYPE_INTEGER: // variableInt = content.readInt(); // break; // case TYPE_DOUBLE: // variableDouble = content.readDouble(); // break; // } // // remember the result // switch (varId) { // case VAR_CURRENT_TRAVELTIME: // travelTime = variableDouble; // break; // case VAR_EDGE_TRAVELTIME: // travelTime = variableDouble; // break; // } }
void TraCIServer::writeResponseWithLength(tcpip::Storage& outputStorage, tcpip::Storage& tempMsg) { if (tempMsg.size() < 254) { outputStorage.writeUnsignedByte(1 + (int)tempMsg.size()); // command length -> short } else { outputStorage.writeUnsignedByte(0); // command length -> extended outputStorage.writeInt(1 + 4 + (int)tempMsg.size()); } outputStorage.writeStorage(tempMsg); }
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; }
// ---------- Conversion helper int SUMO_CLIENT::setValueTypeDependant(tcpip::Storage& into, std::ifstream& defFile, std::stringstream& msg) { std::string dataTypeS; defFile >> dataTypeS; if (dataTypeS == "<airDist>") { into.writeUnsignedByte(REQUEST_AIRDIST); return 1; } else if (dataTypeS == "<drivingDist>") { into.writeUnsignedByte(REQUEST_DRIVINGDIST); return 1; } else if (dataTypeS == "<objSubscription>") { int beginTime, endTime, numVars; defFile >> beginTime >> endTime >> numVars; into.writeInt(beginTime); into.writeInt(endTime); into.writeInt(numVars); for (int i = 0; i < numVars; ++i) { int var; defFile >> var; into.writeUnsignedByte(var); } return 4 + 4 + 4 + numVars; }
//---------------------------------------------------------------------------- Command::Command(tcpip::Storage& storageP, size_t* sizeP) //---------------------------------------------------------------------------- { Storage(); m_is_data_written = false; if (*sizeP >= 7) { m_equipment_type = storageP.readChar(); m_equipment_id = storageP.readChar(); m_action = storageP.readChar(); m_object_type = storageP.readChar(); m_object_id = storageP.readChar(); this->writeChar(m_equipment_type); this->writeChar(m_equipment_id); this->writeChar(m_action); this->writeChar(m_object_type); this->writeChar(m_object_id); unsigned short size = storageP.readShort(); this->writeShort(size); *sizeP = *sizeP - 7; if (size > 0) { if (*sizeP >= size) { for (int i = 0; i < size ; i++) { this->writeChar(storageP.readChar()); } } else { throw command_deserialize_length_error(); } *sizeP = *sizeP - size; } m_is_data_written = true; } else { throw command_deserialize_length_error(); } }
bool SUMO_CLIENT::validateSimulationStep2(tcpip::Storage& inMsg) { try { int noSubscriptions = inMsg.readInt(); for (int s = 0; s < noSubscriptions; ++s) { if (!validateSubscription(inMsg)) { return false; } } } catch (std::invalid_argument& e) { answerLog << "#Error while reading message:" << e.what() << std::endl; return false; } return true; }
// =========================================================================== // 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; }
void TraCIServerAPI_Simulation::writeVehicleStateIDs(TraCIServer& server, tcpip::Storage& outputStorage, MSNet::VehicleState state) { const std::vector<std::string>& ids = server.getVehicleStateChanges().find(state)->second; outputStorage.writeUnsignedByte(TYPE_STRINGLIST); outputStorage.writeStringList(ids); }