SUMO - Simulation of Urban MObility
SUMOXMLDefinitions.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2002-2018 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 /****************************************************************************/
20 // Definitions of elements and attributes known by SUMO
21 /****************************************************************************/
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #include <config.h>
28 
29 #include <cassert>
32 
33 #include "SUMOXMLDefinitions.h"
34 
35 // ===========================================================================
36 // definitions
37 // ===========================================================================
38 
40  // Simulation elements
41  { "net", SUMO_TAG_NET },
42  { "edge", SUMO_TAG_EDGE },
43  { "lane", SUMO_TAG_LANE },
44  { "neigh", SUMO_TAG_NEIGH },
45  { "poi", SUMO_TAG_POI },
46  { "poiLane", SUMO_TAG_POILANE },
47  { "poly", SUMO_TAG_POLY },
48  { "junction", SUMO_TAG_JUNCTION },
49  { "restriction", SUMO_TAG_RESTRICTION },
50  { "e1Detector", SUMO_TAG_E1DETECTOR },
51  { "inductionLoop", SUMO_TAG_INDUCTION_LOOP },
52  { "e2Detector", SUMO_TAG_E2DETECTOR },
53  { "e2MultilaneDetector", SUMO_TAG_E2DETECTOR_MULTILANE },
54  { "laneAreaDetector", SUMO_TAG_LANE_AREA_DETECTOR },
55  { "e3Detector", SUMO_TAG_E3DETECTOR },
56  { "entryExitDetector", SUMO_TAG_ENTRY_EXIT_DETECTOR },
57  { "edgeData", SUMO_TAG_MEANDATA_EDGE },
58  { "laneData", SUMO_TAG_MEANDATA_LANE },
59  { "detEntry", SUMO_TAG_DET_ENTRY },
60  { "detExit", SUMO_TAG_DET_EXIT },
61  { "edgeFollowDetector", SUMO_TAG_EDGEFOLLOWDETECTOR },
62  { "instantInductionLoop", SUMO_TAG_INSTANT_INDUCTION_LOOP },
63  { "variableSpeedSign", SUMO_TAG_VSS },
64  { "calibrator", SUMO_TAG_CALIBRATOR },
65  { "laneCalibrator", SUMO_TAG_LANECALIBRATOR },
66  { "rerouter", SUMO_TAG_REROUTER },
67  { "busStop", SUMO_TAG_BUS_STOP },
68  { "trainStop", SUMO_TAG_TRAIN_STOP },
69  { "ptLine", SUMO_TAG_PT_LINE },
70  { "access", SUMO_TAG_ACCESS },
71  { "containerStop", SUMO_TAG_CONTAINER_STOP },
72  { "parkingArea", SUMO_TAG_PARKING_AREA },
73  { "space", SUMO_TAG_PARKING_SPACE },
74  { "chargingStation", SUMO_TAG_CHARGING_STATION },
75  { "vTypeProbe", SUMO_TAG_VTYPEPROBE },
76  { "routeProbe", SUMO_TAG_ROUTEPROBE },
77  { "routes", SUMO_TAG_ROUTES },
78  { "vehicle", SUMO_TAG_VEHICLE },
79  { "vType", SUMO_TAG_VTYPE },
80  { "route", SUMO_TAG_ROUTE },
81  { "request", SUMO_TAG_REQUEST },
82  { "source", SUMO_TAG_SOURCE },
83  { "taz", SUMO_TAG_TAZ },
84  { "tazSource", SUMO_TAG_TAZSOURCE },
85  { "tazSink", SUMO_TAG_TAZSINK },
86  { "trafficLight", SUMO_TAG_TRAFFIC_LIGHT },
87  { "tlLogic", SUMO_TAG_TLLOGIC },
88  { "phase", SUMO_TAG_PHASE },
89  { "trip", SUMO_TAG_TRIP },
90  { "flow", SUMO_TAG_FLOW },
91  { "flowState", SUMO_TAG_FLOWSTATE },
92  { "step", SUMO_TAG_STEP },
93  { "interval", SUMO_TAG_INTERVAL },
94  { "timedEvent", SUMO_TAG_TIMEDEVENT },
95  { "fromEdge", SUMO_TAG_FROMEDGE },
96  { "toEdge", SUMO_TAG_TOEDGE },
97  { "sink", SUMO_TAG_SINK },
98  { "param", SUMO_TAG_PARAM },
99  { "WAUT", SUMO_TAG_WAUT },
100  { "wautSwitch", SUMO_TAG_WAUT_SWITCH },
101  { "wautJunction", SUMO_TAG_WAUT_JUNCTION },
102  { "segment", SUMO_TAG_SEGMENT },
103  { "delete", SUMO_TAG_DELETE },
104  { "stop", SUMO_TAG_STOP },
105  { "destProbReroute", SUMO_TAG_DEST_PROB_REROUTE },
106  { "closingReroute", SUMO_TAG_CLOSING_REROUTE },
107  { "closingLaneReroute", SUMO_TAG_CLOSING_LANE_REROUTE },
108  { "routeProbReroute", SUMO_TAG_ROUTE_PROB_REROUTE },
109  { "parkingAreaReroute", SUMO_TAG_PARKING_ZONE_REROUTE },
110  { "polygonType", SUMO_TAG_POLYTYPE },
111  { "connection", SUMO_TAG_CONNECTION },
112  { "prohibition", SUMO_TAG_PROHIBITION },
113  { "split", SUMO_TAG_SPLIT },
114  { "node", SUMO_TAG_NODE },
115  { "type", SUMO_TAG_TYPE },
116  { "detectorDefinition", SUMO_TAG_DETECTOR_DEFINITION },
117  { "routeDistribution", SUMO_TAG_ROUTE_DISTRIBUTION },
118  { "vTypeDistribution", SUMO_TAG_VTYPE_DISTRIBUTION },
119  { "vaporizer", SUMO_TAG_VAPORIZER },
120  { "roundabout", SUMO_TAG_ROUNDABOUT },
121  { "join", SUMO_TAG_JOIN },
122  { "joinExclude", SUMO_TAG_JOINEXCLUDE },
123  { "crossing", SUMO_TAG_CROSSING },
124  { "walkingArea", SUMO_TAG_WALKINGAREA },
125  { "stopOffset", SUMO_TAG_STOPOFFSET },
126  // OSM
127  { "way", SUMO_TAG_WAY },
128  { "nd", SUMO_TAG_ND },
129  { "tag", SUMO_TAG_TAG },
130  { "relation", SUMO_TAG_RELATION },
131  { "member", SUMO_TAG_MEMBER },
132  // View
133  { "viewsettings", SUMO_TAG_VIEWSETTINGS },
134  { "decal", SUMO_TAG_VIEWSETTINGS_DECAL },
135  { "light", SUMO_TAG_VIEWSETTINGS_LIGHT },
136  { "scheme", SUMO_TAG_VIEWSETTINGS_SCHEME },
137  { "opengl", SUMO_TAG_VIEWSETTINGS_OPENGL },
138  { "background", SUMO_TAG_VIEWSETTINGS_BACKGROUND },
139  { "edges", SUMO_TAG_VIEWSETTINGS_EDGES },
140  { "vehicles", SUMO_TAG_VIEWSETTINGS_VEHICLES },
141  { "persons", SUMO_TAG_VIEWSETTINGS_PERSONS },
142  { "containers", SUMO_TAG_VIEWSETTINGS_CONTAINERS },
143  { "junctions", SUMO_TAG_VIEWSETTINGS_JUNCTIONS },
144  { "additionals", SUMO_TAG_VIEWSETTINGS_ADDITIONALS },
145  { "pois", SUMO_TAG_VIEWSETTINGS_POIS },
146  { "polys", SUMO_TAG_VIEWSETTINGS_POLYS },
147  { "legend", SUMO_TAG_VIEWSETTINGS_LEGEND },
148  { "event", SUMO_TAG_VIEWSETTINGS_EVENT },
150  { "include", SUMO_TAG_INCLUDE },
151  { "delay", SUMO_TAG_DELAY },
152  { "viewport", SUMO_TAG_VIEWPORT },
153  { "snapshot", SUMO_TAG_SNAPSHOT },
154  { "breakpoints-file", SUMO_TAG_BREAKPOINTS_FILE },
155  { "breakpoint", SUMO_TAG_BREAKPOINT },
156  { "location", SUMO_TAG_LOCATION },
157  { "colorScheme", SUMO_TAG_COLORSCHEME },
158  { "scalingScheme", SUMO_TAG_SCALINGSCHEME },
159  { "entry", SUMO_TAG_ENTRY },
160  { "rngState", SUMO_TAG_RNGSTATE },
161  { "vehicleTransfer", SUMO_TAG_VEHICLETRANSFER },
162  { "device", SUMO_TAG_DEVICE },
163  // Cars
164  { "carFollowing-IDM", SUMO_TAG_CF_IDM },
165  { "carFollowing-IDMM", SUMO_TAG_CF_IDMM },
166  { "carFollowing-Krauss", SUMO_TAG_CF_KRAUSS },
167  { "carFollowing-KraussPS", SUMO_TAG_CF_KRAUSS_PLUS_SLOPE },
168  { "carFollowing-KraussOrig1", SUMO_TAG_CF_KRAUSS_ORIG1 },
169  { "carFollowing-KraussX", SUMO_TAG_CF_KRAUSSX },
170  { "carFollowing-SmartSK", SUMO_TAG_CF_SMART_SK },
171  { "carFollowing-Daniel1", SUMO_TAG_CF_DANIEL1 },
172  { "carFollowing-PWagner2009", SUMO_TAG_CF_PWAGNER2009 },
173  { "carFollowing-BKerner", SUMO_TAG_CF_BKERNER },
174  { "carFollowing-Wiedemann", SUMO_TAG_CF_WIEDEMANN },
175  { "carFollowing-Rail", SUMO_TAG_CF_RAIL },
176  { "carFollowing-ACC", SUMO_TAG_CF_ACC },
177  { "carFollowing-CACC", SUMO_TAG_CF_CACC },
178  // Person
179  { "person", SUMO_TAG_PERSON },
180  { "personTrip", SUMO_TAG_PERSONTRIP },
181  { "ride", SUMO_TAG_RIDE },
182  { "walk", SUMO_TAG_WALK },
183  // Transport
184  { "container", SUMO_TAG_CONTAINER },
185  { "transport", SUMO_TAG_TRANSPORT },
186  { "tranship", SUMO_TAG_TRANSHIP },
187  //Trajectories
188  { "trajectories", SUMO_TAG_TRAJECTORIES },
189  { "timestep", SUMO_TAG_TIMESTEP },
190  { "timeSlice", SUMO_TAG_TIMESLICE },
191  { "actorConfig", SUMO_TAG_ACTORCONFIG },
192  { "motionState", SUMO_TAG_MOTIONSTATE },
193  { "odPair", SUMO_TAG_OD_PAIR },
194  // ActivityGen statistics file
195  { "general", AGEN_TAG_GENERAL },
196  { "street", AGEN_TAG_STREET },
197  { "workHours", AGEN_TAG_WORKHOURS },
198  { "opening", AGEN_TAG_OPENING },
199  { "closing", AGEN_TAG_CLOSING },
200  { "schools", AGEN_TAG_SCHOOLS },
201  { "school", AGEN_TAG_SCHOOL },
202  { "busStation", AGEN_TAG_BUSSTATION },
203  { "busLine", AGEN_TAG_BUSLINE },
204  { "stations", AGEN_TAG_STATIONS },
205  { "revStations", AGEN_TAG_REV_STATIONS },
206  { "station", AGEN_TAG_STATION },
207  { "frequency", AGEN_TAG_FREQUENCY },
208  { "population", AGEN_TAG_POPULATION },
209  { "bracket", AGEN_TAG_BRACKET },
210  { "cityGates", AGEN_TAG_CITYGATES },
211  { "entrance", AGEN_TAG_ENTRANCE },
212  { "parameters", AGEN_TAG_PARAM },
213  // Other
214  { "", SUMO_TAG_NOTHING } //< must be the last one
215 };
216 
217 
219  // Edge
220  { "id", SUMO_ATTR_ID },
221  { "refId", SUMO_ATTR_REFID },
222  { "name", SUMO_ATTR_NAME },
223  { "type", SUMO_ATTR_TYPE },
224  { "priority", SUMO_ATTR_PRIORITY },
225  { "numLanes", SUMO_ATTR_NUMLANES },
226  { "speed", SUMO_ATTR_SPEED },
227  { "oneway", SUMO_ATTR_ONEWAY },
228  { "width", SUMO_ATTR_WIDTH },
229  { "sidewalkWidth", SUMO_ATTR_SIDEWALKWIDTH },
230  { "bikeLaneWidth", SUMO_ATTR_BIKELANEWIDTH },
231  { "remove", SUMO_ATTR_REMOVE },
232  { "length", SUMO_ATTR_LENGTH },
233  { "bidi", SUMO_ATTR_BIDI },
234  // Split
235  { "idBefore", SUMO_ATTR_ID_BEFORE },
236  { "idAfter", SUMO_ATTR_ID_AFTER },
237  // Positions
238  { "x", SUMO_ATTR_X },
239  { "y", SUMO_ATTR_Y },
240  { "z", SUMO_ATTR_Z },
241  { "centerX", SUMO_ATTR_CENTER_X },
242  { "centerY", SUMO_ATTR_CENTER_Y },
243  { "centerZ", SUMO_ATTR_CENTER_Z },
244 
245  { "key", SUMO_ATTR_KEY },
246  { "requestSize", SUMO_ATTR_REQUESTSIZE },
247  { "request", SUMO_ATTR_REQUEST },
248  { "response", SUMO_ATTR_RESPONSE },
249  { "programID", SUMO_ATTR_PROGRAMID },
250  { "offset", SUMO_ATTR_OFFSET },
251  { "endOffset", SUMO_ATTR_ENDOFFSET },
252  { "incLanes", SUMO_ATTR_INCLANES },
253  { "intLanes", SUMO_ATTR_INTLANES },
254 
255  { "weight", SUMO_ATTR_WEIGHT },
256  { "node", SUMO_ATTR_NODE },
257  { "edge", SUMO_ATTR_EDGE },
258  { "edges", SUMO_ATTR_EDGES },
259  // Vehicle
260  { "depart", SUMO_ATTR_DEPART },
261  { "departLane", SUMO_ATTR_DEPARTLANE },
262  { "departPos", SUMO_ATTR_DEPARTPOS },
263  { "departPosLat", SUMO_ATTR_DEPARTPOS_LAT },
264  { "departSpeed", SUMO_ATTR_DEPARTSPEED },
265  { "arrivalLane", SUMO_ATTR_ARRIVALLANE },
266  { "arrivalPos", SUMO_ATTR_ARRIVALPOS },
267  { "arrivalPosLat", SUMO_ATTR_ARRIVALPOS_LAT },
268  { "arrivalSpeed", SUMO_ATTR_ARRIVALSPEED },
269  { "route", SUMO_ATTR_ROUTE },
270  { "maxSpeed", SUMO_ATTR_MAXSPEED },
271  { "maxSpeedLat", SUMO_ATTR_MAXSPEED_LAT },
272  { "latAlignment", SUMO_ATTR_LATALIGNMENT },
273  { "minGapLat", SUMO_ATTR_MINGAP_LAT },
274  { "accel", SUMO_ATTR_ACCEL },
275  { "decel", SUMO_ATTR_DECEL },
276  { "emergencyDecel", SUMO_ATTR_EMERGENCYDECEL },
277  { "apparentDecel", SUMO_ATTR_APPARENTDECEL },
278  { "actionStepLength", SUMO_ATTR_ACTIONSTEPLENGTH },
279  { "hasDriverState", SUMO_ATTR_HASDRIVERSTATE },
280  { "vClass", SUMO_ATTR_VCLASS },
281  { "vClasses", SUMO_ATTR_VCLASSES },
282  { "exceptions", SUMO_ATTR_EXCEPTIONS },
283  { "repno", SUMO_ATTR_REPNUMBER },
284  { "speedFactor", SUMO_ATTR_SPEEDFACTOR },
285  { "speedDev", SUMO_ATTR_SPEEDDEV },
286  { "laneChangeModel", SUMO_ATTR_LANE_CHANGE_MODEL },
287  { "carFollowModel", SUMO_ATTR_CAR_FOLLOW_MODEL },
288  { "minGap", SUMO_ATTR_MINGAP },
289  { "collisionMinGapFactor", SUMO_ATTR_COLLISION_MINGAP_FACTOR },
290  { "boardingDuration", SUMO_ATTR_BOARDING_DURATION },
291  { "loadingDuration", SUMO_ATTR_LOADING_DURATION },
292  // Charging Station
293  { "power", SUMO_ATTR_CHARGINGPOWER },
294  { "efficiency", SUMO_ATTR_EFFICIENCY },
295  { "chargeInTransit", SUMO_ATTR_CHARGEINTRANSIT },
296  { "chargeDelay", SUMO_ATTR_CHARGEDELAY},
297  // MSDevice_Battery
298  { "actualBatteryCapacity", SUMO_ATTR_ACTUALBATTERYCAPACITY },
299  { "maximumBatteryCapacity", SUMO_ATTR_MAXIMUMBATTERYCAPACITY },
300  { "maximumPower", SUMO_ATTR_MAXIMUMPOWER },
301  { "vehicleMass", SUMO_ATTR_VEHICLEMASS },
302  { "frontSurfaceArea", SUMO_ATTR_FRONTSURFACEAREA },
303  { "airDragCoefficient", SUMO_ATTR_AIRDRAGCOEFFICIENT },
304  { "internalMomentOfInertia", SUMO_ATTR_INTERNALMOMENTOFINERTIA },
305  { "radialDragCoefficient", SUMO_ATTR_RADIALDRAGCOEFFICIENT },
306  { "rollDragCoefficient", SUMO_ATTR_ROLLDRAGCOEFFICIENT },
307  { "constantPowerIntake", SUMO_ATTR_CONSTANTPOWERINTAKE },
308  { "propulsionEfficiency", SUMO_ATTR_PROPULSIONEFFICIENCY },
309  { "recuperationEfficiency", SUMO_ATTR_RECUPERATIONEFFICIENCY },
310  { "stoppingTreshold", SUMO_ATTR_STOPPINGTRESHOLD },
311  // MSBatteryExport
312  { "energyConsumed", SUMO_ATTR_ENERGYCONSUMED },
313  { "chargingStationId", SUMO_ATTR_CHARGINGSTATIONID },
314  { "energyCharged", SUMO_ATTR_ENERGYCHARGED },
315  { "energyChargedInTransit", SUMO_ATTR_ENERGYCHARGEDINTRANSIT },
316  { "energyChargedStopped", SUMO_ATTR_ENERGYCHARGEDSTOPPED },
317  { "posOnLane", SUMO_ATTR_POSONLANE },
318  { "timeStopped", SUMO_ATTR_TIMESTOPPED },
319  // ChargingStation output
320  { "chargingStatus", SUMO_ATTR_CHARGING_STATUS },
321  { "totalEnergyCharged", SUMO_ATTR_TOTALENERGYCHARGED },
322  { "chargingSteps", SUMO_ATTR_CHARGINGSTEPS },
323  { "totalEnergyChargedIntoVehicle", SUMO_ATTR_TOTALENERGYCHARGED_VEHICLE },
324  { "chargingBegin", SUMO_ATTR_CHARGINGBEGIN },
325  { "chargingEnd", SUMO_ATTR_CHARGINGEND },
326  { "partialCharge", SUMO_ATTR_PARTIALCHARGE },
327 
328  { "sigma", SUMO_ATTR_SIGMA },
329  { "tau", SUMO_ATTR_TAU },
330  { "tmp1", SUMO_ATTR_TMP1 },
331  { "tmp2", SUMO_ATTR_TMP2 },
332  { "tmp3", SUMO_ATTR_TMP3 },
333  { "tmp4", SUMO_ATTR_TMP4 },
334  { "tmp5", SUMO_ATTR_TMP5 },
335 
336  { "speedControlGain", SUMO_ATTR_SC_GAIN },
337  { "gapClosingControlGainSpeed", SUMO_ATTR_GCC_GAIN_SPEED },
338  { "gapClosingControlGainSpace", SUMO_ATTR_GCC_GAIN_SPACE },
339  { "gapControlGainSpeed", SUMO_ATTR_GC_GAIN_SPEED },
340  { "gapControlGainSpace", SUMO_ATTR_GC_GAIN_SPACE },
341  { "collisionAvoidanceGainSpeed", SUMO_ATTR_CA_GAIN_SPEED },
342  { "collisionAvoidanceGainSpace", SUMO_ATTR_CA_GAIN_SPACE },
343 
344  { "speedControlGainCACC", SUMO_ATTR_SC_GAIN_CACC },
345  { "gapClosingControlGainGap", SUMO_ATTR_GCC_GAIN_GAP_CACC },
346  { "gapClosingControlGainGapDot", SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC },
347  { "gapControlGainGap", SUMO_ATTR_GC_GAIN_GAP_CACC },
348  { "gapControlGainGapDot", SUMO_ATTR_GC_GAIN_GAP_DOT_CACC },
349  { "collisionAvoidanceGainGap", SUMO_ATTR_CA_GAIN_GAP_CACC },
350  { "collisionAvoidanceGainGapDot", SUMO_ATTR_CA_GAIN_GAP_DOT_CACC },
351 
352  { "trainType", SUMO_ATTR_TRAIN_TYPE },
353 
354  { "lcStrategic", SUMO_ATTR_LCA_STRATEGIC_PARAM },
355  { "lcCooperative", SUMO_ATTR_LCA_COOPERATIVE_PARAM },
356  { "lcSpeedGain", SUMO_ATTR_LCA_SPEEDGAIN_PARAM },
357  { "lcKeepRight", SUMO_ATTR_LCA_KEEPRIGHT_PARAM },
358  { "lcSublane", SUMO_ATTR_LCA_SUBLANE_PARAM },
359  { "lcOpposite", SUMO_ATTR_LCA_OPPOSITE_PARAM },
360  { "lcPushy", SUMO_ATTR_LCA_PUSHY },
361  { "lcPushyGap", SUMO_ATTR_LCA_PUSHYGAP },
362  { "lcAssertive", SUMO_ATTR_LCA_ASSERTIVE },
363  { "lcImpatience", SUMO_ATTR_LCA_IMPATIENCE },
364  { "lcTimeToImpatience", SUMO_ATTR_LCA_TIME_TO_IMPATIENCE },
365  { "lcAccelLat", SUMO_ATTR_LCA_ACCEL_LAT },
366  { "lcTurnAlignmentDistance", SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE },
367  { "lcLookaheadLeft", SUMO_ATTR_LCA_LOOKAHEADLEFT },
368  { "lcSpeedGainRight", SUMO_ATTR_LCA_SPEEDGAINRIGHT },
369  { "lcMaxSpeedLatStanding", SUMO_ATTR_LCA_MAXSPEEDLATSTANDING },
370  { "lcMaxSpeedLatFactor", SUMO_ATTR_LCA_MAXSPEEDLATFACTOR },
371  { "lcExperimental1", SUMO_ATTR_LCA_EXPERIMENTAL1 },
372 
373  { "jmCrossingGap", SUMO_ATTR_JM_CROSSING_GAP },
374  { "jmDriveAfterRedTime", SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME },
375  { "jmDriveRedSpeed", SUMO_ATTR_JM_DRIVE_RED_SPEED },
376  { "jmIgnoreKeepClearTime", SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME },
377  { "jmIgnoreFoeSpeed", SUMO_ATTR_JM_IGNORE_FOE_SPEED },
378  { "jmIgnoreFoeProb", SUMO_ATTR_JM_IGNORE_FOE_PROB },
379  { "jmSigmaMinor", SUMO_ATTR_JM_SIGMA_MINOR },
380  { "jmTimegapMinor", SUMO_ATTR_JM_TIMEGAP_MINOR },
381 
382  { "last", SUMO_ATTR_LAST },
383  { "cost", SUMO_ATTR_COST },
384  { "savings", SUMO_ATTR_SAVINGS },
385  { "probability", SUMO_ATTR_PROB },
386  { "probabilities", SUMO_ATTR_PROBS },
387  { "routes", SUMO_ATTR_ROUTES },
388  { "vTypes", SUMO_ATTR_VTYPES },
389 
390  { "lane", SUMO_ATTR_LANE },
391  { "lanes", SUMO_ATTR_LANES },
392  { "from", SUMO_ATTR_FROM },
393  { "to", SUMO_ATTR_TO },
394  { "period", SUMO_ATTR_PERIOD },
395  { "fromTaz", SUMO_ATTR_FROM_TAZ },
396  { "toTaz", SUMO_ATTR_TO_TAZ },
397  { "reroute", SUMO_ATTR_REROUTE },
398  { "personCapacity", SUMO_ATTR_PERSON_CAPACITY },
399  { "containerCapacity", SUMO_ATTR_CONTAINER_CAPACITY },
400  { "personNumber", SUMO_ATTR_PERSON_NUMBER },
401  { "containerNumber", SUMO_ATTR_CONTAINER_NUMBER },
402  { "modes", SUMO_ATTR_MODES },
403  { "walkFactor", SUMO_ATTR_WALKFACTOR },
404 
405  { "function", SUMO_ATTR_FUNCTION },
406  { "pos", SUMO_ATTR_POSITION },
407  { "posLat", SUMO_ATTR_POSITION_LAT },
408  { "freq", SUMO_ATTR_FREQUENCY },
409  { "style", SUMO_ATTR_STYLE },
410  { "file", SUMO_ATTR_FILE },
411  { "junction", SUMO_ATTR_JUNCTION },
412  { "number", SUMO_ATTR_NUMBER },
413  { "duration", SUMO_ATTR_DURATION },
414  { "until", SUMO_ATTR_UNTIL },
415  { "routeProbe", SUMO_ATTR_ROUTEPROBE },
416  { "crossingEdges", SUMO_ATTR_CROSSING_EDGES },
417  // Traffic light & Nodes
418  { "time", SUMO_ATTR_TIME },
419  { "begin", SUMO_ATTR_BEGIN },
420  { "end", SUMO_ATTR_END },
421  { "tl", SUMO_ATTR_TLID },
422  { "tlType", SUMO_ATTR_TLTYPE },
423  { "linkIndex", SUMO_ATTR_TLLINKINDEX },
424  { "linkIndex2", SUMO_ATTR_TLLINKINDEX2 },
425  { "shape", SUMO_ATTR_SHAPE },
426  { "spreadType", SUMO_ATTR_SPREADTYPE },
427  { "radius", SUMO_ATTR_RADIUS },
428  { "customShape", SUMO_ATTR_CUSTOMSHAPE },
429  { "keepClear", SUMO_ATTR_KEEP_CLEAR },
430  { "rightOfWay", SUMO_ATTR_RIGHT_OF_WAY },
431  { "color", SUMO_ATTR_COLOR },
432  { "dir", SUMO_ATTR_DIR },
433  { "state", SUMO_ATTR_STATE },
434  { "layer", SUMO_ATTR_LAYER },
435  { "fill", SUMO_ATTR_FILL },
436  { "lineWidth", SUMO_ATTR_LINEWIDTH },
437  { "prefix", SUMO_ATTR_PREFIX },
438  { "discard", SUMO_ATTR_DISCARD },
439 
440  { "fromLane", SUMO_ATTR_FROM_LANE },
441  { "toLane", SUMO_ATTR_TO_LANE },
442  { "dest", SUMO_ATTR_DEST },
443  { "source", SUMO_ATTR_SOURCE },
444  { "via", SUMO_ATTR_VIA },
445  { "nodes", SUMO_ATTR_NODES },
446  { "visibility", SUMO_ATTR_VISIBILITY_DISTANCE },
447 
448  { "minDur", SUMO_ATTR_MINDURATION },
449  { "maxDur", SUMO_ATTR_MAXDURATION },
450  { "next", SUMO_ATTR_NEXT },
451  { "foes", SUMO_ATTR_FOES },
452  // E2 detector
453  { "cont", SUMO_ATTR_CONT },
454  { "contPos", SUMO_ATTR_CONTPOS },
455  { "timeThreshold", SUMO_ATTR_HALTING_TIME_THRESHOLD },
456  { "speedThreshold", SUMO_ATTR_HALTING_SPEED_THRESHOLD },
457  { "jamThreshold", SUMO_ATTR_JAM_DIST_THRESHOLD },
458  { "show", SUMO_ATTR_SHOW_DETECTOR },
459  // E3 detector
460  { "openEntry", SUMO_ATTR_OPEN_ENTRY },
461 
462  { "wautID", SUMO_ATTR_WAUT_ID },
463  { "junctionID", SUMO_ATTR_JUNCTION_ID },
464  { "procedure", SUMO_ATTR_PROCEDURE },
465  { "synchron", SUMO_ATTR_SYNCHRON },
466  { "refTime", SUMO_ATTR_REF_TIME },
467  { "startProg", SUMO_ATTR_START_PROG },
468  { "off", SUMO_ATTR_OFF },
469  { "friendlyPos", SUMO_ATTR_FRIENDLY_POS },
470  { "splitByType", SUMO_ATTR_SPLIT_VTYPE },
471  { "uncontrolled", SUMO_ATTR_UNCONTROLLED },
472  { "pass", SUMO_ATTR_PASS },
473  { "busStop", SUMO_ATTR_BUS_STOP },
474  { "containerStop", SUMO_ATTR_CONTAINER_STOP },
475  { "parkingArea", SUMO_ATTR_PARKING_AREA },
476  { "roadsideCapacity", SUMO_ATTR_ROADSIDE_CAPACITY },
477  { "onRoad", SUMO_ATTR_ONROAD },
478  { "chargingStation", SUMO_ATTR_CHARGING_STATION},
479  { "line", SUMO_ATTR_LINE },
480  { "lines", SUMO_ATTR_LINES },
481  { "intended", SUMO_ATTR_INTENDED },
482  { "value", SUMO_ATTR_VALUE },
483  { "prohibitor", SUMO_ATTR_PROHIBITOR },
484  { "prohibited", SUMO_ATTR_PROHIBITED },
485  { "allow", SUMO_ATTR_ALLOW },
486  { "disallow", SUMO_ATTR_DISALLOW },
487  { "prefer", SUMO_ATTR_PREFER },
488  { "controlledInner", SUMO_ATTR_CONTROLLED_INNER },
489  { "vehsPerHour", SUMO_ATTR_VEHSPERHOUR },
490  { "output", SUMO_ATTR_OUTPUT },
491  { "height", SUMO_ATTR_HEIGHT },
492  { "guiShape", SUMO_ATTR_GUISHAPE },
493  { "osgFile", SUMO_ATTR_OSGFILE },
494  { "imgFile", SUMO_ATTR_IMGFILE },
495  { "relativePath", SUMO_ATTR_RELATIVEPATH },
496  { "angle", SUMO_ATTR_ANGLE },
497  { "emissionClass", SUMO_ATTR_EMISSIONCLASS },
498  { "impatience", SUMO_ATTR_IMPATIENCE },
499  { "startPos", SUMO_ATTR_STARTPOS },
500  { "endPos", SUMO_ATTR_ENDPOS },
501  { "triggered", SUMO_ATTR_TRIGGERED },
502  { "containerTriggered", SUMO_ATTR_CONTAINER_TRIGGERED },
503  { "parking", SUMO_ATTR_PARKING },
504  { "expected", SUMO_ATTR_EXPECTED },
505  { "expectedContainers", SUMO_ATTR_EXPECTED_CONTAINERS },
506  { "index", SUMO_ATTR_INDEX },
507 
508  { "entering", SUMO_ATTR_ENTERING },
509  { "excludeEmpty", SUMO_ATTR_EXCLUDE_EMPTY },
510  { "withInternal", SUMO_ATTR_WITH_INTERNAL },
511  { "trackVehicles", SUMO_ATTR_TRACK_VEHICLES },
512  { "maxTraveltime", SUMO_ATTR_MAX_TRAVELTIME },
513  { "minSamples", SUMO_ATTR_MIN_SAMPLES },
514 
515  { "lon", SUMO_ATTR_LON },
516  { "lat", SUMO_ATTR_LAT },
517  { "geo", SUMO_ATTR_GEO },
518  { "geoShape", SUMO_ATTR_GEOSHAPE },
519  { "lon/lat", SUMO_ATTR_GEOPOSITION },
520  { "k", SUMO_ATTR_K },
521  { "v", SUMO_ATTR_V },
522  { "ref", SUMO_ATTR_REF },
523  { "href", SUMO_ATTR_HREF },
524  { "zoom", SUMO_ATTR_ZOOM },
525  { "interpolated", SUMO_ATTR_INTERPOLATED },
526  { "threshold", SUMO_ATTR_THRESHOLD },
527 
528  { "netOffset", SUMO_ATTR_NET_OFFSET },
529  { "convBoundary", SUMO_ATTR_CONV_BOUNDARY },
530  { "origBoundary", SUMO_ATTR_ORIG_BOUNDARY },
531  { "projParameter", SUMO_ATTR_ORIG_PROJ },
532 
533  { "tauLast", SUMO_ATTR_CF_PWAGNER2009_TAULAST },
534  { "apProb", SUMO_ATTR_CF_PWAGNER2009_APPROB },
535  { "delta", SUMO_ATTR_CF_IDM_DELTA },
536  { "stepping", SUMO_ATTR_CF_IDM_STEPPING },
537  { "adaptFactor", SUMO_ATTR_CF_IDMM_ADAPT_FACTOR },
538  { "adaptTime", SUMO_ATTR_CF_IDMM_ADAPT_TIME },
539  { "phi", SUMO_ATTR_CF_KERNER_PHI },
540 
541  { "security", SUMO_ATTR_CF_WIEDEMANN_SECURITY },
542  { "estimation", SUMO_ATTR_CF_WIEDEMANN_ESTIMATION },
543 
544  { "generateWalks", SUMO_ATTR_GENERATE_WALKS },
545  { "actType", SUMO_ATTR_ACTTYPE },
546  { "slope", SUMO_ATTR_SLOPE },
547  { "version", SUMO_ATTR_VERSION },
548  { "junctionCornerDetail", SUMO_ATTR_CORNERDETAIL },
549  { "junctionLinkDetail", SUMO_ATTR_LINKDETAIL },
550  { "rectangularLaneCut", SUMO_ATTR_RECTANGULAR_LANE_CUT },
551  { "walkingareas", SUMO_ATTR_WALKINGAREAS },
552  { "lefthand", SUMO_ATTR_LEFTHAND },
553  { "limitTurnSpeed", SUMO_ATTR_LIMIT_TURN_SPEED },
554  { "checkLaneFoesAll", SUMO_ATTR_CHECKLANEFOES_ALL },
555  { "checkLaneFoesRoundabout",SUMO_ATTR_CHECKLANEFOES_ROUNDABOUT },
556 
557  { "actorConfig", SUMO_ATTR_ACTORCONFIG },
558  { "vehicle", SUMO_ATTR_VEHICLE },
559  { "startTime", SUMO_ATTR_STARTTIME },
560  { "vehicleClass", SUMO_ATTR_VEHICLECLASS },
561  { "fuel", SUMO_ATTR_FUEL },
562  { "acceleration", SUMO_ATTR_ACCELERATION },
563  { "amount", SUMO_ATTR_AMOUNT },
564  { "origin", SUMO_ATTR_ORIGIN },
565  { "destination", SUMO_ATTR_DESTINATION },
566  { "visible", SUMO_ATTR_VISIBLE },
567 
568 #ifndef WIN32
569  { "commandPosix", SUMO_ATTR_COMMAND },
570 #else
571  { "commandWindows", SUMO_ATTR_COMMAND },
572 #endif
573 
574  // ActivityGen statistics file
575  { "inhabitants", AGEN_ATTR_INHABITANTS },
576  { "households", AGEN_ATTR_HOUSEHOLDS },
577  { "childrenAgeLimit", AGEN_ATTR_CHILDREN },
578  { "retirementAgeLimit", AGEN_ATTR_RETIREMENT },
579  { "carRate", AGEN_ATTR_CARS },
580  { "unemploymentRate", AGEN_ATTR_UNEMPLOYEMENT },
581  { "laborDemand", AGEN_ATTR_LABORDEMAND },
582  { "footDistanceLimit", AGEN_ATTR_MAX_FOOT_DIST },
583  { "incomingTraffic", AGEN_ATTR_IN_TRAFFIC },
584  { "incoming", AGEN_ATTR_INCOMING },
585  { "outgoingTraffic", AGEN_ATTR_OUT_TRAFFIC },
586  { "outgoing", AGEN_ATTR_OUTGOING },
587  { "population", AGEN_ATTR_POPULATION },
588  { "workPosition", AGEN_ATTR_OUT_WORKPOSITION },
589  { "hour", AGEN_ATTR_HOUR },
590  { "proportion", AGEN_ATTR_PROP },
591  { "capacity", AGEN_ATTR_CAPACITY },
592  { "opening", AGEN_ATTR_OPENING },
593  { "closing", AGEN_ATTR_CLOSING },
594  { "maxTripDuration", AGEN_ATTR_MAX_TRIP_DURATION },
595  { "rate", AGEN_ATTR_RATE },
596  { "beginAge", AGEN_ATTR_BEGINAGE },
597  { "endAge", AGEN_ATTR_ENDAGE },
598  { "peopleNbr", AGEN_ATTR_PEOPLENBR },
599  { "carPreference", AGEN_ATTR_CARPREF },
600  { "meanTimePerKmInCity", AGEN_ATTR_CITYSPEED },
601  { "freeTimeActivityRate", AGEN_ATTR_FREETIMERATE },
602  { "uniformRandomTraffic", AGEN_ATTR_UNI_RAND_TRAFFIC },
603  { "departureVariation", AGEN_ATTR_DEP_VARIATION },
604 
605  // netEdit
606  { "selected", GNE_ATTR_SELECTED },
607  { "modificationStatusNotForPrinting", GNE_ATTR_MODIFICATION_STATUS },
608  { "shapeStart", GNE_ATTR_SHAPE_START },
609  { "shapeEnd", GNE_ATTR_SHAPE_END },
610  { "bidiRail", GNE_ATTR_BIDIR },
611  { "blockMovement", GNE_ATTR_BLOCK_MOVEMENT },
612  { "blockShape", GNE_ATTR_BLOCK_SHAPE },
613  { "closedShape", GNE_ATTR_CLOSE_SHAPE },
614  { "parentItem", GNE_ATTR_PARENT },
615  { "genericParameter", GNE_ATTR_GENERIC },
616 
617  { "targetLanes", SUMO_ATTR_TARGETLANE },
618  { "crossing", SUMO_ATTR_CROSSING },
619 
620  { "xmlns:xsi", SUMO_ATTR_XMLNS },
621  { "xsi:noNamespaceSchemaLocation", SUMO_ATTR_SCHEMA_LOCATION },
622 
623  //@name RNG state saving attributes
624  // @{
625  { "default", SUMO_ATTR_RNG_DEFAULT },
626  { "routeHandler", SUMO_ATTR_RNG_ROUTEHANDLER },
627  { "insertionControl", SUMO_ATTR_RNG_INSERTIONCONTROL },
628  { "device", SUMO_ATTR_RNG_DEVICE },
629  { "device.btreceiver", SUMO_ATTR_RNG_DEVICE_BT },
630  { "driverState", SUMO_ATTR_RNG_DRIVERSTATE },
631  // @}
632 
633  // Other
634  { "", SUMO_ATTR_NOTHING } //< must be the last one
635 };
636 
637 
638 const std::string SUMO_PARAM_ORIGID("origId");
639 
640 
642  {"traffic_light", NODETYPE_TRAFFIC_LIGHT},
643  {"traffic_light_unregulated", NODETYPE_TRAFFIC_LIGHT_NOJUNCTION},
644  {"traffic_light_right_on_red", NODETYPE_TRAFFIC_LIGHT_RIGHT_ON_RED},
645  {"rail_signal", NODETYPE_RAIL_SIGNAL},
646  {"rail_crossing", NODETYPE_RAIL_CROSSING},
647  {"priority", NODETYPE_PRIORITY},
648  {"priority_stop", NODETYPE_PRIORITY_STOP},
649  {"right_before_left", NODETYPE_RIGHT_BEFORE_LEFT},
650  {"allway_stop", NODETYPE_ALLWAY_STOP},
651  {"zipper", NODETYPE_ZIPPER},
652  {"district", NODETYPE_DISTRICT},
653  {"unregulated", NODETYPE_NOJUNCTION},
654  {"internal", NODETYPE_INTERNAL},
655  {"dead_end", NODETYPE_DEAD_END},
656  {"DEAD_END", NODETYPE_DEAD_END_DEPRECATED},
657  {"unknown", NODETYPE_UNKNOWN} //< must be the last one
658 };
659 
660 
662  {"unknown", EDGEFUNC_UNKNOWN},
663  {"normal", EDGEFUNC_NORMAL},
664  {"connector", EDGEFUNC_CONNECTOR},
665  {"crossing", EDGEFUNC_CROSSING},
666  {"walkingarea", EDGEFUNC_WALKINGAREA},
667  {"internal", EDGEFUNC_INTERNAL} //< must be the last one
668 };
669 
670 
672  {"right", LANESPREAD_RIGHT }, // default
673  {"center", LANESPREAD_CENTER } //< must be the last one
674 };
675 
677  {"edgePriority", RIGHT_OF_WAY_EDGEPRIORITY },
678  {"default", RIGHT_OF_WAY_DEFAULT } // default (must be the last one)
679 };
680 
681 
683  { "G", LINKSTATE_TL_GREEN_MAJOR },
684  { "g", LINKSTATE_TL_GREEN_MINOR },
685  { "r", LINKSTATE_TL_RED },
686  { "u", LINKSTATE_TL_REDYELLOW },
687  { "Y", LINKSTATE_TL_YELLOW_MAJOR },
688  { "y", LINKSTATE_TL_YELLOW_MINOR },
689  { "o", LINKSTATE_TL_OFF_BLINKING },
690  { "O", LINKSTATE_TL_OFF_NOSIGNAL },
691  { "M", LINKSTATE_MAJOR },
692  { "m", LINKSTATE_MINOR },
693  { "=", LINKSTATE_EQUAL },
694  { "s", LINKSTATE_STOP },
695  { "w", LINKSTATE_ALLWAY_STOP },
696  { "Z", LINKSTATE_ZIPPER },
697  { "-", LINKSTATE_DEADEND } //< must be the last one
698 };
699 
703  LINKSTATE_STOP, // used for NODETYPE_TRAFFIC_LIGHT_RIGHT_ON_RED
710 };
711 const std::string SUMOXMLDefinitions::ALLOWED_TLS_LINKSTATES(AllowedTLS_linkStatesInitializer, 9);
712 
714  { "s", LINKDIR_STRAIGHT },
715  { "t", LINKDIR_TURN },
716  { "T", LINKDIR_TURN_LEFTHAND },
717  { "l", LINKDIR_LEFT },
718  { "r", LINKDIR_RIGHT },
719  { "L", LINKDIR_PARTLEFT },
720  { "R", LINKDIR_PARTRIGHT },
721  { "invalid", LINKDIR_NODIR } //< must be the last one
722 };
723 
724 
726  { "static", TLTYPE_STATIC },
727  { "railSignal", TLTYPE_RAIL_SIGNAL },
728  { "railCrossing", TLTYPE_RAIL_CROSSING },
729  { "actuated", TLTYPE_ACTUATED },
730  { "delay_based", TLTYPE_DELAYBASED },
731  { "sotl_phase", TLTYPE_SOTL_PHASE },
732  { "sotl_platoon", TLTYPE_SOTL_PLATOON },
733  { "sotl_request", TLTYPE_SOTL_REQUEST },
734  { "sotl_wave", TLTYPE_SOTL_WAVE },
735  { "sotl_marching", TLTYPE_SOTL_MARCHING },
736  { "swarm", TLTYPE_SWARM_BASED },
737  { "deterministic", TLTYPE_HILVL_DETERMINISTIC },
738  { "off", TLTYPE_OFF },
739  { "<invalid>", TLTYPE_INVALID } //< must be the last one
740 };
741 
742 
744  { "DK2008", LCM_DK2008 },
745  { "LC2013", LCM_LC2013 },
746  { "SL2015", LCM_SL2015 },
747  { "default", LCM_DEFAULT } //< must be the last one
748 };
749 
751  { "IDM", SUMO_TAG_CF_IDM },
752  { "IDMM", SUMO_TAG_CF_IDMM },
753  { "Krauss", SUMO_TAG_CF_KRAUSS },
754  { "KraussPS", SUMO_TAG_CF_KRAUSS_PLUS_SLOPE },
755  { "KraussOrig1", SUMO_TAG_CF_KRAUSS_ORIG1 },
756  { "KraussX", SUMO_TAG_CF_KRAUSSX }, // experimental extensions to the Krauss model
757  { "SmartSK", SUMO_TAG_CF_SMART_SK },
758  { "Daniel1", SUMO_TAG_CF_DANIEL1 },
759  { "PWagner2009", SUMO_TAG_CF_PWAGNER2009 },
760  { "BKerner", SUMO_TAG_CF_BKERNER },
761  { "Rail", SUMO_TAG_CF_RAIL },
762  { "ACC", SUMO_TAG_CF_ACC },
763  { "CACC", SUMO_TAG_CF_CACC },
764  { "Wiedemann", SUMO_TAG_CF_WIEDEMANN } //< must be the last one
765 };
766 
768  { "right", LATALIGN_RIGHT },
769  { "center", LATALIGN_CENTER },
770  { "arbitrary", LATALIGN_ARBITRARY },
771  { "nice", LATALIGN_NICE },
772  { "compact", LATALIGN_COMPACT },
773  { "left", LATALIGN_LEFT } //< must be the last one
774 };
775 
777  { "stay", LCA_STAY },
778  { "left", LCA_LEFT },
779  { "right", LCA_RIGHT },
780  { "strategic", LCA_STRATEGIC },
781  { "cooperative", LCA_COOPERATIVE },
782  { "speedGain", LCA_SPEEDGAIN },
783  { "keepRight", LCA_KEEPRIGHT },
784  { "sublane", LCA_SUBLANE },
785  { "traci", LCA_TRACI },
786  { "urgent", LCA_URGENT },
787  { "overlapping", LCA_OVERLAPPING },
788  { "blocked", LCA_BLOCKED },
789  { "amBL", LCA_AMBLOCKINGLEADER },
790  { "amBF", LCA_AMBLOCKINGFOLLOWER },
791  { "amBB", LCA_AMBACKBLOCKER },
792  { "amBBS", LCA_AMBACKBLOCKER_STANDING },
793  { "MR", LCA_MRIGHT },
794  { "ML", LCA_MLEFT },
795 
796  { "unknown", LCA_UNKNOWN } //< must be the last one
797 };
798 
800  SUMOXMLDefinitions::tags, SUMO_TAG_NOTHING);
801 
803  SUMOXMLDefinitions::attrs, SUMO_ATTR_NOTHING);
804 
806  SUMOXMLDefinitions::sumoNodeTypeValues, NODETYPE_UNKNOWN);
807 
809  SUMOXMLDefinitions::sumoEdgeFuncValues, EDGEFUNC_INTERNAL);
810 
812  SUMOXMLDefinitions::laneSpreadFunctionValues, LANESPREAD_CENTER);
813 
815  SUMOXMLDefinitions::rightOfWayValuesInitializer, RIGHT_OF_WAY_DEFAULT);
816 
818  SUMOXMLDefinitions::linkStateValues, LINKSTATE_DEADEND);
819 
821  SUMOXMLDefinitions::linkDirectionValues, LINKDIR_NODIR);
822 
824  SUMOXMLDefinitions::trafficLightTypesValues, TLTYPE_INVALID);
825 
827  SUMOXMLDefinitions::laneChangeModelValues, LCM_DEFAULT);
828 
830  SUMOXMLDefinitions::carFollowModelValues, SUMO_TAG_CF_WIEDEMANN);
831 
833  SUMOXMLDefinitions::lateralAlignmentValues, LATALIGN_LEFT);
834 
836  SUMOXMLDefinitions::laneChangeActionValues, LCA_UNKNOWN);
837 
838 
839 std::string
840 SUMOXMLDefinitions::getJunctionIDFromInternalEdge(const std::string internalEdge) {
841  assert(internalEdge[0] == ':');
842  return internalEdge.substr(1, internalEdge.rfind('_') - 1);
843 }
844 
845 
846 std::string
847 SUMOXMLDefinitions::getEdgeIDFromLane(const std::string laneID) {
848  return laneID.substr(0, laneID.rfind('_'));
849 }
850 
851 
852 bool
853 SUMOXMLDefinitions::isValidNetID(const std::string& value) {
854  return (value.size() > 0) && value.find_first_of(" \t\n\r|\\'\";,:!<>&*?") == std::string::npos;
855 }
856 
857 
858 bool
859 SUMOXMLDefinitions::isValidVehicleID(const std::string& value) {
860  return (value.size() > 0) && value.find_first_of(" \t\n\r|\\'\";,!<>&*?") == std::string::npos;
861 }
862 
863 
864 bool
865 SUMOXMLDefinitions::isValidTypeID(const std::string& value) {
866  return (value.size() > 0) && value.find_first_of(" \t\n\r|\\'\";,<>&*?") == std::string::npos;
867 }
868 
869 
870 bool
871 SUMOXMLDefinitions::isValidDetectorID(const std::string& value) {
872  return (value.size() > 0) && value.find_first_of("\t\n\r|\\'\";,:!<>&*?") == std::string::npos;
873 }
874 
875 
876 bool
877 SUMOXMLDefinitions::isValidAttribute(const std::string& value) {
878  return value.find_first_of("\t\n\r@$%^&/|\\{}*'\";:<>") == std::string::npos;
879 }
880 
881 
882 bool
883 SUMOXMLDefinitions::isValidFilename(const std::string& value) {
884  return (value.find_first_of("\t\n\r@$%^&|\\{}*'\";:<>") == std::string::npos);
885 }
886 
887 
888 bool
889 SUMOXMLDefinitions::isValidListOfNetIDs(const std::string& value) {
890  std::vector<std::string> typeIDs;
891  SUMOSAXAttributes::parseStringVector(value, typeIDs);
892  if (typeIDs.empty()) {
893  return false;
894  } else {
895  // check that gives IDs are valid
896  for (auto i : typeIDs) {
898  return false;
899  }
900  }
901  return true;
902  }
903 }
904 
905 
906 bool
907 SUMOXMLDefinitions::isValidListOfTypeID(const std::string& value) {
908  std::vector<std::string> typeIDs;
909  SUMOSAXAttributes::parseStringVector(value, typeIDs);
910  if (typeIDs.empty()) {
911  return false;
912  } else {
913  // check that gives IDs are valid
914  for (auto i : typeIDs) {
916  return false;
917  }
918  }
919  return true;
920  }
921 }
922 
923 
924 bool
926  // Generic parameters keys cannot be empty
927  return (value.size() > 0);
928 }
929 
930 
931 bool
933  // Generic parameters should not be restricted (characters such as <>'" only
934  // reach this function if they are properly escaped in the xml inputs (and
935  // they are also escaped when writing)
936  return true;
937 }
938 
939 /****************************************************************************/
940 
number of steps that a vehicle is charging
The information about how to spread the lanes from the given position.
static StringBijection< LaneChangeModel >::Entry laneChangeModelValues[]
lane change model values
static StringBijection< RightOfWay > RightOfWayValues
lane spread functions
The link is a partial left direction.
The link has green light, may pass.
Internal moment of inertia.
segment of a lane
static StringBijection< SumoXMLTag > CarFollowModels
car following models
static StringBijection< SumoXMLNodeType > NodeTypes
node types
a routeprobe detector
static StringBijection< LinkDirection >::Entry linkDirectionValues[]
link direction values
a list of node ids, used for controlling joining
alternative tag for e1 detector
description of a vehicle type
Whether vehicles must keep the junction clear.
split something
whether a given shape is user-defined
a source within a district (connection road)
The action is due to the default of keeping right "Rechtsfahrgebot".
ActivityGen Tags.
The action is done to help someone else.
static StringBijection< int >::Entry attrs[]
The names of SUMO-XML attributes (for passing to GenericSAXHandler)
static bool isValidAttribute(const std::string &value)
whether the given string is a valid attribute for a certain key (for example, a name) ...
static StringBijection< LinkState >::Entry linkStateValues[]
link state values
static bool isValidListOfTypeID(const std::string &value)
whether the given string is a valid list of ids for an edge or vehicle type (empty aren&#39;t allowed) ...
root element of a network file
begin/end of the description of a junction
begin/end of the description of a single lane
a flow definition (used by router)
block shape of a graphic element (Used mainly in GNEShapes)
Outgoing edge specification (jtrrouter)
static StringBijection< LaneSpreadFunction >::Entry laneSpreadFunctionValues[]
lane spread function values
A calibrator placed over edge.
an e2 detector over multiple lanes (used by Netedit)
static StringBijection< LaneSpreadFunction > LaneSpreadFunctions
lane spread functions
a traffic assignment zone
static const std::string ALLOWED_TLS_LINKSTATES
all allowed characters for phase state
distribution of a route
lane of a reroute of type closing
A layer number.
The link has green light, has to brake.
connectio between two lanes
This is an uncontrolled, minor link, has to stop.
Allow/disallow charge in transit in Charging Stations.
static StringBijection< LateralAlignment >::Entry lateralAlignmentValues[]
lanteral alignment values
static std::string getJunctionIDFromInternalEdge(const std::string internalEdge)
return the junction id when given an edge of type internal, crossing or WalkingArea ...
workingHours object
closing for workingHours object
foe visibility distance of a link
population and children accompaniment brackets
The link is a 180 degree turn.
Wants go to the right.
Close shape of a polygon (Used by GNEPolys)
a flow state definition (used when saving and loading simulatino state)
weights: time range begin
link,node: the traffic light id responsible for this link
This is a dead end link.
tgotal of Energy charged
begin/end of the description of a Point of interest
This is an uncontrolled, right-before-left link.
maximum duration of a phase
align with the closest sublane border
static StringBijection< LinkState > LinkStates
link states
static StringBijection< SumoXMLNodeType >::Entry sumoNodeTypeValues[]
containers for the different SUMOXMLDefinitions
drive on the right side
begin/end of the description of an edge restriction
The link is controlled by a tls which is off, not blinking, may pass.
A parking space for a single vehicle within a parking area.
Wants go to the left.
first coordinate of edge shape
static bool isValidGenericParameterKey(const std::string &value)
whether the given string is a valid key for a generic parameter
This is an uncontrolled, all-way stop link.
The action is due to the wish to be faster (tactical lc)
generic attribute
used by the sublane model
prohibition of circulation between two edges
The link is a (hard) left direction.
This is an uncontrolled, zipper-merge link.
begin/end of the description of a route
Position on lane.
an e3 entry point
Sink(s) specification.
link: the index of the opposite direction link of a pedestrian crossing
whether a feature has been loaded,guessed,modified or approved
Radial drag coefficient.
an edge based mean data detector
The link is a straight direction.
Needs to stay on the current lane.
The state of a link.
drive on the left side
static StringBijection< LinkDirection > LinkDirections
link directions
alternative definition for Population
static void parseStringVector(const std::string &def, std::vector< std::string > &into)
Splits the given string.
The action has not been determined.
The definition of a periodic event.
How to compute right of way.
root element of a route file
The turning radius at an intersection in m.
whether an edge is part of a bidirectional railway
static StringBijection< LaneChangeAction > LaneChangeActions
lane change actions
static bool isValidGenericParameterValue(const std::string &value)
whether the given string is a valid value for a generic parameter
blocked in all directions
the edges of a route
station for a certain vehicle
rev stations for certain vehicles
The action is urgent (to be defined by lc-model)
frequency of a object
An instantenous induction loop.
static StringBijection< TrafficLightType > TrafficLightTypes
traffic light types
This is an uncontrolled, minor link, has to brake.
walking area for pedestrians
parameter associated to a certain key
an e3 exit point
timesteps in which charging ends
schools object
static bool isValidDetectorID(const std::string &value)
whether the given string is a valid id for an detector
An edge-following detector.
A calibrator placed over lane (used in netedit)
busStation and bus objects
block movement of a graphic element
invalid attribute
definition of a detector
roundabout defined in junction
Incoming edge specification (jtrrouter)
energy provied by charging station at certain timestep
The link is a (hard) right direction.
Energy charged in transit.
The action is needed to follow the route (navigational lc)
node: the type of traffic light
edge: the shape in xml-definition
probability of route of a reroute
probability of destiny of a reroute
begin/end of the description of a neighboring lane
maintain the current alignment
The link is a partial right direction.
description of a logic request within the junction
streets object
begin/end of the description of an edge
timestep in which charging begins
static bool isValidNetID(const std::string &value)
whether the given string is a valid id for a network element
reroute of type closing
succesor phase index
drive in the middle
entry for an alternative parking zone
static StringBijection< int >::Entry tags[]
The names of SUMO-XML elements (for passing to GenericSAXHandler)
static StringBijection< LateralAlignment > LateralAlignments
lateral alignments
stop for vehicles
a lane based mean data detector
trigger: the time of the step
A train stop (alias for bus stop)
alternative definition for city entrances
a sink within a district (connection road)
the edges crossed by a pedestrian crossing
static StringBijection< LaneChangeAction >::Entry laneChangeActionValues[]
lane change action values
The link has yellow light, may pass.
static StringBijection< RightOfWay >::Entry rightOfWayValuesInitializer[]
lane spread function values
The vehicle is blocked being overlapping.
The link is controlled by a tls which is off and blinks, has to brake.
static StringBijection< int > Attrs
The names of SUMO-XML attributes for use in netbuild.
weights: time range end
Join operation.
a vtypeprobe detector
element is selected
alternative definition for junction
static bool isValidListOfNetIDs(const std::string &value)
whether the given string is a valid list of id for a network (empty aren&#39;t allowed) ...
The link has red light (must brake)
Energy charged stopped.
This is an uncontrolled, major link, may pass.
total energy charged into a single vehicle
crossing between edges for pedestrians
vaporizer of vehicles
The abstract direction of a link.
align with the rightmost sublane that allows keeping the current speed
description of a vehicle
an aggreagated-output interval
The action is due to a TraCI request.
The link is a 180 degree turn (left-hand network)
static StringBijection< SumoXMLTag >::Entry carFollowModelValues[]
car follwing model values
A variable speed sign.
Eficiency of the charge in Charging Stations.
link: the index of the link within the traffic light
last coordinate of edge shape
a single trip definition (used by router)
type of polygon
parent of an additional element
static StringBijection< int > Tags
The names of SUMO-XML elements for use in netbuild.
a traffic light logic
static const char AllowedTLS_linkStatesInitializer[]
all allowed characters for phase state
static bool isValidTypeID(const std::string &value)
whether the given string is a valid id for an edge or vehicle type
Delay in the charge of charging stations.
static StringBijection< SumoXMLEdgeFunc >::Entry sumoEdgeFuncValues[]
edge function values
The link has yellow light, has to brake anyway.
opening for workingHours object
delete certain element
begin/end of the description of a Point of interest over Lane (used by Netedit)
static std::string getEdgeIDFromLane(const std::string laneID)
return edge id when given the lane ID
static StringBijection< SumoXMLEdgeFunc > EdgeFunctions
edge functions
An access point for a train stop.
distribution of a vehicle type
static bool isValidFilename(const std::string &value)
whether the given string is a valid attribute for a filename (for example, a name) ...
A color information.
The link has red light (must brake) but indicates upcoming green.
a single phase description
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
alternative tag for e3 detector
static bool isValidVehicleID(const std::string &value)
whether the given string is a valid id for a vehicle or flow
Fill the polygon.
alternative tag for e2 detector
const std::string SUMO_PARAM_ORIGID("origId")
stations for certain vehicles
join exlude operation
static StringBijection< TrafficLightType >::Entry trafficLightTypesValues[]
traffic light types values
begin/end of the description of a polygon
trigger: a step description
The link has no direction (is a dead end link)
Information on vClass specific stop offsets at lane end.