Eclipse SUMO - Simulation of Urban MObility
SUMOVehicleClass.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-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 /****************************************************************************/
22 // Definitions of SUMO vehicle classes and helper functions
23 /****************************************************************************/
24 #include <config.h>
25 
26 #include <string>
27 #include <map>
28 #include "SUMOVehicleClass.h"
30 #include <utils/common/ToString.h>
35 
36 
37 // ===========================================================================
38 // static members
39 // ===========================================================================
40 
42  {"ignoring", SVC_IGNORING},
43  {"private", SVC_PRIVATE},
44  {"public_emergency", SVC_EMERGENCY}, // !!! deprecated
45  {"emergency", SVC_EMERGENCY},
46  {"public_authority", SVC_AUTHORITY}, // !!! deprecated
47  {"authority", SVC_AUTHORITY},
48  {"public_army", SVC_ARMY}, // !!! deprecated
49  {"army", SVC_ARMY},
50  {"vip", SVC_VIP},
51  {"passenger", SVC_PASSENGER},
52  {"hov", SVC_HOV},
53  {"taxi", SVC_TAXI},
54  {"public_transport", SVC_BUS}, // !!! deprecated
55  {"bus", SVC_BUS},
56  {"coach", SVC_COACH},
57  {"delivery", SVC_DELIVERY},
58  {"transport", SVC_TRUCK},
59  {"truck", SVC_TRUCK},
60  {"trailer", SVC_TRAILER},
61  {"lightrail", SVC_TRAM}, // !!! deprecated
62  {"tram", SVC_TRAM},
63  {"cityrail", SVC_RAIL_URBAN}, // !!! deprecated
64  {"rail_urban", SVC_RAIL_URBAN},
65  {"rail_slow", SVC_RAIL}, // !!! deprecated
66  {"rail", SVC_RAIL},
67  {"rail_fast", SVC_RAIL_FAST},
68  {"rail_electric", SVC_RAIL_ELECTRIC},
69  {"motorcycle", SVC_MOTORCYCLE},
70  {"moped", SVC_MOPED},
71  {"bicycle", SVC_BICYCLE},
72  {"pedestrian", SVC_PEDESTRIAN},
73  {"evehicle", SVC_E_VEHICLE},
74  {"ship", SVC_SHIP},
75  {"custom1", SVC_CUSTOM1},
76  {"custom2", SVC_CUSTOM2}
77 };
78 
79 
82 
83 
84 std::set<std::string> deprecatedVehicleClassesSeen;
85 
86 
88  {"pedestrian", SUMOVehicleShape::PEDESTRIAN},
89  {"bicycle", SUMOVehicleShape::BICYCLE},
90  {"moped", SUMOVehicleShape::MOPED},
91  {"motorcycle", SUMOVehicleShape::MOTORCYCLE},
92  {"passenger", SUMOVehicleShape::PASSENGER},
93  {"passenger/sedan", SUMOVehicleShape::PASSENGER_SEDAN},
94  {"passenger/hatchback", SUMOVehicleShape::PASSENGER_HATCHBACK},
95  {"passenger/wagon", SUMOVehicleShape::PASSENGER_WAGON},
96  {"passenger/van", SUMOVehicleShape::PASSENGER_VAN},
97  {"delivery", SUMOVehicleShape::DELIVERY},
98  {"transport", SUMOVehicleShape::TRUCK}, // !!! deprecated
99  {"truck", SUMOVehicleShape::TRUCK},
100  {"transport/semitrailer", SUMOVehicleShape::TRUCK_SEMITRAILER}, // !!! deprecated
101  {"truck/semitrailer", SUMOVehicleShape::TRUCK_SEMITRAILER},
102  {"transport/trailer", SUMOVehicleShape::TRUCK_1TRAILER}, // !!! deprecated
103  {"truck/trailer", SUMOVehicleShape::TRUCK_1TRAILER},
104  {"bus/city", SUMOVehicleShape::BUS}, // !!! deprecated
105  {"bus", SUMOVehicleShape::BUS},
106  {"bus/overland", SUMOVehicleShape::BUS_COACH}, // !!! deprecated
107  {"bus/coach", SUMOVehicleShape::BUS_COACH},
108  {"bus/flexible", SUMOVehicleShape::BUS_FLEXIBLE},
109  {"bus/trolley", SUMOVehicleShape::BUS_TROLLEY},
110  {"rail/slow", SUMOVehicleShape::RAIL}, // !!! deprecated
111  {"rail/fast", SUMOVehicleShape::RAIL}, // !!! deprecated
112  {"rail", SUMOVehicleShape::RAIL},
113  {"rail/light", SUMOVehicleShape::RAIL_CAR}, // !!! deprecated
114  {"rail/city", SUMOVehicleShape::RAIL_CAR}, // !!! deprecated
115  {"rail/railcar", SUMOVehicleShape::RAIL_CAR},
116  {"rail/cargo", SUMOVehicleShape::RAIL_CARGO},
117  {"evehicle", SUMOVehicleShape::E_VEHICLE},
118  {"ant", SUMOVehicleShape::ANT},
119  {"ship", SUMOVehicleShape::SHIP},
120  {"emergency", SUMOVehicleShape::EMERGENCY},
121  {"firebrigade", SUMOVehicleShape::FIREBRIGADE},
122  {"police", SUMOVehicleShape::POLICE},
123  {"rickshaw", SUMOVehicleShape::RICKSHAW },
124  {"scooter", SUMOVehicleShape::SCOOTER},
126 };
127 
128 
131 
132 // ===========================================================================
133 // static values used for cached
134 // ===========================================================================
135 
136 static std::map<int, std::vector<std::string> > vehicleClassNamesListCached;
137 static std::map<std::string, SVCPermissions> parseVehicleClassesCached;
138 static std::map<SVCPermissions, std::string> getVehicleClassNamesCached;
139 static std::string vehicleClassNameAll = "all";
140 
141 // ===========================================================================
142 // additional constants
143 // ===========================================================================
144 
146 
147 const SVCPermissions SVCAll = 2 * (int)SUMOVehicleClass_MAX - 1; // all relevant bits set to 1
148 
150 
151 const std::string DEFAULT_VTYPE_ID("DEFAULT_VEHTYPE");
152 
153 const std::string DEFAULT_PEDTYPE_ID("DEFAULT_PEDTYPE");
154 
155 const std::string DEFAULT_BIKETYPE_ID("DEFAULT_BIKETYPE");
156 
157 const std::string DEFAULT_CONTAINERTYPE_ID("DEFAULT_CONTAINERTYPE");
158 
159 const std::string DEFAULT_TAXITYPE_ID("DEFAULT_TAXITYPE");
160 
162 
163 const double DEFAULT_VEH_PROB(1.);
164 
165 const double DEFAULT_PEDESTRIAN_SPEED(5. / 3.6);
166 
167 const double DEFAULT_CONTAINER_TRANSHIP_SPEED(5. / 3.6);
168 
169 // ===========================================================================
170 // method definitions
171 // ===========================================================================
172 
173 // Stop Offset
174 
176  myPermissions(SVCAll),
177  myOffset(0) {
178 }
179 
180 
181 StopOffset::StopOffset(const SUMOSAXAttributes& attrs, bool& ok) :
182  myPermissions(SVC_IGNORING),
183  myOffset(0) {
184  // first check conditions
186  WRITE_ERROR("Simultaneous specification of vClasses and exceptions is not allowed");
187  ok = false;
188  }
189  if (!attrs.hasAttribute(SUMO_ATTR_VALUE)) {
190  WRITE_ERROR("StopOffset requires an offset value");
191  ok = false;
192  }
193  // parse elements
194  const std::string vClasses = attrs.getOpt<std::string>(SUMO_ATTR_VCLASSES, nullptr, ok, "");
195  const std::string exceptions = attrs.getOpt<std::string>(SUMO_ATTR_EXCEPTIONS, nullptr, ok, "");
196  // parse permissions
197  if (attrs.hasAttribute(SUMO_ATTR_VCLASSES)) {
199  } else if (attrs.hasAttribute(SUMO_ATTR_EXCEPTIONS)) {
200  myPermissions = ~parseVehicleClasses(exceptions);
201  } else {
202  // no vClasses specified, thus apply to all
204  }
205  // parse offset
206  myOffset = attrs.getOpt<double>(SUMO_ATTR_VALUE, nullptr, ok, 0);
207 }
208 
209 
210 bool
212  return myOffset != 0;
213 }
214 
215 
216 void
219  myOffset = 0;
220 }
221 
222 
225  return myPermissions;
226 }
227 
228 
229 std::string
232 }
233 
234 
235 double
237  return myOffset;
238 }
239 
240 
241 void
243  myPermissions = permissions;
244 }
245 
246 
247 void
248 StopOffset::setExceptions(const std::string permissions) {
249  myPermissions = ~parseVehicleClasses(permissions);
250 }
251 
252 
253 void
254 StopOffset::setOffset(const double offset) {
255  myOffset = offset;
256 }
257 
258 
259 bool
260 StopOffset::operator==(StopOffset const& other) const {
261  return ((myPermissions == other.myPermissions) &&
262  (myOffset == other.myOffset));
263 }
264 
265 
266 bool
267 StopOffset::operator!=(StopOffset const& other) const {
268  return ((myPermissions != other.myPermissions) ||
269  (myOffset != other.myOffset));
270 }
271 
272 // Conversion of SUMOVehicleClass
273 
274 const std::string&
275 getVehicleClassNames(SVCPermissions permissions, bool expand) {
276  if (permissions == SVCAll && !expand) {
277  return vehicleClassNameAll;
278  }
279  // check if previously was cached
280  if (getVehicleClassNamesCached.count(permissions) == 0) {
281  getVehicleClassNamesCached[permissions] = joinToString(getVehicleClassNamesList(permissions), ' ');
282  }
283  return getVehicleClassNamesCached.at(permissions);
284 }
285 
286 
287 const std::vector<std::string>&
289  // first check if it's cached
290  if (vehicleClassNamesListCached.count(permissions) == 0) {
291  const std::vector<std::string> classNames = SumoVehicleClassStrings.getStrings();
292  std::vector<std::string> result;
293  for (std::vector<std::string>::const_iterator it = classNames.begin(); it != classNames.end(); it++) {
294  const int svc = (int)SumoVehicleClassStrings.get(*it);
295  if ((svc & permissions) == svc && svc != SVC_IGNORING) {
296  result.push_back(*it);
297  }
298  }
299  // add it into vehicleClassNamesListCached
300  vehicleClassNamesListCached[permissions] = result;
301  }
302  return vehicleClassNamesListCached.at(permissions);
303 }
304 
305 
307 getVehicleClassID(const std::string& name) {
308  if (SumoVehicleClassStrings.hasString(name)) {
309  return SumoVehicleClassStrings.get(name);
310  }
311  throw InvalidArgument("Unknown vehicle class '" + name + "'.");
312 }
313 
314 
315 int
316 getVehicleClassCompoundID(const std::string& name) {
317  int ret = SVC_IGNORING;
318  const std::vector<std::string> names = SumoVehicleClassStrings.getStrings();
319  for (std::vector<std::string>::const_iterator it = names.begin(); it != names.end(); it++) {
320  if (name.find(*it) != std::string::npos) {
321  ret = ret | (int) SumoVehicleClassStrings.get(*it);
322  }
323  }
324  return ret;
325 }
326 
327 
329 parseVehicleClasses(const std::string& allowedS) {
330  if (allowedS == "all") {
331  return SVCAll;
332  }
333  // check if allowedS was previously cached
334  if (parseVehicleClassesCached.count(allowedS) == 0) {
335  SVCPermissions result = 0;
336  StringTokenizer sta(allowedS, " ");
337  while (sta.hasNext()) {
338  const std::string s = sta.next();
339  if (!SumoVehicleClassStrings.hasString(s)) {
340  WRITE_ERROR("Unknown vehicle class '" + s + "' encountered.");
341  } else {
342  const SUMOVehicleClass vc = getVehicleClassID(s);
343  const std::string& realName = SumoVehicleClassStrings.getString(vc);
344  if (realName != s) {
346  }
347  result |= vc;
348  }
349  }
350  // save parsed vehicle class cached
351  parseVehicleClassesCached[allowedS] = result;
352  }
353  return parseVehicleClassesCached.at(allowedS);
354 }
355 
356 
357 bool
358 canParseVehicleClasses(const std::string& classes) {
359  if (classes == "all") {
360  return true;
361  }
362  // check if was previously cached
363  if (parseVehicleClassesCached.count(classes) != 0) {
364  return true;
365  }
366  StringTokenizer sta(classes, " ");
367  while (sta.hasNext()) {
368  if (!SumoVehicleClassStrings.hasString(sta.next())) {
369  return false;
370  }
371  }
372  return true;
373 }
374 
375 
377 parseVehicleClasses(const std::string& allowedS, const std::string& disallowedS, double networkVersion) {
378  if (allowedS.size() == 0 && disallowedS.size() == 0) {
379  return SVCAll;
380  } else if (allowedS.size() > 0 && disallowedS.size() > 0) {
381  WRITE_WARNING("SVCPermissions must be specified either via 'allow' or 'disallow'. Ignoring 'disallow'");
382  return parseVehicleClasses(allowedS);
383  } else if (allowedS.size() > 0) {
384  return parseVehicleClasses(allowedS);
385  } else {
386  return invertPermissions(parseVehicleClasses(disallowedS) | (networkVersion < 1.3 ? SVC_RAIL_FAST : 0));
387  }
388 }
389 
390 
393  return SVCAll & ~permissions;
394 }
395 
396 
398 parseVehicleClasses(const std::vector<std::string>& allowedS) {
399  SVCPermissions result = 0;
400  if (std::find(allowedS.begin(), allowedS.end(), "all") != allowedS.end()) {
401  return SVCAll;
402  }
403  for (std::vector<std::string>::const_iterator i = allowedS.begin(); i != allowedS.end(); ++i) {
404  const SUMOVehicleClass vc = getVehicleClassID(*i);
405  const std::string& realName = SumoVehicleClassStrings.getString(vc);
406  if (realName != *i) {
407  WRITE_WARNING("The vehicle class '" + (*i) + "' is deprecated, use '" + realName + "' instead.");
408  }
409  result |= getVehicleClassID(*i);
410  }
411  return result;
412 }
413 
414 
415 void
417  if (permissions == SVCAll) {
418  return;
419  } else if (permissions == 0) {
420  into.writeAttr(SUMO_ATTR_DISALLOW, "all");
421  return;
422  } else {
423  int num_allowed = 0;
424  for (int mask = 1; mask <= SUMOVehicleClass_MAX; mask = mask << 1) {
425  if ((mask & permissions) == mask) {
426  ++num_allowed;
427  }
428  }
429  if (num_allowed <= (SumoVehicleClassStrings.size() - num_allowed) && num_allowed > 0) {
430  into.writeAttr(SUMO_ATTR_ALLOW, getVehicleClassNames(permissions));
431  } else {
433  }
434  }
435 }
436 
437 
438 void
440  if (preferred == SVCAll || preferred == 0) {
441  return;
442  } else {
444  }
445 }
446 
447 
449 getVehicleShapeID(const std::string& name) {
450  if (SumoVehicleShapeStrings.hasString(name)) {
451  return SumoVehicleShapeStrings.get(name);
452  } else {
453  throw InvalidArgument("Unknown vehicle shape '" + name + "'.");
454  }
455 }
456 
457 
458 bool
459 canParseVehicleShape(const std::string& shape) {
460  return SumoVehicleShapeStrings.hasString(shape);
461 }
462 
463 
464 std::string
466  return SumoVehicleShapeStrings.getString(id);
467 }
468 
469 
470 bool isRailway(SVCPermissions permissions) {
471  return (permissions & SVC_RAIL_CLASSES) > 0 && (permissions & SVC_PASSENGER) == 0;
472 }
473 
474 bool isTram(SVCPermissions permissions) {
475  return (permissions & SVC_RAIL_CLASSES) == SVC_TRAM && (permissions & SVC_PASSENGER) == 0;
476 }
477 
478 bool isBikepath(SVCPermissions permissions) {
479  return (permissions & SVC_BICYCLE) == SVC_BICYCLE && (permissions & SVC_PASSENGER) == 0;
480 }
481 
482 
483 bool
485  return permissions == SVC_SHIP;
486 }
487 
488 
489 bool
491  return (permissions & SVCAll) == 0;
492 }
493 
494 
495 bool
497  return (permissions & SVCAll) == SVC_PEDESTRIAN;
498 }
499 
500 
501 bool
503  return isForbidden(permissions) || isSidewalk(permissions);
504 }
505 
506 
507 double
509  switch (vc) {
510  case SVC_PEDESTRIAN:
511  return 0.215;
512  case SVC_BICYCLE:
513  return 1.6;
514  case SVC_MOPED:
515  return 2.1;
516  case SVC_MOTORCYCLE:
517  return 2.2;
518  case SVC_TRUCK:
519  return 7.1;
520  case SVC_TRAILER:
521  return 16.5;
522  case SVC_BUS:
523  return 12.;
524  case SVC_COACH:
525  return 14.;
526  case SVC_TRAM:
527  return 22.;
528  case SVC_RAIL_URBAN:
529  return 36.5 * 3;
530  case SVC_RAIL:
531  return 67.5 * 2;
532  case SVC_RAIL_ELECTRIC:
533  case SVC_RAIL_FAST:
534  return 25. * 8;
535  case SVC_DELIVERY:
536  case SVC_EMERGENCY:
537  return 6.5;
538  case SVC_SHIP:
539  return 17;
540  default:
541  return 5; /*4.3*/
542  }
543 }
544 
545 
546 
547 /****************************************************************************/
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:288
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:280
static std::map< int, std::vector< std::string > > vehicleClassNamesListCached
bool canParseVehicleShape(const std::string &shape)
Checks whether the given string contains only known vehicle shape.
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
double getDefaultVehicleLength(const SUMOVehicleClass vc)
Returns the default vehicle length This put into a function so it can be used by NBVehicle.
const SVCPermissions SVCAll
all VClasses are allowed
const std::string DEFAULT_VTYPE_ID("DEFAULT_VEHTYPE")
const std::set< std::string > DEFAULT_VTYPES({DEFAULT_VTYPE_ID, DEFAULT_PEDTYPE_ID, DEFAULT_BIKETYPE_ID, DEFAULT_CONTAINERTYPE_ID, DEFAULT_TAXITYPE_ID})
std::set< std::string > deprecatedVehicleClassesSeen
SVCPermissions invertPermissions(SVCPermissions permissions)
negate the given permissions and ensure that only relevant bits are set
static std::map< std::string, SVCPermissions > parseVehicleClassesCached
bool isRailway(SVCPermissions permissions)
Returns whether an edge with the given permission is a railway edge.
static StringBijection< SUMOVehicleShape >::Entry sumoVehicleShapeStringInitializer[]
const double DEFAULT_PEDESTRIAN_SPEED(5./3.6)
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
const std::string DEFAULT_CONTAINERTYPE_ID("DEFAULT_CONTAINERTYPE")
static StringBijection< SUMOVehicleClass >::Entry sumoVehicleClassStringInitializer[]
bool isWaterway(SVCPermissions permissions)
Returns whether an edge with the given permission is a waterway edge.
const std::string DEFAULT_PEDTYPE_ID("DEFAULT_PEDTYPE")
bool isTram(SVCPermissions permissions)
Returns whether an edge with the given permission is a tram edge.
int getVehicleClassCompoundID(const std::string &name)
Returns the OR'ed id of the compound class given by its name.
const double DEFAULT_CONTAINER_TRANSHIP_SPEED(5./3.6)
const std::vector< std::string > & getVehicleClassNamesList(SVCPermissions permissions)
Returns the ids of the given classes, divided using a ' '.
const std::string & getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a ' '.
void writePermissions(OutputDevice &into, SVCPermissions permissions)
writes allowed disallowed attributes if needed;
SUMOVehicleShape getVehicleShapeID(const std::string &name)
Returns the class id of the shape class given by its name.
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
const double DEFAULT_VEH_PROB(1.)
bool isForbidden(SVCPermissions permissions)
Returns whether an edge with the given permission is a forbidden edge.
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
static std::string vehicleClassNameAll
bool isSidewalk(SVCPermissions permissions)
Returns whether an edge with the given permission is a sidewalk.
bool canParseVehicleClasses(const std::string &classes)
Checks whether the given string contains only known vehicle classes.
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
void writePreferences(OutputDevice &into, SVCPermissions preferred)
writes allowed disallowed attributes if needed;
bool noVehicles(SVCPermissions permissions)
Returns whether an edge with the given permission forbids vehicles.
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SUMOVehicleShape::UNKNOWN, false)
bool isBikepath(SVCPermissions permissions)
Returns whether an edge with the given permission is a bicycle edge.
static std::map< SVCPermissions, std::string > getVehicleClassNamesCached
const std::string DEFAULT_BIKETYPE_ID("DEFAULT_BIKETYPE")
const SUMOVehicleClass SUMOVehicleClass_MAX
const std::string DEFAULT_TAXITYPE_ID("DEFAULT_TAXITYPE")
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_SHIP
is an arbitrary ship
@ SVC_PRIVATE
private vehicles
@ SVC_VIP
vip vehicles
@ SVC_HOV
vehicle is a HOV
@ SVC_TRUCK
vehicle is a large transport vehicle
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_CUSTOM2
is a user-defined type
@ SVC_RAIL
vehicle is a not electrified rail
@ SVC_RAIL_CLASSES
classes which drive on tracks
@ SVC_COACH
vehicle is a coach
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
@ SVC_BICYCLE
vehicle is a bicycle
@ SVC_RAIL_FAST
vehicle that is allowed to drive on high-speed rail tracks
@ SVC_TRAILER
vehicle is a large transport vehicle
@ SVC_CUSTOM1
is a user-defined type
@ SVC_ARMY
army vehicles
@ SVC_RAIL_ELECTRIC
rail vehicle that requires electrified tracks
@ SVC_DELIVERY
vehicle is a small delivery vehicle
@ SVC_RAIL_URBAN
vehicle is a city rail
@ SVC_MOTORCYCLE
vehicle is a motorcycle
@ SVC_EMERGENCY
public emergency vehicles
@ SVC_MOPED
vehicle is a moped
@ SVC_AUTHORITY
authorities vehicles
@ SVC_TRAM
vehicle is a light rail
@ SVC_TAXI
vehicle is a taxi
@ SVC_BUS
vehicle is a bus
@ SVC_E_VEHICLE
is an electric vehicle
@ SVC_PEDESTRIAN
pedestrian
SUMOVehicleShape
Definition of vehicle classes to differ between different appearences.
@ RICKSHAW
render as a rickshaw
@ BUS
render as a bus
@ RAIL_CARGO
render as a cargo train
@ EMERGENCY
render as an emergency vehicle
@ RAIL
render as a rail
@ PASSENGER_VAN
render as a van
@ PASSENGER
render as a passenger vehicle
@ SCOOTER
render as a scooter
@ RAIL_CAR
render as a (city) rail without locomotive
@ SHIP
render as a arbitrary ship
@ DELIVERY
automated car (with cruise controllers)
@ BICYCLE
render as a bicycle
@ MOTORCYCLE
render as a motorcycle
@ UNKNOWN
not defined
@ BUS_TROLLEY
render as a trolley bus
@ E_VEHICLE
render as a (futuristic) e-vehicle
@ ANT
render as a giant ant
@ TRUCK
render as a transport vehicle
@ FIREBRIGADE
render as a fire brigade
@ PASSENGER_HATCHBACK
render as a hatchback passenger vehicle ("Fliessheck")
@ MOPED
render as a moped
@ BUS_FLEXIBLE
render as a flexible city bus
@ TRUCK_1TRAILER
render as a transport vehicle with one trailer
@ PASSENGER_SEDAN
render as a sedan passenger vehicle ("Stufenheck")
@ BUS_COACH
render as a coach
@ POLICE
render as a police car
@ PASSENGER_WAGON
render as a wagon passenger vehicle ("Combi")
@ TRUCK_SEMITRAILER
render as a semi-trailer transport vehicle ("Sattelschlepper")
@ PEDESTRIAN
render as a pedestrian
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
@ SUMO_ATTR_PREFER
@ SUMO_ATTR_DISALLOW
@ SUMO_ATTR_ALLOW
@ SUMO_ATTR_VALUE
@ SUMO_ATTR_VCLASSES
@ SUMO_ATTR_EXCEPTIONS
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:269
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:248
Encapsulated SAX-Attributes.
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
stop offset
void setOffset(const double offset)
set offset
StopOffset()
constructor
bool isDefined() const
check if stopOffset was defined
void reset()
reset stopOffset
SVCPermissions getPermissions() const
get permissions
void setExceptions(const std::string permissions)
set exceptions (used in NETEDIT)
SVCPermissions myPermissions
permissions (allowed)
double myOffset
offset
std::string getExceptions() const
get exceptions (used in NETEDIT)
void setPermissions(const SVCPermissions permissions)
update permissions
bool operator==(StopOffset const &other) const
comparator
bool operator!=(StopOffset const &other) const
comparator
double getOffset() const
get offset
bool hasNext()
returns the information whether further substrings exist
std::string next()
returns the next substring when it exists. Otherwise the behaviour is undefined