Eclipse SUMO - Simulation of Urban MObility
TraCIDefs.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2012-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 /****************************************************************************/
21 // C++ TraCI client API implementation
22 /****************************************************************************/
23 #pragma once
24 // we do not include config.h here, since we should be independent of a special sumo build
25 #include <libsumo/TraCIConstants.h>
26 #include <vector>
27 #include <limits>
28 #include <map>
29 #include <string>
30 #include <stdexcept>
31 #include <sstream>
32 #include <memory>
33 
34 
35 // ===========================================================================
36 // global definitions
37 // ===========================================================================
38 #ifdef LIBTRACI
39 #define LIBSUMO_NAMESPACE libtraci
40 #else
41 #define LIBSUMO_NAMESPACE libsumo
42 #endif
43 
44 #define LIBSUMO_SUBSCRIPTION_API \
45 static void subscribe(const std::string& objectID, const std::vector<int>& varIDs = std::vector<int>({-1}), \
46  double begin = libsumo::INVALID_DOUBLE_VALUE, double end = libsumo::INVALID_DOUBLE_VALUE, const libsumo::TraCIResults& params = libsumo::TraCIResults()); \
47 static void unsubscribe(const std::string& objectID); \
48 static void subscribeContext(const std::string& objectID, int domain, double dist, const std::vector<int>& varIDs = std::vector<int>({-1}), \
49  double begin = libsumo::INVALID_DOUBLE_VALUE, double end = libsumo::INVALID_DOUBLE_VALUE, const libsumo::TraCIResults& params = libsumo::TraCIResults()); \
50 static void unsubscribeContext(const std::string& objectID, int domain, double dist); \
51 static const libsumo::SubscriptionResults getAllSubscriptionResults(); \
52 static const libsumo::TraCIResults getSubscriptionResults(const std::string& objectID); \
53 static const libsumo::ContextSubscriptionResults getAllContextSubscriptionResults(); \
54 static const libsumo::SubscriptionResults getContextSubscriptionResults(const std::string& objectID); \
55 static void subscribeParameterWithKey(const std::string& objectID, const std::string& key, double beginTime = libsumo::INVALID_DOUBLE_VALUE, double endTime = libsumo::INVALID_DOUBLE_VALUE);
56 
57 #define LIBSUMO_SUBSCRIPTION_IMPLEMENTATION(CLASS, DOMAIN) \
58 void \
59 CLASS::subscribe(const std::string& objectID, const std::vector<int>& varIDs, double begin, double end, const libsumo::TraCIResults& params) { \
60  libsumo::Helper::subscribe(libsumo::CMD_SUBSCRIBE_##DOMAIN##_VARIABLE, objectID, varIDs, begin, end, params); \
61 } \
62 void \
63 CLASS::unsubscribe(const std::string& objectID) { \
64  libsumo::Helper::subscribe(libsumo::CMD_SUBSCRIBE_##DOMAIN##_VARIABLE, objectID, std::vector<int>(), libsumo::INVALID_DOUBLE_VALUE, libsumo::INVALID_DOUBLE_VALUE, libsumo::TraCIResults()); \
65 } \
66 void \
67 CLASS::subscribeContext(const std::string& objectID, int domain, double dist, const std::vector<int>& varIDs, double begin, double end, const TraCIResults& params) { \
68  libsumo::Helper::subscribe(libsumo::CMD_SUBSCRIBE_##DOMAIN##_CONTEXT, objectID, varIDs, begin, end, params, domain, dist); \
69 } \
70 void \
71 CLASS::unsubscribeContext(const std::string& objectID, int domain, double dist) { \
72  libsumo::Helper::subscribe(libsumo::CMD_SUBSCRIBE_##DOMAIN##_CONTEXT, objectID, std::vector<int>(), libsumo::INVALID_DOUBLE_VALUE, libsumo::INVALID_DOUBLE_VALUE, libsumo::TraCIResults(), domain, dist); \
73 } \
74 const libsumo::SubscriptionResults \
75 CLASS::getAllSubscriptionResults() { \
76  return mySubscriptionResults; \
77 } \
78 const libsumo::TraCIResults \
79 CLASS::getSubscriptionResults(const std::string& objectID) { \
80  return mySubscriptionResults[objectID]; \
81 } \
82 const libsumo::ContextSubscriptionResults \
83 CLASS::getAllContextSubscriptionResults() { \
84  return myContextSubscriptionResults; \
85 } \
86 const libsumo::SubscriptionResults \
87 CLASS::getContextSubscriptionResults(const std::string& objectID) { \
88  return myContextSubscriptionResults[objectID]; \
89 } \
90 void \
91 CLASS::subscribeParameterWithKey(const std::string& objectID, const std::string& key, double beginTime, double endTime) { \
92  libsumo::Helper::subscribe(libsumo::CMD_SUBSCRIBE_##DOMAIN##_VARIABLE, objectID, std::vector<int>({libsumo::VAR_PARAMETER_WITH_KEY}), beginTime, endTime, libsumo::TraCIResults {{libsumo::VAR_PARAMETER_WITH_KEY, std::make_shared<libsumo::TraCIString>(key)}}); \
93  libsumo::Helper::addSubscriptionParam(key); \
94 }
95 
96 
97 #define LIBSUMO_ID_PARAMETER_API \
98 static std::vector<std::string> getIDList(); \
99 static int getIDCount(); \
100 static std::string getParameter(const std::string& objectID, const std::string& param); \
101 static const std::pair<std::string, std::string> getParameterWithKey(const std::string& objectID, const std::string& key); \
102 static void setParameter(const std::string& objectID, const std::string& param, const std::string& value);
103 
104 #define LIBSUMO_GET_PARAMETER_WITH_KEY_IMPLEMENTATION(CLASS) \
105 const std::pair<std::string, std::string> \
106 CLASS::getParameterWithKey(const std::string& objectID, const std::string& key) { \
107  return std::make_pair(key, getParameter(objectID, key)); \
108 }
109 
110 
111 // ===========================================================================
112 // class and type definitions
113 // ===========================================================================
114 namespace libsumo {
118 class TraCIException : public std::runtime_error {
119 public:
121  TraCIException(std::string what)
122  : std::runtime_error(what) {}
123 };
124 
127 
128 struct TraCIResult {
129  virtual ~TraCIResult() {}
130  virtual std::string getString() {
131  return "";
132  }
133  virtual const std::vector<unsigned char> toPacket() const {
134  return std::vector<unsigned char>();
135  }
136 };
137 
142  std::string getString() {
143  std::ostringstream os;
144  os << "TraCIPosition(" << x << "," << y << "," << z << ")";
145  return os.str();
146  }
148 };
149 
154  std::string getString() {
155  std::ostringstream os;
156  os << "TraCIRoadPosition(" << edgeID << "_" << laneIndex << "," << pos << ")";
157  return os.str();
158  }
159  std::string edgeID;
160  double pos;
162 };
163 
168  TraCIColor() : r(0), g(0), b(0), a(255) {}
169  TraCIColor(int r, int g, int b, int a = 255) : r(r), g(g), b(b), a(a) {}
170  std::string getString() {
171  std::ostringstream os;
172  os << "TraCIColor(" << r << "," << g << "," << b << "," << a << ")";
173  return os.str();
174  }
175  int r, g, b, a;
176 };
177 
178 
183  std::string getString() {
184  std::ostringstream os;
185  os << "TraCILeaderDistance(" << leaderID << "," << dist << ")";
186  return os.str();
187  }
188  std::string leaderID;
189  double dist;
190 };
191 
192 
196 typedef std::vector<TraCIPosition> TraCIPositionVector;
197 
198 
200  TraCIInt() : value(0) {}
201  TraCIInt(int v) : value(v) {}
202  std::string getString() {
203  std::ostringstream os;
204  os << value;
205  return os.str();
206  }
207  int value;
208 };
209 
210 
212  TraCIDouble() : value(0.) {}
213  TraCIDouble(double v) : value(v) {}
214  std::string getString() {
215  std::ostringstream os;
216  os << value;
217  return os.str();
218  }
219  double value;
220 };
221 
222 
224  TraCIString() : value("") {}
225  TraCIString(std::string v) : value(v) {}
226  std::string getString() {
227  return value;
228  }
229  std::string value;
230 };
231 
232 
234  std::string getString() {
235  std::ostringstream os;
236  os << "[";
237  for (std::string v : value) {
238  os << v << ",";
239  }
240  os << "]";
241  return os.str();
242  }
243  std::vector<std::string> value;
244 };
245 
246 
248 typedef std::map<int, std::shared_ptr<TraCIResult> > TraCIResults;
250 typedef std::map<std::string, TraCIResults> SubscriptionResults;
251 typedef std::map<std::string, SubscriptionResults> ContextSubscriptionResults;
252 
253 
254 class TraCIPhase {
255 public:
257  TraCIPhase(const double _duration, const std::string& _state, const double _minDur = libsumo::INVALID_DOUBLE_VALUE,
258  const double _maxDur = libsumo::INVALID_DOUBLE_VALUE,
259  const std::vector<int>& _next = std::vector<int>(),
260  const std::string& _name = "") :
261  duration(_duration), state(_state), minDur(_minDur), maxDur(_maxDur), next(_next), name(_name) {}
263 
264  double duration;
265  std::string state;
266  double minDur, maxDur;
267  std::vector<int> next;
268  std::string name;
269 };
270 }
271 
272 
273 #ifdef SWIG
274 %template(TraCIPhaseVector) std::vector<libsumo::TraCIPhase*>; // *NOPAD*
275 #endif
276 
277 
278 namespace libsumo {
279 class TraCILogic {
280 public:
282  TraCILogic(const std::string& _programID, const int _type, const int _currentPhaseIndex,
283  const std::vector<libsumo::TraCIPhase*>& _phases = std::vector<libsumo::TraCIPhase*>())
284  : programID(_programID), type(_type), currentPhaseIndex(_currentPhaseIndex), phases(_phases) {}
286 
287  std::string programID;
288  int type;
290  std::vector<TraCIPhase*> phases;
291  std::map<std::string, std::string> subParameter;
292 };
293 
294 
295 class TraCILink {
296 public:
297  TraCILink(const std::string& _from, const std::string& _via, const std::string& _to)
298  : fromLane(_from), viaLane(_via), toLane(_to) {}
300 
301  std::string fromLane;
302  std::string viaLane;
303  std::string toLane;
304 };
305 
306 
308 public:
309  TraCIConnection() {} // this is needed by SWIG when building a vector of this type, please don't use it
310  TraCIConnection(const std::string& _approachedLane, const bool _hasPrio, const bool _isOpen, const bool _hasFoe,
311  const std::string _approachedInternal, const std::string _state, const std::string _direction, const double _length)
312  : approachedLane(_approachedLane), hasPrio(_hasPrio), isOpen(_isOpen), hasFoe(_hasFoe),
313  approachedInternal(_approachedInternal), state(_state), direction(_direction), length(_length) {}
315 
316  std::string approachedLane;
317  bool hasPrio;
318  bool isOpen;
319  bool hasFoe;
320  std::string approachedInternal;
321  std::string state;
322  std::string direction;
323  double length;
324 };
325 
326 
330  std::string id;
332  double length;
334  double entryTime;
336  double leaveTime;
338  std::string typeID;
339 };
340 
341 
344  std::string id;
346  int tlIndex;
348  double dist;
350  char state;
351 };
352 
353 
355 
356  TraCINextStopData(const std::string& lane = "",
357  double startPos = INVALID_DOUBLE_VALUE,
358  double endPos = INVALID_DOUBLE_VALUE,
359  const std::string& stoppingPlaceID = "",
360  int stopFlags = 0,
361  double duration = INVALID_DOUBLE_VALUE,
362  double until = INVALID_DOUBLE_VALUE,
363  double intendedArrival = INVALID_DOUBLE_VALUE,
364  double arrival = INVALID_DOUBLE_VALUE,
365  double depart = INVALID_DOUBLE_VALUE,
366  const std::string& split = "",
367  const std::string& join = "",
368  const std::string& actType = "",
369  const std::string& tripId = "",
370  const std::string& line = "",
371  double speed = 0):
372  lane(lane),
373  startPos(startPos),
374  endPos(endPos),
375  stoppingPlaceID(stoppingPlaceID),
376  stopFlags(stopFlags),
377  duration(duration),
378  until(until),
379  intendedArrival(intendedArrival),
380  arrival(arrival),
381  depart(depart),
382  split(split),
383  join(join),
384  actType(actType),
385  tripId(tripId),
386  line(line),
387  speed(speed)
388  {}
389 
390  std::string getString() {
391  std::ostringstream os;
392  os << "TraCINextStopData(" << lane << "," << endPos << "," << stoppingPlaceID
393  << "," << stopFlags << "," << duration << "," << until
394  << "," << arrival << ")";
395  return os.str();
396  }
397 
399  std::string lane;
401  double startPos;
403  double endPos;
405  std::string stoppingPlaceID;
409  double duration;
411  double until;
415  double arrival;
417  double depart;
419  std::string split;
421  std::string join;
423  std::string actType;
425  std::string tripId;
427  std::string line;
429  double speed;
430 };
431 
432 
438  std::string getString() {
439  std::ostringstream os;
440  os << "TraCINextStopDataVector[";
441  for (TraCINextStopData v : value) {
442  os << v.getString() << ",";
443  }
444  os << "]";
445  return os.str();
446  }
447 
448  std::vector<TraCINextStopData> value;
449 };
450 
451 
454  std::string laneID;
456  double length;
458  double occupation;
464  std::vector<std::string> continuationLanes;
465 };
466 
467 
468 class TraCIStage {
469 public:
470  TraCIStage(int type = INVALID_INT_VALUE, const std::string& vType = "", const std::string& line = "", const std::string& destStop = "",
471  const std::vector<std::string>& edges = std::vector<std::string>(),
472  double travelTime = INVALID_DOUBLE_VALUE, double cost = INVALID_DOUBLE_VALUE, double length = INVALID_DOUBLE_VALUE,
473  const std::string& intended = "", double depart = INVALID_DOUBLE_VALUE, double departPos = INVALID_DOUBLE_VALUE,
474  double arrivalPos = INVALID_DOUBLE_VALUE, const std::string& description = "") :
475  type(type), vType(vType), line(line), destStop(destStop), edges(edges), travelTime(travelTime), cost(cost),
476  length(length), intended(intended), depart(depart), departPos(departPos), arrivalPos(arrivalPos), description(description) {}
478  int type;
480  std::string vType;
482  std::string line;
484  std::string destStop;
486  std::vector<std::string> edges;
488  double travelTime;
490  double cost;
492  double length;
494  std::string intended;
496  double depart;
498  double departPos;
500  double arrivalPos;
502  std::string description;
503 };
504 
505 
506 
508 public:
510  TraCIReservation(const std::string& id,
511  const std::vector<std::string>& persons,
512  const std::string& group,
513  const std::string& fromEdge,
514  const std::string& toEdge,
515  double departPos,
516  double arrivalPos,
517  double depart,
518  double reservationTime) :
519  id(id), persons(persons), group(group), fromEdge(fromEdge), toEdge(toEdge), departPos(departPos), arrivalPos(arrivalPos),
520  depart(depart), reservationTime(reservationTime) {}
522  std::string id;
524  std::vector<std::string> persons;
526  std::string group;
528  std::string fromEdge;
530  std::string toEdge;
532  double departPos;
534  double arrivalPos;
536  double depart;
539 };
540 }
std::vector< std::string > & split(const std::string &s, char delim, std::vector< std::string > &elems)
TraCIConnection(const std::string &_approachedLane, const bool _hasPrio, const bool _isOpen, const bool _hasFoe, const std::string _approachedInternal, const std::string _state, const std::string _direction, const double _length)
Definition: TraCIDefs.h:310
std::string approachedLane
Definition: TraCIDefs.h:316
std::string approachedInternal
Definition: TraCIDefs.h:320
TraCIException(std::string what)
Definition: TraCIDefs.h:121
std::map< std::string, std::string > subParameter
Definition: TraCIDefs.h:291
std::string programID
Definition: TraCIDefs.h:287
TraCILogic(const std::string &_programID, const int _type, const int _currentPhaseIndex, const std::vector< libsumo::TraCIPhase * > &_phases=std::vector< libsumo::TraCIPhase * >())
Definition: TraCIDefs.h:282
std::vector< TraCIPhase * > phases
Definition: TraCIDefs.h:290
std::vector< int > next
Definition: TraCIDefs.h:267
std::string state
Definition: TraCIDefs.h:265
std::string name
Definition: TraCIDefs.h:268
TraCIPhase(const double _duration, const std::string &_state, const double _minDur=libsumo::INVALID_DOUBLE_VALUE, const double _maxDur=libsumo::INVALID_DOUBLE_VALUE, const std::vector< int > &_next=std::vector< int >(), const std::string &_name="")
Definition: TraCIDefs.h:257
double depart
pickup-time
Definition: TraCIDefs.h:536
double departPos
pickup position on the origin edge
Definition: TraCIDefs.h:532
double reservationTime
time when the reservation was made
Definition: TraCIDefs.h:538
double arrivalPos
drop-off position on the destination edge
Definition: TraCIDefs.h:534
TraCIReservation(const std::string &id, const std::vector< std::string > &persons, const std::string &group, const std::string &fromEdge, const std::string &toEdge, double departPos, double arrivalPos, double depart, double reservationTime)
Definition: TraCIDefs.h:510
std::vector< std::string > persons
The persons ids that are part of this reservation.
Definition: TraCIDefs.h:524
std::string fromEdge
The origin edge id.
Definition: TraCIDefs.h:528
std::string group
The group id of this reservation.
Definition: TraCIDefs.h:526
std::string id
The id of the taxi reservation (usable for traci.vehicle.dispatchTaxi)
Definition: TraCIDefs.h:522
std::string toEdge
The destination edge id.
Definition: TraCIDefs.h:530
std::string intended
id of the intended vehicle for public transport ride
Definition: TraCIDefs.h:494
int type
The type of stage (walking, driving, ...)
Definition: TraCIDefs.h:478
std::string destStop
The id of the destination stop.
Definition: TraCIDefs.h:484
double length
length in m
Definition: TraCIDefs.h:492
double travelTime
duration of the stage in seconds
Definition: TraCIDefs.h:488
double departPos
position on the lane when starting the stage
Definition: TraCIDefs.h:498
std::string description
arbitrary description string
Definition: TraCIDefs.h:502
std::string line
The line or the id of the vehicle type.
Definition: TraCIDefs.h:482
double cost
effort needed
Definition: TraCIDefs.h:490
TraCIStage(int type=INVALID_INT_VALUE, const std::string &vType="", const std::string &line="", const std::string &destStop="", const std::vector< std::string > &edges=std::vector< std::string >(), double travelTime=INVALID_DOUBLE_VALUE, double cost=INVALID_DOUBLE_VALUE, double length=INVALID_DOUBLE_VALUE, const std::string &intended="", double depart=INVALID_DOUBLE_VALUE, double departPos=INVALID_DOUBLE_VALUE, double arrivalPos=INVALID_DOUBLE_VALUE, const std::string &description="")
Definition: TraCIDefs.h:470
double depart
intended depart time for public transport ride or INVALID_DOUBLE_VALUE
Definition: TraCIDefs.h:496
std::vector< std::string > edges
The sequence of edges to travel.
Definition: TraCIDefs.h:486
double arrivalPos
position on the lane when ending the stage
Definition: TraCIDefs.h:500
std::string vType
The vehicle type when using a private car or bike.
Definition: TraCIDefs.h:480
TRACI_CONST double INVALID_DOUBLE_VALUE
std::map< int, std::shared_ptr< TraCIResult > > TraCIResults
{variable->value}
Definition: TraCIDefs.h:248
std::vector< TraCIPosition > TraCIPositionVector
Definition: TraCIDefs.h:196
std::map< std::string, TraCIResults > SubscriptionResults
{object->{variable->value}}
Definition: TraCIDefs.h:250
TRACI_CONST int INVALID_INT_VALUE
std::map< std::string, SubscriptionResults > ContextSubscriptionResults
Definition: TraCIDefs.h:251
double length
The length than can be driven from that lane without lane change.
Definition: TraCIDefs.h:456
double occupation
The traffic density along length.
Definition: TraCIDefs.h:458
bool allowsContinuation
Whether this lane allows continuing the route.
Definition: TraCIDefs.h:462
int bestLaneOffset
The offset of this lane from the best lane.
Definition: TraCIDefs.h:460
std::vector< std::string > continuationLanes
The sequence of lanes that best allows continuing the route without lane change.
Definition: TraCIDefs.h:464
std::string laneID
The id of the lane.
Definition: TraCIDefs.h:454
std::string getString()
Definition: TraCIDefs.h:170
TraCIColor(int r, int g, int b, int a=255)
Definition: TraCIDefs.h:169
std::string getString()
Definition: TraCIDefs.h:214
TraCIDouble(double v)
Definition: TraCIDefs.h:213
std::string getString()
Definition: TraCIDefs.h:202
A leaderId and distance to leader.
Definition: TraCIDefs.h:182
std::string stoppingPlaceID
Id assigned to the stop.
Definition: TraCIDefs.h:405
std::string lane
The lane to stop at.
Definition: TraCIDefs.h:399
int stopFlags
Stop flags.
Definition: TraCIDefs.h:407
std::string actType
additional information for this stop
Definition: TraCIDefs.h:423
std::string tripId
id of the trip within a cyclical public transport route
Definition: TraCIDefs.h:425
double startPos
The stopping position start.
Definition: TraCIDefs.h:401
double arrival
The actual arrival time (only for past stops)
Definition: TraCIDefs.h:415
TraCINextStopData(const std::string &lane="", double startPos=INVALID_DOUBLE_VALUE, double endPos=INVALID_DOUBLE_VALUE, const std::string &stoppingPlaceID="", int stopFlags=0, double duration=INVALID_DOUBLE_VALUE, double until=INVALID_DOUBLE_VALUE, double intendedArrival=INVALID_DOUBLE_VALUE, double arrival=INVALID_DOUBLE_VALUE, double depart=INVALID_DOUBLE_VALUE, const std::string &split="", const std::string &join="", const std::string &actType="", const std::string &tripId="", const std::string &line="", double speed=0)
Definition: TraCIDefs.h:356
double depart
The time at which this stop was ended.
Definition: TraCIDefs.h:417
std::string getString()
Definition: TraCIDefs.h:390
std::string join
the id of the vehicle (train portion) to which this vehicle shall be joined
Definition: TraCIDefs.h:421
double speed
the speed at which this stop counts as reached (waypoint mode)
Definition: TraCIDefs.h:429
double intendedArrival
The intended arrival time.
Definition: TraCIDefs.h:413
double endPos
The stopping position end.
Definition: TraCIDefs.h:403
std::string split
the id of the vehicle (train portion) that splits of upon reaching this stop
Definition: TraCIDefs.h:419
std::string line
the new line id of the trip within a cyclical public transport route
Definition: TraCIDefs.h:427
double duration
The intended (minimum) stopping duration.
Definition: TraCIDefs.h:409
double until
The time at which the vehicle may continue its journey.
Definition: TraCIDefs.h:411
A list of vehicle stops.
Definition: TraCIDefs.h:437
std::vector< TraCINextStopData > value
Definition: TraCIDefs.h:448
double dist
The distance to the tls.
Definition: TraCIDefs.h:348
int tlIndex
The tls index of the controlled link.
Definition: TraCIDefs.h:346
std::string id
The id of the next tls.
Definition: TraCIDefs.h:344
char state
The current state of the tls.
Definition: TraCIDefs.h:350
A 3D-position.
Definition: TraCIDefs.h:141
std::string getString()
Definition: TraCIDefs.h:142
virtual std::string getString()
Definition: TraCIDefs.h:130
virtual ~TraCIResult()
Definition: TraCIDefs.h:129
virtual const std::vector< unsigned char > toPacket() const
Definition: TraCIDefs.h:133
An edgeId, position and laneIndex.
Definition: TraCIDefs.h:153
std::string getString()
Definition: TraCIDefs.h:154
std::string getString()
Definition: TraCIDefs.h:226
TraCIString(std::string v)
Definition: TraCIDefs.h:225
std::string value
Definition: TraCIDefs.h:229
std::string getString()
Definition: TraCIDefs.h:234
std::vector< std::string > value
Definition: TraCIDefs.h:243
mirrors MSInductLoop::VehicleData
Definition: TraCIDefs.h:328
std::string id
The id of the vehicle.
Definition: TraCIDefs.h:330
double entryTime
Entry-time of the vehicle in [s].
Definition: TraCIDefs.h:334
std::string typeID
Type of the vehicle in.
Definition: TraCIDefs.h:338
double length
Length of the vehicle.
Definition: TraCIDefs.h:332
double leaveTime
Leave-time of the vehicle in [s].
Definition: TraCIDefs.h:336