Eclipse SUMO - Simulation of Urban MObility
TraCIServerAPI_Person.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-2020 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
18 // APIs for getting/setting person values via TraCI
19 /****************************************************************************/
20 #include <config.h>
21 
26 #include <microsim/MSNet.h>
27 #include <microsim/MSEdge.h>
28 #include <libsumo/Person.h>
29 #include <libsumo/TraCIConstants.h>
30 #include <libsumo/VehicleType.h>
31 #include "TraCIServer.h"
33 #include "TraCIServerAPI_Person.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::Person::handleVariable(id, variable, &server)) {
48  switch (variable) {
49  case libsumo::VAR_EDGES: {
50  int nextStageIndex = 0;
51  if (!server.readTypeCheckingInt(inputStorage, nextStageIndex)) {
52  return server.writeErrorStatusCmd(libsumo::CMD_GET_PERSON_VARIABLE, "The message must contain the stage index.", outputStorage);
53  }
55  server.getWrapperStorage().writeStringList(libsumo::Person::getEdges(id, nextStageIndex));
56  break;
57  }
58  case libsumo::VAR_STAGE: {
59  int nextStageIndex = 0;
60  if (!server.readTypeCheckingInt(inputStorage, nextStageIndex)) {
61  return server.writeErrorStatusCmd(libsumo::CMD_GET_PERSON_VARIABLE, "The message must contain the stage index.", outputStorage);
62  }
63  TraCIServerAPI_Simulation::writeStage(server.getWrapperStorage(), libsumo::Person::getStage(id, nextStageIndex));
64  break;
65  }
67  std::string paramName = "";
68  if (!server.readTypeCheckingString(inputStorage, paramName)) {
69  return server.writeErrorStatusCmd(libsumo::CMD_GET_PERSON_VARIABLE, "Retrieval of a parameter requires its name.", outputStorage);
70  }
72  server.getWrapperStorage().writeString(libsumo::Person::getParameter(id, paramName));
73  break;
74  }
76  std::string paramName = "";
77  if (!server.readTypeCheckingString(inputStorage, paramName)) {
78  return server.writeErrorStatusCmd(libsumo::CMD_GET_PERSON_VARIABLE, "Retrieval of a parameter requires its name.", outputStorage);
79  }
81  server.getWrapperStorage().writeInt(2);
83  server.getWrapperStorage().writeString(paramName);
85  server.getWrapperStorage().writeString(libsumo::Person::getParameter(id, paramName));
86  break;
87  }
89  int onlyNew = 0;
90  if (!server.readTypeCheckingInt(inputStorage, onlyNew)) {
91  return server.writeErrorStatusCmd(libsumo::CMD_GET_PERSON_VARIABLE, "Retrieval of reservations requires an integer flag.", outputStorage);
92  }
93  const std::vector<libsumo::TraCIReservation> result = libsumo::Person::getTaxiReservations(onlyNew);
95  server.getWrapperStorage().writeInt((int)result.size());
96  for (const libsumo::TraCIReservation& r : result) {
98  server.getWrapperStorage().writeInt(9);
100  server.getWrapperStorage().writeString(r.id);
102  server.getWrapperStorage().writeStringList(r.persons);
104  server.getWrapperStorage().writeString(r.group);
106  server.getWrapperStorage().writeString(r.fromEdge);
108  server.getWrapperStorage().writeString(r.toEdge);
110  server.getWrapperStorage().writeDouble(r.departPos);
112  server.getWrapperStorage().writeDouble(r.arrivalPos);
114  server.getWrapperStorage().writeDouble(r.depart);
116  server.getWrapperStorage().writeDouble(r.reservationTime);
117  }
118  break;
119  }
120  default:
121  return server.writeErrorStatusCmd(libsumo::CMD_GET_PERSON_VARIABLE, "Get Person Variable: unsupported variable " + toHex(variable, 2) + " specified", outputStorage);
122  }
123  }
124  } catch (libsumo::TraCIException& e) {
125  return server.writeErrorStatusCmd(libsumo::CMD_GET_PERSON_VARIABLE, e.what(), outputStorage);
126  }
128  server.writeResponseWithLength(outputStorage, server.getWrapperStorage());
129  return true;
130 }
131 
132 
133 bool
135  tcpip::Storage& outputStorage) {
136  std::string warning = ""; // additional description for response
137  // variable
138  int variable = inputStorage.readUnsignedByte();
139  if (variable != libsumo::VAR_PARAMETER
140  && variable != libsumo::ADD
141  && variable != libsumo::APPEND_STAGE
142  && variable != libsumo::REPLACE_STAGE
143  && variable != libsumo::REMOVE_STAGE
144  && variable != libsumo::CMD_REROUTE_TRAVELTIME
145  && variable != libsumo::MOVE_TO_XY
146  && variable != libsumo::VAR_SPEED
147  && variable != libsumo::VAR_TYPE
148  && variable != libsumo::VAR_LENGTH
149  && variable != libsumo::VAR_WIDTH
150  && variable != libsumo::VAR_HEIGHT
151  && variable != libsumo::VAR_MINGAP
152  && variable != libsumo::VAR_COLOR
153  ) {
154  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Change Person State: unsupported variable " + toHex(variable, 2) + " specified", outputStorage);
155  }
156 
157  try {
158  // TODO: remove declaration of c after completion
160  // id
161  std::string id = inputStorage.readString();
162  // TODO: remove declaration of p after completion
163  const bool shouldExist = variable != libsumo::ADD;
164  MSTransportable* p = c.get(id);
165  if (p == nullptr && shouldExist) {
166  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Person '" + id + "' is not known", outputStorage);
167  }
168  // process
169  switch (variable) {
170  case libsumo::VAR_SPEED: {
171  double speed = 0;
172  if (!server.readTypeCheckingDouble(inputStorage, speed)) {
173  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Setting speed requires a double.", outputStorage);
174  }
175  // set the speed for all (walking) stages
176  libsumo::Person::setSpeed(id, speed);
177  // modify the vType so that stages added later are also affected
178  TraCIServerAPI_VehicleType::setVariable(libsumo::CMD_SET_VEHICLE_VARIABLE, variable, p->getSingularType().getID(), server, inputStorage, outputStorage);
179  }
180  break;
181  case libsumo::VAR_TYPE: {
182  std::string vTypeID;
183  if (!server.readTypeCheckingString(inputStorage, vTypeID)) {
184  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "The vehicle type id must be given as a string.", outputStorage);
185  }
186  libsumo::Person::setType(id, vTypeID);
187  break;
188  }
189  case libsumo::VAR_COLOR: {
191  if (!server.readTypeCheckingColor(inputStorage, col)) {
192  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The color must be given using the according type.", outputStorage);
193  }
194  libsumo::Person::setColor(id, col);
195  break;
196  }
197  case libsumo::ADD: {
198  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
199  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Adding a person requires a compound object.", outputStorage);
200  }
201  if (inputStorage.readInt() != 4) {
202  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Adding a person needs four parameters.", outputStorage);
203  }
204  std::string vTypeID;
205  if (!server.readTypeCheckingString(inputStorage, vTypeID)) {
206  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "First parameter (type) requires a string.", outputStorage);
207  }
208  std::string edgeID;
209  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
210  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Second parameter (edge) requires a string.", outputStorage);
211  }
212  double depart;
213  if (!server.readTypeCheckingDouble(inputStorage, depart)) {
214  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Third parameter (depart) requires a double.", outputStorage);
215  }
216  double pos;
217  if (!server.readTypeCheckingDouble(inputStorage, pos)) {
218  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Fourth parameter (position) requires a double.", outputStorage);
219  }
220  libsumo::Person::add(id, edgeID, pos, depart, vTypeID);
221  }
222  break;
223  case libsumo::APPEND_STAGE: {
224  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
225  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Adding a person stage requires a compound object.", outputStorage);
226  }
227  int numParameters = inputStorage.readInt();
228  if (numParameters == 13) {
229  libsumo::Person::appendStage(id, *TraCIServerAPI_Simulation::readStage(server, inputStorage));
230  } else {
231  int stageType;
232  if (!server.readTypeCheckingInt(inputStorage, stageType)) {
233  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "The first parameter for adding a stage must be the stage type given as int.", outputStorage);
234  }
235  if (stageType == libsumo::STAGE_DRIVING) {
236  // append driving stage
237  if (numParameters != 4) {
238  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Adding a driving stage needs four parameters.", outputStorage);
239  }
240  std::string edgeID;
241  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
242  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Second parameter (edge) requires a string.", outputStorage);
243  }
244  std::string lines;
245  if (!server.readTypeCheckingString(inputStorage, lines)) {
246  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Third parameter (lines) requires a string.", outputStorage);
247  }
248  std::string stopID;
249  if (!server.readTypeCheckingString(inputStorage, stopID)) {
250  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Fourth parameter (stopID) requires a string.", outputStorage);
251  }
252  libsumo::Person::appendDrivingStage(id, edgeID, lines, stopID);
253  } else if (stageType == libsumo::STAGE_WAITING) {
254  // append waiting stage
255  if (numParameters != 4) {
256  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Adding a waiting stage needs four parameters.", outputStorage);
257  }
258  double duration;
259  if (!server.readTypeCheckingDouble(inputStorage, duration)) {
260  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Second parameter (duration) requires a double.", outputStorage);
261  }
262  std::string description;
263  if (!server.readTypeCheckingString(inputStorage, description)) {
264  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Third parameter (description) requires a string.", outputStorage);
265  }
266  std::string stopID;
267  if (!server.readTypeCheckingString(inputStorage, stopID)) {
268  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Fourth parameter (stopID) requires a string.", outputStorage);
269  }
270  libsumo::Person::appendWaitingStage(id, duration, description, stopID);
271  } else if (stageType == libsumo::STAGE_WALKING) {
272  // append walking stage
273  if (numParameters != 6) {
274  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Adding a walking stage needs six parameters.", outputStorage);
275  }
276  std::vector<std::string> edgeIDs;
277  if (!server.readTypeCheckingStringList(inputStorage, edgeIDs)) {
278  return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Second parameter (edges) route must be defined as a list of edge ids.", outputStorage);
279  }
280  double arrivalPos;
281  if (!server.readTypeCheckingDouble(inputStorage, arrivalPos)) {
282  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Third parameter (arrivalPos) requires a double.", outputStorage);
283  }
284  double duration;
285  if (!server.readTypeCheckingDouble(inputStorage, duration)) {
286  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Fourth parameter (duration) requires a double.", outputStorage);
287  }
288  double speed;
289  if (!server.readTypeCheckingDouble(inputStorage, speed)) {
290  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Fifth parameter (speed) requires a double.", outputStorage);
291  }
292  std::string stopID;
293  if (!server.readTypeCheckingString(inputStorage, stopID)) {
294  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Fourth parameter (stopID) requires a string.", outputStorage);
295  }
296  libsumo::Person::appendWalkingStage(id, edgeIDs, arrivalPos, duration, speed, stopID);
297  } else {
298  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Invalid stage type for person '" + id + "'", outputStorage);
299  }
300  }
301 
302  }
303  break;
304 
305  case libsumo::REPLACE_STAGE : {
306  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
307  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Replacing a person stage requires a compound object.", outputStorage);
308  }
309  if (inputStorage.readInt() != 2) {
310  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Replacing a person stage requires a compound object of size 2.", outputStorage);
311  }
312  int nextStageIndex = 0;
313  if (!server.readTypeCheckingInt(inputStorage, nextStageIndex)) {
314  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "First parameter of replace stage should be an integer", outputStorage);
315  }
316  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
317  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Second parameter of replace stage should be a compound object", outputStorage);
318  }
319  if (inputStorage.readInt() != 13) {
320  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Second parameter of replace stage should be a compound object of size 13", outputStorage);
321  }
322  libsumo::Person::replaceStage(id, nextStageIndex, *TraCIServerAPI_Simulation::readStage(server, inputStorage));
323  }
324  break;
325 
326  case libsumo::REMOVE_STAGE: {
327  int nextStageIndex = 0;
328  if (!server.readTypeCheckingInt(inputStorage, nextStageIndex)) {
329  return server.writeErrorStatusCmd(libsumo::CMD_GET_PERSON_VARIABLE, "The message must contain the stage index.", outputStorage);
330  }
331  libsumo::Person::removeStage(id, nextStageIndex);
332  }
333  break;
335  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
336  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Rerouting requires a compound object.", outputStorage);
337  }
338  if (inputStorage.readInt() != 0) {
339  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "Rerouting should obtain an empty compound object.", outputStorage);
340  }
341  libsumo::Person::rerouteTraveltime(id);
342  }
343  break;
344  case libsumo::MOVE_TO_XY: {
345  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
346  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "MoveToXY person requires a compound object.", outputStorage);
347  }
348  const int numArgs = inputStorage.readInt();
349  if (numArgs != 5) {
350  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "MoveToXY person should obtain: edgeID, x, y, angle and keepRouteFlag.", outputStorage);
351  }
352  // edge ID
353  std::string edgeID;
354  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
355  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "The first parameter for moveToXY must be the edge ID given as a string.", outputStorage);
356  }
357  // x
358  double x = 0;
359  if (!server.readTypeCheckingDouble(inputStorage, x)) {
360  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "The second parameter for moveToXY must be the x-position given as a double.", outputStorage);
361  }
362  // y
363  double y = 0;
364  if (!server.readTypeCheckingDouble(inputStorage, y)) {
365  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "The third parameter for moveToXY must be the y-position given as a double.", outputStorage);
366  }
367  // angle
368  double angle = 0;
369  if (!server.readTypeCheckingDouble(inputStorage, angle)) {
370  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "The fourth parameter for moveToXY must be the angle given as a double.", outputStorage);
371  }
372  int keepRouteFlag = 1;
373  if (!server.readTypeCheckingByte(inputStorage, keepRouteFlag)) {
374  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "The fifth parameter for moveToXY must be the keepRouteFlag given as a byte.", outputStorage);
375  }
376  libsumo::Person::moveToXY(id, edgeID, x, y, angle, keepRouteFlag);
377  }
378  break;
379  case libsumo::VAR_PARAMETER: {
380  if (inputStorage.readUnsignedByte() != libsumo::TYPE_COMPOUND) {
381  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "A compound object is needed for setting a parameter.", outputStorage);
382  }
383  //read itemNo
384  inputStorage.readInt();
385  std::string name;
386  if (!server.readTypeCheckingString(inputStorage, name)) {
387  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "The name of the parameter must be given as a string.", outputStorage);
388  }
389  std::string value;
390  if (!server.readTypeCheckingString(inputStorage, value)) {
391  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, "The value of the parameter must be given as a string.", outputStorage);
392  }
393  libsumo::Person::setParameter(id, name, value);
394  }
395  break;
396  default:
397  try {
398  if (!TraCIServerAPI_VehicleType::setVariable(libsumo::CMD_SET_PERSON_VARIABLE, variable, p->getSingularType().getID(), server, inputStorage, outputStorage)) {
399  return false;
400  }
401  } catch (ProcessError& e) {
402  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, e.what(), outputStorage);
403  }
404  break;
405  }
406  } catch (libsumo::TraCIException& e) {
407  return server.writeErrorStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, e.what(), outputStorage);
408  }
409  server.writeStatusCmd(libsumo::CMD_SET_PERSON_VARIABLE, libsumo::RTYPE_OK, warning, outputStorage);
410  return true;
411 }
412 
413 
414 /****************************************************************************/
std::string toHex(const T i, std::streamsize numDigits=0)
Definition: ToString.h:54
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:171
virtual MSTransportableControl & getPersonControl()
Returns the person control.
Definition: MSNet.cpp:986
MSTransportable * get(const std::string &id) const
Returns the named transportable, if existing.
MSVehicleType & getSingularType()
Replaces the current vehicle type with a new one used by this vehicle only.
const std::string & getID() const
Returns the name of the vehicle type.
Definition: MSVehicleType.h:90
static bool processGet(TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage)
Processes a get value command (Command 0xae: Get Person Variable)
static bool processSet(TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage)
Processes a set value command (Command 0xce: Change Person State)
static libsumo::TraCIStage * readStage(TraCIServer &server, tcpip::Storage &inputStorage)
static void writeStage(tcpip::Storage &outputStorage, const libsumo::TraCIStage &stage)
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.
TraCI server used to control sumo by a remote TraCI client.
Definition: TraCIServer.h:59
void writeStatusCmd(int commandId, int status, const std::string &description, tcpip::Storage &outputStorage)
Writes a status command to the given storage.
bool readTypeCheckingString(tcpip::Storage &inputStorage, std::string &into)
Reads the value type and a string, verifying the type.
bool readTypeCheckingByte(tcpip::Storage &inputStorage, int &into)
Reads the value type and a byte, verifying the type.
tcpip::Storage & getWrapperStorage()
void initWrapper(const int domainID, const int variable, const std::string &objID)
bool writeErrorStatusCmd(int commandId, const std::string &description, tcpip::Storage &outputStorage)
Writes a status command to the given storage with status = RTYPE_ERR.
bool readTypeCheckingInt(tcpip::Storage &inputStorage, int &into)
Reads the value type and an int, verifying the type.
bool readTypeCheckingStringList(tcpip::Storage &inputStorage, std::vector< std::string > &into)
Reads the value type and a string list, verifying the type.
bool readTypeCheckingDouble(tcpip::Storage &inputStorage, double &into)
Reads the value type and a double, verifying the type.
void writeResponseWithLength(tcpip::Storage &outputStorage, tcpip::Storage &tempMsg)
bool readTypeCheckingColor(tcpip::Storage &inputStorage, libsumo::TraCIColor &into)
Reads the value type and a color, verifying the type.
virtual std::string readString()
Definition: storage.cpp:175
virtual void writeString(const std::string &s)
Definition: storage.cpp:192
virtual void writeInt(int)
Definition: storage.cpp:316
virtual void writeDouble(double)
Definition: storage.cpp:349
virtual int readUnsignedByte()
Definition: storage.cpp:150
virtual void writeStringList(const std::vector< std::string > &s)
Definition: storage.cpp:242
virtual void writeUnsignedByte(int)
Definition: storage.cpp:160
virtual int readInt()
Definition: storage.cpp:306
TRACI_CONST int VAR_EDGES
TRACI_CONST int VAR_TYPE
TRACI_CONST int VAR_MINGAP
TRACI_CONST int REPLACE_STAGE
TRACI_CONST int VAR_TAXI_RESERVATIONS
TRACI_CONST int MOVE_TO_XY
TRACI_CONST int TYPE_COMPOUND
TRACI_CONST int CMD_GET_PERSON_VARIABLE
TRACI_CONST int VAR_STAGE
TRACI_CONST int VAR_COLOR
TRACI_CONST int VAR_WIDTH
TRACI_CONST int STAGE_WAITING
TRACI_CONST int CMD_REROUTE_TRAVELTIME
TRACI_CONST int TYPE_STRINGLIST
TRACI_CONST int APPEND_STAGE
TRACI_CONST int CMD_SET_VEHICLE_VARIABLE
TRACI_CONST int VAR_LENGTH
TRACI_CONST int VAR_PARAMETER
TRACI_CONST int CMD_SET_PERSON_VARIABLE
TRACI_CONST int VAR_HEIGHT
TRACI_CONST int RESPONSE_GET_PERSON_VARIABLE
TRACI_CONST int STAGE_WALKING
TRACI_CONST int REMOVE_STAGE
TRACI_CONST int VAR_SPEED
TRACI_CONST int VAR_PARAMETER_WITH_KEY
TRACI_CONST int TYPE_DOUBLE
TRACI_CONST int STAGE_DRIVING
TRACI_CONST int RTYPE_OK
TRACI_CONST int ADD
TRACI_CONST int TYPE_STRING