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-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
18 // Definitions of SUMO vehicle classes and helper functions
19 /****************************************************************************/
20 
21 
22 // ===========================================================================
23 // included modules
24 // ===========================================================================
25 #include <config.h>
26 
27 #include <string>
28 #include <map>
29 #include "SUMOVehicleClass.h"
31 #include <utils/common/ToString.h>
36 
37 
38 // ===========================================================================
39 // static members
40 // ===========================================================================
41 
43  {"ignoring", SVC_IGNORING},
44  {"private", SVC_PRIVATE},
45  {"public_emergency", SVC_EMERGENCY}, // !!! deprecated
46  {"emergency", SVC_EMERGENCY},
47  {"public_authority", SVC_AUTHORITY}, // !!! deprecated
48  {"authority", SVC_AUTHORITY},
49  {"public_army", SVC_ARMY}, // !!! deprecated
50  {"army", SVC_ARMY},
51  {"vip", SVC_VIP},
52  {"passenger", SVC_PASSENGER},
53  {"hov", SVC_HOV},
54  {"taxi", SVC_TAXI},
55  {"public_transport", SVC_BUS}, // !!! deprecated
56  {"bus", SVC_BUS},
57  {"coach", SVC_COACH},
58  {"delivery", SVC_DELIVERY},
59  {"transport", SVC_TRUCK},
60  {"truck", SVC_TRUCK},
61  {"trailer", SVC_TRAILER},
62  {"lightrail", SVC_TRAM}, // !!! deprecated
63  {"tram", SVC_TRAM},
64  {"cityrail", SVC_RAIL_URBAN}, // !!! deprecated
65  {"rail_urban", SVC_RAIL_URBAN},
66  {"rail_slow", SVC_RAIL}, // !!! deprecated
67  {"rail", SVC_RAIL},
68  {"rail_fast", SVC_RAIL_FAST},
69  {"rail_electric", SVC_RAIL_ELECTRIC},
70  {"motorcycle", SVC_MOTORCYCLE},
71  {"moped", SVC_MOPED},
72  {"bicycle", SVC_BICYCLE},
73  {"pedestrian", SVC_PEDESTRIAN},
74  {"evehicle", SVC_E_VEHICLE},
75  {"ship", SVC_SHIP},
76  {"custom1", SVC_CUSTOM1},
77  {"custom2", SVC_CUSTOM2}
78 };
79 
82 
83 
84 std::set<std::string> deprecatedVehicleClassesSeen;
85 
86 
88  {"pedestrian", SVS_PEDESTRIAN},
89  {"bicycle", SVS_BICYCLE},
90  {"moped", SVS_MOPED},
91  {"motorcycle", SVS_MOTORCYCLE},
92  {"passenger", SVS_PASSENGER},
93  {"passenger/sedan", SVS_PASSENGER_SEDAN},
94  {"passenger/hatchback", SVS_PASSENGER_HATCHBACK},
95  {"passenger/wagon", SVS_PASSENGER_WAGON},
96  {"passenger/van", SVS_PASSENGER_VAN},
97  {"delivery", SVS_DELIVERY},
98  {"transport", SVS_TRUCK}, // !!! deprecated
99  {"truck", SVS_TRUCK},
100  {"transport/semitrailer", SVS_TRUCK_SEMITRAILER}, // !!! deprecated
101  {"truck/semitrailer", SVS_TRUCK_SEMITRAILER},
102  {"transport/trailer", SVS_TRUCK_1TRAILER}, // !!! deprecated
103  {"truck/trailer", SVS_TRUCK_1TRAILER},
104  {"bus/city", SVS_BUS}, // !!! deprecated
105  {"bus", SVS_BUS},
106  {"bus/overland", SVS_BUS_COACH}, // !!! deprecated
107  {"bus/coach", SVS_BUS_COACH},
108  {"bus/flexible", SVS_BUS_FLEXIBLE},
109  {"bus/trolley", SVS_BUS_TROLLEY},
110  {"rail/slow", SVS_RAIL}, // !!! deprecated
111  {"rail/fast", SVS_RAIL}, // !!! deprecated
112  {"rail", SVS_RAIL},
113  {"rail/light", SVS_RAIL_CAR}, // !!! deprecated
114  {"rail/city", SVS_RAIL_CAR}, // !!! deprecated
115  {"rail/railcar", SVS_RAIL_CAR},
116  {"rail/cargo", SVS_RAIL_CARGO},
117  {"evehicle", SVS_E_VEHICLE},
118  {"ant", SVS_ANT},
119  {"ship", SVS_SHIP},
120  {"emergency", SVS_EMERGENCY},
121  {"firebrigade", SVS_FIREBRIGADE},
122  {"police", SVS_POLICE},
123  {"rickshaw", SVS_RICKSHAW },
124  {"", SVS_UNKNOWN}
125 };
126 
127 
130 
131 // ===========================================================================
132 // static values used for cached
133 // ===========================================================================
134 
135 static std::map<int, std::vector<std::string> > vehicleClassNamesListCached;
136 static std::map<std::string, SVCPermissions> parseVehicleClassesCached;
137 static std::map<SVCPermissions, std::string> getVehicleClassNamesCached;
138 static std::string vehicleClassNameAll = "all";
139 
140 // ===========================================================================
141 // additional constants
142 // ===========================================================================
143 
145 
146 const SVCPermissions SVCAll = 2 * (int)SUMOVehicleClass_MAX - 1; // all relevant bits set to 1
147 
149 
150 const std::string DEFAULT_VTYPE_ID("DEFAULT_VEHTYPE");
151 
152 const std::string DEFAULT_PEDTYPE_ID("DEFAULT_PEDTYPE");
153 
154 const std::string DEFAULT_BIKETYPE_ID("DEFAULT_BIKETYPE");
155 
156 const double DEFAULT_VEH_PROB(1.);
157 
158 const double DEFAULT_PEDESTRIAN_SPEED(5. / 3.6);
159 
160 const double DEFAULT_CONTAINER_TRANSHIP_SPEED(5. / 3.6);
161 
162 // ===========================================================================
163 // method definitions
164 // ===========================================================================
165 // ------------ Conversion of SUMOVehicleClass
166 
167 const std::string&
168 getVehicleClassNames(SVCPermissions permissions, bool expand) {
169  if (permissions == SVCAll && !expand) {
170  return vehicleClassNameAll;
171  }
172  // check if previously was cached
173  if (getVehicleClassNamesCached.count(permissions) == 0) {
174  getVehicleClassNamesCached[permissions] = joinToString(getVehicleClassNamesList(permissions), ' ');
175  }
176  return getVehicleClassNamesCached.at(permissions);
177 }
178 
179 
180 const std::vector<std::string>&
182  // first check if it's cached
183  if (vehicleClassNamesListCached.count(permissions) == 0) {
184  const std::vector<std::string> classNames = SumoVehicleClassStrings.getStrings();
185  std::vector<std::string> result;
186  for (std::vector<std::string>::const_iterator it = classNames.begin(); it != classNames.end(); it++) {
187  const int svc = (int)SumoVehicleClassStrings.get(*it);
188  if ((svc & permissions) == svc && svc != SVC_IGNORING) {
189  result.push_back(*it);
190  }
191  }
192  // add it into vehicleClassNamesListCached
193  vehicleClassNamesListCached[permissions] = result;
194  }
195  return vehicleClassNamesListCached.at(permissions);
196 }
197 
198 
200 getVehicleClassID(const std::string& name) {
201  if (SumoVehicleClassStrings.hasString(name)) {
202  return SumoVehicleClassStrings.get(name);
203  }
204  throw InvalidArgument("Unknown vehicle class '" + name + "'.");
205 }
206 
207 
208 int
209 getVehicleClassCompoundID(const std::string& name) {
210  int ret = SVC_IGNORING;
211  const std::vector<std::string> names = SumoVehicleClassStrings.getStrings();
212  for (std::vector<std::string>::const_iterator it = names.begin(); it != names.end(); it++) {
213  if (name.find(*it) != std::string::npos) {
214  ret = ret | (int) SumoVehicleClassStrings.get(*it);
215  }
216  }
217  return ret;
218 }
219 
220 
222 parseVehicleClasses(const std::string& allowedS) {
223  if (allowedS == "all") {
224  return SVCAll;
225  }
226  // check if allowedS was previously cached
227  if (parseVehicleClassesCached.count(allowedS) == 0) {
228  SVCPermissions result = 0;
229  StringTokenizer sta(allowedS, " ");
230  while (sta.hasNext()) {
231  const std::string s = sta.next();
232  if (!SumoVehicleClassStrings.hasString(s)) {
233  WRITE_ERROR("Unknown vehicle class '" + s + "' encountered.");
234  } else {
235  const SUMOVehicleClass vc = getVehicleClassID(s);
236  const std::string& realName = SumoVehicleClassStrings.getString(vc);
237  if (realName != s) {
239  }
240  result |= vc;
241  }
242  }
243  // save parsed vehicle class cached
244  parseVehicleClassesCached[allowedS] = result;
245  }
246  return parseVehicleClassesCached.at(allowedS);
247 }
248 
249 
250 bool
251 canParseVehicleClasses(const std::string& classes) {
252  if (classes == "all") {
253  return true;
254  }
255  // check if was previously cached
256  if (parseVehicleClassesCached.count(classes) != 0) {
257  return true;
258  }
259  StringTokenizer sta(classes, " ");
260  while (sta.hasNext()) {
261  if (!SumoVehicleClassStrings.hasString(sta.next())) {
262  return false;
263  }
264  }
265  return true;
266 }
267 
268 
270 parseVehicleClasses(const std::string& allowedS, const std::string& disallowedS, double networkVersion) {
271  if (allowedS.size() == 0 && disallowedS.size() == 0) {
272  return SVCAll;
273  } else if (allowedS.size() > 0 && disallowedS.size() > 0) {
274  WRITE_WARNING("SVCPermissions must be specified either via 'allow' or 'disallow'. Ignoring 'disallow'");
275  return parseVehicleClasses(allowedS);
276  } else if (allowedS.size() > 0) {
277  return parseVehicleClasses(allowedS);
278  } else {
279  return invertPermissions(parseVehicleClasses(disallowedS) | (networkVersion < 1.3 ? SVC_RAIL_FAST : 0));
280  }
281 }
282 
283 
286  return SVCAll & ~permissions;
287 }
288 
289 
291 parseVehicleClasses(const std::vector<std::string>& allowedS) {
292  SVCPermissions result = 0;
293  if (std::find(allowedS.begin(), allowedS.end(), "all") != allowedS.end()) {
294  return SVCAll;
295  }
296  for (std::vector<std::string>::const_iterator i = allowedS.begin(); i != allowedS.end(); ++i) {
297  const SUMOVehicleClass vc = getVehicleClassID(*i);
298  const std::string& realName = SumoVehicleClassStrings.getString(vc);
299  if (realName != *i) {
300  WRITE_WARNING("The vehicle class '" + (*i) + "' is deprecated, use '" + realName + "' instead.");
301  }
302  result |= getVehicleClassID(*i);
303  }
304  return result;
305 }
306 
307 
308 void
310  if (permissions == SVCAll) {
311  return;
312  } else if (permissions == 0) {
313  into.writeAttr(SUMO_ATTR_DISALLOW, "all");
314  return;
315  } else {
316  int num_allowed = 0;
317  for (int mask = 1; mask <= SUMOVehicleClass_MAX; mask = mask << 1) {
318  if ((mask & permissions) == mask) {
319  ++num_allowed;
320  }
321  }
322  if (num_allowed <= (SumoVehicleClassStrings.size() - num_allowed) && num_allowed > 0) {
323  into.writeAttr(SUMO_ATTR_ALLOW, getVehicleClassNames(permissions));
324  } else {
326  }
327  }
328 }
329 
330 
331 void
333  if (preferred == SVCAll || preferred == 0) {
334  return;
335  } else {
337  }
338 }
339 
340 
342 getVehicleShapeID(const std::string& name) {
343  if (SumoVehicleShapeStrings.hasString(name)) {
344  return SumoVehicleShapeStrings.get(name);
345  } else {
346  throw InvalidArgument("Unknown vehicle shape '" + name + "'.");
347  }
348 }
349 
350 
351 bool
352 canParseVehicleShape(const std::string& shape) {
353  return SumoVehicleShapeStrings.hasString(shape);
354 }
355 
356 
357 std::string
359  return SumoVehicleShapeStrings.getString(id);
360 }
361 
362 
363 bool isRailway(SVCPermissions permissions) {
364  return (permissions & SVC_RAIL_CLASSES) > 0 && (permissions & SVC_PASSENGER) == 0;
365 }
366 
367 
368 bool
370  return permissions == SVC_SHIP;
371 }
372 
373 
374 bool
376  return (permissions & SVCAll) == 0;
377 }
378 
379 
380 bool
382  return (permissions & SVCAll) == SVC_PEDESTRIAN;
383 }
384 
385 
386 bool
388  return isForbidden(permissions) || isSidewalk(permissions);
389 }
390 
391 
392 std::map<SVCPermissions, double> parseStopOffsets(const SUMOSAXAttributes& attrs, bool& ok) {
393  const std::string vClasses = attrs.getOpt<std::string>(SUMO_ATTR_VCLASSES, nullptr, ok, "");
394  const std::string exceptions = attrs.getOpt<std::string>(SUMO_ATTR_EXCEPTIONS, nullptr, ok, "");
396  WRITE_ERROR("Simultaneous specification of vClasses and exceptions is not allowed!");
397  ok = false;
398  return std::map<SVCPermissions, double>();
399  }
400  const double value = attrs.get<double>(SUMO_ATTR_VALUE, nullptr, ok);
401 
402  int vClassBitset;
403  if (attrs.hasAttribute(SUMO_ATTR_VCLASSES)) {
404  vClassBitset = parseVehicleClasses(vClasses);
405  } else if (attrs.hasAttribute(SUMO_ATTR_EXCEPTIONS)) {
406  vClassBitset = ~parseVehicleClasses(exceptions);
407  } else {
408  // no vClasses specified, thus apply to all
409  vClassBitset = parseVehicleClasses("all");
410  }
411 
412  std::map<SVCPermissions, double> offsets;
413  offsets[vClassBitset] = value;
414  return offsets;
415 }
416 
417 /****************************************************************************/
418 
SVC_RAIL_FAST
@ SVC_RAIL_FAST
vehicle that is allowed to drive on high-speed rail tracks
Definition: SUMOVehicleClass.h:192
getVehicleClassCompoundID
int getVehicleClassCompoundID(const std::string &name)
Returns the OR'ed id of the compound class given by its name.
Definition: SUMOVehicleClass.cpp:209
SVC_PEDESTRIAN
@ SVC_PEDESTRIAN
pedestrian
Definition: SUMOVehicleClass.h:156
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:133
SVC_UNSPECIFIED
const SVCPermissions SVC_UNSPECIFIED
permissions not specified
Definition: SUMOVehicleClass.cpp:148
ToString.h
parseVehicleClassesCached
static std::map< std::string, SVCPermissions > parseVehicleClassesCached
Definition: SUMOVehicleClass.cpp:136
SUMOSAXAttributes::hasAttribute
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SVC_E_VEHICLE
@ SVC_E_VEHICLE
is an electric vehicle
Definition: SUMOVehicleClass.h:181
getVehicleClassNamesList
const std::vector< std::string > & getVehicleClassNamesList(SVCPermissions permissions)
Returns the ids of the given classes, divided using a ' '.
Definition: SUMOVehicleClass.cpp:181
SVC_EMERGENCY
@ SVC_EMERGENCY
public emergency vehicles
Definition: SUMOVehicleClass.h:143
getVehicleClassID
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
Definition: SUMOVehicleClass.cpp:200
SUMO_ATTR_DISALLOW
@ SUMO_ATTR_DISALLOW
Definition: SUMOXMLDefinitions.h:783
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:275
SVS_MOTORCYCLE
@ SVS_MOTORCYCLE
render as a motorcycle
Definition: SUMOVehicleClass.h:60
SVC_COACH
@ SVC_COACH
vehicle is a coach
Definition: SUMOVehicleClass.h:167
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:63
SVS_BUS_TROLLEY
@ SVS_BUS_TROLLEY
render as a trolley bus
Definition: SUMOVehicleClass.h:88
SVC_CUSTOM2
@ SVC_CUSTOM2
is a user-defined type
Definition: SUMOVehicleClass.h:200
StringTokenizer::hasNext
bool hasNext()
returns the information whether further substrings exist
Definition: StringTokenizer.cpp:94
SUMOSAXAttributes::get
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:492
MsgHandler.h
DEFAULT_PEDTYPE_ID
const std::string DEFAULT_PEDTYPE_ID("DEFAULT_PEDTYPE")
DEFAULT_PEDESTRIAN_SPEED
const double DEFAULT_PEDESTRIAN_SPEED(5./3.6)
SVS_TRUCK
@ SVS_TRUCK
render as a transport vehicle
Definition: SUMOVehicleClass.h:76
SVC_BICYCLE
@ SVC_BICYCLE
vehicle is a bicycle
Definition: SUMOVehicleClass.h:179
SVC_DELIVERY
@ SVC_DELIVERY
vehicle is a small delivery vehicle
Definition: SUMOVehicleClass.h:169
StringTokenizer::next
std::string next()
returns the next substring when it exists. Otherwise the behaviour is undefined
Definition: StringTokenizer.cpp:99
getVehicleClassNamesCached
static std::map< SVCPermissions, std::string > getVehicleClassNamesCached
Definition: SUMOVehicleClass.cpp:137
SUMO_ATTR_PREFER
@ SUMO_ATTR_PREFER
Definition: SUMOXMLDefinitions.h:784
SUMO_ATTR_EXCEPTIONS
@ SUMO_ATTR_EXCEPTIONS
Definition: SUMOXMLDefinitions.h:452
DEFAULT_BIKETYPE_ID
const std::string DEFAULT_BIKETYPE_ID("DEFAULT_BIKETYPE")
getVehicleShapeName
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
Definition: SUMOVehicleClass.cpp:358
SVC_RAIL
@ SVC_RAIL
vehicle is a not electrified rail
Definition: SUMOVehicleClass.h:188
SVC_RAIL_URBAN
@ SVC_RAIL_URBAN
vehicle is a city rail
Definition: SUMOVehicleClass.h:186
DEFAULT_CONTAINER_TRANSHIP_SPEED
const double DEFAULT_CONTAINER_TRANSHIP_SPEED(5./3.6)
SVC_AUTHORITY
@ SVC_AUTHORITY
authorities vehicles
Definition: SUMOVehicleClass.h:145
SVS_BUS_FLEXIBLE
@ SVS_BUS_FLEXIBLE
render as a flexible city bus
Definition: SUMOVehicleClass.h:86
SVS_PASSENGER_SEDAN
@ SVS_PASSENGER_SEDAN
render as a sedan passenger vehicle ("Stufenheck")
Definition: SUMOVehicleClass.h:64
SumoVehicleClassStrings
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
SVC_PRIVATE
@ SVC_PRIVATE
private vehicles
Definition: SUMOVehicleClass.h:141
SVS_UNKNOWN
@ SVS_UNKNOWN
not defined
Definition: SUMOVehicleClass.h:52
SVS_BICYCLE
@ SVS_BICYCLE
render as a bicycle
Definition: SUMOVehicleClass.h:56
parseVehicleClasses
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
Definition: SUMOVehicleClass.cpp:222
SVC_TRAM
@ SVC_TRAM
vehicle is a light rail
Definition: SUMOVehicleClass.h:184
vehicleClassNameAll
static std::string vehicleClassNameAll
Definition: SUMOVehicleClass.cpp:138
OutputDevice::writeAttr
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:255
sumoVehicleShapeStringInitializer
StringBijection< SUMOVehicleShape >::Entry sumoVehicleShapeStringInitializer[]
Definition: SUMOVehicleClass.cpp:87
SVS_DELIVERY
@ SVS_DELIVERY
automated car (with cruise controllers)
Definition: SUMOVehicleClass.h:74
canParseVehicleClasses
bool canParseVehicleClasses(const std::string &classes)
Checks whether the given string contains only known vehicle classes.
Definition: SUMOVehicleClass.cpp:251
isForbidden
bool isForbidden(SVCPermissions permissions)
Returns whether an edge with the given permission is a forbidden edge.
Definition: SUMOVehicleClass.cpp:375
StringBijection
Definition: StringBijection.h:43
SVC_TRUCK
@ SVC_TRUCK
vehicle is a large transport vehicle
Definition: SUMOVehicleClass.h:171
writePreferences
void writePreferences(OutputDevice &into, SVCPermissions preferred)
writes allowed disallowed attributes if needed;
Definition: SUMOVehicleClass.cpp:332
SVC_CUSTOM1
@ SVC_CUSTOM1
is a user-defined type
Definition: SUMOVehicleClass.h:198
SVC_ARMY
@ SVC_ARMY
army vehicles
Definition: SUMOVehicleClass.h:147
SVS_BUS
@ SVS_BUS
render as a bus
Definition: SUMOVehicleClass.h:82
SVCPermissions
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
Definition: SUMOVehicleClass.h:218
SVC_RAIL_CLASSES
@ SVC_RAIL_CLASSES
classes which drive on tracks
Definition: SUMOVehicleClass.h:204
canParseVehicleShape
bool canParseVehicleShape(const std::string &shape)
Checks whether the given string contains only known vehicle shape.
Definition: SUMOVehicleClass.cpp:352
SVC_HOV
@ SVC_HOV
vehicle is a HOV
Definition: SUMOVehicleClass.h:161
SUMOVehicleShape
SUMOVehicleShape
Definition of vehicle classes to differ between different appearences.
Definition: SUMOVehicleClass.h:50
StringTokenizer
Definition: StringTokenizer.h:61
isWaterway
bool isWaterway(SVCPermissions permissions)
Returns whether an edge with the given permission is a waterway edge.
Definition: SUMOVehicleClass.cpp:369
writePermissions
void writePermissions(OutputDevice &into, SVCPermissions permissions)
writes allowed disallowed attributes if needed;
Definition: SUMOVehicleClass.cpp:309
SVC_PASSENGER
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
Definition: SUMOVehicleClass.h:159
SUMOVehicleClass.h
SVC_RAIL_ELECTRIC
@ SVC_RAIL_ELECTRIC
rail vehicle that requires electrified tracks
Definition: SUMOVehicleClass.h:190
OutputDevice.h
SVS_RAIL_CARGO
@ SVS_RAIL_CARGO
render as a cargo train
Definition: SUMOVehicleClass.h:94
SVS_PASSENGER_HATCHBACK
@ SVS_PASSENGER_HATCHBACK
render as a hatchback passenger vehicle ("Fliessheck")
Definition: SUMOVehicleClass.h:66
getVehicleClassNames
const std::string & getVehicleClassNames(SVCPermissions permissions, bool expand)
Returns the ids of the given classes, divided using a ' '.
Definition: SUMOVehicleClass.cpp:168
isRailway
bool isRailway(SVCPermissions permissions)
Returns whether an edge with the given permission is a railway edge.
Definition: SUMOVehicleClass.cpp:363
SVS_MOPED
@ SVS_MOPED
render as a moped
Definition: SUMOVehicleClass.h:58
vehicleClassNamesListCached
static std::map< int, std::vector< std::string > > vehicleClassNamesListCached
Definition: SUMOVehicleClass.cpp:135
SVS_POLICE
@ SVS_POLICE
render as a police car
Definition: SUMOVehicleClass.h:106
SUMOSAXAttributes::getOpt
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.
Definition: SUMOSAXAttributes.h:518
SVC_VIP
@ SVC_VIP
vip vehicles
Definition: SUMOVehicleClass.h:149
SVC_SHIP
@ SVC_SHIP
is an arbitrary ship
Definition: SUMOVehicleClass.h:195
SVS_RAIL_CAR
@ SVS_RAIL_CAR
render as a (city) rail without locomotive
Definition: SUMOVehicleClass.h:92
SVS_PASSENGER_VAN
@ SVS_PASSENGER_VAN
render as a van
Definition: SUMOVehicleClass.h:70
SVS_PEDESTRIAN
@ SVS_PEDESTRIAN
render as a pedestrian
Definition: SUMOVehicleClass.h:54
SumoVehicleShapeStrings
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SVS_UNKNOWN, false)
StringUtils.h
SVC_MOPED
@ SVC_MOPED
vehicle is a moped
Definition: SUMOVehicleClass.h:177
deprecatedVehicleClassesSeen
std::set< std::string > deprecatedVehicleClassesSeen
Definition: SUMOVehicleClass.cpp:84
sumoVehicleClassStringInitializer
StringBijection< SUMOVehicleClass >::Entry sumoVehicleClassStringInitializer[]
Definition: SUMOVehicleClass.cpp:42
SVC_TAXI
@ SVC_TAXI
vehicle is a taxi
Definition: SUMOVehicleClass.h:163
InvalidArgument
Definition: UtilExceptions.h:56
SVCAll
const SVCPermissions SVCAll
all VClasses are allowed
Definition: SUMOVehicleClass.cpp:146
SUMO_ATTR_VALUE
@ SUMO_ATTR_VALUE
Definition: SUMOXMLDefinitions.h:779
DEFAULT_VTYPE_ID
const std::string DEFAULT_VTYPE_ID("DEFAULT_VEHTYPE")
SVS_PASSENGER
@ SVS_PASSENGER
render as a passenger vehicle
Definition: SUMOVehicleClass.h:62
StringBijection::Entry
Definition: StringBijection.h:51
SUMO_ATTR_ALLOW
@ SUMO_ATTR_ALLOW
Definition: SUMOXMLDefinitions.h:782
DEFAULT_VEH_PROB
const double DEFAULT_VEH_PROB(1.)
SUMOSAXAttributes.h
SVS_EMERGENCY
@ SVS_EMERGENCY
render as an emergency vehicle
Definition: SUMOVehicleClass.h:102
SVS_E_VEHICLE
@ SVS_E_VEHICLE
render as a (futuristic) e-vehicle
Definition: SUMOVehicleClass.h:96
SVS_SHIP
@ SVS_SHIP
render as a arbitrary ship
Definition: SUMOVehicleClass.h:100
parseStopOffsets
std::map< SVCPermissions, double > parseStopOffsets(const SUMOSAXAttributes &attrs, bool &ok)
Extract stopOffsets from attributes of stopOffset element.
Definition: SUMOVehicleClass.cpp:392
joinToString
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition: ToString.h:246
SVS_TRUCK_SEMITRAILER
@ SVS_TRUCK_SEMITRAILER
render as a semi-trailer transport vehicle ("Sattelschlepper")
Definition: SUMOVehicleClass.h:78
noVehicles
bool noVehicles(SVCPermissions permissions)
Returns whether an edge with the given permission forbids vehicles.
Definition: SUMOVehicleClass.cpp:387
getVehicleShapeID
SUMOVehicleShape getVehicleShapeID(const std::string &name)
Returns the class id of the shape class given by its name.
Definition: SUMOVehicleClass.cpp:342
config.h
SVS_FIREBRIGADE
@ SVS_FIREBRIGADE
render as a fire brigade
Definition: SUMOVehicleClass.h:104
SVC_TRAILER
@ SVC_TRAILER
vehicle is a large transport vehicle
Definition: SUMOVehicleClass.h:173
SVC_BUS
@ SVC_BUS
vehicle is a bus
Definition: SUMOVehicleClass.h:165
StringTokenizer.h
SVS_ANT
@ SVS_ANT
render as a giant ant
Definition: SUMOVehicleClass.h:98
SVS_TRUCK_1TRAILER
@ SVS_TRUCK_1TRAILER
render as a transport vehicle with one trailer
Definition: SUMOVehicleClass.h:80
SVS_PASSENGER_WAGON
@ SVS_PASSENGER_WAGON
render as a wagon passenger vehicle ("Combi")
Definition: SUMOVehicleClass.h:68
SUMOVehicleClass_MAX
const SUMOVehicleClass SUMOVehicleClass_MAX
Definition: SUMOVehicleClass.cpp:144
SVC_MOTORCYCLE
@ SVC_MOTORCYCLE
vehicle is a motorcycle
Definition: SUMOVehicleClass.h:175
SVS_BUS_COACH
@ SVS_BUS_COACH
render as a coach
Definition: SUMOVehicleClass.h:84
isSidewalk
bool isSidewalk(SVCPermissions permissions)
Returns whether an edge with the given permission is a sidewalk.
Definition: SUMOVehicleClass.cpp:381
SVS_RICKSHAW
@ SVS_RICKSHAW
render as a rickshaw
Definition: SUMOVehicleClass.h:108
invertPermissions
SVCPermissions invertPermissions(SVCPermissions permissions)
negate the given permissions and ensure that only relevant bits are set
Definition: SUMOVehicleClass.cpp:285
SVC_IGNORING
@ SVC_IGNORING
vehicles ignoring classes
Definition: SUMOVehicleClass.h:135
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:56
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:283
SUMO_ATTR_VCLASSES
@ SUMO_ATTR_VCLASSES
Definition: SUMOXMLDefinitions.h:451
SVS_RAIL
@ SVS_RAIL
render as a rail
Definition: SUMOVehicleClass.h:90