Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
SUMOVehicleClass.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 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"
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
84std::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 {"taxi", SUMOVehicleShape::TAXI},
98 {"delivery", SUMOVehicleShape::DELIVERY},
99 {"transport", SUMOVehicleShape::TRUCK}, // !!! deprecated
100 {"truck", SUMOVehicleShape::TRUCK},
101 {"transport/semitrailer", SUMOVehicleShape::TRUCK_SEMITRAILER}, // !!! deprecated
102 {"truck/semitrailer", SUMOVehicleShape::TRUCK_SEMITRAILER},
103 {"transport/trailer", SUMOVehicleShape::TRUCK_1TRAILER}, // !!! deprecated
104 {"truck/trailer", SUMOVehicleShape::TRUCK_1TRAILER},
105 {"bus/city", SUMOVehicleShape::BUS}, // !!! deprecated
106 {"bus", SUMOVehicleShape::BUS},
107 {"bus/overland", SUMOVehicleShape::BUS_COACH}, // !!! deprecated
108 {"bus/coach", SUMOVehicleShape::BUS_COACH},
109 {"bus/flexible", SUMOVehicleShape::BUS_FLEXIBLE},
110 {"bus/trolley", SUMOVehicleShape::BUS_TROLLEY},
111 {"rail/slow", SUMOVehicleShape::RAIL}, // !!! deprecated
112 {"rail/fast", SUMOVehicleShape::RAIL}, // !!! deprecated
113 {"rail", SUMOVehicleShape::RAIL},
114 {"rail/light", SUMOVehicleShape::RAIL_CAR}, // !!! deprecated
115 {"rail/city", SUMOVehicleShape::RAIL_CAR}, // !!! deprecated
116 {"rail/railcar", SUMOVehicleShape::RAIL_CAR},
117 {"rail/cargo", SUMOVehicleShape::RAIL_CARGO},
118 {"evehicle", SUMOVehicleShape::E_VEHICLE},
119 {"ant", SUMOVehicleShape::ANT},
120 {"ship", SUMOVehicleShape::SHIP},
121 {"emergency", SUMOVehicleShape::EMERGENCY},
122 {"firebrigade", SUMOVehicleShape::FIREBRIGADE},
123 {"police", SUMOVehicleShape::POLICE},
124 {"rickshaw", SUMOVehicleShape::RICKSHAW },
125 {"scooter", SUMOVehicleShape::SCOOTER},
126 {"aircraft", SUMOVehicleShape::AIRCRAFT},
128};
129
130
133
134// ===========================================================================
135// static values used for cached
136// ===========================================================================
137
138static std::map<int, std::vector<std::string> > vehicleClassNamesListCached;
139static std::map<std::string, SVCPermissions> parseVehicleClassesCached;
140static std::map<SVCPermissions, std::string> getVehicleClassNamesCached;
141static std::string vehicleClassNameAll = "all";
142
143// ===========================================================================
144// additional constants
145// ===========================================================================
146
148
149const SVCPermissions SVCAll = 2 * (int)SUMOVehicleClass_MAX - 1; // all relevant bits set to 1
150
152
153const std::string DEFAULT_VTYPE_ID("DEFAULT_VEHTYPE");
154const std::string DEFAULT_PEDTYPE_ID("DEFAULT_PEDTYPE");
155const std::string DEFAULT_BIKETYPE_ID("DEFAULT_BIKETYPE");
156const std::string DEFAULT_CONTAINERTYPE_ID("DEFAULT_CONTAINERTYPE");
157const std::string DEFAULT_TAXITYPE_ID("DEFAULT_TAXITYPE");
158const std::string DEFAULT_RAILTYPE_ID("DEFAULT_RAILTYPE");
159
161
162const double DEFAULT_VEH_PROB(1.);
163
164const double DEFAULT_PEDESTRIAN_SPEED(5. / 3.6);
165
166const double DEFAULT_BICYCLE_SPEED(20. / 3.6);
167
168const double DEFAULT_CONTAINER_TRANSHIP_SPEED(5. / 3.6);
169
170// ===========================================================================
171// method definitions
172// ===========================================================================
173
174// Stop Offset
175
177 myPermissions(SVCAll),
178 myOffset(0) {
179}
180
181
183 myPermissions(SVC_IGNORING),
184 myOffset(0) {
185 // first check conditions
187 WRITE_ERROR(TL("Simultaneous specification of vClasses and exceptions is not allowed"));
188 ok = false;
189 }
190 if (!attrs.hasAttribute(SUMO_ATTR_VALUE)) {
191 WRITE_ERROR(TL("StopOffset requires an offset value"));
192 ok = false;
193 }
194 // parse elements
195 const std::string vClasses = attrs.getOpt<std::string>(SUMO_ATTR_VCLASSES, nullptr, ok, "");
196 const std::string exceptions = attrs.getOpt<std::string>(SUMO_ATTR_EXCEPTIONS, nullptr, ok, "");
197 // parse permissions
198 if (attrs.hasAttribute(SUMO_ATTR_VCLASSES)) {
200 } else if (attrs.hasAttribute(SUMO_ATTR_EXCEPTIONS)) {
201 myPermissions = ~parseVehicleClasses(exceptions);
202 } else {
203 // no vClasses specified, thus apply to all
205 }
206 // parse offset
207 myOffset = attrs.getOpt<double>(SUMO_ATTR_VALUE, nullptr, ok, 0);
208}
209
210
211bool
213 return myOffset != 0;
214}
215
216
217void
222
223
226 return myPermissions;
227}
228
229
230std::string
234
235
236double
238 return myOffset;
239}
240
241
242void
244 myPermissions = permissions;
245}
246
247
248void
249StopOffset::setExceptions(const std::string permissions) {
250 myPermissions = ~parseVehicleClasses(permissions);
251}
252
253
254void
255StopOffset::setOffset(const double offset) {
256 myOffset = offset;
257}
258
259
260bool
262 return ((myPermissions == other.myPermissions) &&
263 (myOffset == other.myOffset));
264}
265
266
267bool
269 return ((myPermissions != other.myPermissions) ||
270 (myOffset != other.myOffset));
271}
272
273// Conversion of SUMOVehicleClass
274
275const std::string&
276getVehicleClassNames(SVCPermissions permissions, bool expand) {
277 if ((permissions & SVCAll) == SVCAll && !expand) {
278 return vehicleClassNameAll;
279 }
280 // check if previously was cached
281 if (getVehicleClassNamesCached.count(permissions) == 0) {
282 getVehicleClassNamesCached[permissions] = joinToString(getVehicleClassNamesList(permissions), ' ');
283 }
284 return getVehicleClassNamesCached.at(permissions);
285}
286
287
288const std::vector<std::string>&
290 // first check if it's cached
291 if (vehicleClassNamesListCached.count(permissions) == 0) {
292 const std::vector<std::string> classNames = SumoVehicleClassStrings.getStrings();
293 std::vector<std::string> result;
294 for (std::vector<std::string>::const_iterator it = classNames.begin(); it != classNames.end(); it++) {
295 const int svc = (int)SumoVehicleClassStrings.get(*it);
296 if ((svc & permissions) == svc && svc != SVC_IGNORING) {
297 result.push_back(*it);
298 }
299 }
300 // add it into vehicleClassNamesListCached
301 vehicleClassNamesListCached[permissions] = result;
302 }
303 return vehicleClassNamesListCached.at(permissions);
304}
305
306
308getVehicleClassID(const std::string& name) {
309 if (SumoVehicleClassStrings.hasString(name)) {
310 return SumoVehicleClassStrings.get(name);
311 }
312 throw InvalidArgument("Unknown vehicle class '" + name + "'.");
313}
314
315
316int
317getVehicleClassCompoundID(const std::string& name) {
318 int ret = SVC_IGNORING;
319 const std::vector<std::string> names = SumoVehicleClassStrings.getStrings();
320 for (std::vector<std::string>::const_iterator it = names.begin(); it != names.end(); it++) {
321 if (name.find(*it) != std::string::npos) {
322 ret = ret | (int) SumoVehicleClassStrings.get(*it);
323 }
324 }
325 return ret;
326}
327
328
330parseVehicleClasses(const std::string& allowedS) {
331 if (allowedS == "all") {
332 return SVCAll;
333 }
334 // check if allowedS was previously cached
335 if (parseVehicleClassesCached.count(allowedS) == 0) {
336 SVCPermissions result = 0;
337 StringTokenizer sta(allowedS, " ");
338 while (sta.hasNext()) {
339 const std::string s = sta.next();
340 if (!SumoVehicleClassStrings.hasString(s)) {
341 WRITE_ERRORF(TL("Unknown vehicle class '%' encountered."), s);
342 } else {
344 const std::string& realName = SumoVehicleClassStrings.getString(vc);
345 if (realName != s) {
347 }
348 result |= vc;
349 }
350 }
351 // save parsed vehicle class cached
352 parseVehicleClassesCached[allowedS] = result;
353 }
354 return parseVehicleClassesCached.at(allowedS);
355}
356
357
358bool
359canParseVehicleClasses(const std::string& classes) {
360 if (classes == "all") {
361 return true;
362 }
363 // check if was previously cached
364 if (parseVehicleClassesCached.count(classes) != 0) {
365 return true;
366 }
367 StringTokenizer sta(classes, " ");
368 while (sta.hasNext()) {
369 if (!SumoVehicleClassStrings.hasString(sta.next())) {
370 return false;
371 }
372 }
373 return true;
374}
375
376
378parseVehicleClasses(const std::string& allowedS, const std::string& disallowedS, const MMVersion& networkVersion) {
379 if (allowedS.size() == 0 && disallowedS.size() == 0) {
380 return SVCAll;
381 } else if (allowedS.size() > 0 && disallowedS.size() > 0) {
382 WRITE_WARNING(TL("SVCPermissions must be specified either via 'allow' or 'disallow'. Ignoring 'disallow'"));
383 return parseVehicleClasses(allowedS);
384 } else if (allowedS.size() > 0) {
385 return parseVehicleClasses(allowedS);
386 } else {
387 return invertPermissions(parseVehicleClasses(disallowedS) | (networkVersion < MMVersion(1, 3) ? SVC_RAIL_FAST : 0));
388 }
389}
390
391
394 return SVCAll & ~permissions;
395}
396
397
399parseVehicleClasses(const std::vector<std::string>& allowedS) {
400 SVCPermissions result = 0;
401 if (std::find(allowedS.begin(), allowedS.end(), "all") != allowedS.end()) {
402 return SVCAll;
403 }
404 for (std::vector<std::string>::const_iterator i = allowedS.begin(); i != allowedS.end(); ++i) {
405 const SUMOVehicleClass vc = getVehicleClassID(*i);
406 const std::string& realName = SumoVehicleClassStrings.getString(vc);
407 if (realName != *i) {
408 WRITE_WARNINGF(TL("The vehicle class '%' is deprecated, use '%' instead."), (*i), realName);
409 }
410 result |= getVehicleClassID(*i);
411 }
412 return result;
413}
414
415
416void
418 if (permissions == SVCAll) {
419 return;
420 } else if (permissions == 0) {
421 into.writeAttr(SUMO_ATTR_DISALLOW, "all");
422 return;
423 } else {
424 int num_allowed = 0;
425 for (int mask = 1; mask <= SUMOVehicleClass_MAX; mask = mask << 1) {
426 if ((mask & permissions) == mask) {
427 ++num_allowed;
428 }
429 }
430 if (num_allowed <= (SumoVehicleClassStrings.size() - num_allowed) && num_allowed > 0) {
432 } else {
434 }
435 }
436}
437
438
439void
441 if (preferred == SVCAll || preferred == 0) {
442 return;
443 } else {
445 }
446}
447
448
450getVehicleShapeID(const std::string& name) {
451 if (SumoVehicleShapeStrings.hasString(name)) {
452 return SumoVehicleShapeStrings.get(name);
453 } else {
454 throw InvalidArgument("Unknown vehicle shape '" + name + "'.");
455 }
456}
457
458
459bool
460canParseVehicleShape(const std::string& shape) {
461 return SumoVehicleShapeStrings.hasString(shape);
462}
463
464
465std::string
469
470
471bool isRailway(SVCPermissions permissions) {
472 return (permissions & SVC_RAIL_CLASSES) > 0 && (permissions & SVC_PASSENGER) == 0;
473}
474
475bool isTram(SVCPermissions permissions) {
476 return (permissions & SVC_RAIL_CLASSES) == SVC_TRAM && (permissions & SVC_PASSENGER) == 0;
477}
478
479bool isBikepath(SVCPermissions permissions) {
480 return (permissions & SVC_BICYCLE) == SVC_BICYCLE && (permissions & SVC_PASSENGER) == 0;
481}
482
483
484bool
486 return permissions == SVC_SHIP;
487}
488
489
490bool
492 return (permissions & SVCAll) == 0;
493}
494
495
496bool
498 return (permissions & SVCAll) == SVC_PEDESTRIAN;
499}
500
501
502bool
504 return isForbidden(permissions) || isSidewalk(permissions);
505}
506
507
508double
510 switch (vc) {
511 case SVC_PEDESTRIAN:
512 return 0.215;
513 case SVC_BICYCLE:
514 return 1.6;
515 case SVC_MOPED:
516 return 2.1;
517 case SVC_MOTORCYCLE:
518 return 2.2;
519 case SVC_TRUCK:
520 return 7.1;
521 case SVC_TRAILER:
522 return 16.5;
523 case SVC_BUS:
524 return 12.;
525 case SVC_COACH:
526 return 14.;
527 case SVC_TRAM:
528 return 22.;
529 case SVC_RAIL_URBAN:
530 return 36.5 * 3;
531 case SVC_RAIL:
532 return 67.5 * 2;
534 case SVC_RAIL_FAST:
535 return 25. * 8;
536 case SVC_DELIVERY:
537 case SVC_EMERGENCY:
538 return 6.5;
539 case SVC_SHIP:
540 return 17;
541 default:
542 return 5; /*4.3*/
543 }
544}
545
546
547
548/****************************************************************************/
#define WRITE_WARNINGF(...)
Definition MsgHandler.h:271
#define WRITE_ERRORF(...)
Definition MsgHandler.h:280
#define WRITE_ERROR(msg)
Definition MsgHandler.h:279
#define WRITE_WARNING(msg)
Definition MsgHandler.h:270
#define TL(string)
Definition MsgHandler.h:287
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.
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SUMOVehicleShape::UNKNOWN, false)
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
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 SVCPermissions SVC_UNSPECIFIED
permissions not specified
static StringBijection< SUMOVehicleClass >::Entry sumoVehicleClassStringInitializer[]
bool isWaterway(SVCPermissions permissions)
Returns whether an edge with the given permission is a waterway edge.
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 std::string & getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a ' '.
const std::vector< std::string > & getVehicleClassNamesList(SVCPermissions permissions)
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.
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.
bool isBikepath(SVCPermissions permissions)
Returns whether an edge with the given permission is a bicycle edge.
static std::map< SVCPermissions, std::string > getVehicleClassNamesCached
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
const SUMOVehicleClass SUMOVehicleClass_MAX
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
const std::string DEFAULT_TAXITYPE_ID
const double DEFAULT_VEH_PROB
const std::string DEFAULT_RAILTYPE_ID
const std::string DEFAULT_PEDTYPE_ID
const std::set< std::string > DEFAULT_VTYPES
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
SUMOVehicleShape
Definition of vehicle classes to differ between different appearances.
@ 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
render as a delivery vehicle
@ BICYCLE
render as a bicycle
@ MOTORCYCLE
render as a motorcycle
@ UNKNOWN
not defined
@ BUS_TROLLEY
render as a trolley bus
@ TAXI
automated car (with cruise controllers)
@ E_VEHICLE
render as a (futuristic) e-vehicle
@ ANT
render as a giant ant
@ TRUCK
render as a transport vehicle
@ AIRCRAFT
render as aircraft
@ 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
const double DEFAULT_PEDESTRIAN_SPEED
const double DEFAULT_BICYCLE_SPEED
const std::string DEFAULT_VTYPE_ID
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
const std::string DEFAULT_CONTAINERTYPE_ID
const double DEFAULT_CONTAINER_TRANSHIP_SPEED
const std::string & getVehicleClassNames(SVCPermissions permissions, bool expand=false)
Returns the ids of the given classes, divided using a ' '.
const std::string DEFAULT_BIKETYPE_ID
@ SUMO_ATTR_PREFER
@ SUMO_ATTR_DISALLOW
@ SUMO_ATTR_ALLOW
@ SUMO_ATTR_VALUE
@ SUMO_ATTR_VCLASSES
@ SUMO_ATTR_EXCEPTIONS
std::pair< int, double > MMVersion
(M)ajor/(M)inor version for written networks and default version for loading
Definition StdDefs.h:67
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition ToString.h:283
Static storage of an output device and its base (abstract) implementation.
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Encapsulated SAX-Attributes.
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue=T(), 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