Eclipse SUMO - Simulation of Urban MObility
TraCIServerAPI_VehicleType.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
19 // APIs for getting/setting vehicle type values via TraCI
20 /****************************************************************************/
21 
22 
23 // ===========================================================================
24 // included modules
25 // ===========================================================================
26 #include <config.h>
27 
28 #include <limits>
30 #include <microsim/MSNet.h>
31 #include <microsim/MSVehicleType.h>
32 #include <libsumo/TraCIConstants.h>
33 #include <libsumo/VehicleType.h>
35 
36 
37 // ===========================================================================
38 // method definitions
39 // ===========================================================================
40 bool
42  tcpip::Storage& outputStorage) {
43  const int variable = inputStorage.readUnsignedByte();
44  const std::string id = inputStorage.readString();
46  try {
47  if (!libsumo::VehicleType::handleVariable(id, variable, &server)) {
48  switch (variable) {
50  std::string paramName = "";
51  if (!server.readTypeCheckingString(inputStorage, paramName)) {
53  "Retrieval of a parameter requires its name.", outputStorage);
54  }
57  break;
58  }
59  default:
61  "Get Vehicle Type Variable: unsupported variable " + toHex(variable, 2)
62  + " specified", outputStorage);
63  }
64  }
65  } catch (libsumo::TraCIException& e) {
66  return server.writeErrorStatusCmd(libsumo::CMD_GET_VEHICLETYPE_VARIABLE, e.what(), outputStorage);
67  }
69  server.writeResponseWithLength(outputStorage, server.getWrapperStorage());
70  return true;
71 }
72 
73 
74 bool
76  tcpip::Storage& outputStorage) {
77  std::string warning = ""; // additional description for response
78  // variable
79  int variable = inputStorage.readUnsignedByte();
80  if (variable != libsumo::VAR_LENGTH && variable != libsumo::VAR_MAXSPEED && variable != libsumo::VAR_VEHICLECLASS
81  && variable != libsumo::VAR_SPEED_FACTOR && variable != libsumo::VAR_SPEED_DEVIATION && variable != libsumo::VAR_EMISSIONCLASS
82  && variable != libsumo::VAR_WIDTH && variable != libsumo::VAR_MINGAP && variable != libsumo::VAR_SHAPECLASS
83  && variable != libsumo::VAR_ACCEL && variable != libsumo::VAR_IMPERFECTION
84  && variable != libsumo::VAR_DECEL && variable != libsumo::VAR_EMERGENCY_DECEL && variable != libsumo::VAR_APPARENT_DECEL
85  && variable != libsumo::VAR_TAU && variable != libsumo::VAR_COLOR && variable != libsumo::VAR_ACTIONSTEPLENGTH
86  && variable != libsumo::VAR_HEIGHT
87  && variable != libsumo::VAR_MINGAP_LAT
88  && variable != libsumo::VAR_MAXSPEED_LAT
89  && variable != libsumo::VAR_LATALIGNMENT
90  && variable != libsumo::VAR_PARAMETER
91  && variable != libsumo::COPY
92  ) {
94  "Change Vehicle Type State: unsupported variable " + toHex(variable, 2)
95  + " specified", outputStorage);
96  }
97  // id
98  std::string id = inputStorage.readString();
99 // MSVehicleType* v = libsumo::VehicleType::getVType(id);
100 // if (v == 0) {
101 // return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, "Vehicle type '" + id + "' is not known",
102 // outputStorage);
103 // }
104  // process
105  try {
106  if (setVariable(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, variable, id, server, inputStorage, outputStorage)) {
108  return true;
109  }
110  } catch (ProcessError& e) {
111  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, e.what(), outputStorage);
112  } catch (libsumo::TraCIException& e) {
113  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, e.what(), outputStorage);
114  }
115  return false;
116 }
117 
118 
119 bool
120 TraCIServerAPI_VehicleType::setVariable(const int cmd, const int variable,
121  const std::string& id, TraCIServer& server,
122  tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) {
123  switch (variable) {
124  case libsumo::VAR_LENGTH: {
125  double value = 0;
126  if (!server.readTypeCheckingDouble(inputStorage, value)) {
127  return server.writeErrorStatusCmd(cmd, "Setting length requires a double.", outputStorage);
128  }
129  if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
130  return server.writeErrorStatusCmd(cmd, "Invalid length.", outputStorage);
131  }
132  libsumo::VehicleType::setLength(id, value);
133  }
134  break;
135  case libsumo::VAR_HEIGHT: {
136  double value = 0;
137  if (!server.readTypeCheckingDouble(inputStorage, value)) {
138  return server.writeErrorStatusCmd(cmd, "Setting height requires a double.", outputStorage);
139  }
140  if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
141  return server.writeErrorStatusCmd(cmd, "Invalid height.", outputStorage);
142  }
143  libsumo::VehicleType::setHeight(id, value);
144  }
145  break;
146  case libsumo::VAR_MAXSPEED: {
147  double value = 0;
148  if (!server.readTypeCheckingDouble(inputStorage, value)) {
149  return server.writeErrorStatusCmd(cmd, "Setting maximum speed requires a double.", outputStorage);
150  }
151  if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
152  return server.writeErrorStatusCmd(cmd, "Invalid maximum speed.", outputStorage);
153  }
154  libsumo::VehicleType::setMaxSpeed(id, value);
155  }
156  break;
158  std::string vclass;
159  if (!server.readTypeCheckingString(inputStorage, vclass)) {
160  return server.writeErrorStatusCmd(cmd, "Setting vehicle class requires a string.", outputStorage);
161  }
162  try {
163  libsumo::VehicleType::setVehicleClass(id, vclass);
164  } catch (InvalidArgument&) {
165  return server.writeErrorStatusCmd(cmd, "Unknown vehicle class '" + vclass + "'.", outputStorage);
166  }
167  }
168  break;
170  double value = 0;
171  if (!server.readTypeCheckingDouble(inputStorage, value)) {
172  return server.writeErrorStatusCmd(cmd, "Setting speed factor requires a double.", outputStorage);
173  }
174  if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
175  return server.writeErrorStatusCmd(cmd, "Invalid speed factor.", outputStorage);
176  }
177  libsumo::VehicleType::setSpeedFactor(id, value);
178  }
179  break;
181  double value = 0;
182  if (!server.readTypeCheckingDouble(inputStorage, value)) {
183  return server.writeErrorStatusCmd(cmd, "Setting speed deviation requires a double.", outputStorage);
184  }
185  if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
186  return server.writeErrorStatusCmd(cmd, "Invalid speed deviation.", outputStorage);
187  }
189  }
190  break;
192  std::string eclass;
193  if (!server.readTypeCheckingString(inputStorage, eclass)) {
194  return server.writeErrorStatusCmd(cmd, "Setting emission class requires a string.", outputStorage);
195  }
196  try {
197  libsumo::VehicleType::setEmissionClass(id, eclass);
198  } catch (InvalidArgument& e) {
199  return server.writeErrorStatusCmd(cmd, e.what(), outputStorage);
200  }
201  }
202  break;
203  case libsumo::VAR_WIDTH: {
204  double value = 0;
205  if (!server.readTypeCheckingDouble(inputStorage, value)) {
206  return server.writeErrorStatusCmd(cmd, "Setting width requires a double.", outputStorage);
207  }
208  if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
209  return server.writeErrorStatusCmd(cmd, "Invalid width.", outputStorage);
210  }
211  libsumo::VehicleType::setWidth(id, value);
212  }
213  break;
214  case libsumo::VAR_MINGAP: {
215  double value = 0;
216  if (!server.readTypeCheckingDouble(inputStorage, value)) {
217  return server.writeErrorStatusCmd(cmd, "Setting minimum gap requires a double.", outputStorage);
218  }
219  if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
220  return server.writeErrorStatusCmd(cmd, "Invalid minimum gap.", outputStorage);
221  }
222  libsumo::VehicleType::setMinGap(id, value);
223  }
224  break;
226  double value = 0;
227  if (!server.readTypeCheckingDouble(inputStorage, value)) {
228  return server.writeErrorStatusCmd(cmd, "Setting minimum lateral gap requires a double.", outputStorage);
229  }
230  if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
231  return server.writeErrorStatusCmd(cmd, "Invalid minimum lateral gap.", outputStorage);
232  }
233  libsumo::VehicleType::setMinGapLat(id, value);
234  }
235  break;
237  double value = 0;
238  if (!server.readTypeCheckingDouble(inputStorage, value)) {
239  return server.writeErrorStatusCmd(cmd, "Setting maximum lateral speed requires a double.", outputStorage);
240  }
241  if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
242  return server.writeErrorStatusCmd(cmd, "Invalid maximum lateral speed.", outputStorage);
243  }
244  libsumo::VehicleType::setMaxSpeedLat(id, value);
245  }
246  break;
248  std::string latAlign;
249  if (!server.readTypeCheckingString(inputStorage, latAlign)) {
250  return server.writeErrorStatusCmd(cmd, "Setting preferred lateral alignment requires a string.",
251  outputStorage);
252  }
253  if (SUMOXMLDefinitions::LateralAlignments.hasString(latAlign)) {
254  libsumo::VehicleType::setLateralAlignment(id, latAlign);
255  } else {
256  return server.writeErrorStatusCmd(cmd, "Unknown lateral alignment " + latAlign + "'.", outputStorage);
257  }
258  }
259  break;
261  std::string sclass;
262  if (!server.readTypeCheckingString(inputStorage, sclass)) {
263  return server.writeErrorStatusCmd(cmd, "Setting vehicle shape requires a string.", outputStorage);
264  }
265  try {
266  libsumo::VehicleType::setShapeClass(id, sclass);
267  } catch (InvalidArgument& e) {
268  return server.writeErrorStatusCmd(cmd, e.what(), outputStorage);
269  }
270  }
271  break;
272  case libsumo::VAR_ACCEL: {
273  double value = 0;
274  if (!server.readTypeCheckingDouble(inputStorage, value)) {
275  return server.writeErrorStatusCmd(cmd, "Setting acceleration requires a double.", outputStorage);
276  }
277  if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
278  return server.writeErrorStatusCmd(cmd, "Invalid acceleration.", outputStorage);
279  }
280  libsumo::VehicleType::setAccel(id, value);
281  }
282  break;
283  case libsumo::VAR_DECEL: {
284  double value = 0;
285  if (!server.readTypeCheckingDouble(inputStorage, value)) {
286  return server.writeErrorStatusCmd(cmd, "Setting deceleration requires a double.", outputStorage);
287  }
288  if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
289  return server.writeErrorStatusCmd(cmd, "Invalid deceleration.", outputStorage);
290  }
291  libsumo::VehicleType::setDecel(id, value);
292  }
293  break;
295  double value = 0;
296  if (!server.readTypeCheckingDouble(inputStorage, value)) {
297  return server.writeErrorStatusCmd(cmd, "Setting deceleration requires a double.", outputStorage);
298  }
299  if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
300  return server.writeErrorStatusCmd(cmd, "Invalid deceleration.", outputStorage);
301  }
302  libsumo::VehicleType::setEmergencyDecel(id, value);
303  }
304  break;
306  double value = 0;
307  if (!server.readTypeCheckingDouble(inputStorage, value)) {
308  return server.writeErrorStatusCmd(cmd, "Setting deceleration requires a double.", outputStorage);
309  }
310  if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
311  return server.writeErrorStatusCmd(cmd, "Invalid deceleration.", outputStorage);
312  }
313  libsumo::VehicleType::setApparentDecel(id, value);
314  }
315  break;
317  double value = 0;
318  if (!server.readTypeCheckingDouble(inputStorage, value)) {
319  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Setting action step length requires a double.", outputStorage);
320  }
321  if (fabs(value) == std::numeric_limits<double>::infinity()) {
322  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Invalid action step length.", outputStorage);
323  }
324  bool resetActionOffset = value >= 0.0;
325  libsumo::VehicleType::setActionStepLength(id, fabs(value), resetActionOffset);
326  }
327  break;
329  double value = 0;
330  if (!server.readTypeCheckingDouble(inputStorage, value)) {
331  return server.writeErrorStatusCmd(cmd, "Setting driver imperfection requires a double.", outputStorage);
332  }
333  if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
334  return server.writeErrorStatusCmd(cmd, "Invalid driver imperfection.", outputStorage);
335  }
336  libsumo::VehicleType::setImperfection(id, value);
337  }
338  break;
339  case libsumo::VAR_TAU: {
340  double value = 0;
341  if (!server.readTypeCheckingDouble(inputStorage, value)) {
342  return server.writeErrorStatusCmd(cmd, "Setting headway time requires a double.", outputStorage);
343  }
344  if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
345  return server.writeErrorStatusCmd(cmd, "Invalid headway time.", outputStorage);
346  }
347  libsumo::VehicleType::setTau(id, value);
348  }
349  break;
350  case libsumo::VAR_COLOR: {
352  if (!server.readTypeCheckingColor(inputStorage, col)) {
353  return server.writeErrorStatusCmd(cmd, "The color must be given using the according type.", outputStorage);
354  }
355  libsumo::VehicleType::setColor(id, col);
356  }
357  break;
358  case libsumo::COPY: {
359  std::string newTypeID;
360  if (!server.readTypeCheckingString(inputStorage, newTypeID)) {
361  return server.writeErrorStatusCmd(cmd, "copying a vehicle type requires a string.",
362  outputStorage);
363  }
364  libsumo::VehicleType::copy(id, newTypeID);
365  }
366  break;
367  case libsumo::VAR_PARAMETER: {
368  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
369  return server.writeErrorStatusCmd(cmd, "A compound object is needed for setting a parameter.",
370  outputStorage);
371  }
372  //readt itemNo
373  inputStorage.readInt();
374  std::string name;
375  if (!server.readTypeCheckingString(inputStorage, name)) {
376  return server.writeErrorStatusCmd(cmd, "The name of the parameter must be given as a string.",
377  outputStorage);
378  }
379  std::string value;
380  if (!server.readTypeCheckingString(inputStorage, value)) {
381  return server.writeErrorStatusCmd(cmd, "The value of the parameter must be given as a string.",
382  outputStorage);
383  }
384  libsumo::VehicleType::setParameter(id, name, value);
385  }
386  break;
387  default:
388  break;
389  }
390  return true;
391 }
392 
393 
394 /****************************************************************************/
libsumo::RTYPE_OK
TRACI_CONST int RTYPE_OK
Definition: TraCIConstants.h:352
libsumo::VAR_HEIGHT
TRACI_CONST int VAR_HEIGHT
Definition: TraCIConstants.h:772
MSNet.h
libsumo::VAR_EMISSIONCLASS
TRACI_CONST int VAR_EMISSIONCLASS
Definition: TraCIConstants.h:657
TraCIServerAPI_VehicleType::processGet
static bool processGet(TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage)
Processes a get value command (Command 0xa5: Get Vehicle Type Variable)
Definition: TraCIServerAPI_VehicleType.cpp:41
libsumo::VAR_MINGAP
TRACI_CONST int VAR_MINGAP
Definition: TraCIConstants.h:663
libsumo::VAR_MAXSPEED
TRACI_CONST int VAR_MAXSPEED
Definition: TraCIConstants.h:615
tcpip::Storage::writeUnsignedByte
virtual void writeUnsignedByte(int)
libsumo::VAR_COLOR
TRACI_CONST int VAR_COLOR
Definition: TraCIConstants.h:630
TraCIServer::readTypeCheckingColor
bool readTypeCheckingColor(tcpip::Storage &inputStorage, libsumo::TraCIColor &into)
Reads the value type and a color, verifying the type.
Definition: TraCIServer.cpp:1444
libsumo::VehicleType::getParameter
static LIBSUMO_VEHICLE_TYPE_GETTER std::string getParameter(const std::string &typeID, const std::string &key)
Definition: VehicleType.cpp:185
TraCIServer::readTypeCheckingString
bool readTypeCheckingString(tcpip::Storage &inputStorage, std::string &into)
Reads the value type and a string, verifying the type.
Definition: TraCIServer.cpp:1414
libsumo::VAR_WIDTH
TRACI_CONST int VAR_WIDTH
Definition: TraCIConstants.h:666
TraCIServer::writeResponseWithLength
void writeResponseWithLength(tcpip::Storage &outputStorage, tcpip::Storage &tempMsg)
Definition: TraCIServer.cpp:1366
libsumo::VAR_VEHICLECLASS
TRACI_CONST int VAR_VEHICLECLASS
Definition: TraCIConstants.h:654
libsumo::VAR_PARAMETER
TRACI_CONST int VAR_PARAMETER
Definition: TraCIConstants.h:939
libsumo::VAR_ACCEL
TRACI_CONST int VAR_ACCEL
Definition: TraCIConstants.h:633
libsumo::VehicleType::handleVariable
static bool handleVariable(const std::string &objID, const int variable, VariableWrapper *wrapper)
Definition: VehicleType.cpp:365
VehicleType.h
libsumo::TraCIColor
A color.
Definition: TraCIDefs.h:135
TraCIServer::getWrapperStorage
tcpip::Storage & getWrapperStorage()
Definition: TraCIServer.cpp:174
TraCIServerAPI_VehicleType.h
libsumo::CMD_SET_VEHICLE_VARIABLE
TRACI_CONST int CMD_SET_VEHICLE_VARIABLE
Definition: TraCIConstants.h:153
libsumo::CMD_GET_VEHICLETYPE_VARIABLE
TRACI_CONST int CMD_GET_VEHICLETYPE_VARIABLE
Definition: TraCIConstants.h:164
TraCIServer::readTypeCheckingDouble
bool readTypeCheckingDouble(tcpip::Storage &inputStorage, double &into)
Reads the value type and a double, verifying the type.
Definition: TraCIServer.cpp:1404
MSVehicleType.h
libsumo::VAR_TAU
TRACI_CONST int VAR_TAU
Definition: TraCIConstants.h:651
TraCIServer::writeStatusCmd
void writeStatusCmd(int commandId, int status, const std::string &description, tcpip::Storage &outputStorage)
Writes a status command to the given storage.
Definition: TraCIServer.cpp:968
libsumo::VehicleType::copy
static LIBSUMO_VEHICLE_TYPE_SETTER void copy(const std::string &origTypeID, const std::string &newTypeID)
Definition: VehicleType.cpp:334
TraCIServerAPI_VehicleType::setVariable
static bool setVariable(const int cmd, const int variable, const std::string &id, TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage)
Processes a set value for the given type.
Definition: TraCIServerAPI_VehicleType.cpp:120
TraCIServer::initWrapper
void initWrapper(const int domainID, const int variable, const std::string &objID)
Definition: TraCIServer.cpp:102
libsumo::VAR_MINGAP_LAT
TRACI_CONST int VAR_MINGAP_LAT
Definition: TraCIConstants.h:769
tcpip::Storage::readUnsignedByte
virtual int readUnsignedByte()
libsumo::VAR_LATALIGNMENT
TRACI_CONST int VAR_LATALIGNMENT
Definition: TraCIConstants.h:763
tcpip::Storage::readString
virtual std::string readString()
TraCIConstants.h
tcpip::Storage::readInt
virtual int readInt()
PollutantsInterface.h
libsumo::CMD_SET_VEHICLETYPE_VARIABLE
TRACI_CONST int CMD_SET_VEHICLETYPE_VARIABLE
Definition: TraCIConstants.h:168
ProcessError
Definition: UtilExceptions.h:39
toHex
std::string toHex(const T i, std::streamsize numDigits=0)
Definition: ToString.h:57
libsumo::VehicleType::setSpeedDeviation
static void setSpeedDeviation(const std::string &typeID, double deviation)
Definition: VehicleType.cpp:225
TraCIServerAPI_VehicleType::processSet
static bool processSet(TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage)
Processes a set value command (Command 0xc5: Change Vehicle Type State)
Definition: TraCIServerAPI_VehicleType.cpp:75
libsumo::VAR_SPEED_FACTOR
TRACI_CONST int VAR_SPEED_FACTOR
Definition: TraCIConstants.h:729
libsumo::VAR_SPEED_DEVIATION
TRACI_CONST int VAR_SPEED_DEVIATION
Definition: TraCIConstants.h:732
libsumo::VAR_LENGTH
TRACI_CONST int VAR_LENGTH
Definition: TraCIConstants.h:627
libsumo::TraCIException
Definition: TraCIDefs.h:89
libsumo::VAR_EMERGENCY_DECEL
TRACI_CONST int VAR_EMERGENCY_DECEL
Definition: TraCIConstants.h:639
tcpip::Storage::writeString
virtual void writeString(const std::string &s)
libsumo::VAR_SHAPECLASS
TRACI_CONST int VAR_SHAPECLASS
Definition: TraCIConstants.h:660
InvalidArgument
Definition: UtilExceptions.h:56
libsumo::TYPE_STRING
TRACI_CONST int TYPE_STRING
Definition: TraCIConstants.h:337
libsumo::VAR_DECEL
TRACI_CONST int VAR_DECEL
Definition: TraCIConstants.h:636
libsumo::RESPONSE_GET_VEHICLETYPE_VARIABLE
TRACI_CONST int RESPONSE_GET_VEHICLETYPE_VARIABLE
Definition: TraCIConstants.h:166
config.h
libsumo::VehicleType::setParameter
static void setParameter(const std::string &id, const std::string &name, const std::string &value)
Definition: VehicleType.cpp:340
libsumo::VAR_IMPERFECTION
TRACI_CONST int VAR_IMPERFECTION
Definition: TraCIConstants.h:726
libsumo::VAR_APPARENT_DECEL
TRACI_CONST int VAR_APPARENT_DECEL
Definition: TraCIConstants.h:642
SUMOXMLDefinitions::LateralAlignments
static StringBijection< LateralAlignment > LateralAlignments
lateral alignments
Definition: SUMOXMLDefinitions.h:1401
TraCIServer
TraCI server used to control sumo by a remote TraCI client.
Definition: TraCIServer.h:61
libsumo::VAR_MAXSPEED_LAT
TRACI_CONST int VAR_MAXSPEED_LAT
Definition: TraCIConstants.h:766
libsumo::VAR_ACTIONSTEPLENGTH
TRACI_CONST int VAR_ACTIONSTEPLENGTH
Definition: TraCIConstants.h:645
libsumo::COPY
TRACI_CONST int COPY
Definition: TraCIConstants.h:949
tcpip::Storage
Definition: storage.h:36
libsumo::TYPE_COMPOUND
TRACI_CONST int TYPE_COMPOUND
Definition: TraCIConstants.h:341
TraCIServer::writeErrorStatusCmd
bool writeErrorStatusCmd(int commandId, const std::string &description, tcpip::Storage &outputStorage)
Writes a status command to the given storage with status = RTYPE_ERR.
Definition: TraCIServer.cpp:982