Eclipse SUMO - Simulation of Urban MObility
libtraci/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) 2017-2022 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 // C++ TraCI client API implementation
19 /****************************************************************************/
20 #include <config.h>
21 
22 #define LIBTRACI 1
23 #include "Domain.h"
24 #include <libsumo/Person.h>
25 #include <libsumo/StorageHelper.h>
26 
27 namespace libtraci {
28 
29 typedef Domain<libsumo::CMD_GET_PERSON_VARIABLE, libsumo::CMD_SET_PERSON_VARIABLE> Dom;
30 
31 // ===========================================================================
32 // static member definitions
33 // ===========================================================================
34 std::vector<std::string>
35 Person::getIDList() {
37 }
38 
39 
40 int
41 Person::getIDCount() {
42  return Dom::getInt(libsumo::ID_COUNT, "");
43 }
44 
45 
47 Person::getPosition(const std::string& personID, const bool includeZ) {
48  return includeZ ? getPosition3D(personID) : Dom::getPos(libsumo::VAR_POSITION, personID);
49 }
50 
51 
53 Person::getPosition3D(const std::string& personID) {
54  return Dom::getPos3D(libsumo::VAR_POSITION3D, personID);
55 }
56 
57 
58 double
59 Person::getAngle(const std::string& personID) {
60  return Dom::getDouble(libsumo::VAR_ANGLE, personID);
61 }
62 
63 
64 double
65 Person::getSlope(const std::string& personID) {
66  return Dom::getDouble(libsumo::VAR_SLOPE, personID);
67 }
68 
69 
70 double
71 Person::getSpeed(const std::string& personID) {
72  return Dom::getDouble(libsumo::VAR_SPEED, personID);
73 }
74 
75 
76 std::string
77 Person::getRoadID(const std::string& personID) {
78  return Dom::getString(libsumo::VAR_ROAD_ID, personID);
79 }
80 
81 
82 std::string
83 Person::getLaneID(const std::string& personID) {
84  return Dom::getString(libsumo::VAR_LANE_ID, personID);
85 }
86 
87 
88 double
89 Person::getLanePosition(const std::string& personID) {
90  return Dom::getDouble(libsumo::VAR_LANEPOSITION, personID);
91 }
92 
93 
94 std::vector<libsumo::TraCIReservation>
95 Person::getTaxiReservations(int onlyNew) {
96  tcpip::Storage content;
97  StoHelp::writeTypedInt(content, onlyNew);
99  std::vector<libsumo::TraCIReservation> result;
100  int numReservations = ret.readInt();
101  while (numReservations-- > 0) {
103  StoHelp::readCompound(ret, 10);
104  r.id = StoHelp::readTypedString(ret);
113  r.state = StoHelp::readTypedInt(ret);
114  result.emplace_back(r);
115  }
116  return result;
117 }
118 
119 
120 std::string
121 Person::splitTaxiReservation(std::string reservationID, const std::vector<std::string>& personIDs) {
122  tcpip::Storage content;
123  StoHelp::writeTypedStringList(content, personIDs);
124  return Dom::getString(libsumo::SPLIT_TAXI_RESERVATIONS, reservationID, &content);
125 }
126 
127 
129 Person::getColor(const std::string& personID) {
130  return Dom::getCol(libsumo::VAR_COLOR, personID);
131 }
132 
133 
134 std::string
135 Person::getTypeID(const std::string& personID) {
136  return Dom::getString(libsumo::VAR_TYPE, personID);
137 }
138 
139 
140 double
141 Person::getWaitingTime(const std::string& personID) {
142  return Dom::getDouble(libsumo::VAR_WAITING_TIME, personID);
143 }
144 
145 
146 std::string
147 Person::getNextEdge(const std::string& personID) {
148  return Dom::getString(libsumo::VAR_NEXT_EDGE, personID);
149 }
150 
151 
152 std::vector<std::string>
153 Person::getEdges(const std::string& personID, int nextStageIndex) {
154  tcpip::Storage content;
156  content.writeInt(nextStageIndex);
157  return Dom::getStringVector(libsumo::VAR_EDGES, personID, &content);
158 }
159 
160 
162 Person::getStage(const std::string& personID, int nextStageIndex) {
163  tcpip::Storage content;
165  content.writeInt(nextStageIndex);
166  return Dom::getTraCIStage(libsumo::VAR_STAGE, personID, &content);
167 }
168 
169 
170 int
171 Person::getRemainingStages(const std::string& personID) {
172  return Dom::getInt(libsumo::VAR_STAGES_REMAINING, personID);
173 }
174 
175 
176 std::string
177 Person::getVehicle(const std::string& personID) {
178  return Dom::getString(libsumo::VAR_VEHICLE, personID);
179 }
180 
181 
182 std::string
183 Person::getEmissionClass(const std::string& personID) {
184  return Dom::getString(libsumo::VAR_EMISSIONCLASS, personID);
185 }
186 
187 
188 std::string
189 Person::getShapeClass(const std::string& personID) {
190  return Dom::getString(libsumo::VAR_SHAPECLASS, personID);
191 }
192 
193 
194 double
195 Person::getLength(const std::string& personID) {
196  return Dom::getDouble(libsumo::VAR_LENGTH, personID);
197 }
198 
199 
200 double
201 Person::getSpeedFactor(const std::string& personID) {
202  return Dom::getDouble(libsumo::VAR_SPEED_FACTOR, personID);
203 }
204 
205 
206 double
207 Person::getAccel(const std::string& personID) {
208  return Dom::getDouble(libsumo::VAR_ACCEL, personID);
209 }
210 
211 
212 double
213 Person::getDecel(const std::string& personID) {
214  return Dom::getDouble(libsumo::VAR_DECEL, personID);
215 }
216 
217 
218 double Person::getEmergencyDecel(const std::string& personID) {
220 }
221 
222 
223 double Person::getApparentDecel(const std::string& personID) {
225 }
226 
227 
228 double Person::getActionStepLength(const std::string& personID) {
230 }
231 
232 
233 double
234 Person::getTau(const std::string& personID) {
235  return Dom::getDouble(libsumo::VAR_TAU, personID);
236 }
237 
238 
239 double
240 Person::getImperfection(const std::string& personID) {
241  return Dom::getDouble(libsumo::VAR_IMPERFECTION, personID);
242 }
243 
244 
245 double
246 Person::getSpeedDeviation(const std::string& personID) {
248 }
249 
250 
251 std::string
252 Person::getVehicleClass(const std::string& personID) {
253  return Dom::getString(libsumo::VAR_VEHICLECLASS, personID);
254 }
255 
256 
257 double
258 Person::getMinGap(const std::string& personID) {
259  return Dom::getDouble(libsumo::VAR_MINGAP, personID);
260 }
261 
262 
263 double
264 Person::getMinGapLat(const std::string& personID) {
265  return Dom::getDouble(libsumo::VAR_MINGAP_LAT, personID);
266 }
267 
268 
269 double
270 Person::getMaxSpeed(const std::string& personID) {
271  return Dom::getDouble(libsumo::VAR_MAXSPEED, personID);
272 }
273 
274 
275 double
276 Person::getMaxSpeedLat(const std::string& personID) {
277  return Dom::getDouble(libsumo::VAR_MAXSPEED_LAT, personID);
278 }
279 
280 
281 std::string
282 Person::getLateralAlignment(const std::string& personID) {
283  return Dom::getString(libsumo::VAR_LATALIGNMENT, personID);
284 }
285 
286 
287 double
288 Person::getWidth(const std::string& personID) {
289  return Dom::getDouble(libsumo::VAR_WIDTH, personID);
290 }
291 
292 
293 double
294 Person::getHeight(const std::string& personID) {
295  return Dom::getDouble(libsumo::VAR_HEIGHT, personID);
296 }
297 
298 
299 int
300 Person::getPersonCapacity(const std::string& personID) {
301  return Dom::getInt(libsumo::VAR_PERSON_CAPACITY, personID);
302 }
303 
304 
306 
307 
308 void
309 Person::setSpeed(const std::string& personID, double speed) {
310  Dom::setDouble(libsumo::VAR_SPEED, personID, speed);
311 }
312 
313 
314 void
315 Person::setType(const std::string& personID, const std::string& typeID) {
316  Dom::setString(libsumo::VAR_TYPE, personID, typeID);
317 }
318 
319 
320 void
321 Person::add(const std::string& personID, const std::string& edgeID, double pos, double departInSecs, const std::string typeID) {
322  tcpip::Storage content;
324  content.writeInt(4);
326  content.writeString(typeID);
328  content.writeString(edgeID);
330  content.writeDouble(departInSecs);
332  content.writeDouble(pos);
333  Dom::set(libsumo::ADD, personID, &content);
334 }
335 
336 
337 void
338 Person::writeStage(const libsumo::TraCIStage& stage, tcpip::Storage& content) {
340  content.writeInt(13);
342  content.writeInt(stage.type);
344  content.writeString(stage.vType);
346  content.writeString(stage.line);
348  content.writeString(stage.destStop);
350  content.writeStringList(stage.edges);
352  content.writeDouble(stage.travelTime);
354  content.writeDouble(stage.cost);
356  content.writeDouble(stage.length);
358  content.writeString(stage.intended);
360  content.writeDouble(stage.depart);
362  content.writeDouble(stage.departPos);
364  content.writeDouble(stage.arrivalPos);
366  content.writeString(stage.description);
367 }
368 
369 
370 void
371 Person::appendStage(const std::string& personID, const libsumo::TraCIStage& stage) {
372  tcpip::Storage content;
373  writeStage(stage, content);
374  Dom::set(libsumo::APPEND_STAGE, personID, &content);
375 }
376 
377 
378 void
379 Person::replaceStage(const std::string& personID, const int stageIndex, const libsumo::TraCIStage& stage) {
380  tcpip::Storage content;
382  content.writeInt(2);
384  content.writeInt(stageIndex);
385  writeStage(stage, content);
386  Dom::set(libsumo::REPLACE_STAGE, personID, &content);
387 }
388 
389 
390 void
391 Person::appendDrivingStage(const std::string& personID, const std::string& toEdge, const std::string& lines, const std::string& stopID) {
392  tcpip::Storage content;
394  content.writeInt(4);
398  content.writeString(toEdge);
400  content.writeString(lines);
402  content.writeString(stopID);
403  Dom::set(libsumo::APPEND_STAGE, personID, &content);
404 }
405 
406 
407 void
408 Person::appendWaitingStage(const std::string& personID, double duration, const std::string& description, const std::string& stopID) {
409  tcpip::Storage content;
411  content.writeInt(4);
415  content.writeDouble(duration);
417  content.writeString(description);
419  content.writeString(stopID);
420  Dom::set(libsumo::APPEND_STAGE, personID, &content);
421 }
422 
423 
424 void
425 Person::appendWalkingStage(const std::string& personID, const std::vector<std::string>& edges, double arrivalPos, double duration, double speed, const std::string& stopID) {
426  tcpip::Storage content;
428  content.writeInt(6);
432  content.writeStringList(edges);
434  content.writeDouble(arrivalPos);
436  content.writeDouble(duration);
438  content.writeDouble(speed);
440  content.writeString(stopID);
441  Dom::set(libsumo::APPEND_STAGE, personID, &content);
442 }
443 
444 
445 void
446 Person::removeStage(const std::string& personID, int nextStageIndex) {
447  Dom::setInt(libsumo::REMOVE_STAGE, personID, nextStageIndex);
448 }
449 
450 
451 void
452 Person::rerouteTraveltime(const std::string& personID) {
453  tcpip::Storage content;
455  content.writeInt(0);
456  Dom::set(libsumo::CMD_REROUTE_TRAVELTIME, personID, &content);
457 }
458 
459 
460 void
461 Person::moveTo(const std::string& personID, const std::string& edgeID, double position) {
462  tcpip::Storage content;
464  content.writeInt(2);
466  content.writeString(edgeID);
468  content.writeDouble(position);
469  Dom::set(libsumo::VAR_MOVE_TO, personID, &content);
470 }
471 
472 
473 void
474 Person::moveToXY(const std::string& personID, const std::string& edgeID, const double x, const double y, double angle, const int keepRoute, double matchThreshold) {
475  tcpip::Storage content;
477  content.writeInt(6);
479  content.writeString(edgeID);
481  content.writeDouble(x);
483  content.writeDouble(y);
485  content.writeDouble(angle);
487  content.writeByte(keepRoute);
488  StoHelp::writeTypedDouble(content, matchThreshold);
489  Dom::set(libsumo::MOVE_TO_XY, personID, &content);
490 }
491 
492 
495 void
496 Person::setLength(const std::string& personID, double length) {
497  Dom::setDouble(libsumo::VAR_LENGTH, personID, length);
498 }
499 
500 
501 void
502 Person::setMaxSpeed(const std::string& personID, double speed) {
503  Dom::setDouble(libsumo::VAR_MAXSPEED, personID, speed);
504 }
505 
506 
507 void
508 Person::setVehicleClass(const std::string& personID, const std::string& clazz) {
509  Dom::setString(libsumo::VAR_VEHICLECLASS, personID, clazz);
510 }
511 
512 
513 void
514 Person::setShapeClass(const std::string& personID, const std::string& clazz) {
515  Dom::setString(libsumo::VAR_SHAPECLASS, personID, clazz);
516 }
517 
518 
519 void
520 Person::setEmissionClass(const std::string& personID, const std::string& clazz) {
521  Dom::setString(libsumo::VAR_EMISSIONCLASS, personID, clazz);
522 }
523 
524 
525 void
526 Person::setWidth(const std::string& personID, double width) {
527  Dom::setDouble(libsumo::VAR_WIDTH, personID, width);
528 }
529 
530 
531 void
532 Person::setHeight(const std::string& personID, double height) {
533  Dom::setDouble(libsumo::VAR_HEIGHT, personID, height);
534 }
535 
536 
537 void
538 Person::setMinGap(const std::string& personID, double minGap) {
539  Dom::setDouble(libsumo::VAR_MINGAP, personID, minGap);
540 }
541 
542 
543 void
544 Person::setAccel(const std::string& personID, double accel) {
545  Dom::setDouble(libsumo::VAR_ACCEL, personID, accel);
546 }
547 
548 
549 void
550 Person::setDecel(const std::string& personID, double decel) {
551  Dom::setDouble(libsumo::VAR_DECEL, personID, decel);
552 }
553 
554 
555 void
556 Person::setEmergencyDecel(const std::string& personID, double decel) {
558 }
559 
560 
561 void
562 Person::setApparentDecel(const std::string& personID, double decel) {
564 }
565 
566 
567 void
568 Person::setImperfection(const std::string& personID, double imperfection) {
569  Dom::setDouble(libsumo::VAR_IMPERFECTION, personID, imperfection);
570 }
571 
572 
573 void
574 Person::setTau(const std::string& personID, double tau) {
575  Dom::setDouble(libsumo::VAR_TAU, personID, tau);
576 }
577 
578 
579 void
580 Person::setMinGapLat(const std::string& personID, double minGapLat) {
581  Dom::setDouble(libsumo::VAR_MINGAP_LAT, personID, minGapLat);
582 }
583 
584 
585 void
586 Person::setMaxSpeedLat(const std::string& personID, double speed) {
587  Dom::setDouble(libsumo::VAR_MAXSPEED_LAT, personID, speed);
588 }
589 
590 
591 void
592 Person::setLateralAlignment(const std::string& personID, const std::string& latAlignment) {
593  Dom::setString(libsumo::VAR_LATALIGNMENT, personID, latAlignment);
594 }
595 
596 
597 void
598 Person::setSpeedFactor(const std::string& personID, double factor) {
599  Dom::setDouble(libsumo::VAR_SPEED_FACTOR, personID, factor);
600 }
601 
602 
603 void
604 Person::setActionStepLength(const std::string& personID, double actionStepLength, bool resetActionOffset) {
605  if (!resetActionOffset) {
606  actionStepLength *= -1;
607  }
608  Dom::setDouble(libsumo::VAR_ACTIONSTEPLENGTH, personID, actionStepLength);
609 }
610 
611 void
612 Person::remove(const std::string& personID, char reason) {
613  tcpip::Storage content;
615  content.writeUnsignedByte(reason);
616  Dom::set(libsumo::REMOVE, personID, &content);
617 }
618 
619 
620 void
621 Person::setColor(const std::string& personID, const libsumo::TraCIColor& color) {
622  Dom::setCol(libsumo::VAR_COLOR, personID, color);
623 }
624 
625 
627 
628 
629 }
630 
631 
632 /****************************************************************************/
#define LIBTRACI_SUBSCRIPTION_IMPLEMENTATION(CLASS, DOMAIN)
Definition: Domain.h:38
#define LIBTRACI_PARAMETER_IMPLEMENTATION(CLASS, DOMAIN)
Definition: Domain.h:76
C++ TraCI client API implementation.
Definition: Person.h:35
static void writeTypedDouble(tcpip::Storage &content, double value)
static int readCompound(tcpip::Storage &ret, int expectedSize=-1, const std::string &error="")
Definition: StorageHelper.h:85
static int readTypedInt(tcpip::Storage &ret, const std::string &error="")
Definition: StorageHelper.h:50
static std::string readTypedString(tcpip::Storage &ret, const std::string &error="")
Definition: StorageHelper.h:71
static void writeTypedInt(tcpip::Storage &content, int value)
static std::vector< std::string > readTypedStringList(tcpip::Storage &ret, const std::string &error="")
Definition: StorageHelper.h:78
static void writeTypedStringList(tcpip::Storage &content, const std::vector< std::string > &value)
static double readTypedDouble(tcpip::Storage &ret, const std::string &error="")
Definition: StorageHelper.h:64
double depart
pickup-time
Definition: TraCIDefs.h:566
double departPos
pickup position on the origin edge
Definition: TraCIDefs.h:562
double reservationTime
time when the reservation was made
Definition: TraCIDefs.h:568
double arrivalPos
drop-off position on the destination edge
Definition: TraCIDefs.h:564
std::vector< std::string > persons
The persons ids that are part of this reservation.
Definition: TraCIDefs.h:554
int state
the state of this reservation
Definition: TraCIDefs.h:570
std::string fromEdge
The origin edge id.
Definition: TraCIDefs.h:558
std::string group
The group id of this reservation.
Definition: TraCIDefs.h:556
std::string id
The id of the taxi reservation (usable for traci.vehicle.dispatchTaxi)
Definition: TraCIDefs.h:552
std::string toEdge
The destination edge id.
Definition: TraCIDefs.h:560
std::string intended
id of the intended vehicle for public transport ride
Definition: TraCIDefs.h:523
int type
The type of stage (walking, driving, ...)
Definition: TraCIDefs.h:507
std::string destStop
The id of the destination stop.
Definition: TraCIDefs.h:513
double length
length in m
Definition: TraCIDefs.h:521
double travelTime
duration of the stage in seconds
Definition: TraCIDefs.h:517
double departPos
position on the lane when starting the stage
Definition: TraCIDefs.h:527
std::string description
arbitrary description string
Definition: TraCIDefs.h:531
std::string line
The line or the id of the vehicle type.
Definition: TraCIDefs.h:511
double cost
effort needed
Definition: TraCIDefs.h:519
double depart
intended depart time for public transport ride or INVALID_DOUBLE_VALUE
Definition: TraCIDefs.h:525
std::vector< std::string > edges
The sequence of edges to travel.
Definition: TraCIDefs.h:515
double arrivalPos
position on the lane when ending the stage
Definition: TraCIDefs.h:529
std::string vType
The vehicle type when using a private car or bike.
Definition: TraCIDefs.h:509
static void setDouble(int var, const std::string &id, double value)
Definition: Domain.h:215
static libsumo::TraCIPosition getPos(int var, const std::string &id, tcpip::Storage *add=nullptr, const bool isGeo=false)
Definition: Domain.h:149
static void setCol(int var, const std::string &id, const libsumo::TraCIColor value)
Definition: Domain.h:236
static std::vector< std::string > getStringVector(int var, const std::string &id, tcpip::Storage *add=nullptr)
Definition: Domain.h:170
static libsumo::TraCIColor getCol(int var, const std::string &id, tcpip::Storage *add=nullptr)
Definition: Domain.h:174
static std::string getString(int var, const std::string &id, tcpip::Storage *add=nullptr)
Definition: Domain.h:166
static int getInt(int var, const std::string &id, tcpip::Storage *add=nullptr)
Definition: Domain.h:124
static libsumo::TraCIStage getTraCIStage(int var, const std::string &id, tcpip::Storage *add=nullptr)
Definition: Domain.h:184
static void set(int var, const std::string &id, tcpip::Storage *add)
Definition: Domain.h:204
static libsumo::TraCIPosition getPos3D(int var, const std::string &id, tcpip::Storage *add=nullptr, const bool isGeo=false)
Definition: Domain.h:157
static double getDouble(int var, const std::string &id, tcpip::Storage *add=nullptr)
Definition: Domain.h:128
static tcpip::Storage & get(int var, const std::string &id, tcpip::Storage *add=nullptr, int expectedType=libsumo::TYPE_COMPOUND)
Definition: Domain.h:110
static void setInt(int var, const std::string &id, int value)
Definition: Domain.h:208
static void setString(int var, const std::string &id, const std::string &value)
Definition: Domain.h:222
virtual void writeString(const std::string &s)
Definition: storage.cpp:197
virtual void writeInt(int)
Definition: storage.cpp:321
virtual void writeDouble(double)
Definition: storage.cpp:354
virtual void writeStringList(const std::vector< std::string > &s)
Definition: storage.cpp:247
virtual void writeUnsignedByte(int)
Definition: storage.cpp:165
virtual void writeByte(int)
Definition: storage.cpp:140
virtual int readInt()
Definition: storage.cpp:311
TRACI_CONST int VAR_EDGES
TRACI_CONST int VAR_VEHICLECLASS
TRACI_CONST int TRACI_ID_LIST
TRACI_CONST int VAR_LATALIGNMENT
TRACI_CONST int VAR_TYPE
TRACI_CONST int VAR_MINGAP
TRACI_CONST int VAR_VEHICLE
TRACI_CONST int VAR_SHAPECLASS
TRACI_CONST int VAR_WAITING_TIME
TRACI_CONST int REPLACE_STAGE
TRACI_CONST int VAR_ROAD_ID
TRACI_CONST int VAR_TAXI_RESERVATIONS
TRACI_CONST int VAR_ACTIONSTEPLENGTH
TRACI_CONST int VAR_SPEED_FACTOR
TRACI_CONST int MOVE_TO_XY
TRACI_CONST int VAR_ANGLE
TRACI_CONST int VAR_TAU
TRACI_CONST int TYPE_COMPOUND
TRACI_CONST int VAR_STAGE
TRACI_CONST int VAR_MOVE_TO
TRACI_CONST int VAR_COLOR
TRACI_CONST int VAR_POSITION
TRACI_CONST int VAR_WIDTH
TRACI_CONST int VAR_PERSON_CAPACITY
TRACI_CONST int VAR_MAXSPEED
TRACI_CONST int STAGE_WAITING
TRACI_CONST int CMD_REROUTE_TRAVELTIME
TRACI_CONST int TYPE_STRINGLIST
TRACI_CONST int APPEND_STAGE
TRACI_CONST int TYPE_INTEGER
TRACI_CONST int VAR_SLOPE
TRACI_CONST int VAR_LENGTH
TRACI_CONST int VAR_MAXSPEED_LAT
TRACI_CONST int ID_COUNT
TRACI_CONST int VAR_LANEPOSITION
TRACI_CONST int REMOVE
TRACI_CONST int VAR_LANE_ID
TRACI_CONST int VAR_IMPERFECTION
TRACI_CONST int VAR_HEIGHT
TRACI_CONST int VAR_APPARENT_DECEL
TRACI_CONST int STAGE_WALKING
TRACI_CONST int VAR_POSITION3D
TRACI_CONST int REMOVE_STAGE
TRACI_CONST int VAR_SPEED
TRACI_CONST int VAR_DECEL
TRACI_CONST int VAR_MINGAP_LAT
TRACI_CONST int VAR_NEXT_EDGE
TRACI_CONST int TYPE_DOUBLE
TRACI_CONST int TYPE_BYTE
TRACI_CONST int VAR_EMERGENCY_DECEL
TRACI_CONST int STAGE_DRIVING
TRACI_CONST int VAR_EMISSIONCLASS
TRACI_CONST int VAR_ACCEL
TRACI_CONST int ADD
TRACI_CONST int VAR_STAGES_REMAINING
TRACI_CONST int SPLIT_TAXI_RESERVATIONS
TRACI_CONST int VAR_SPEED_DEVIATION
TRACI_CONST int TYPE_STRING
Domain< libsumo::CMD_GET_BUSSTOP_VARIABLE, libsumo::CMD_SET_BUSSTOP_VARIABLE > Dom
A 3D-position.
Definition: TraCIDefs.h:164