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;
}
// ===========================================================================
// 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;
}
// ===========================================================================
// 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_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;
}
// ===========================================================================
// 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) {
server.writeStatusCmd(CMD_GET_ROUTE_VARIABLE, RTYPE_ERR, "Get Route Variable: unsupported variable specified", outputStorage);
return false;
}
// 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) {
server.writeStatusCmd(CMD_GET_ROUTE_VARIABLE, RTYPE_ERR, "Route '" + id + "' is not known", outputStorage);
return false;
}
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;
default:
break;
}
}
server.writeStatusCmd(CMD_GET_ROUTE_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_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;
}
// ===========================================================================
// 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) {
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_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;
}
bool
TraCIServerAPI_TLS::processSet(TraCIServer& server, tcpip::Storage& inputStorage,
tcpip::Storage& outputStorage) {
std::string warning = ""; // additional description for response
// variable
int variable = inputStorage.readUnsignedByte();
if (variable != TL_PHASE_INDEX && variable != TL_PROGRAM
&& variable != TL_PHASE_DURATION && variable != TL_RED_YELLOW_GREEN_STATE && variable != TL_COMPLETE_PROGRAM_RYG) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "Change TLS State: unsupported variable specified", outputStorage);
return false;
}
std::string id = inputStorage.readString();
if (!MSNet::getInstance()->getTLSControl().knows(id)) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "Traffic light '" + id + "' is not known", outputStorage);
return false;
}
MSTLLogicControl& tlsControl = MSNet::getInstance()->getTLSControl();
SUMOTime cTime = MSNet::getInstance()->getCurrentTimeStep();
MSTLLogicControl::TLSLogicVariants& vars = tlsControl.get(id);
int valueDataType = inputStorage.readUnsignedByte();
switch (variable) {
case TL_PHASE_INDEX: {
if (valueDataType != TYPE_INTEGER) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "The phase index must be given as an integer.", outputStorage);
return false;
}
int index = inputStorage.readInt();
if (index < 0 || vars.getActive()->getPhaseNumber() <= (unsigned int)index) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "The phase index is not in the allowed range.", outputStorage);
return false;
}
int duration = vars.getActive()->getPhase(index).duration;
vars.getActive()->changeStepAndDuration(tlsControl, cTime, index, duration);
}
break;
case TL_PROGRAM: {
if (valueDataType != TYPE_STRING) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "The program must be given as a string.", outputStorage);
return false;
}
std::string subID = inputStorage.readString();
try {
vars.switchTo(tlsControl, subID);
} catch (ProcessError& e) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, e.what(), outputStorage);
return false;
}
}
break;
case TL_PHASE_DURATION: {
if (valueDataType != TYPE_INTEGER) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "The phase duration must be given as an integer.", outputStorage);
return false;
}
int duration = inputStorage.readInt();
int index = vars.getActive()->getCurrentPhaseIndex();
vars.getActive()->changeStepAndDuration(tlsControl, cTime, index, duration);
}
break;
case TL_RED_YELLOW_GREEN_STATE: {
if (valueDataType != TYPE_STRING) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "The phase must be given as a string.", outputStorage);
return false;
}
// build only once...
std::string state = inputStorage.readString();
if (vars.getLogic("online") == 0) {
MSPhaseDefinition* phase = new MSPhaseDefinition(DELTA_T, state);
std::vector<MSPhaseDefinition*> phases;
phases.push_back(phase);
MSTrafficLightLogic* logic = new MSSimpleTrafficLightLogic(tlsControl, id, "online", phases, 0, cTime + DELTA_T);
vars.addLogic("online", logic, true, true);
} else {
MSPhaseDefinition nphase(DELTA_T, state);
*(static_cast<MSSimpleTrafficLightLogic*>(vars.getLogic("online"))->getPhases()[0]) = nphase;
}
// @note: this assumes logic "online" is still active
vars.getActive()->setTrafficLightSignals(MSNet::getInstance()->getCurrentTimeStep());
vars.executeOnSwitchActions();
}
break;
case TL_COMPLETE_PROGRAM_RYG: {
if (valueDataType != TYPE_COMPOUND) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "A compound object is needed for setting a new program.", outputStorage);
return false;
}
//read itemNo
inputStorage.readInt();
if (inputStorage.readUnsignedByte() != TYPE_STRING) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 1. parameter (subid) must be a string.", outputStorage);
return false;
}
std::string subid = inputStorage.readString();
if (inputStorage.readUnsignedByte() != TYPE_INTEGER) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 2. parameter (type) must be an int.", outputStorage);
return false;
}
//read type
inputStorage.readInt();
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 3. parameter (subparams) must be a compound object.", outputStorage);
return false;
}
//read sublength
inputStorage.readInt();
if (inputStorage.readUnsignedByte() != TYPE_INTEGER) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 4. parameter (index) must be an int.", outputStorage);
return false;
}
int index = inputStorage.readInt();
if (inputStorage.readUnsignedByte() != TYPE_INTEGER) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 5. parameter (phase number) must be an int.", outputStorage);
return false;
}
int phaseNo = inputStorage.readInt();
// make sure index and phaseNo are consistent
if (index >= phaseNo) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 4/5. parameter (index) must be less than parameter (phase number).", outputStorage);
return false;
}
std::vector<MSPhaseDefinition*> phases;
for (int j = 0; j < phaseNo; ++j) {
if (inputStorage.readUnsignedByte() != TYPE_INTEGER) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 6.1. parameter (duration) must be an int.", outputStorage);
return false;
}
int duration = inputStorage.readInt();
if (inputStorage.readUnsignedByte() != TYPE_INTEGER) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 6.2. parameter (min duration) must be an int.", outputStorage);
return false;
}
int minDuration = inputStorage.readInt();
if (inputStorage.readUnsignedByte() != TYPE_INTEGER) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 6.3. parameter (max duration) must be an int.", outputStorage);
return false;
}
int maxDuration = inputStorage.readInt();
if (inputStorage.readUnsignedByte() != TYPE_STRING) {
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_ERR, "set program: 6.4. parameter (phase) must be a string.", outputStorage);
return false;
}
std::string state = inputStorage.readString();
MSPhaseDefinition* phase = new MSPhaseDefinition(duration, minDuration, maxDuration, state);
phases.push_back(phase);
}
if (vars.getLogic(subid) == 0) {
MSTrafficLightLogic* logic = new MSSimpleTrafficLightLogic(tlsControl, id, subid, phases, index, 0);
vars.addLogic(subid, logic, true, true);
} else {
static_cast<MSSimpleTrafficLightLogic*>(vars.getLogic(subid))->setPhases(phases, index);
}
vars.getActive()->setTrafficLightSignals(MSNet::getInstance()->getCurrentTimeStep());
vars.executeOnSwitchActions();
}
break;
default:
break;
}
server.writeStatusCmd(CMD_SET_TL_VARIABLE, RTYPE_OK, warning, outputStorage);
return true;
}
// ===========================================================================
// method definitions
// ===========================================================================
bool
TraCIServerAPI_Simulation::processGet(TraCIServer& server, tcpip::Storage& inputStorage,
tcpip::Storage& outputStorage) {
const int variable = inputStorage.readUnsignedByte();
const std::string id = inputStorage.readString();
server.initWrapper(RESPONSE_GET_SIM_VARIABLE, variable, id);
try {
switch (variable) {
case VAR_TIME:
server.getWrapperStorage().writeUnsignedByte(TYPE_DOUBLE);
server.getWrapperStorage().writeDouble(SIMTIME);
break;
case VAR_TIME_STEP:
server.getWrapperStorage().writeUnsignedByte(TYPE_INTEGER);
server.getWrapperStorage().writeInt((int)libsumo::Simulation::getCurrentTime());
break;
case VAR_LOADED_VEHICLES_NUMBER:
writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_BUILT);
break;
case VAR_LOADED_VEHICLES_IDS:
writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_BUILT);
break;
case VAR_DEPARTED_VEHICLES_NUMBER:
writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_DEPARTED);
break;
case VAR_DEPARTED_VEHICLES_IDS:
writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_DEPARTED);
break;
case VAR_TELEPORT_STARTING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_STARTING_TELEPORT);
break;
case VAR_TELEPORT_STARTING_VEHICLES_IDS:
writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_STARTING_TELEPORT);
break;
case VAR_TELEPORT_ENDING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ENDING_TELEPORT);
break;
case VAR_TELEPORT_ENDING_VEHICLES_IDS:
writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ENDING_TELEPORT);
break;
case VAR_ARRIVED_VEHICLES_NUMBER:
writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ARRIVED);
break;
case VAR_ARRIVED_VEHICLES_IDS:
writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ARRIVED);
break;
case VAR_PARKING_STARTING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_STARTING_PARKING);
break;
case VAR_PARKING_STARTING_VEHICLES_IDS:
writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_STARTING_PARKING);
break;
case VAR_PARKING_ENDING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ENDING_PARKING);
break;
case VAR_PARKING_ENDING_VEHICLES_IDS:
writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ENDING_PARKING);
break;
case VAR_STOP_STARTING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_STARTING_STOP);
break;
case VAR_STOP_STARTING_VEHICLES_IDS:
writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_STARTING_STOP);
break;
case VAR_STOP_ENDING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ENDING_STOP);
break;
case VAR_STOP_ENDING_VEHICLES_IDS:
writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_ENDING_STOP);
break;
case VAR_COLLIDING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_COLLISION);
break;
case VAR_COLLIDING_VEHICLES_IDS:
writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_COLLISION);
break;
case VAR_EMERGENCYSTOPPING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_EMERGENCYSTOP);
break;
case VAR_EMERGENCYSTOPPING_VEHICLES_IDS:
writeVehicleStateIDs(server, server.getWrapperStorage(), MSNet::VEHICLE_STATE_EMERGENCYSTOP);
break;
case VAR_DELTA_T:
server.getWrapperStorage().writeUnsignedByte(TYPE_INTEGER);
server.getWrapperStorage().writeInt((int)libsumo::Simulation::getDeltaT());
break;
case VAR_MIN_EXPECTED_VEHICLES:
server.getWrapperStorage().writeUnsignedByte(TYPE_INTEGER);
server.getWrapperStorage().writeInt(libsumo::Simulation::getMinExpectedNumber());
break;
case VAR_BUS_STOP_WAITING:
server.getWrapperStorage().writeUnsignedByte(TYPE_INTEGER);
server.getWrapperStorage().writeInt(libsumo::Simulation::getBusStopWaiting(id));
break;
case VAR_NET_BOUNDING_BOX: {
server.getWrapperStorage().writeUnsignedByte(TYPE_POLYGON);
libsumo::TraCIPositionVector tb = libsumo::Simulation::getNetBoundary();
server.getWrapperStorage().writeByte(2);
server.getWrapperStorage().writeDouble(tb[0].x);
server.getWrapperStorage().writeDouble(tb[0].y);
server.getWrapperStorage().writeDouble(tb[1].x);
server.getWrapperStorage().writeDouble(tb[1].y);
break;
}
case POSITION_CONVERSION:
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Position conversion requires a compound object.", outputStorage);
}
if (inputStorage.readInt() != 2) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Position conversion requires a source position and a position type as parameter.", outputStorage);
}
if (!commandPositionConversion(server, inputStorage, server.getWrapperStorage(), CMD_GET_SIM_VARIABLE)) {
return false;
}
break;
case DISTANCE_REQUEST:
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of distance requires a compound object.", outputStorage);
}
if (inputStorage.readInt() != 3) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of distance requires two positions and a distance type as parameter.", outputStorage);
}
if (!commandDistanceRequest(server, inputStorage, server.getWrapperStorage(), CMD_GET_SIM_VARIABLE)) {
return false;
}
break;
case FIND_ROUTE: {
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a compound object.", outputStorage);
}
if (inputStorage.readInt() != 5) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires five parameter.", outputStorage);
}
std::string from, to, vtype;
double depart;
int routingMode;
if (!server.readTypeCheckingString(inputStorage, from)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as first parameter.", outputStorage);
}
if (!server.readTypeCheckingString(inputStorage, to)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as second parameter.", outputStorage);
}
if (!server.readTypeCheckingString(inputStorage, vtype)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as third parameter.", outputStorage);
}
if (!server.readTypeCheckingDouble(inputStorage, depart)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as fourth parameter.", outputStorage);
}
if (!server.readTypeCheckingInt(inputStorage, routingMode)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires an integer as fifth parameter.", outputStorage);
}
writeStage(server.getWrapperStorage(), libsumo::Simulation::findRoute(from, to, vtype, TIME2STEPS(depart), routingMode));
break;
}
case FIND_INTERMODAL_ROUTE: {
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of an intermodal route requires a compound object.", outputStorage);
}
if (inputStorage.readInt() != 13) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of an intermodal route requires thirteen parameters.", outputStorage);
}
std::string from, to, modes, ptype, vtype, destStop;
double depart, speed, walkFactor, departPos, arrivalPos, departPosLat;
int routingMode;
if (!server.readTypeCheckingString(inputStorage, from)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as first parameter.", outputStorage);
}
if (!server.readTypeCheckingString(inputStorage, to)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as second parameter.", outputStorage);
}
if (!server.readTypeCheckingString(inputStorage, modes)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as third parameter.", outputStorage);
}
if (!server.readTypeCheckingDouble(inputStorage, depart)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as fourth parameter.", outputStorage);
}
if (!server.readTypeCheckingInt(inputStorage, routingMode)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires an integer as fifth parameter.", outputStorage);
}
if (!server.readTypeCheckingDouble(inputStorage, speed)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as sixth parameter.", outputStorage);
}
if (!server.readTypeCheckingDouble(inputStorage, walkFactor)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as seventh parameter.", outputStorage);
}
if (!server.readTypeCheckingDouble(inputStorage, departPos)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as eigth parameter.", outputStorage);
}
if (!server.readTypeCheckingDouble(inputStorage, arrivalPos)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as nineth parameter.", outputStorage);
}
if (!server.readTypeCheckingDouble(inputStorage, departPosLat)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a double as tenth parameter.", outputStorage);
}
if (!server.readTypeCheckingString(inputStorage, ptype)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as eleventh parameter.", outputStorage);
}
if (!server.readTypeCheckingString(inputStorage, vtype)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as twelvth parameter.", outputStorage);
}
if (!server.readTypeCheckingString(inputStorage, destStop)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a route requires a string as thirteenth parameter.", outputStorage);
}
const std::vector<libsumo::TraCIStage> result = libsumo::Simulation::findIntermodalRoute(from, to, modes, TIME2STEPS(depart), routingMode, speed, walkFactor, departPos, arrivalPos, departPosLat, ptype, vtype, destStop);
server.getWrapperStorage().writeUnsignedByte(TYPE_COMPOUND);
server.getWrapperStorage().writeInt((int)result.size());
for (const libsumo::TraCIStage s : result) {
writeStage(server.getWrapperStorage(), s);
}
break;
}
case VAR_PARAMETER: {
std::string paramName = "";
if (!server.readTypeCheckingString(inputStorage, paramName)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of a parameter requires its name.", outputStorage);
}
server.getWrapperStorage().writeUnsignedByte(TYPE_STRING);
server.getWrapperStorage().writeString(libsumo::Simulation::getParameter(id, paramName));
break;
}
default:
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Get Simulation Variable: unsupported variable " + toHex(variable, 2) + " specified", outputStorage);
}
} catch (libsumo::TraCIException& e) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, e.what(), outputStorage);
}
server.writeStatusCmd(CMD_GET_SIM_VARIABLE, RTYPE_OK, "", outputStorage);
server.writeResponseWithLength(outputStorage, server.getWrapperStorage());
return true;
}
bool
TraCIServerAPI_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;
}
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);
}
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_TLS::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 != TL_RED_YELLOW_GREEN_STATE && variable != TL_COMPLETE_DEFINITION_RYG
&& variable != TL_CONTROLLED_LANES && variable != TL_CONTROLLED_LINKS
&& variable != TL_CURRENT_PHASE && variable != TL_CURRENT_PROGRAM
&& variable != TL_NEXT_SWITCH && variable != TL_PHASE_DURATION && variable != ID_COUNT) {
server.writeStatusCmd(CMD_GET_TL_VARIABLE, RTYPE_ERR, "Get TLS Variable: unsupported variable specified", outputStorage);
return false;
}
// begin response building
tcpip::Storage tempMsg;
// response-code, variableID, objectID
tempMsg.writeUnsignedByte(RESPONSE_GET_TL_VARIABLE);
tempMsg.writeUnsignedByte(variable);
tempMsg.writeString(id);
if (variable == ID_LIST) {
std::vector<std::string> ids = MSNet::getInstance()->getTLSControl().getAllTLIds();
tempMsg.writeUnsignedByte(TYPE_STRINGLIST);
tempMsg.writeStringList(ids);
} else if (variable == ID_COUNT) {
std::vector<std::string> ids = MSNet::getInstance()->getTLSControl().getAllTLIds();
tempMsg.writeUnsignedByte(TYPE_INTEGER);
tempMsg.writeInt((int) ids.size());
} else {
if (!MSNet::getInstance()->getTLSControl().knows(id)) {
server.writeStatusCmd(CMD_GET_TL_VARIABLE, RTYPE_ERR, "Traffic light '" + id + "' is not known", outputStorage);
return false;
}
MSTLLogicControl::TLSLogicVariants& vars = MSNet::getInstance()->getTLSControl().get(id);
switch (variable) {
case ID_LIST:
break;
case TL_RED_YELLOW_GREEN_STATE: {
tempMsg.writeUnsignedByte(TYPE_STRING);
std::string state = vars.getActive()->getCurrentPhaseDef().getState();
tempMsg.writeString(state);
}
break;
case TL_COMPLETE_DEFINITION_RYG: {
std::vector<MSTrafficLightLogic*> logics = vars.getAllLogics();
tempMsg.writeUnsignedByte(TYPE_COMPOUND);
tcpip::Storage tempContent;
unsigned int cnt = 0;
tempContent.writeUnsignedByte(TYPE_INTEGER);
tempContent.writeInt((int) logics.size());
++cnt;
for (unsigned int i = 0; i < logics.size(); ++i) {
MSTrafficLightLogic* logic = logics[i];
tempContent.writeUnsignedByte(TYPE_STRING);
tempContent.writeString(logic->getProgramID());
++cnt;
// type (always 0 by now)
tempContent.writeUnsignedByte(TYPE_INTEGER);
tempContent.writeInt(0);
++cnt;
// subparameter (always 0 by now)
tempContent.writeUnsignedByte(TYPE_COMPOUND);
tempContent.writeInt(0);
++cnt;
// (current) phase index
tempContent.writeUnsignedByte(TYPE_INTEGER);
tempContent.writeInt((int) logic->getCurrentPhaseIndex());
++cnt;
// phase number
unsigned int phaseNo = logic->getPhaseNumber();
tempContent.writeUnsignedByte(TYPE_INTEGER);
tempContent.writeInt((int) phaseNo);
++cnt;
for (unsigned int j = 0; j < phaseNo; ++j) {
MSPhaseDefinition phase = logic->getPhase(j);
tempContent.writeUnsignedByte(TYPE_INTEGER);
tempContent.writeInt(phase.duration);
++cnt;
tempContent.writeUnsignedByte(TYPE_INTEGER);
tempContent.writeInt(phase.minDuration);
++cnt; // not implemented
tempContent.writeUnsignedByte(TYPE_INTEGER);
tempContent.writeInt(phase.maxDuration);
++cnt; // not implemented
const std::string& state = phase.getState();
//unsigned int linkNo = (unsigned int)(vars.getActive()->getLinks().size());
tempContent.writeUnsignedByte(TYPE_STRING);
tempContent.writeString(state);
++cnt;
}
}
tempMsg.writeInt((int) cnt);
tempMsg.writeStorage(tempContent);
}
break;
case TL_CONTROLLED_LANES: {
const MSTrafficLightLogic::LaneVectorVector& lanes = vars.getActive()->getLanes();
tempMsg.writeUnsignedByte(TYPE_STRINGLIST);
std::vector<std::string> laneIDs;
for (MSTrafficLightLogic::LaneVectorVector::const_iterator i = lanes.begin(); i != lanes.end(); ++i) {
const MSTrafficLightLogic::LaneVector& llanes = (*i);
for (MSTrafficLightLogic::LaneVector::const_iterator j = llanes.begin(); j != llanes.end(); ++j) {
laneIDs.push_back((*j)->getID());
}
}
tempMsg.writeStringList(laneIDs);
}
break;
case TL_CONTROLLED_LINKS: {
const MSTrafficLightLogic::LaneVectorVector& lanes = vars.getActive()->getLanes();
const MSTrafficLightLogic::LinkVectorVector& links = vars.getActive()->getLinks();
//
tempMsg.writeUnsignedByte(TYPE_COMPOUND);
tcpip::Storage tempContent;
unsigned int cnt = 0;
tempContent.writeUnsignedByte(TYPE_INTEGER);
unsigned int no = (unsigned int) lanes.size();
tempContent.writeInt((int) no);
for (unsigned int i = 0; i < no; ++i) {
const MSTrafficLightLogic::LaneVector& llanes = lanes[i];
const MSTrafficLightLogic::LinkVector& llinks = links[i];
// number of links controlled by this signal (signal i)
tempContent.writeUnsignedByte(TYPE_INTEGER);
unsigned int no2 = (unsigned int) llanes.size();
tempContent.writeInt((int) no2);
++cnt;
for (unsigned int j = 0; j < no2; ++j) {
MSLink* link = llinks[j];
std::vector<std::string> def;
// incoming lane
def.push_back(llanes[j]->getID());
// approached non-internal lane (if any)
def.push_back(link->getLane() != 0 ? link->getLane()->getID() : "");
// approached "via", internal lane (if any)
#ifdef HAVE_INTERNAL_LANES
def.push_back(link->getViaLane() != 0 ? link->getViaLane()->getID() : "");
#else
def.push_back("");
#endif
tempContent.writeUnsignedByte(TYPE_STRINGLIST);
tempContent.writeStringList(def);
++cnt;
}
}
tempMsg.writeInt((int) cnt);
tempMsg.writeStorage(tempContent);
}
break;
case TL_CURRENT_PHASE:
tempMsg.writeUnsignedByte(TYPE_INTEGER);
tempMsg.writeInt((int) vars.getActive()->getCurrentPhaseIndex());
break;
case TL_CURRENT_PROGRAM:
tempMsg.writeUnsignedByte(TYPE_STRING);
tempMsg.writeString(vars.getActive()->getProgramID());
break;
case TL_PHASE_DURATION:
tempMsg.writeUnsignedByte(TYPE_INTEGER);
tempMsg.writeInt((int) vars.getActive()->getCurrentPhaseDef().duration);
break;
case TL_NEXT_SWITCH:
tempMsg.writeUnsignedByte(TYPE_INTEGER);
tempMsg.writeInt((int) vars.getActive()->getNextSwitchTime());
break;
case TL_CONTROLLED_JUNCTIONS: {
}
break;
default:
break;
}
}
server.writeStatusCmd(CMD_GET_TL_VARIABLE, RTYPE_OK, "", outputStorage);
server.writeResponseWithLength(outputStorage, tempMsg);
return true;
}
bool
TraCIServerAPI_Polygon::processSet(TraCIServer& server, tcpip::Storage& inputStorage,
tcpip::Storage& outputStorage) {
std::string warning = ""; // additional description for response
// variable
int variable = inputStorage.readUnsignedByte();
if (variable != VAR_TYPE && variable != VAR_COLOR && variable != VAR_SHAPE && variable != VAR_FILL
&& variable != ADD && variable != REMOVE) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "Change Polygon State: unsupported variable specified", outputStorage);
}
// id
std::string id = inputStorage.readString();
Polygon* p = 0;
ShapeContainer& shapeCont = MSNet::getInstance()->getShapeContainer();
if (variable != ADD && variable != REMOVE) {
p = getPolygon(id);
if (p == 0) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "Polygon '" + id + "' is not known", outputStorage);
}
}
// process
switch (variable) {
case VAR_TYPE: {
std::string type;
if (!server.readTypeCheckingString(inputStorage, type)) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The type must be given as a string.", outputStorage);
}
p->setType(type);
}
break;
case VAR_COLOR: {
RGBColor col;
if (!server.readTypeCheckingColor(inputStorage, col)) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The color must be given using an according type.", outputStorage);
}
p->setColor(col);
}
break;
case VAR_SHAPE: {
PositionVector shape;
if (!server.readTypeCheckingPolygon(inputStorage, shape)) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The shape must be given using an accoring type.", outputStorage);
}
shapeCont.reshapePolygon(id, shape);
}
break;
case VAR_FILL: {
int value = 0;
if (!server.readTypeCheckingUnsignedByte(inputStorage, value)) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "'fill' must be defined using an unsigned byte.", outputStorage);
}
p->setFill(value != 0);
}
break;
case ADD: {
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "A compound object is needed for setting a new polygon.", outputStorage);
}
//readt itemNo
inputStorage.readInt();
std::string type;
if (!server.readTypeCheckingString(inputStorage, type)) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The type must be given as a string.", outputStorage);
}
RGBColor col;
if (!server.readTypeCheckingColor(inputStorage, col)) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The second polygon parameter must be the color.", outputStorage);
}
int value = 0;
if (!server.readTypeCheckingUnsignedByte(inputStorage, value)) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The third polygon parameter must be 'fill' encoded as ubyte.", outputStorage);
}
bool fill = value != 0;
int layer = 0;
if (!server.readTypeCheckingInt(inputStorage, layer)) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The fourth polygon parameter must be the layer encoded as int.", outputStorage);
}
PositionVector shape;
if (!server.readTypeCheckingPolygon(inputStorage, shape)) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The fifth polygon parameter must be the shape.", outputStorage);
}
//
if (!shapeCont.addPolygon(id, type, col, (SUMOReal)layer,
Shape::DEFAULT_ANGLE, Shape::DEFAULT_IMG_FILE, shape, fill)) {
delete p;
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "Could not add polygon.", outputStorage);
}
}
break;
case REMOVE: {
int layer = 0; // !!! layer not used yet (shouldn't the id be enough?)
if (!server.readTypeCheckingInt(inputStorage, layer)) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "The layer must be given using an int.", outputStorage);
}
if (!shapeCont.removePolygon(id)) {
return server.writeErrorStatusCmd(CMD_SET_POLYGON_VARIABLE, "Could not remove polygon '" + id + "'", outputStorage);
}
}
break;
default:
break;
}
server.writeStatusCmd(CMD_SET_POLYGON_VARIABLE, RTYPE_OK, warning, outputStorage);
return true;
}
// ===========================================================================
// method definitions
// ===========================================================================
bool
TraCIServerAPI_Polygon::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_SHAPE && variable != VAR_FILL
&& variable != ID_COUNT) {
return server.writeErrorStatusCmd(CMD_GET_POLYGON_VARIABLE, "Get Polygon Variable: unsupported variable specified", outputStorage);
}
// begin response building
tcpip::Storage tempMsg;
// response-code, variableID, objectID
tempMsg.writeUnsignedByte(RESPONSE_GET_POLYGON_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.getPolygons().insertIDs(ids);
if (variable == ID_LIST) {
tempMsg.writeUnsignedByte(TYPE_STRINGLIST);
tempMsg.writeStringList(ids);
} else {
tempMsg.writeUnsignedByte(TYPE_INTEGER);
tempMsg.writeInt((int) ids.size());
}
} else {
Polygon* p = getPolygon(id);
if (p == 0) {
return server.writeErrorStatusCmd(CMD_GET_POLYGON_VARIABLE, "Polygon '" + 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_SHAPE:
tempMsg.writeUnsignedByte(TYPE_POLYGON);
tempMsg.writeUnsignedByte(MIN2(static_cast<int>(255), static_cast<int>(p->getShape().size())));
for (unsigned int iPoint = 0; iPoint < MIN2(static_cast<size_t>(255), p->getShape().size()); ++iPoint) {
tempMsg.writeDouble(p->getShape()[iPoint].x());
tempMsg.writeDouble(p->getShape()[iPoint].y());
}
break;
case VAR_FILL:
tempMsg.writeUnsignedByte(TYPE_UBYTE);
tempMsg.writeUnsignedByte(p->getFill() ? 1 : 0);
break;
default:
break;
}
}
server.writeStatusCmd(CMD_GET_POLYGON_VARIABLE, RTYPE_OK, "", outputStorage);
server.writeResponseWithLength(outputStorage, tempMsg);
return true;
}
bool
TraCIServerAPI_POI::processSet(TraCIServer& server, tcpip::Storage& inputStorage,
tcpip::Storage& outputStorage) {
std::string warning = ""; // additional description for response
// variable
int variable = inputStorage.readUnsignedByte();
if (variable != VAR_TYPE && variable != VAR_COLOR && variable != VAR_POSITION
&& variable != ADD && variable != REMOVE) {
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "Change PoI State: unsupported variable specified", outputStorage);
}
// id
std::string id = inputStorage.readString();
PointOfInterest* p = 0;
ShapeContainer& shapeCont = MSNet::getInstance()->getShapeContainer();
if (variable != ADD && variable != REMOVE) {
p = getPoI(id);
if (p == 0) {
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "POI '" + id + "' is not known", outputStorage);
}
}
// process
switch (variable) {
case VAR_TYPE: {
std::string type;
if (!server.readTypeCheckingString(inputStorage, type)) {
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The type must be given as a string.", outputStorage);
}
p->setType(type);
}
break;
case VAR_COLOR: {
RGBColor col;
if (!server.readTypeCheckingColor(inputStorage, col)) {
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The color must be given using an according type.", outputStorage);
}
p->setColor(col);
}
break;
case VAR_POSITION: {
Position pos;
if (!server.readTypeCheckingPosition2D(inputStorage, pos)) {
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The position must be given using an accoring type.", outputStorage);
}
shapeCont.movePOI(id, pos);
}
break;
case ADD: {
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "A compound object is needed for setting a new PoI.", outputStorage);
}
//read itemNo
inputStorage.readInt();
std::string type;
if (!server.readTypeCheckingString(inputStorage, type)) {
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The first PoI parameter must be the type encoded as a string.", outputStorage);
}
RGBColor col;
if (!server.readTypeCheckingColor(inputStorage, col)) {
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The second PoI parameter must be the color.", outputStorage);
}
int layer = 0;
if (!server.readTypeCheckingInt(inputStorage, layer)) {
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The third PoI parameter must be the layer encoded as int.", outputStorage);
}
Position pos;
if (!server.readTypeCheckingPosition2D(inputStorage, pos)) {
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The fourth PoI parameter must be the position.", outputStorage);
}
//
if (!shapeCont.addPOI(id, type, col, (SUMOReal)layer,
Shape::DEFAULT_ANGLE, Shape::DEFAULT_IMG_FILE, pos,
Shape::DEFAULT_IMG_WIDTH, Shape::DEFAULT_IMG_HEIGHT)) {
delete p;
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "Could not add PoI.", outputStorage);
}
}
break;
case REMOVE: {
int layer = 0; // !!! layer not used yet (shouldn't the id be enough?)
if (!server.readTypeCheckingInt(inputStorage, layer)) {
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "The layer must be given using an int.", outputStorage);
}
if (!shapeCont.removePOI(id)) {
return server.writeErrorStatusCmd(CMD_SET_POI_VARIABLE, "Could not remove PoI '" + id + "'", outputStorage);
}
}
break;
default:
break;
}
server.writeStatusCmd(CMD_SET_POI_VARIABLE, RTYPE_OK, warning, outputStorage);
return true;
}
bool
TraCIServerAPI_Route::processSet(TraCIServer& server, tcpip::Storage& inputStorage,
tcpip::Storage& outputStorage) {
std::string warning = ""; // additional description for response
// variable
int variable = inputStorage.readUnsignedByte();
if (variable != ADD && variable != VAR_PARAMETER) {
return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "Change Route State: unsupported variable " + toHex(variable, 2) + " specified", outputStorage);
}
// id
std::string id = inputStorage.readString();
const MSRoute* r = 0;
if (variable != ADD) {
r = MSRoute::dictionary(id);
if (r == 0) {
return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "Route '" + id + "' is not known", outputStorage);
}
}
// process
switch (variable) {
case ADD: {
std::vector<std::string> edgeIDs;
if (!server.readTypeCheckingStringList(inputStorage, edgeIDs)) {
return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "A string list is needed for adding a new route.", outputStorage);
}
//read itemNo
ConstMSEdgeVector edges;
for (std::vector<std::string>::const_iterator i = edgeIDs.begin(); i != edgeIDs.end(); ++i) {
MSEdge* edge = MSEdge::dictionary(*i);
if (edge == 0) {
return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "Unknown edge '" + *i + "' in route.", outputStorage);
}
edges.push_back(edge);
}
const std::vector<SUMOVehicleParameter::Stop> stops;
if (!MSRoute::dictionary(id, new MSRoute(id, edges, true, 0, stops))) {
return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "Could not add route.", outputStorage);
}
}
break;
case VAR_PARAMETER: {
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "A compound object is needed for setting a parameter.", outputStorage);
}
//readt itemNo
inputStorage.readInt();
std::string name;
if (!server.readTypeCheckingString(inputStorage, name)) {
return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "The name of the parameter must be given as a string.", outputStorage);
}
std::string value;
if (!server.readTypeCheckingString(inputStorage, value)) {
return server.writeErrorStatusCmd(CMD_SET_ROUTE_VARIABLE, "The value of the parameter must be given as a string.", outputStorage);
}
((MSRoute*) r)->addParameter(name, value);
}
break;
default:
break;
}
server.writeStatusCmd(CMD_SET_ROUTE_VARIABLE, RTYPE_OK, warning, outputStorage);
return true;
}
void
TraCIServerAPI_Simulation::writeVehicleStateNumber(TraCIServer& server, tcpip::Storage& outputStorage, MSNet::VehicleState state) {
const std::vector<std::string>& ids = server.getVehicleStateChanges().find(state)->second;
outputStorage.writeUnsignedByte(TYPE_INTEGER);
outputStorage.writeInt((int) ids.size());
}
// ===========================================================================
// 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;
}
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;
}
bool
TraCIServerAPI_Edge::processSet(TraCIServer& server, tcpip::Storage& inputStorage,
tcpip::Storage& outputStorage) {
std::string warning = ""; // additional description for response
// variable
int variable = inputStorage.readUnsignedByte();
if (variable != VAR_EDGE_TRAVELTIME && variable != VAR_EDGE_EFFORT && variable != VAR_MAXSPEED && variable != VAR_PARAMETER) {
return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "Change Edge State: unsupported variable " + toHex(variable, 2) + " specified", outputStorage);
}
// id
std::string id = inputStorage.readString();
MSEdge* e = MSEdge::dictionary(id);
if (e == 0) {
return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "Edge '" + id + "' is not known", outputStorage);
}
// process
switch (variable) {
case LANE_ALLOWED: {
// read and set allowed vehicle classes
std::vector<std::string> classes;
if (!server.readTypeCheckingStringList(inputStorage, classes)) {
return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "Allowed vehicle classes must be given as a list of strings.", outputStorage);
}
SVCPermissions permissions = parseVehicleClasses(classes);
const std::vector<MSLane*>& lanes = e->getLanes();
for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) {
(*i)->setPermissions(permissions);
}
e->rebuildAllowedLanes();
}
break;
case LANE_DISALLOWED: {
// read and set disallowed vehicle classes
std::vector<std::string> classes;
if (!server.readTypeCheckingStringList(inputStorage, classes)) {
return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "Not allowed vehicle classes must be given as a list of strings.", outputStorage);
}
SVCPermissions permissions = ~parseVehicleClasses(classes); // negation yields allowed
const std::vector<MSLane*>& lanes = e->getLanes();
for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) {
(*i)->setPermissions(permissions);
}
e->rebuildAllowedLanes();
}
break;
case VAR_EDGE_TRAVELTIME: {
// read and set travel time
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time requires a compound object.", outputStorage);
}
int parameterCount = inputStorage.readInt();
if (parameterCount == 3) {
// bound by time
int begTime = 0, endTime = 0;
double value = 0;
if (!server.readTypeCheckingInt(inputStorage, begTime)) {
return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "The first variable must be the begin time given as int.", outputStorage);
}
if (!server.readTypeCheckingInt(inputStorage, endTime)) {
return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "The second variable must be the end time given as int.", outputStorage);
}
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The third variable must be the value given as double", outputStorage);
}
MSNet::getInstance()->getWeightsStorage().addTravelTime(e, begTime, endTime, value);
} else if (parameterCount == 1) {
// unbound
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The variable must be the value given as double", outputStorage);
}
MSNet::getInstance()->getWeightsStorage().addTravelTime(e, SUMOReal(0), SUMOReal(SUMOTime_MAX), value);
} else {
return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time requires either begin time, end time, and value, or only value as parameter.", outputStorage);
}
}
break;
case VAR_EDGE_EFFORT: {
// read and set effort
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort requires a compound object.", outputStorage);
}
int parameterCount = inputStorage.readInt();
if (parameterCount == 3) {
// bound by time
int begTime = 0, endTime = 0;
double value = 0;
if (!server.readTypeCheckingInt(inputStorage, begTime)) {
return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "The first variable must be the begin time given as int.", outputStorage);
}
if (!server.readTypeCheckingInt(inputStorage, endTime)) {
return server.writeErrorStatusCmd(CMD_GET_EDGE_VARIABLE, "The second variable must be the end time given as int.", outputStorage);
}
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The third variable must be the value given as double", outputStorage);
}
MSNet::getInstance()->getWeightsStorage().addEffort(e, begTime, endTime, value);
} else if (parameterCount == 1) {
// unbound
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The variable must be the value given as double", outputStorage);
}
MSNet::getInstance()->getWeightsStorage().addEffort(e, SUMOReal(0), SUMOReal(SUMOTime_MAX), value);
} else {
return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort requires either begin time, end time, and value, or only value as parameter.", outputStorage);
}
}
break;
case VAR_MAXSPEED: {
// read and set max. speed
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The speed must be given as a double.", outputStorage);
}
const std::vector<MSLane*>& lanes = e->getLanes();
for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) {
(*i)->setMaxSpeed(value);
}
}
break;
case VAR_PARAMETER: {
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "A compound object is needed for setting a parameter.", outputStorage);
}
//readt itemNo
inputStorage.readInt();
std::string name;
if (!server.readTypeCheckingString(inputStorage, name)) {
return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The name of the parameter must be given as a string.", outputStorage);
}
std::string value;
if (!server.readTypeCheckingString(inputStorage, value)) {
return server.writeErrorStatusCmd(CMD_SET_EDGE_VARIABLE, "The value of the parameter must be given as a string.", outputStorage);
}
e->addParameter(name, value);
}
break;
default:
break;
}
server.writeStatusCmd(CMD_SET_EDGE_VARIABLE, RTYPE_OK, warning, outputStorage);
return true;
}
// ===========================================================================
// method definitions
// ===========================================================================
bool
TraCIServerAPI_Simulation::processGet(TraCIServer& server, tcpip::Storage& inputStorage,
tcpip::Storage& outputStorage) {
// 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;
}
// ===========================================================================
// 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;
}