Eclipse SUMO - Simulation of Urban MObility
AdditionalHandler.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-2024 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 /****************************************************************************/
18 // The XML-Handler for additionals loading
19 /****************************************************************************/
20 #include <config.h>
21 
22 #include <utils/common/MsgHandler.h>
23 #include <utils/xml/SUMOSAXHandler.h>
24 #include <utils/shapes/Shape.h>
25 #include <utils/shapes/PointOfInterest.h>
26 #include <utils/options/OptionsCont.h>
27 #include <utils/vehicle/SUMOVehicleParserHelper.h>
28 
29 #include "AdditionalHandler.h"
30 
31 
32 // ===========================================================================
33 // method definitions
34 // ===========================================================================
35 
36 AdditionalHandler::AdditionalHandler() {}
37 
38 
39 AdditionalHandler::~AdditionalHandler() {}
40 
41 
42 bool
43 AdditionalHandler::beginParseAttributes(SumoXMLTag tag, const SUMOSAXAttributes& attrs) {
44  // open SUMOBaseOBject
45  myCommonXMLStructure.openSUMOBaseOBject();
46  // check tag
47  try {
48  switch (tag) {
49  // Stopping Places
50  case SUMO_TAG_BUS_STOP:
51  parseBusStopAttributes(attrs);
52  break;
53  case SUMO_TAG_TRAIN_STOP:
54  parseTrainStopAttributes(attrs);
55  break;
56  case SUMO_TAG_ACCESS:
57  parseAccessAttributes(attrs);
58  break;
59  case SUMO_TAG_CONTAINER_STOP:
60  parseContainerStopAttributes(attrs);
61  break;
62  case SUMO_TAG_CHARGING_STATION:
63  parseChargingStationAttributes(attrs);
64  break;
65  case SUMO_TAG_PARKING_AREA:
66  parseParkingAreaAttributes(attrs);
67  break;
68  case SUMO_TAG_PARKING_SPACE:
69  parseParkingSpaceAttributes(attrs);
70  break;
71  // Detectors
72  case SUMO_TAG_E1DETECTOR:
73  case SUMO_TAG_INDUCTION_LOOP:
74  parseE1Attributes(attrs);
75  break;
76  case SUMO_TAG_E2DETECTOR:
77  case SUMO_TAG_LANE_AREA_DETECTOR:
78  parseE2Attributes(attrs);
79  break;
80  case SUMO_TAG_E3DETECTOR:
81  case SUMO_TAG_ENTRY_EXIT_DETECTOR:
82  parseE3Attributes(attrs);
83  break;
84  case SUMO_TAG_DET_ENTRY:
85  parseEntryAttributes(attrs);
86  break;
87  case SUMO_TAG_DET_EXIT:
88  parseExitAttributes(attrs);
89  break;
90  case SUMO_TAG_INSTANT_INDUCTION_LOOP:
91  parseE1InstantAttributes(attrs);
92  break;
93  // TAZs
94  case SUMO_TAG_TAZ:
95  parseTAZAttributes(attrs);
96  break;
97  case SUMO_TAG_TAZSOURCE:
98  parseTAZSourceAttributes(attrs);
99  break;
100  case SUMO_TAG_TAZSINK:
101  parseTAZSinkAttributes(attrs);
102  break;
103  // Variable Speed Sign
104  case SUMO_TAG_VSS:
105  parseVariableSpeedSignAttributes(attrs);
106  break;
107  case SUMO_TAG_STEP:
108  parseVariableSpeedSignStepAttributes(attrs);
109  break;
110  // Calibrator
111  case SUMO_TAG_CALIBRATOR:
112  case GNE_TAG_CALIBRATOR_LANE:
113  parseCalibratorAttributes(attrs);
114  break;
115  // flow (calibrator)
116  case SUMO_TAG_FLOW:
117  parseCalibratorFlowAttributes(attrs);
118  break;
119  // Rerouter
120  case SUMO_TAG_REROUTER:
121  parseRerouterAttributes(attrs);
122  break;
123  case SUMO_TAG_INTERVAL:
124  parseRerouterIntervalAttributes(attrs);
125  break;
126  case SUMO_TAG_CLOSING_LANE_REROUTE:
127  parseClosingLaneRerouteAttributes(attrs);
128  break;
129  case SUMO_TAG_CLOSING_REROUTE:
130  parseClosingRerouteAttributes(attrs);
131  break;
132  case SUMO_TAG_DEST_PROB_REROUTE:
133  parseDestProbRerouteAttributes(attrs);
134  break;
135  case SUMO_TAG_PARKING_AREA_REROUTE:
136  parseParkingAreaRerouteAttributes(attrs);
137  break;
138  case SUMO_TAG_ROUTE_PROB_REROUTE:
139  parseRouteProbRerouteAttributes(attrs);
140  break;
141  // Route probe
142  case SUMO_TAG_ROUTEPROBE:
143  parseRouteProbeAttributes(attrs);
144  break;
145  // Vaporizer (deprecated)
146  case SUMO_TAG_VAPORIZER:
147  parseVaporizerAttributes(attrs);
148  break;
149  // wires
150  case SUMO_TAG_TRACTION_SUBSTATION:
151  parseTractionSubstation(attrs);
152  break;
153  case SUMO_TAG_OVERHEAD_WIRE_CLAMP:
154  parseOverheadWireClamp(attrs);
155  break;
156  case SUMO_TAG_OVERHEAD_WIRE_SECTION:
157  parseOverheadWire(attrs);
158  break;
159  // Poly
160  case SUMO_TAG_POLY:
161  parsePolyAttributes(attrs);
162  break;
163  case SUMO_TAG_POI:
164  parsePOIAttributes(attrs);
165  break;
166  // JuPedSim
167  case GNE_TAG_JPS_WALKABLEAREA:
168  parseJpsWalkableAreaAttributes(attrs);
169  break;
170  case GNE_TAG_JPS_OBSTACLE:
171  parseJpsObstacleAttributes(attrs);
172  break;
173  // parameters
174  case SUMO_TAG_PARAM:
175  parseParameters(attrs);
176  break;
177  default:
178  // tag cannot be parsed in AdditionalHandler
179  return false;
180  break;
181  }
182  } catch (InvalidArgument& e) {
183  writeError(e.what());
184  }
185  return true;
186 }
187 
188 
189 void
190 AdditionalHandler::endParseAttributes() {
191  // get last inserted object
192  CommonXMLStructure::SumoBaseObject* obj = myCommonXMLStructure.getCurrentSumoBaseObject();
193  // close SUMOBaseOBject
194  myCommonXMLStructure.closeSUMOBaseOBject();
195  // check tag
196  switch (obj->getTag()) {
197  // Stopping Places
198  case SUMO_TAG_BUS_STOP:
199  case SUMO_TAG_TRAIN_STOP:
200  case SUMO_TAG_CONTAINER_STOP:
201  case SUMO_TAG_CHARGING_STATION:
202  case SUMO_TAG_PARKING_AREA:
203  // detectors
204  case SUMO_TAG_E1DETECTOR:
205  case SUMO_TAG_INDUCTION_LOOP:
206  case SUMO_TAG_E2DETECTOR:
207  case SUMO_TAG_LANE_AREA_DETECTOR:
208  case SUMO_TAG_E3DETECTOR:
209  case SUMO_TAG_ENTRY_EXIT_DETECTOR:
210  case SUMO_TAG_INSTANT_INDUCTION_LOOP:
211  // TAZs
212  case SUMO_TAG_TAZ:
213  // Variable Speed Sign
214  case SUMO_TAG_VSS:
215  // Calibrator
216  case SUMO_TAG_CALIBRATOR:
217  case GNE_TAG_CALIBRATOR_LANE:
218  // Rerouter
219  case SUMO_TAG_REROUTER:
220  // Route probe
221  case SUMO_TAG_ROUTEPROBE:
222  // Vaporizer (deprecated)
223  case SUMO_TAG_VAPORIZER:
224  // wires
225  case SUMO_TAG_TRACTION_SUBSTATION:
226  case SUMO_TAG_OVERHEAD_WIRE_SECTION:
227  case SUMO_TAG_OVERHEAD_WIRE_CLAMP:
228  // Shapes
229  case SUMO_TAG_POLY:
230  case SUMO_TAG_POI:
231  // JuPedSim
232  case GNE_TAG_JPS_WALKABLEAREA:
233  case GNE_TAG_JPS_OBSTACLE:
234  // parse object and all their childrens
235  parseSumoBaseObject(obj);
236  // delete object (and all of their childrens)
237  delete obj;
238  break;
239  default:
240  break;
241  }
242 }
243 
244 
245 void
246 AdditionalHandler::parseSumoBaseObject(CommonXMLStructure::SumoBaseObject* obj) {
247  // switch tag
248  switch (obj->getTag()) {
249  // Stopping Places
250  case SUMO_TAG_BUS_STOP:
251  buildBusStop(obj,
252  obj->getStringAttribute(SUMO_ATTR_ID),
253  obj->getStringAttribute(SUMO_ATTR_LANE),
254  obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
255  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
256  obj->getStringAttribute(SUMO_ATTR_NAME),
257  obj->getStringListAttribute(SUMO_ATTR_LINES),
258  obj->getIntAttribute(SUMO_ATTR_PERSON_CAPACITY),
259  obj->getDoubleAttribute(SUMO_ATTR_PARKING_LENGTH),
260  obj->getColorAttribute(SUMO_ATTR_COLOR),
261  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
262  obj->getParameters());
263  break;
264  case SUMO_TAG_TRAIN_STOP:
265  buildTrainStop(obj,
266  obj->getStringAttribute(SUMO_ATTR_ID),
267  obj->getStringAttribute(SUMO_ATTR_LANE),
268  obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
269  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
270  obj->getStringAttribute(SUMO_ATTR_NAME),
271  obj->getStringListAttribute(SUMO_ATTR_LINES),
272  obj->getIntAttribute(SUMO_ATTR_PERSON_CAPACITY),
273  obj->getDoubleAttribute(SUMO_ATTR_PARKING_LENGTH),
274  obj->getColorAttribute(SUMO_ATTR_COLOR),
275  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
276  obj->getParameters());
277  break;
278  case SUMO_TAG_ACCESS:
279  buildAccess(obj,
280  obj->getStringAttribute(SUMO_ATTR_LANE),
281  obj->getStringAttribute(SUMO_ATTR_POSITION),
282  obj->getDoubleAttribute(SUMO_ATTR_LENGTH),
283  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
284  obj->getParameters());
285  break;
286  case SUMO_TAG_CONTAINER_STOP:
287  buildContainerStop(obj,
288  obj->getStringAttribute(SUMO_ATTR_ID),
289  obj->getStringAttribute(SUMO_ATTR_LANE),
290  obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
291  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
292  obj->getStringAttribute(SUMO_ATTR_NAME),
293  obj->getStringListAttribute(SUMO_ATTR_LINES),
294  obj->getIntAttribute(SUMO_ATTR_CONTAINER_CAPACITY),
295  obj->getDoubleAttribute(SUMO_ATTR_PARKING_LENGTH),
296  obj->getColorAttribute(SUMO_ATTR_COLOR),
297  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
298  obj->getParameters());
299  break;
300  case SUMO_TAG_CHARGING_STATION:
301  buildChargingStation(obj,
302  obj->getStringAttribute(SUMO_ATTR_ID),
303  obj->getStringAttribute(SUMO_ATTR_LANE),
304  obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
305  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
306  obj->getStringAttribute(SUMO_ATTR_NAME),
307  obj->getDoubleAttribute(SUMO_ATTR_CHARGINGPOWER),
308  obj->getDoubleAttribute(SUMO_ATTR_EFFICIENCY),
309  obj->getBoolAttribute(SUMO_ATTR_CHARGEINTRANSIT),
310  obj->getTimeAttribute(SUMO_ATTR_CHARGEDELAY),
311  obj->getStringAttribute(SUMO_ATTR_CHARGETYPE),
312  obj->getTimeAttribute(SUMO_ATTR_WAITINGTIME),
313  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
314  obj->getStringAttribute(SUMO_ATTR_PARKING_AREA),
315  obj->getParameters());
316  break;
317  case SUMO_TAG_PARKING_AREA:
318  buildParkingArea(obj,
319  obj->getStringAttribute(SUMO_ATTR_ID),
320  obj->getStringAttribute(SUMO_ATTR_LANE),
321  obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
322  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
323  obj->getStringAttribute(SUMO_ATTR_DEPARTPOS),
324  obj->getStringAttribute(SUMO_ATTR_NAME),
325  obj->getStringListAttribute(SUMO_ATTR_ACCEPTED_BADGES),
326  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
327  obj->getIntAttribute(SUMO_ATTR_ROADSIDE_CAPACITY),
328  obj->getBoolAttribute(SUMO_ATTR_ONROAD),
329  obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
330  obj->getDoubleAttribute(SUMO_ATTR_LENGTH),
331  obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
332  obj->getBoolAttribute(SUMO_ATTR_LEFTHAND),
333  obj->getParameters());
334  break;
335  case SUMO_TAG_PARKING_SPACE:
336  buildParkingSpace(obj,
337  obj->getDoubleAttribute(SUMO_ATTR_X),
338  obj->getDoubleAttribute(SUMO_ATTR_Y),
339  obj->getDoubleAttribute(SUMO_ATTR_Z),
340  obj->getStringAttribute(SUMO_ATTR_NAME),
341  obj->getStringAttribute(SUMO_ATTR_WIDTH),
342  obj->getStringAttribute(SUMO_ATTR_LENGTH),
343  obj->getStringAttribute(SUMO_ATTR_ANGLE),
344  obj->getDoubleAttribute(SUMO_ATTR_SLOPE),
345  obj->getParameters());
346  break;
347  // Detectors
348  case SUMO_TAG_E1DETECTOR:
349  case SUMO_TAG_INDUCTION_LOOP:
350  // build E1
351  buildE1Detector(obj,
352  obj->getStringAttribute(SUMO_ATTR_ID),
353  obj->getStringAttribute(SUMO_ATTR_LANE),
354  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
355  obj->getPeriodAttribute(),
356  obj->getStringAttribute(SUMO_ATTR_FILE),
357  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
358  obj->getStringAttribute(SUMO_ATTR_NAME),
359  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
360  obj->getParameters());
361  break;
362  case SUMO_TAG_E2DETECTOR:
363  case SUMO_TAG_LANE_AREA_DETECTOR:
364  if (obj->hasStringAttribute(SUMO_ATTR_LANE)) {
365  buildSingleLaneDetectorE2(obj,
366  obj->getStringAttribute(SUMO_ATTR_ID),
367  obj->getStringAttribute(SUMO_ATTR_LANE),
368  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
369  obj->getDoubleAttribute(SUMO_ATTR_LENGTH),
370  obj->getPeriodAttribute(),
371  obj->getStringAttribute(SUMO_ATTR_TLID),
372  obj->getStringAttribute(SUMO_ATTR_FILE),
373  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
374  obj->getStringAttribute(SUMO_ATTR_NAME),
375  obj->getTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD),
376  obj->getDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD),
377  obj->getDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD),
378  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
379  obj->getParameters());
380  } else {
381  buildMultiLaneDetectorE2(obj,
382  obj->getStringAttribute(SUMO_ATTR_ID),
383  obj->getStringListAttribute(SUMO_ATTR_LANES),
384  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
385  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
386  obj->getPeriodAttribute(),
387  obj->getStringAttribute(SUMO_ATTR_TLID),
388  obj->getStringAttribute(SUMO_ATTR_FILE),
389  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
390  obj->getStringAttribute(SUMO_ATTR_NAME),
391  obj->getTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD),
392  obj->getDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD),
393  obj->getDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD),
394  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
395  obj->getParameters());
396  }
397  break;
398  case SUMO_TAG_E3DETECTOR:
399  case SUMO_TAG_ENTRY_EXIT_DETECTOR:
400  buildDetectorE3(obj,
401  obj->getStringAttribute(SUMO_ATTR_ID),
402  obj->getPositionAttribute(SUMO_ATTR_POSITION),
403  obj->getPeriodAttribute(),
404  obj->getStringAttribute(SUMO_ATTR_FILE),
405  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
406  obj->getStringAttribute(SUMO_ATTR_NAME),
407  obj->getTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD),
408  obj->getDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD),
409  obj->getBoolAttribute(SUMO_ATTR_EXPECT_ARRIVAL),
410  obj->getParameters());
411  break;
412  case SUMO_TAG_DET_ENTRY:
413  buildDetectorEntry(obj,
414  obj->getStringAttribute(SUMO_ATTR_LANE),
415  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
416  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
417  obj->getParameters());
418  break;
419  case SUMO_TAG_DET_EXIT:
420  buildDetectorExit(obj,
421  obj->getStringAttribute(SUMO_ATTR_LANE),
422  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
423  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
424  obj->getParameters());
425  break;
426  case SUMO_TAG_INSTANT_INDUCTION_LOOP:
427  buildDetectorE1Instant(obj,
428  obj->getStringAttribute(SUMO_ATTR_ID),
429  obj->getStringAttribute(SUMO_ATTR_LANE),
430  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
431  obj->getStringAttribute(SUMO_ATTR_FILE),
432  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
433  obj->getStringAttribute(SUMO_ATTR_NAME),
434  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
435  obj->getParameters());
436  break;
437  // TAZs
438  case SUMO_TAG_TAZ:
439  buildTAZ(obj,
440  obj->getStringAttribute(SUMO_ATTR_ID),
441  obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
442  obj->getPositionAttribute(SUMO_ATTR_CENTER),
443  obj->getBoolAttribute(SUMO_ATTR_FILL),
444  obj->getColorAttribute(SUMO_ATTR_COLOR),
445  obj->getStringListAttribute(SUMO_ATTR_EDGES),
446  obj->getStringAttribute(SUMO_ATTR_NAME),
447  obj->getParameters());
448  break;
449  case SUMO_TAG_TAZSOURCE:
450  buildTAZSource(obj,
451  obj->getStringAttribute(SUMO_ATTR_ID),
452  obj->getDoubleAttribute(SUMO_ATTR_WEIGHT));
453  break;
454  case SUMO_TAG_TAZSINK:
455  buildTAZSink(obj,
456  obj->getStringAttribute(SUMO_ATTR_ID),
457  obj->getDoubleAttribute(SUMO_ATTR_WEIGHT));
458  break;
459  // Variable Speed Sign
460  case SUMO_TAG_VSS:
461  buildVariableSpeedSign(obj,
462  obj->getStringAttribute(SUMO_ATTR_ID),
463  obj->getPositionAttribute(SUMO_ATTR_POSITION),
464  obj->getStringListAttribute(SUMO_ATTR_LANES),
465  obj->getStringAttribute(SUMO_ATTR_NAME),
466  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
467  obj->getParameters());
468  break;
469  case SUMO_TAG_STEP:
470  buildVariableSpeedSignStep(obj,
471  obj->getTimeAttribute(SUMO_ATTR_TIME),
472  obj->getStringAttribute(SUMO_ATTR_SPEED));
473  break;
474  // Calibrator
475  case SUMO_TAG_CALIBRATOR:
476  buildEdgeCalibrator(obj,
477  obj->getStringAttribute(SUMO_ATTR_ID),
478  obj->getStringAttribute(SUMO_ATTR_EDGE),
479  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
480  obj->getStringAttribute(SUMO_ATTR_NAME),
481  obj->getStringAttribute(SUMO_ATTR_OUTPUT),
482  obj->getPeriodAttribute(),
483  obj->getStringAttribute(SUMO_ATTR_ROUTEPROBE),
484  obj->getDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD),
485  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
486  obj->getParameters());
487  break;
488  case GNE_TAG_CALIBRATOR_LANE:
489  buildLaneCalibrator(obj,
490  obj->getStringAttribute(SUMO_ATTR_ID),
491  obj->getStringAttribute(SUMO_ATTR_LANE),
492  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
493  obj->getStringAttribute(SUMO_ATTR_NAME),
494  obj->getStringAttribute(SUMO_ATTR_OUTPUT),
495  obj->getPeriodAttribute(),
496  obj->getStringAttribute(SUMO_ATTR_ROUTEPROBE),
497  obj->getDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD),
498  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
499  obj->getParameters());
500  break;
501  case SUMO_TAG_FLOW:
502  buildCalibratorFlow(obj,
503  obj->getVehicleParameter());
504  break;
505  // Rerouter
506  case SUMO_TAG_REROUTER:
507  buildRerouter(obj,
508  obj->getStringAttribute(SUMO_ATTR_ID),
509  obj->getPositionAttribute(SUMO_ATTR_POSITION),
510  obj->getStringListAttribute(SUMO_ATTR_EDGES),
511  obj->getDoubleAttribute(SUMO_ATTR_PROB),
512  obj->getStringAttribute(SUMO_ATTR_NAME),
513  obj->getBoolAttribute(SUMO_ATTR_OFF),
514  obj->getBoolAttribute(SUMO_ATTR_OPTIONAL),
515  obj->getTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD),
516  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
517  obj->getParameters());
518  break;
519  case SUMO_TAG_CLOSING_LANE_REROUTE:
520  buildClosingLaneReroute(obj,
521  obj->getStringAttribute(SUMO_ATTR_ID),
522  parseVehicleClasses(obj->getStringAttribute(SUMO_ATTR_ALLOW), obj->getStringAttribute(SUMO_ATTR_DISALLOW)));
523  break;
524  case SUMO_TAG_CLOSING_REROUTE:
525  buildClosingReroute(obj,
526  obj->getStringAttribute(SUMO_ATTR_ID),
527  parseVehicleClasses(obj->getStringAttribute(SUMO_ATTR_ALLOW), obj->getStringAttribute(SUMO_ATTR_DISALLOW)));
528  break;
529  case SUMO_TAG_DEST_PROB_REROUTE:
530  buildDestProbReroute(obj,
531  obj->getStringAttribute(SUMO_ATTR_ID),
532  obj->getDoubleAttribute(SUMO_ATTR_PROB));
533  break;
534  case SUMO_TAG_PARKING_AREA_REROUTE:
535  buildParkingAreaReroute(obj,
536  obj->getStringAttribute(SUMO_ATTR_ID),
537  obj->getDoubleAttribute(SUMO_ATTR_PROB),
538  obj->getBoolAttribute(SUMO_ATTR_VISIBLE));
539  break;
540  case SUMO_TAG_ROUTE_PROB_REROUTE:
541  buildRouteProbReroute(obj,
542  obj->getStringAttribute(SUMO_ATTR_ID),
543  obj->getDoubleAttribute(SUMO_ATTR_PROB));
544  break;
545  case SUMO_TAG_INTERVAL:
546  // check if is VSS or a REROUTER interval
547  if (obj->getParentSumoBaseObject()->getTag() == SUMO_TAG_REROUTER) {
548  buildRerouterInterval(obj,
549  obj->getTimeAttribute(SUMO_ATTR_BEGIN),
550  obj->getTimeAttribute(SUMO_ATTR_END));
551  } else {
552  buildVariableSpeedSignStep(obj,
553  obj->getTimeAttribute(SUMO_ATTR_TIME),
554  obj->getStringAttribute(SUMO_ATTR_SPEED));
555  }
556  break;
557  // Route probe
558  case SUMO_TAG_ROUTEPROBE:
559  buildRouteProbe(obj,
560  obj->getStringAttribute(SUMO_ATTR_ID),
561  obj->getStringAttribute(SUMO_ATTR_EDGE),
562  obj->getPeriodAttribute(),
563  obj->getStringAttribute(SUMO_ATTR_NAME),
564  obj->getStringAttribute(SUMO_ATTR_FILE),
565  obj->getTimeAttribute(SUMO_ATTR_BEGIN),
566  obj->getParameters());
567  break;
568  // Vaporizer (deprecated)
569  case SUMO_TAG_VAPORIZER:
570  buildVaporizer(obj,
571  obj->getStringAttribute(SUMO_ATTR_ID),
572  obj->getTimeAttribute(SUMO_ATTR_BEGIN),
573  obj->getTimeAttribute(SUMO_ATTR_END),
574  obj->getStringAttribute(SUMO_ATTR_NAME),
575  obj->getParameters());
576  break;
577  // wire elements
578  case SUMO_TAG_TRACTION_SUBSTATION:
579  buildTractionSubstation(obj,
580  obj->getStringAttribute(SUMO_ATTR_ID),
581  obj->getPositionAttribute(SUMO_ATTR_POSITION),
582  obj->getDoubleAttribute(SUMO_ATTR_VOLTAGE),
583  obj->getDoubleAttribute(SUMO_ATTR_CURRENTLIMIT),
584  obj->getParameters());
585  break;
586  case SUMO_TAG_OVERHEAD_WIRE_SECTION:
587  buildOverheadWire(obj,
588  obj->getStringAttribute(SUMO_ATTR_ID),
589  obj->getStringAttribute(SUMO_ATTR_SUBSTATIONID),
590  obj->getStringListAttribute(SUMO_ATTR_LANES),
591  obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
592  obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
593  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
594  obj->getStringListAttribute(SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN),
595  obj->getParameters());
596  break;
597  case SUMO_TAG_OVERHEAD_WIRE_CLAMP:
598  buildOverheadWireClamp(obj,
599  obj->getStringAttribute(SUMO_ATTR_ID),
600  obj->getStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_START),
601  obj->getStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART),
602  obj->getStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_END),
603  obj->getStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND),
604  obj->getParameters());
605  break;
606  // Polygon
607  case SUMO_TAG_POLY:
608  buildPolygon(obj,
609  obj->getStringAttribute(SUMO_ATTR_ID),
610  obj->getStringAttribute(SUMO_ATTR_TYPE),
611  obj->getColorAttribute(SUMO_ATTR_COLOR),
612  obj->getDoubleAttribute(SUMO_ATTR_LAYER),
613  obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
614  obj->getStringAttribute(SUMO_ATTR_IMGFILE),
615  obj->getBoolAttribute(SUMO_ATTR_RELATIVEPATH),
616  obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
617  obj->getBoolAttribute(SUMO_ATTR_GEO),
618  obj->getBoolAttribute(SUMO_ATTR_FILL),
619  obj->getDoubleAttribute(SUMO_ATTR_LINEWIDTH),
620  obj->getStringAttribute(SUMO_ATTR_NAME),
621  obj->getParameters());
622  break;
623  // POI
624  case SUMO_TAG_POI:
625  // check if we want to create a POI, POILane or POIGEO
626  if (obj->hasDoubleAttribute(SUMO_ATTR_X)) {
627  // build POI over view
628  buildPOI(obj,
629  obj->getStringAttribute(SUMO_ATTR_ID),
630  obj->getStringAttribute(SUMO_ATTR_TYPE),
631  obj->getColorAttribute(SUMO_ATTR_COLOR),
632  obj->getDoubleAttribute(SUMO_ATTR_X),
633  obj->getDoubleAttribute(SUMO_ATTR_Y),
634  obj->getStringAttribute(SUMO_ATTR_ICON),
635  obj->getDoubleAttribute(SUMO_ATTR_LAYER),
636  obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
637  obj->getStringAttribute(SUMO_ATTR_IMGFILE),
638  obj->getBoolAttribute(SUMO_ATTR_RELATIVEPATH),
639  obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
640  obj->getDoubleAttribute(SUMO_ATTR_HEIGHT),
641  obj->getStringAttribute(SUMO_ATTR_NAME),
642  obj->getParameters());
643  } else if (obj->hasStringAttribute(SUMO_ATTR_LANE)) {
644  // build POI over Lane
645  buildPOILane(obj,
646  obj->getStringAttribute(SUMO_ATTR_ID),
647  obj->getStringAttribute(SUMO_ATTR_TYPE),
648  obj->getColorAttribute(SUMO_ATTR_COLOR),
649  obj->getStringAttribute(SUMO_ATTR_LANE),
650  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
651  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
652  obj->getDoubleAttribute(SUMO_ATTR_POSITION_LAT),
653  obj->getStringAttribute(SUMO_ATTR_ICON),
654  obj->getDoubleAttribute(SUMO_ATTR_LAYER),
655  obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
656  obj->getStringAttribute(SUMO_ATTR_IMGFILE),
657  obj->getBoolAttribute(SUMO_ATTR_RELATIVEPATH),
658  obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
659  obj->getDoubleAttribute(SUMO_ATTR_HEIGHT),
660  obj->getStringAttribute(SUMO_ATTR_NAME),
661  obj->getParameters());
662  } else {
663  // build POIGEO over view
664  buildPOIGeo(obj,
665  obj->getStringAttribute(SUMO_ATTR_ID),
666  obj->getStringAttribute(SUMO_ATTR_TYPE),
667  obj->getColorAttribute(SUMO_ATTR_COLOR),
668  obj->getDoubleAttribute(SUMO_ATTR_LON),
669  obj->getDoubleAttribute(SUMO_ATTR_LAT),
670  obj->getStringAttribute(SUMO_ATTR_ICON),
671  obj->getDoubleAttribute(SUMO_ATTR_LAYER),
672  obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
673  obj->getStringAttribute(SUMO_ATTR_IMGFILE),
674  obj->getBoolAttribute(SUMO_ATTR_RELATIVEPATH),
675  obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
676  obj->getDoubleAttribute(SUMO_ATTR_HEIGHT),
677  obj->getStringAttribute(SUMO_ATTR_NAME),
678  obj->getParameters());
679  }
680  break;
681  // Jps WalkableArea
682  case GNE_TAG_JPS_WALKABLEAREA:
683  buildJpsWalkableArea(obj,
684  obj->getStringAttribute(SUMO_ATTR_ID),
685  obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
686  obj->getBoolAttribute(SUMO_ATTR_GEO),
687  obj->getStringAttribute(SUMO_ATTR_NAME),
688  obj->getParameters());
689  break;
690  // Jps Obstacle
691  case GNE_TAG_JPS_OBSTACLE:
692  buildJpsObstacle(obj,
693  obj->getStringAttribute(SUMO_ATTR_ID),
694  obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
695  obj->getBoolAttribute(SUMO_ATTR_GEO),
696  obj->getStringAttribute(SUMO_ATTR_NAME),
697  obj->getParameters());
698  break;
699  default:
700  break;
701  }
702  // now iterate over childrens
703  for (const auto& child : obj->getSumoBaseObjectChildren()) {
704  // call this function recursively
705  parseSumoBaseObject(child);
706  }
707 }
708 
709 
710 bool
711 AdditionalHandler::isErrorCreatingElement() const {
712  return myErrorCreatingElement;
713 }
714 
715 
716 void
717 AdditionalHandler::writeError(const std::string& error) {
718  WRITE_ERROR(error);
719  myErrorCreatingElement = true;
720 }
721 
722 
723 void
724 AdditionalHandler::parseBusStopAttributes(const SUMOSAXAttributes& attrs) {
725  // declare Ok Flag
726  bool parsedOk = true;
727  // needed attributes
728  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
729  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
730  // optional attributes
731  const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
732  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
733  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
734  const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
735  const int personCapacity = attrs.getOpt<int>(SUMO_ATTR_PERSON_CAPACITY, id.c_str(), parsedOk, 6);
736  const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), parsedOk, 0);
737  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
738  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
739  // continue if flag is ok
740  if (parsedOk) {
741  // set tag
742  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_BUS_STOP);
743  // add all attributes
744  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
745  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
746  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
747  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
748  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
749  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
750  myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_PERSON_CAPACITY, personCapacity);
751  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PARKING_LENGTH, parkingLength);
752  myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
753  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
754  }
755 }
756 
757 
758 void
759 AdditionalHandler::parseTrainStopAttributes(const SUMOSAXAttributes& attrs) {
760  // declare Ok Flag
761  bool parsedOk = true;
762  // needed attributes
763  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
764  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
765  // optional attributes
766  const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
767  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
768  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
769  const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
770  const int personCapacity = attrs.getOpt<int>(SUMO_ATTR_PERSON_CAPACITY, id.c_str(), parsedOk, 6);
771  const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), parsedOk, 0);
772  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
773  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
774  // continue if flag is ok
775  if (parsedOk) {
776  // set tag
777  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TRAIN_STOP);
778  // add all attributes
779  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
780  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
781  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
782  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
783  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
784  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
785  myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_PERSON_CAPACITY, personCapacity);
786  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PARKING_LENGTH, parkingLength);
787  myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
788  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
789  }
790 }
791 
792 
793 void
794 AdditionalHandler::parseAccessAttributes(const SUMOSAXAttributes& attrs) {
795  // declare Ok Flag
796  bool parsedOk = true;
797  // needed attributes
798  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, "", parsedOk);
799  const std::string position = attrs.get<std::string>(SUMO_ATTR_POSITION, "", parsedOk);
800  // optional attributes
801  const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, "", parsedOk, -1.00); /* in future updates, INVALID_DOUBLE */
802  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "", parsedOk, false);
803  // check parent
804  checkParent(SUMO_TAG_ACCESS, {SUMO_TAG_BUS_STOP, SUMO_TAG_TRAIN_STOP}, parsedOk);
805  // continue if flag is ok
806  if (parsedOk) {
807  // set tag
808  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ACCESS);
809  // add all attributes
810  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
811  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_POSITION, position);
812  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
813  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
814  }
815 }
816 
817 
818 void
819 AdditionalHandler::parseContainerStopAttributes(const SUMOSAXAttributes& attrs) {
820  // declare Ok Flag
821  bool parsedOk = true;
822  // needed attributes
823  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
824  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
825  // optional attributes
826  const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
827  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
828  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
829  const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
830  const int containerCapacity = attrs.getOpt<int>(SUMO_ATTR_CONTAINER_CAPACITY, id.c_str(), parsedOk, 6);
831  const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), parsedOk, 0);
832  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
833  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
834  // continue if flag is ok
835  if (parsedOk) {
836  // set tag
837  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CONTAINER_STOP);
838  // add all attributes
839  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
840  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
841  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
842  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
843  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
844  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
845  myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_CONTAINER_CAPACITY, containerCapacity);
846  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PARKING_LENGTH, parkingLength);
847  myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
848  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
849  }
850 }
851 
852 
853 void
854 AdditionalHandler::parseChargingStationAttributes(const SUMOSAXAttributes& attrs) {
855  // declare Ok Flag
856  bool parsedOk = true;
857  // needed attributes
858  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
859  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
860  // optional attributes
861  const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
862  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
863  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
864  const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
865  const double chargingPower = attrs.getOpt<double>(SUMO_ATTR_CHARGINGPOWER, id.c_str(), parsedOk, 22000);
866  const double efficiency = attrs.getOpt<double>(SUMO_ATTR_EFFICIENCY, id.c_str(), parsedOk, 0.95);
867  const bool chargeInTransit = attrs.getOpt<bool>(SUMO_ATTR_CHARGEINTRANSIT, id.c_str(), parsedOk, 0);
868  const SUMOTime chargeDelay = attrs.getOptSUMOTimeReporting(SUMO_ATTR_CHARGEDELAY, id.c_str(), parsedOk, 0);
869  const std::string chargeType = attrs.getOpt<std::string>(SUMO_ATTR_CHARGETYPE, id.c_str(), parsedOk, "normal");
870  const SUMOTime waitingTime = attrs.getOptSUMOTimeReporting(SUMO_ATTR_WAITINGTIME, id.c_str(), parsedOk, TIME2STEPS(900));
871  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
872  const std::string parkingAreaID = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, id.c_str(), parsedOk, "");
873 
874  // check charge type
875  if ((chargeType != "normal") && (chargeType != "electric") && (chargeType != "fuel")) {
876  writeError(TLF("Invalid charge type '%' defined in chargingStation '%'.", chargeType, id));
877  parsedOk = false;
878  }
879  // continue if flag is ok
880  if (parsedOk) {
881  // set tag
882  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CHARGING_STATION);
883  // add all attributes
884  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
885  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
886  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
887  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
888  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
889  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
890  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_CHARGINGPOWER, chargingPower);
891  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_EFFICIENCY, efficiency);
892  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_CHARGEINTRANSIT, chargeInTransit);
893  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_CHARGEDELAY, chargeDelay);
894  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_CHARGETYPE, chargeType);
895  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_WAITINGTIME, waitingTime);
896  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
897  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_PARKING_AREA, parkingAreaID);
898  }
899 }
900 
901 
902 void
903 AdditionalHandler::parseParkingAreaAttributes(const SUMOSAXAttributes& attrs) {
904  // declare Ok Flag
905  bool parsedOk = true;
906  // needed attributes
907  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
908  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
909  // optional attributes
910  const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
911  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
912  const std::string departPos = attrs.getOpt<std::string>(SUMO_ATTR_DEPARTPOS, id.c_str(), parsedOk, "");
913  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
914  const std::vector<std::string> badges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_ACCEPTED_BADGES, id.c_str(), parsedOk, std::vector<std::string>());
915  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
916  const int roadSideCapacity = attrs.getOpt<int>(SUMO_ATTR_ROADSIDE_CAPACITY, id.c_str(), parsedOk, 0);
917  const bool onRoad = attrs.getOpt<bool>(SUMO_ATTR_ONROAD, id.c_str(), parsedOk, false);
918  const double width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, id.c_str(), parsedOk, 0);
919  const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, id.c_str(), parsedOk, 0);
920  const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, 0);
921  const bool lefthand = attrs.getOpt<bool>(SUMO_ATTR_LEFTHAND, id.c_str(), parsedOk, false);
922 
923  // continue if flag is ok
924  if (parsedOk) {
925  // set tag
926  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_PARKING_AREA);
927  // add all attributes
928  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
929  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
930  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
931  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
932  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DEPARTPOS, departPos);
933  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
934  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_ACCEPTED_BADGES, badges);
935  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
936  myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_ROADSIDE_CAPACITY, roadSideCapacity);
937  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_ONROAD, onRoad);
938  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WIDTH, width);
939  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
940  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
941  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_LEFTHAND, lefthand);
942  }
943 }
944 
945 
946 void
947 AdditionalHandler::parseParkingSpaceAttributes(const SUMOSAXAttributes& attrs) {
948  // declare Ok Flag
949  bool parsedOk = true;
950  // needed attributes
951  const double x = attrs.get<double>(SUMO_ATTR_X, "", parsedOk);
952  const double y = attrs.get<double>(SUMO_ATTR_Y, "", parsedOk);
953  // optional attributes
954  const double z = attrs.getOpt<double>(SUMO_ATTR_Z, "", parsedOk, 0);
955  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, "", parsedOk, "");
956  const std::string width = attrs.getOpt<std::string>(SUMO_ATTR_WIDTH, "", parsedOk, "");
957  const std::string length = attrs.getOpt<std::string>(SUMO_ATTR_LENGTH, "", parsedOk, "");
958  const std::string angle = attrs.getOpt<std::string>(SUMO_ATTR_ANGLE, "", parsedOk, "");
959  const double slope = attrs.getOpt<double>(SUMO_ATTR_SLOPE, "", parsedOk, 0);
960  // check parent
961  checkParent(SUMO_TAG_PARKING_SPACE, {SUMO_TAG_PARKING_AREA}, parsedOk);
962  // continue if flag is ok
963  if (parsedOk) {
964  // set tag
965  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_PARKING_SPACE);
966  // add all attributes
967  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_X, x);
968  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_Y, y);
969  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_Z, z);
970  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
971  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_WIDTH, width);
972  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LENGTH, length);
973  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ANGLE, angle);
974  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_SLOPE, slope);
975  }
976 }
977 
978 
979 void
980 AdditionalHandler::parseE1Attributes(const SUMOSAXAttributes& attrs) {
981  // declare Ok Flag
982  bool parsedOk = true;
983  // needed attributes
984  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
985  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
986  const double position = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
987  const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
988  const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
989  // optional attributes
990  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
991  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
992  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
993  // continue if flag is ok
994  if (parsedOk) {
995  // set tag
996  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_E1DETECTOR);
997  // add all attributes
998  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
999  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1000  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1001  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1002  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1003  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1004  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1005  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1006  }
1007 }
1008 
1009 
1010 void
1011 AdditionalHandler::parseE2Attributes(const SUMOSAXAttributes& attrs) {
1012  // declare Ok Flag
1013  bool parsedOk = true;
1014  // check that lane and length are defined together
1015  if (attrs.hasAttribute(SUMO_ATTR_LANE) && !attrs.hasAttribute(SUMO_ATTR_LENGTH)) {
1016  writeError(TL("'lane' and 'length' must be defined together in a lane area detector."));
1017  parsedOk = false;
1018  }
1019  // check that lanes and endPos are defined together
1020  if (attrs.hasAttribute(SUMO_ATTR_LANES) && !attrs.hasAttribute(SUMO_ATTR_ENDPOS)) {
1021  writeError(TL("'lanes' and 'endPos' must be defined together in a lane area detector."));
1022  parsedOk = false;
1023  }
1024  // needed attributes
1025  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1026  const double position = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
1027  const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1028  // special attributes
1029  const std::string laneId = attrs.getOpt<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk, "");
1030  const std::vector<std::string> laneIds = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LANES, id.c_str(), parsedOk, std::vector<std::string>());
1031  const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, id.c_str(), parsedOk, 0);
1032  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, 0);
1033  // optional attributes
1034  const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1035  const std::string trafficLight = attrs.getOpt<std::string>(SUMO_ATTR_TLID, id.c_str(), parsedOk, "");
1036  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1037  const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), parsedOk, TIME2STEPS(1));
1038  const double haltingSpeedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), parsedOk, 1.39);
1039  const double jamDistThreshold = attrs.getOpt<double>(SUMO_ATTR_JAM_DIST_THRESHOLD, id.c_str(), parsedOk, 10);
1040  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1041  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1042  // continue if flag is ok
1043  if (parsedOk) {
1044  // set tag
1045  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_E2DETECTOR);
1046  // add attributes depending of Lane/Lanes
1047  if (attrs.hasAttribute(SUMO_ATTR_LANE)) {
1048  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1049  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
1050  } else {
1051  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LANES, laneIds);
1052  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
1053  }
1054  // add all attributes
1055  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1056  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1057  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1058  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TLID, trafficLight);
1059  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1060  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1061  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1062  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD, haltingTimeThreshold);
1063  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD, haltingSpeedThreshold);
1064  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD, jamDistThreshold);
1065  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1066  }
1067 }
1068 
1069 
1070 void
1071 AdditionalHandler::parseE3Attributes(const SUMOSAXAttributes& attrs) {
1072  // declare Ok Flag
1073  bool parsedOk = true;
1074  // needed attributes
1075  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1076  const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1077  const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1078  // optional attributes
1079  const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position());
1080  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1081  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1082  const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), parsedOk, TIME2STEPS(1));
1083  const double haltingSpeedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), parsedOk, 1.39);
1084  const bool expectedArrival = attrs.getOpt<bool>(SUMO_ATTR_EXPECT_ARRIVAL, id.c_str(), parsedOk, false);
1085  // continue if flag is ok
1086  if (parsedOk) {
1087  // set tag
1088  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_E3DETECTOR);
1089  // add all attributes
1090  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1091  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1092  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1093  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1094  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1095  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1096  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD, haltingTimeThreshold);
1097  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD, haltingSpeedThreshold);
1098  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_EXPECT_ARRIVAL, expectedArrival);
1099  }
1100 }
1101 
1102 
1103 void
1104 AdditionalHandler::parseEntryAttributes(const SUMOSAXAttributes& attrs) {
1105  // declare Ok Flag
1106  bool parsedOk = true;
1107  // needed attributes
1108  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, "", parsedOk);
1109  const double position = attrs.get<double>(SUMO_ATTR_POSITION, "", parsedOk);
1110  // optional attributes
1111  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "", parsedOk, false);
1112  // check parent
1113  checkParent(SUMO_TAG_DET_ENTRY, {SUMO_TAG_E3DETECTOR}, parsedOk);
1114  // continue if flag is ok
1115  if (parsedOk) {
1116  // set tag
1117  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_DET_ENTRY);
1118  // add all attributes
1119  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1120  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1121  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1122  }
1123 }
1124 
1125 
1126 void
1127 AdditionalHandler::parseExitAttributes(const SUMOSAXAttributes& attrs) {
1128  // declare Ok Flag
1129  bool parsedOk = true;
1130  // needed attributes
1131  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, "", parsedOk);
1132  const double position = attrs.get<double>(SUMO_ATTR_POSITION, "", parsedOk);
1133  // optional attributes
1134  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "", parsedOk, false);
1135  // check parent
1136  checkParent(SUMO_TAG_DET_EXIT, {SUMO_TAG_E3DETECTOR}, parsedOk);
1137  // continue if flag is ok
1138  if (parsedOk) {
1139  // set tag
1140  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_DET_EXIT);
1141  // add all attributes
1142  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1143  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1144  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1145  }
1146 }
1147 
1148 
1149 void
1150 AdditionalHandler::parseE1InstantAttributes(const SUMOSAXAttributes& attrs) {
1151  // declare Ok Flag
1152  bool parsedOk = true;
1153  // needed attributes
1154  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1155  const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
1156  const double position = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
1157  const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1158  // optional attributes
1159  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1160  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1161  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1162  // continue if flag is ok
1163  if (parsedOk) {
1164  // set tag
1165  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_INSTANT_INDUCTION_LOOP);
1166  // add all attributes
1167  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1168  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1169  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1170  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1171  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1172  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1173  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1174  }
1175 }
1176 
1177 
1178 void
1179 AdditionalHandler::parseTAZAttributes(const SUMOSAXAttributes& attrs) {
1180  // declare Ok Flag
1181  bool parsedOk = true;
1182  // needed attributes
1183  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1184  // optional attributes
1185  const PositionVector shape = attrs.getOpt<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk, PositionVector());
1186  const Position center = attrs.getOpt<Position>(SUMO_ATTR_CENTER, id.c_str(), parsedOk, shape.size() > 0 ? shape.getCentroid() : Position::INVALID);
1187  const bool fill = attrs.getOpt<bool>(SUMO_ATTR_FILL, id.c_str(), parsedOk, false);
1188  const std::vector<std::string> edges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk, std::vector<std::string>());
1189  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::RED);
1190  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1191  // continue if flag is ok
1192  if (parsedOk) {
1193  // set tag
1194  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZ);
1195  // add all attributes
1196  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1197  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shape);
1198  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_CENTER, center);
1199  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FILL, fill);
1200  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_EDGES, edges);
1201  myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
1202  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1203  }
1204 }
1205 
1206 
1207 void
1208 AdditionalHandler::parseTAZSourceAttributes(const SUMOSAXAttributes& attrs) {
1209  // declare Ok Flag
1210  bool parsedOk = true;
1211  // needed attributes
1212  const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1213  const double weight = attrs.get<double>(SUMO_ATTR_WEIGHT, edgeID.c_str(), parsedOk);
1214  // check parent
1215  checkParent(SUMO_TAG_TAZSOURCE, {SUMO_TAG_TAZ}, parsedOk);
1216  // continue if flag is ok
1217  if (parsedOk) {
1218  // set tag
1219  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZSOURCE);
1220  // add all attributes
1221  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1222  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WEIGHT, weight);
1223  }
1224 }
1225 
1226 
1227 void
1228 AdditionalHandler::parseTAZSinkAttributes(const SUMOSAXAttributes& attrs) {
1229  // declare Ok Flag
1230  bool parsedOk = true;
1231  // needed attributes
1232  const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1233  const double weight = attrs.get<double>(SUMO_ATTR_WEIGHT, edgeID.c_str(), parsedOk);
1234  // check parent
1235  checkParent(SUMO_TAG_TAZSINK, {SUMO_TAG_TAZ}, parsedOk);
1236  // continue if flag is ok
1237  if (parsedOk) {
1238  // set tag
1239  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZSINK);
1240  // add all attributes
1241  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1242  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WEIGHT, weight);
1243  }
1244 }
1245 
1246 
1247 void
1248 AdditionalHandler::parseVariableSpeedSignAttributes(const SUMOSAXAttributes& attrs) {
1249  // declare Ok Flag
1250  bool parsedOk = true;
1251  // needed attributes
1252  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1253  const std::vector<std::string> lanes = attrs.get<std::vector<std::string> >(SUMO_ATTR_LANES, id.c_str(), parsedOk);
1254  // optional attributes
1255  const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position());
1256  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1257  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1258  // continue if flag is ok
1259  if (parsedOk) {
1260  // set tag
1261  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_VSS);
1262  // add all attributes
1263  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1264  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LANES, lanes);
1265  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1266  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1267  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1268  }
1269 }
1270 
1271 
1272 void
1273 AdditionalHandler::parseVariableSpeedSignStepAttributes(const SUMOSAXAttributes& attrs) {
1274  // declare Ok Flag
1275  bool parsedOk = true;
1276  // needed attributes
1277  const SUMOTime time = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME, "", parsedOk);
1278  // optional attributes
1279  const std::string speed = attrs.getOpt<std::string>(SUMO_ATTR_SPEED, "", parsedOk, "");
1280  // check parent
1281  checkParent(SUMO_TAG_STEP, {SUMO_TAG_VSS}, parsedOk);
1282  // continue if flag is ok
1283  if (parsedOk) {
1284  // set tag
1285  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_STEP);
1286  // add all attributes
1287  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_TIME, time);
1288  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_SPEED, speed);
1289  }
1290 }
1291 
1292 
1293 void
1294 AdditionalHandler::parseCalibratorAttributes(const SUMOSAXAttributes& attrs) {
1295  // declare Ok Flag
1296  bool parsedOk = true;
1297  // check that frecuency and trafficLight aren't defined together
1298  if ((attrs.hasAttribute(SUMO_ATTR_EDGE) && attrs.hasAttribute(SUMO_ATTR_LANE)) ||
1299  (!attrs.hasAttribute(SUMO_ATTR_EDGE) && !attrs.hasAttribute(SUMO_ATTR_LANE))) {
1300  writeError(TL("Calibrators need either an edge or a lane"));
1301  parsedOk = false;
1302  }
1303  // needed attributes
1304  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1305  const double pos = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
1306  // special attributes
1307  const std::string edge = attrs.getOpt<std::string>(SUMO_ATTR_EDGE, id.c_str(), parsedOk, "");
1308  const std::string lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk, "");
1309  // optional attributes
1310  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1311  const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, DELTA_T);
1312  const std::string routeProbe = attrs.getOpt<std::string>(SUMO_ATTR_ROUTEPROBE, id.c_str(), parsedOk, "");
1313  const double jamThreshold = attrs.getOpt<double>(SUMO_ATTR_JAM_DIST_THRESHOLD, id.c_str(), parsedOk, 0.5);
1314  const std::string output = attrs.getOpt<std::string>(SUMO_ATTR_OUTPUT, id.c_str(), parsedOk, "");
1315  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1316  // continue if flag is ok
1317  if (parsedOk) {
1318  // set tag depending of edge/lane
1319  if (attrs.hasAttribute(SUMO_ATTR_EDGE)) {
1320  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CALIBRATOR);
1321  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EDGE, edge);
1322  } else {
1323  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(GNE_TAG_CALIBRATOR_LANE);
1324  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, lane);
1325  }
1326  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1327  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, pos);
1328  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1329  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1330  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ROUTEPROBE, routeProbe);
1331  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD, jamThreshold);
1332  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OUTPUT, output);
1333  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1334  }
1335 }
1336 
1337 
1338 void
1339 AdditionalHandler::parseCalibratorFlowAttributes(const SUMOSAXAttributes& attrs) {
1340  // declare Ok Flag
1341  bool parsedOk = true;
1342  // check parent
1343  if (myCommonXMLStructure.getCurrentSumoBaseObject()->getParentSumoBaseObject() &&
1344  myCommonXMLStructure.getCurrentSumoBaseObject()->getParentSumoBaseObject()->getTag() != SUMO_TAG_ROOTFILE) {
1345  // check that frecuency and trafficLight aren't defined together
1346  if (!attrs.hasAttribute(SUMO_ATTR_TYPE) && !attrs.hasAttribute(SUMO_ATTR_VEHSPERHOUR) && !attrs.hasAttribute(SUMO_ATTR_SPEED)) {
1347  writeError(TL("CalibratorFlows need either the attribute vehsPerHour or speed or type (or any combination of these)"));
1348  }
1349  // first parse flow
1350  SUMOVehicleParameter* flowParameter = SUMOVehicleParserHelper::parseVehicleAttributes(SUMO_TAG_FLOW, attrs, false, true, true);
1351  if (flowParameter) {
1352  // set VPH and speed
1353  if (attrs.hasAttribute(SUMO_ATTR_VEHSPERHOUR)) {
1354  flowParameter->repetitionOffset = TIME2STEPS(3600. / attrs.get<double>(SUMO_ATTR_VEHSPERHOUR, "", parsedOk));
1355  flowParameter->parametersSet |= VEHPARS_VPH_SET;
1356  }
1357  if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
1358  flowParameter->calibratorSpeed = attrs.get<double>(SUMO_ATTR_SPEED, "", parsedOk);
1359  flowParameter->parametersSet |= VEHPARS_CALIBRATORSPEED_SET;
1360  }
1361  // set begin and end
1362  flowParameter->depart = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, "", parsedOk);
1363  flowParameter->repetitionEnd = attrs.getSUMOTimeReporting(SUMO_ATTR_END, "", parsedOk);
1364  if (parsedOk) {
1365  // set tag
1366  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_FLOW);
1367  // set vehicle parameters
1368  myCommonXMLStructure.getCurrentSumoBaseObject()->setVehicleParameter(flowParameter);
1369  // delete flow parameter (because in XMLStructure we have a copy)
1370  delete flowParameter;
1371  }
1372  }
1373  }
1374 }
1375 
1376 
1377 void
1378 AdditionalHandler::parseRerouterAttributes(const SUMOSAXAttributes& attrs) {
1379  // declare Ok Flag
1380  bool parsedOk = true;
1381  // needed attributes
1382  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1383  const std::vector<std::string> edges = attrs.get<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk);
1384  // optional attributes
1385  const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position::INVALID);
1386  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1387  const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, id.c_str(), parsedOk, 1);
1388  SUMOTime timeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), parsedOk, 0);
1389  const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1390  const bool off = attrs.getOpt<bool>(SUMO_ATTR_OFF, id.c_str(), parsedOk, false);
1391  const bool optional = attrs.getOpt<bool>(SUMO_ATTR_OPTIONAL, id.c_str(), parsedOk, false);
1392  // continue if flag is ok
1393  if (parsedOk) {
1394  // set tag
1395  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_REROUTER);
1396  // add all attributes
1397  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1398  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_EDGES, edges);
1399  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1400  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1401  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1402  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD, timeThreshold);
1403  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1404  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_OFF, off);
1405  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_OPTIONAL, optional);
1406  }
1407 }
1408 
1409 
1410 void
1411 AdditionalHandler::parseRerouterIntervalAttributes(const SUMOSAXAttributes& attrs) {
1412  // declare Ok Flag
1413  bool parsedOk = true;
1414  // needed attributes
1415  const SUMOTime begin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, "", parsedOk);
1416  const SUMOTime end = attrs.getSUMOTimeReporting(SUMO_ATTR_END, "", parsedOk);
1417  // check parent
1418  checkParent(SUMO_TAG_INTERVAL, {SUMO_TAG_REROUTER}, parsedOk);
1419  // continue if flag is ok
1420  if (parsedOk) {
1421  // set tag
1422  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_INTERVAL);
1423  // add all attributes
1424  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);
1425  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_END, end);
1426  }
1427 }
1428 
1429 
1430 void
1431 AdditionalHandler::parseClosingLaneRerouteAttributes(const SUMOSAXAttributes& attrs) {
1432  // declare Ok Flag
1433  bool parsedOk = true;
1434  // needed attributes
1435  const std::string laneID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1436  // optional attributes
1437  const std::string disallow = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, "", parsedOk, "");
1438  const std::string allow = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, "", parsedOk, !disallow.size() ? "authority" : "");
1439  // check parent
1440  checkParent(SUMO_TAG_CLOSING_LANE_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1441  // continue if flag is ok
1442  if (parsedOk) {
1443  // set tag
1444  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CLOSING_LANE_REROUTE);
1445  // add all attributes
1446  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, laneID);
1447  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ALLOW, allow);
1448  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DISALLOW, disallow);
1449  }
1450 }
1451 
1452 
1453 void
1454 AdditionalHandler::parseClosingRerouteAttributes(const SUMOSAXAttributes& attrs) {
1455  // declare Ok Flag
1456  bool parsedOk = true;
1457  // needed attributes
1458  const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1459  // optional attributes
1460  const std::string disallow = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, "", parsedOk, "");
1461  const std::string allow = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, "", parsedOk, !disallow.size() ? "authority" : "");
1462  // check parent
1463  checkParent(SUMO_TAG_CLOSING_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1464  // continue if flag is ok
1465  if (parsedOk) {
1466  // set tag
1467  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CLOSING_REROUTE);
1468  // add all attributes
1469  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1470  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ALLOW, allow);
1471  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DISALLOW, disallow);
1472  }
1473 }
1474 
1475 
1476 void
1477 AdditionalHandler::parseDestProbRerouteAttributes(const SUMOSAXAttributes& attrs) {
1478  // declare Ok Flag
1479  bool parsedOk = true;
1480  // needed attributes
1481  const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1482  const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, "", parsedOk, 1);
1483  // check parent
1484  checkParent(SUMO_TAG_DEST_PROB_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1485  // continue if flag is ok
1486  if (parsedOk) {
1487  if (probability < 0) {
1488  writeError(TLF("Probability of % must be equal or greater than 0", toString(SUMO_TAG_DEST_PROB_REROUTE)));
1489  } else {
1490  // set tag
1491  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_DEST_PROB_REROUTE);
1492  // add all attributes
1493  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1494  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1495  }
1496  }
1497 }
1498 
1499 
1500 void
1501 AdditionalHandler::parseParkingAreaRerouteAttributes(const SUMOSAXAttributes& attrs) {
1502  // declare Ok Flag
1503  bool parsedOk = true;
1504  // needed attributes
1505  const std::string parkingAreaID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1506  const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, "", parsedOk, 1);
1507  // optional attributes
1508  const bool visible = attrs.getOpt<bool>(SUMO_ATTR_VISIBLE, "", parsedOk, false);
1509  // check parent
1510  checkParent(SUMO_TAG_PARKING_AREA_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1511  // continue if flag is ok
1512  if (parsedOk) {
1513  if (probability < 0) {
1514  writeError(TLF("Probability of % must be equal or greater than 0", toString(SUMO_TAG_PARKING_AREA_REROUTE)));
1515  } else {
1516  // set tag
1517  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_PARKING_AREA_REROUTE);
1518  // add all attributes
1519  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, parkingAreaID);
1520  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1521  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_VISIBLE, visible);
1522  }
1523  }
1524 }
1525 
1526 
1527 void
1528 AdditionalHandler::parseRouteProbRerouteAttributes(const SUMOSAXAttributes& attrs) {
1529  // declare Ok Flag
1530  bool parsedOk = true;
1531  // needed attributes
1532  const std::string routeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1533  const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, "", parsedOk, 1);
1534  // check parent
1535  checkParent(SUMO_TAG_ROUTE_PROB_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1536  // continue if flag is ok
1537  if (parsedOk) {
1538  if (probability < 0) {
1539  writeError(TLF("Probability of % must be equal or greater than 0", toString(SUMO_TAG_ROUTE_PROB_REROUTE)));
1540  } else {
1541  // set tag
1542  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ROUTE_PROB_REROUTE);
1543  // add all attributes
1544  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, routeID);
1545  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1546  }
1547  }
1548 }
1549 
1550 
1551 void
1552 AdditionalHandler::parseRouteProbeAttributes(const SUMOSAXAttributes& attrs) {
1553  // declare Ok Flag
1554  bool parsedOk = true;
1555  // needed attributes
1556  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1557  const std::string edge = attrs.get<std::string>(SUMO_ATTR_EDGE, id.c_str(), parsedOk);
1558  const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1559  const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1560  const SUMOTime begin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, id.c_str(), parsedOk, -1);
1561  // optional attributes
1562  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1563  // continue if flag is ok
1564  if (parsedOk) {
1565  // set tag
1566  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ROUTEPROBE);
1567  // add all attributes
1568  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1569  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EDGE, edge);
1570  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1571  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1572  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1573  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);
1574  }
1575 }
1576 
1577 
1578 void
1579 AdditionalHandler::parseVaporizerAttributes(const SUMOSAXAttributes& attrs) {
1580  // declare Ok Flag
1581  bool parsedOk = true;
1582  // needed attributes
1583  const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1584  SUMOTime begin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, nullptr, parsedOk);
1585  SUMOTime end = attrs.getSUMOTimeReporting(SUMO_ATTR_END, nullptr, parsedOk);
1586  // optional attributes
1587  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, edgeID.c_str(), parsedOk, "");
1588  // continue if flag is ok
1589  if (parsedOk) {
1590  // set tag
1591  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_VAPORIZER);
1592  // add all attributes
1593  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1594  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);
1595  myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_END, end);
1596  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1597  }
1598 }
1599 
1600 
1601 void
1602 AdditionalHandler::parseTractionSubstation(const SUMOSAXAttributes& attrs) {
1603  // declare Ok Flag
1604  bool parsedOk = true;
1605  // needed attributes
1606  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1607  // optional attributes
1608  const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position::INVALID);
1609  const double voltage = attrs.getOpt<double>(SUMO_ATTR_VOLTAGE, id.c_str(), parsedOk, 600);
1610  const double currentLimit = attrs.getOpt<double>(SUMO_ATTR_CURRENTLIMIT, id.c_str(), parsedOk, 400);
1611  // continue if flag is ok
1612  if (parsedOk) {
1613  // set tag
1614  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TRACTION_SUBSTATION);
1615  // add all attributes
1616  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1617  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1618  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_VOLTAGE, voltage);
1619  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_CURRENTLIMIT, currentLimit);
1620  }
1621 }
1622 
1623 
1624 void
1625 AdditionalHandler::parseOverheadWire(const SUMOSAXAttributes& attrs) {
1626  // declare Ok Flag
1627  bool parsedOk = true;
1628  // needed attributes
1629  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1630  const std::string substationID = attrs.get<std::string>(SUMO_ATTR_SUBSTATIONID, id.c_str(), parsedOk);
1631  const std::vector<std::string> laneIDs = attrs.get<std::vector<std::string> >(SUMO_ATTR_LANES, id.c_str(), parsedOk);
1632  // optional attributes
1633  const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, 0);
1634  const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
1635  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1636  const std::vector<std::string> forbiddenInnerLanes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN, "", parsedOk);
1637  // continue if flag is ok
1638  if (parsedOk) {
1639  // set tag
1640  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_OVERHEAD_WIRE_SECTION);
1641  // add all attributes
1642  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1643  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_SUBSTATIONID, substationID);
1644  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LANES, laneIDs);
1645  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
1646  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
1647  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1648  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN, forbiddenInnerLanes);
1649  }
1650 }
1651 
1652 
1653 void
1654 AdditionalHandler::parseOverheadWireClamp(const SUMOSAXAttributes& attrs) {
1655  // declare Ok Flag
1656  bool parsedOk = true;
1657  // needed attributes
1658  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1659  const std::string substationId = attrs.get<std::string>(SUMO_ATTR_SUBSTATIONID, id.c_str(), parsedOk);
1660  const std::string wireClampStart = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_START, id.c_str(), parsedOk);
1661  const std::string wireClampLaneStart = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART, id.c_str(), parsedOk);
1662  const std::string wireClampEnd = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_END, id.c_str(), parsedOk);
1663  const std::string wireClampLaneEnd = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND, id.c_str(), parsedOk);
1664  // continue if flag is ok
1665  if (parsedOk) {
1666  // set tag
1667  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_OVERHEAD_WIRE_CLAMP);
1668  // add all attributes
1669  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1670  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_SUBSTATIONID, substationId);
1671  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_START, wireClampStart);
1672  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART, wireClampLaneStart);
1673  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_END, wireClampEnd);
1674  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND, wireClampLaneEnd);
1675  }
1676 }
1677 
1678 
1679 void
1680 AdditionalHandler::parsePolyAttributes(const SUMOSAXAttributes& attrs) {
1681  // declare Ok Flag
1682  bool parsedOk = true;
1683  // needed attributes
1684  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1685  const PositionVector shapeStr = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk);
1686  // optional attributes
1687  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::RED);
1688  const bool geo = attrs.getOpt<bool>(SUMO_ATTR_GEO, id.c_str(), parsedOk, false);
1689  const bool fill = attrs.getOpt<bool>(SUMO_ATTR_FILL, id.c_str(), parsedOk, false);
1690  const double lineWidth = attrs.getOpt<double>(SUMO_ATTR_LINEWIDTH, id.c_str(), parsedOk, Shape::DEFAULT_LINEWIDTH);
1691  const double layer = attrs.getOpt<double>(SUMO_ATTR_LAYER, id.c_str(), parsedOk, Shape::DEFAULT_LAYER);
1692  const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), parsedOk, Shape::DEFAULT_TYPE);
1693  const std::string imgFile = attrs.getOpt<std::string>(SUMO_ATTR_IMGFILE, id.c_str(), parsedOk, Shape::DEFAULT_IMG_FILE);
1694  const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, Shape::DEFAULT_ANGLE);
1695  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1696  const bool relativePath = attrs.getOpt<bool>(SUMO_ATTR_RELATIVEPATH, id.c_str(), parsedOk, Shape::DEFAULT_RELATIVEPATH);
1697  // continue if flag is ok
1698  if (parsedOk) {
1699  // set tag
1700  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_POLY);
1701  // add all attributes
1702  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1703  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shapeStr);
1704  myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
1705  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_GEO, geo);
1706  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FILL, fill);
1707  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LINEWIDTH, lineWidth);
1708  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LAYER, layer);
1709  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TYPE, type);
1710  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_IMGFILE, imgFile);
1711  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
1712  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1713  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_RELATIVEPATH, relativePath);
1714  }
1715 }
1716 
1717 
1718 void
1719 AdditionalHandler::parsePOIAttributes(const SUMOSAXAttributes& attrs) {
1720  // declare Ok Flag
1721  bool parsedOk = true;
1722  // check that x and y are defined together
1723  if ((attrs.hasAttribute(SUMO_ATTR_X) && !attrs.hasAttribute(SUMO_ATTR_Y)) ||
1724  (!attrs.hasAttribute(SUMO_ATTR_X) && attrs.hasAttribute(SUMO_ATTR_Y))) {
1725  writeError(TL("X and Y must be be defined together in POIs"));
1726  parsedOk = false;
1727  }
1728  // check that lane and pos are defined together
1729  if ((attrs.hasAttribute(SUMO_ATTR_LANE) && !attrs.hasAttribute(SUMO_ATTR_POSITION)) ||
1730  (!attrs.hasAttribute(SUMO_ATTR_LANE) && attrs.hasAttribute(SUMO_ATTR_POSITION))) {
1731  writeError(TL("lane and position must be defined together in POIs"));
1732  parsedOk = false;
1733  }
1734  // check that lon and lat are defined together
1735  if ((attrs.hasAttribute(SUMO_ATTR_LON) && !attrs.hasAttribute(SUMO_ATTR_LAT)) ||
1736  (!attrs.hasAttribute(SUMO_ATTR_LON) && attrs.hasAttribute(SUMO_ATTR_LAT))) {
1737  writeError(TL("lon and lat must be be defined together in POIs"));
1738  parsedOk = false;
1739  }
1740  // needed attributes
1741  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1742  // special attributes
1743  const double x = attrs.getOpt<double>(SUMO_ATTR_X, id.c_str(), parsedOk, 0);
1744  const double y = attrs.getOpt<double>(SUMO_ATTR_Y, id.c_str(), parsedOk, 0);
1745  const std::string lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, "", parsedOk, "");
1746  const double pos = attrs.getOpt<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, 0);
1747  const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1748  const double posLat = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, id.c_str(), parsedOk, 0);
1749  const double lon = attrs.getOpt<double>(SUMO_ATTR_LON, id.c_str(), parsedOk, 0);
1750  const double lat = attrs.getOpt<double>(SUMO_ATTR_LAT, id.c_str(), parsedOk, 0);
1751  // optional attributes
1752  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::RED);
1753  const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, "", parsedOk, Shape::DEFAULT_TYPE);
1754  std::string icon = attrs.getOpt<std::string>(SUMO_ATTR_ICON, "", parsedOk, SUMOXMLDefinitions::POIIcons.getString(POIIcon::NONE));
1755  const double layer = attrs.getOpt<double>(SUMO_ATTR_LAYER, id.c_str(), parsedOk, Shape::DEFAULT_LAYER_POI);
1756  const std::string imgFile = attrs.getOpt<std::string>(SUMO_ATTR_IMGFILE, "", parsedOk, Shape::DEFAULT_IMG_FILE);
1757  const double width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, id.c_str(), parsedOk, Shape::DEFAULT_IMG_WIDTH);
1758  const double height = attrs.getOpt<double>(SUMO_ATTR_HEIGHT, id.c_str(), parsedOk, Shape::DEFAULT_IMG_HEIGHT);
1759  const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, Shape::DEFAULT_ANGLE);
1760  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1761  const bool relativePath = attrs.getOpt<bool>(SUMO_ATTR_RELATIVEPATH, id.c_str(), parsedOk, Shape::DEFAULT_RELATIVEPATH);
1762  // check icon
1763  if (!SUMOXMLDefinitions::POIIcons.hasString(icon)) {
1764  WRITE_WARNING(TLF("Invalid icon % for POI '%', using default", icon, id));
1765  icon = "none";
1766  }
1767  // continue if flag is ok
1768  if (parsedOk) {
1769  // set tag
1770  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_POI);
1771  // add attributes depending of Lane/Lanes
1772  if (attrs.hasAttribute(SUMO_ATTR_X) && attrs.hasAttribute(SUMO_ATTR_Y)) {
1773  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_X, x);
1774  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_Y, y);
1775  } else if (attrs.hasAttribute(SUMO_ATTR_LANE) && attrs.hasAttribute(SUMO_ATTR_POSITION)) {
1776  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, lane);
1777  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, pos);
1778  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1779  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION_LAT, posLat);
1780  } else {
1781  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LON, lon);
1782  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LAT, lat);
1783  }
1784  // add rest attributes
1785  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1786  myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
1787  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TYPE, type);
1788  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ICON, icon);
1789  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LAYER, layer);
1790  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_IMGFILE, imgFile);
1791  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WIDTH, width);
1792  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HEIGHT, height);
1793  myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
1794  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1795  myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_RELATIVEPATH, relativePath);
1796  }
1797 }
1798 
1799 
1800 void
1801 AdditionalHandler::parseJpsWalkableAreaAttributes(const SUMOSAXAttributes& attrs) {
1802  // declare Ok Flag
1803  bool parsedOk = true;
1804  // needed attributes
1805  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1806  const PositionVector shapeStr = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk);
1807  // optional attributes
1808  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1809  // continue if flag is ok
1810  if (parsedOk) {
1811  // set tag
1812  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(GNE_TAG_JPS_WALKABLEAREA);
1813  // add all attributes
1814  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1815  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shapeStr);
1816  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1817  }
1818 }
1819 
1820 
1821 void
1822 AdditionalHandler::parseJpsObstacleAttributes(const SUMOSAXAttributes& attrs) {
1823  // declare Ok Flag
1824  bool parsedOk = true;
1825  // needed attributes
1826  const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1827  const PositionVector shapeStr = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk);
1828  // optional attributes
1829  const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1830  // continue if flag is ok
1831  if (parsedOk) {
1832  // set tag
1833  myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(GNE_TAG_JPS_OBSTACLE);
1834  // add all attributes
1835  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1836  myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shapeStr);
1837  myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1838  }
1839 }
1840 
1841 
1842 void
1843 AdditionalHandler::parseParameters(const SUMOSAXAttributes& attrs) {
1844  // declare Ok Flag
1845  bool parsedOk = true;
1846  // get key
1847  const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, parsedOk);
1848  // get SumoBaseObject parent
1849  CommonXMLStructure::SumoBaseObject* SumoBaseObjectParent = myCommonXMLStructure.getCurrentSumoBaseObject()->getParentSumoBaseObject();
1850  // check parent
1851  if (SumoBaseObjectParent == nullptr) {
1852  writeError(TL("Parameters must be defined within an object."));
1853  } else if (SumoBaseObjectParent->getTag() == SUMO_TAG_ROOTFILE) {
1854  writeError(TL("Parameters cannot be defined in the additional file's root."));
1855  } else if (SumoBaseObjectParent->getTag() == SUMO_TAG_PARAM) {
1856  writeError(TL("Parameters cannot be defined within another parameter."));
1857  } else if (parsedOk) {
1858  // get tag str
1859  const std::string parentTagStr = toString(SumoBaseObjectParent->getTag());
1860  // circumventing empty string value
1861  const std::string value = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
1862  // show warnings if values are invalid
1863  if (key.empty()) {
1864  WRITE_WARNINGF(TL("Error parsing key from % generic parameter. Key cannot be empty."), parentTagStr);
1865  } else if (!SUMOXMLDefinitions::isValidParameterKey(key)) {
1866  WRITE_WARNINGF(TL("Error parsing key from % generic parameter. Key contains invalid characters."), parentTagStr);
1867  } else {
1868  WRITE_DEBUG("Inserting generic parameter '" + key + "|" + value + "' into " + parentTagStr);
1869  // insert parameter in SumoBaseObjectParent
1870  SumoBaseObjectParent->addParameter(key, value);
1871  }
1872  }
1873 }
1874 
1875 
1876 void
1877 AdditionalHandler::checkParent(const SumoXMLTag currentTag, const std::vector<SumoXMLTag>& parentTags, bool& ok) {
1878  // check that parent SUMOBaseObject's tag is the parentTag
1879  CommonXMLStructure::SumoBaseObject* const parent = myCommonXMLStructure.getCurrentSumoBaseObject()->getParentSumoBaseObject();
1880  if ((parent != nullptr) &&
1881  (parentTags.size() > 0) &&
1882  (std::find(parentTags.begin(), parentTags.end(), parent->getTag()) == parentTags.end())) {
1883  const std::string id = parent->hasStringAttribute(SUMO_ATTR_ID) ? ", id: '" + parent->getStringAttribute(SUMO_ATTR_ID) + "'" : "";
1884  writeError("'" + toString(currentTag) + "' must be defined within the definition of a '" + toString(parentTags.front()) + "' (found '" + toString(parent->getTag()) + "'" + id + ").");
1885  ok = false;
1886  }
1887 }
1888 
1889 /****************************************************************************/
SUMOTime
long long int SUMOTime
Definition: GUI.h:35
WRITE_DEBUG
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:306
WRITE_WARNINGF
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:296
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:304
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:295
TL
#define TL(string)
Definition: MsgHandler.h:315
TLF
#define TLF(string,...)
Definition: MsgHandler.h:317
DELTA_T
SUMOTime DELTA_T
Definition: SUMOTime.cpp:38
SUMOTime_MAX_PERIOD
#define SUMOTime_MAX_PERIOD
Definition: SUMOTime.h:36
TIME2STEPS
#define TIME2STEPS(x)
Definition: SUMOTime.h:57
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:342
VEHPARS_VPH_SET
const int VEHPARS_VPH_SET
Definition: SUMOVehicleParameter.h:51
VEHPARS_CALIBRATORSPEED_SET
const int VEHPARS_CALIBRATORSPEED_SET
Definition: SUMOVehicleParameter.h:71
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:41
SUMO_TAG_TRACTION_SUBSTATION
@ SUMO_TAG_TRACTION_SUBSTATION
A traction substation.
Definition: SUMOXMLDefinitions.h:139
SUMO_TAG_INTERVAL
@ SUMO_TAG_INTERVAL
an aggreagated-output interval
Definition: SUMOXMLDefinitions.h:117
SUMO_TAG_CLOSING_REROUTE
@ SUMO_TAG_CLOSING_REROUTE
reroute of type closing
Definition: SUMOXMLDefinitions.h:121
SUMO_TAG_REROUTER
@ SUMO_TAG_REROUTER
A rerouter.
Definition: SUMOXMLDefinitions.h:113
SUMO_TAG_ROUTEPROBE
@ SUMO_TAG_ROUTEPROBE
a routeprobe detector
Definition: SUMOXMLDefinitions.h:105
SUMO_TAG_TAZ
@ SUMO_TAG_TAZ
a traffic assignment zone
Definition: SUMOXMLDefinitions.h:179
SUMO_TAG_E2DETECTOR
@ SUMO_TAG_E2DETECTOR
an e2 detector
Definition: SUMOXMLDefinitions.h:83
SUMO_TAG_CHARGING_STATION
@ SUMO_TAG_CHARGING_STATION
A Charging Station.
Definition: SUMOXMLDefinitions.h:73
SUMO_TAG_ACCESS
@ SUMO_TAG_ACCESS
An access point for a train stop.
Definition: SUMOXMLDefinitions.h:69
SUMO_TAG_CONTAINER_STOP
@ SUMO_TAG_CONTAINER_STOP
A container stop.
Definition: SUMOXMLDefinitions.h:71
SUMO_TAG_PARKING_AREA_REROUTE
@ SUMO_TAG_PARKING_AREA_REROUTE
entry for an alternative parking zone
Definition: SUMOXMLDefinitions.h:127
SUMO_TAG_ROOTFILE
@ SUMO_TAG_ROOTFILE
root file
Definition: SUMOXMLDefinitions.h:43
SUMO_TAG_TAZSINK
@ SUMO_TAG_TAZSINK
a sink within a district (connection road)
Definition: SUMOXMLDefinitions.h:183
SUMO_TAG_BUS_STOP
@ SUMO_TAG_BUS_STOP
A bus stop.
Definition: SUMOXMLDefinitions.h:63
SUMO_TAG_POI
@ SUMO_TAG_POI
begin/end of the description of a Point of interest
Definition: SUMOXMLDefinitions.h:55
SUMO_TAG_STEP
@ SUMO_TAG_STEP
trigger: a step description
Definition: SUMOXMLDefinitions.h:135
SUMO_TAG_OVERHEAD_WIRE_CLAMP
@ SUMO_TAG_OVERHEAD_WIRE_CLAMP
An overhead wire clamp (connection of wires in opposite directions)
Definition: SUMOXMLDefinitions.h:145
SUMO_TAG_FLOW
@ SUMO_TAG_FLOW
a flow definition using from and to edges or a route
Definition: SUMOXMLDefinitions.h:161
SUMO_TAG_PARKING_AREA
@ SUMO_TAG_PARKING_AREA
A parking area.
Definition: SUMOXMLDefinitions.h:75
SUMO_TAG_ROUTE_PROB_REROUTE
@ SUMO_TAG_ROUTE_PROB_REROUTE
probability of route of a reroute
Definition: SUMOXMLDefinitions.h:125
GNE_TAG_CALIBRATOR_LANE
@ GNE_TAG_CALIBRATOR_LANE
A calibrator placed over lane.
Definition: SUMOXMLDefinitions.h:109
SUMO_TAG_DET_ENTRY
@ SUMO_TAG_DET_ENTRY
an e3 entry point
Definition: SUMOXMLDefinitions.h:93
SUMO_TAG_PARKING_SPACE
@ SUMO_TAG_PARKING_SPACE
A parking space for a single vehicle within a parking area.
Definition: SUMOXMLDefinitions.h:77
SUMO_TAG_POLY
@ SUMO_TAG_POLY
begin/end of the description of a polygon
Definition: SUMOXMLDefinitions.h:53
SUMO_TAG_OVERHEAD_WIRE_SECTION
@ SUMO_TAG_OVERHEAD_WIRE_SECTION
An overhead wire section.
Definition: SUMOXMLDefinitions.h:143
SUMO_TAG_TRAIN_STOP
@ SUMO_TAG_TRAIN_STOP
A train stop (alias for bus stop)
Definition: SUMOXMLDefinitions.h:65
SUMO_TAG_INSTANT_INDUCTION_LOOP
@ SUMO_TAG_INSTANT_INDUCTION_LOOP
An instantenous induction loop.
Definition: SUMOXMLDefinitions.h:103
SUMO_TAG_DEST_PROB_REROUTE
@ SUMO_TAG_DEST_PROB_REROUTE
probability of destination of a reroute
Definition: SUMOXMLDefinitions.h:119
SUMO_TAG_PARAM
@ SUMO_TAG_PARAM
parameter associated to a certain key
Definition: SUMOXMLDefinitions.h:211
SUMO_TAG_E1DETECTOR
@ SUMO_TAG_E1DETECTOR
an e1 detector
Definition: SUMOXMLDefinitions.h:79
GNE_TAG_JPS_OBSTACLE
@ GNE_TAG_JPS_OBSTACLE
polygon used for draw juPedSim obstacles
Definition: SUMOXMLDefinitions.h:431
SUMO_TAG_DET_EXIT
@ SUMO_TAG_DET_EXIT
an e3 exit point
Definition: SUMOXMLDefinitions.h:95
SUMO_TAG_VAPORIZER
@ SUMO_TAG_VAPORIZER
vaporizer of vehicles
Definition: SUMOXMLDefinitions.h:137
SUMO_TAG_LANE_AREA_DETECTOR
@ SUMO_TAG_LANE_AREA_DETECTOR
alternative tag for e2 detector
Definition: SUMOXMLDefinitions.h:85
SUMO_TAG_TAZSOURCE
@ SUMO_TAG_TAZSOURCE
a source within a district (connection road)
Definition: SUMOXMLDefinitions.h:181
SUMO_TAG_CLOSING_LANE_REROUTE
@ SUMO_TAG_CLOSING_LANE_REROUTE
lane of a reroute of type closing
Definition: SUMOXMLDefinitions.h:123
SUMO_TAG_INDUCTION_LOOP
@ SUMO_TAG_INDUCTION_LOOP
alternative tag for e1 detector
Definition: SUMOXMLDefinitions.h:81
GNE_TAG_JPS_WALKABLEAREA
@ GNE_TAG_JPS_WALKABLEAREA
polygon used for draw juPedSim walkable areas
Definition: SUMOXMLDefinitions.h:429
SUMO_TAG_CALIBRATOR
@ SUMO_TAG_CALIBRATOR
A calibrator placed over edge.
Definition: SUMOXMLDefinitions.h:107
SUMO_TAG_ENTRY_EXIT_DETECTOR
@ SUMO_TAG_ENTRY_EXIT_DETECTOR
alternative tag for e3 detector
Definition: SUMOXMLDefinitions.h:91
SUMO_TAG_E3DETECTOR
@ SUMO_TAG_E3DETECTOR
an e3 detector
Definition: SUMOXMLDefinitions.h:89
SUMO_TAG_VSS
@ SUMO_TAG_VSS
A variable speed sign.
Definition: SUMOXMLDefinitions.h:131
SUMO_ATTR_EXPECT_ARRIVAL
@ SUMO_ATTR_EXPECT_ARRIVAL
Definition: SUMOXMLDefinitions.h:1219
SUMO_ATTR_STARTPOS
@ SUMO_ATTR_STARTPOS
Definition: SUMOXMLDefinitions.h:1276
SUMO_ATTR_DISALLOW
@ SUMO_ATTR_DISALLOW
Definition: SUMOXMLDefinitions.h:1257
SUMO_ATTR_LINES
@ SUMO_ATTR_LINES
Definition: SUMOXMLDefinitions.h:1244
SUMO_ATTR_ALLOW
@ SUMO_ATTR_ALLOW
Definition: SUMOXMLDefinitions.h:1256
SUMO_ATTR_ICON
@ SUMO_ATTR_ICON
icon
Definition: SUMOXMLDefinitions.h:1149
SUMO_ATTR_LANE
@ SUMO_ATTR_LANE
Definition: SUMOXMLDefinitions.h:606
SUMO_ATTR_ACCEPTED_BADGES
@ SUMO_ATTR_ACCEPTED_BADGES
Definition: SUMOXMLDefinitions.h:1239
SUMO_ATTR_LON
@ SUMO_ATTR_LON
Definition: SUMOXMLDefinitions.h:1298
SUMO_ATTR_VEHSPERHOUR
@ SUMO_ATTR_VEHSPERHOUR
Definition: SUMOXMLDefinitions.h:1262
SUMO_ATTR_SPEED
@ SUMO_ATTR_SPEED
Definition: SUMOXMLDefinitions.h:559
SUMO_ATTR_WAITINGTIME
@ SUMO_ATTR_WAITINGTIME
Definition: SUMOXMLDefinitions.h:557
SUMO_ATTR_VALUE
@ SUMO_ATTR_VALUE
Definition: SUMOXMLDefinitions.h:1253
SUMO_ATTR_FILE
@ SUMO_ATTR_FILE
Definition: SUMOXMLDefinitions.h:1090
SUMO_ATTR_PARKING_AREA
@ SUMO_ATTR_PARKING_AREA
Definition: SUMOXMLDefinitions.h:1237
SUMO_ATTR_Y
@ SUMO_ATTR_Y
Definition: SUMOXMLDefinitions.h:600
SUMO_ATTR_SUBSTATIONID
@ SUMO_ATTR_SUBSTATIONID
id of a traction substation substation
Definition: SUMOXMLDefinitions.h:750
SUMO_ATTR_Z
@ SUMO_ATTR_Z
Definition: SUMOXMLDefinitions.h:601
SUMO_ATTR_EDGE
@ SUMO_ATTR_EDGE
Definition: SUMOXMLDefinitions.h:605
SUMO_ATTR_JAM_DIST_THRESHOLD
@ SUMO_ATTR_JAM_DIST_THRESHOLD
Definition: SUMOXMLDefinitions.h:1216
SUMO_ATTR_CHARGETYPE
@ SUMO_ATTR_CHARGETYPE
Charge type (fuel or electric)
Definition: SUMOXMLDefinitions.h:782
SUMO_ATTR_PARKING_LENGTH
@ SUMO_ATTR_PARKING_LENGTH
Definition: SUMOXMLDefinitions.h:1078
SUMO_ATTR_ENDPOS
@ SUMO_ATTR_ENDPOS
Definition: SUMOXMLDefinitions.h:1277
SUMO_ATTR_VOLTAGE
@ SUMO_ATTR_VOLTAGE
voltage of the traction substation [V]
Definition: SUMOXMLDefinitions.h:744
SUMO_ATTR_X
@ SUMO_ATTR_X
Definition: SUMOXMLDefinitions.h:599
SUMO_ATTR_BEGIN
@ SUMO_ATTR_BEGIN
weights: time range begin
Definition: SUMOXMLDefinitions.h:1107
SUMO_ATTR_EDGES
@ SUMO_ATTR_EDGES
the edges of a route
Definition: SUMOXMLDefinitions.h:685
SUMO_ATTR_OFF
@ SUMO_ATTR_OFF
Definition: SUMOXMLDefinitions.h:1229
SUMO_ATTR_ROUTEPROBE
@ SUMO_ATTR_ROUTEPROBE
Definition: SUMOXMLDefinitions.h:1097
SUMO_ATTR_LINEWIDTH
@ SUMO_ATTR_LINEWIDTH
Definition: SUMOXMLDefinitions.h:1154
SUMO_ATTR_POSITION_LAT
@ SUMO_ATTR_POSITION_LAT
Definition: SUMOXMLDefinitions.h:617
SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN
@ SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN
forbidden lanes for overhead wire segment
Definition: SUMOXMLDefinitions.h:754
SUMO_ATTR_HALTING_TIME_THRESHOLD
@ SUMO_ATTR_HALTING_TIME_THRESHOLD
Definition: SUMOXMLDefinitions.h:1214
SUMO_ATTR_GEO
@ SUMO_ATTR_GEO
Definition: SUMOXMLDefinitions.h:1301
SUMO_ATTR_LANES
@ SUMO_ATTR_LANES
Definition: SUMOXMLDefinitions.h:1061
SUMO_ATTR_VTYPES
@ SUMO_ATTR_VTYPES
Definition: SUMOXMLDefinitions.h:1054
SUMO_ATTR_OVERHEAD_WIRECLAMP_END
@ SUMO_ATTR_OVERHEAD_WIRECLAMP_END
id of the overhead wire, to the end of which the overhead wire clamp is connected
Definition: SUMOXMLDefinitions.h:764
SUMO_ATTR_SHAPE
@ SUMO_ATTR_SHAPE
edge: the shape in xml-definition
Definition: SUMOXMLDefinitions.h:1121
SUMO_ATTR_DEPARTPOS
@ SUMO_ATTR_DEPARTPOS
Definition: SUMOXMLDefinitions.h:691
SUMO_ATTR_LEFTHAND
@ SUMO_ATTR_LEFTHAND
Definition: SUMOXMLDefinitions.h:1363
SUMO_ATTR_WEIGHT
@ SUMO_ATTR_WEIGHT
Definition: SUMOXMLDefinitions.h:680
SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART
@ SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART
id of the overhead wire lane, to the start of which the overhead wire clamp is connected
Definition: SUMOXMLDefinitions.h:766
SUMO_ATTR_CHARGEINTRANSIT
@ SUMO_ATTR_CHARGEINTRANSIT
Allow/disallow charge in transit in Charging Stations.
Definition: SUMOXMLDefinitions.h:778
SUMO_ATTR_OVERHEAD_WIRECLAMP_START
@ SUMO_ATTR_OVERHEAD_WIRECLAMP_START
id of the overhead wire, to the start of which the overhead wire clamp is connected
Definition: SUMOXMLDefinitions.h:762
SUMO_ATTR_CONTAINER_CAPACITY
@ SUMO_ATTR_CONTAINER_CAPACITY
Definition: SUMOXMLDefinitions.h:1077
SUMO_ATTR_FILL
@ SUMO_ATTR_FILL
Fill the polygon.
Definition: SUMOXMLDefinitions.h:1153
SUMO_ATTR_NAME
@ SUMO_ATTR_NAME
Definition: SUMOXMLDefinitions.h:641
SUMO_ATTR_PERIOD
@ SUMO_ATTR_PERIOD
Definition: SUMOXMLDefinitions.h:1070
SUMO_ATTR_LAYER
@ SUMO_ATTR_LAYER
A layer number.
Definition: SUMOXMLDefinitions.h:1151
SUMO_ATTR_SLOPE
@ SUMO_ATTR_SLOPE
Definition: SUMOXMLDefinitions.h:607
SUMO_ATTR_HALTING_SPEED_THRESHOLD
@ SUMO_ATTR_HALTING_SPEED_THRESHOLD
Definition: SUMOXMLDefinitions.h:1215
SUMO_ATTR_CENTER
@ SUMO_ATTR_CENTER
Definition: SUMOXMLDefinitions.h:658
SUMO_ATTR_ANGLE
@ SUMO_ATTR_ANGLE
Definition: SUMOXMLDefinitions.h:602
SUMO_ATTR_HEIGHT
@ SUMO_ATTR_HEIGHT
Definition: SUMOXMLDefinitions.h:1268
SUMO_ATTR_END
@ SUMO_ATTR_END
weights: time range end
Definition: SUMOXMLDefinitions.h:1109
SUMO_ATTR_ROADSIDE_CAPACITY
@ SUMO_ATTR_ROADSIDE_CAPACITY
Definition: SUMOXMLDefinitions.h:1238
SUMO_ATTR_CURRENTLIMIT
@ SUMO_ATTR_CURRENTLIMIT
current limit of the traction substation [A]
Definition: SUMOXMLDefinitions.h:748
SUMO_ATTR_TLID
@ SUMO_ATTR_TLID
link,node: the traffic light id responsible for this link
Definition: SUMOXMLDefinitions.h:1111
SUMO_ATTR_OPTIONAL
@ SUMO_ATTR_OPTIONAL
Definition: SUMOXMLDefinitions.h:1386
SUMO_ATTR_OUTPUT
@ SUMO_ATTR_OUTPUT
Definition: SUMOXMLDefinitions.h:1267
SUMO_ATTR_CHARGINGPOWER
@ SUMO_ATTR_CHARGINGPOWER
Definition: SUMOXMLDefinitions.h:774
SUMO_ATTR_PROB
@ SUMO_ATTR_PROB
Definition: SUMOXMLDefinitions.h:1048
SUMO_ATTR_FRIENDLY_POS
@ SUMO_ATTR_FRIENDLY_POS
Definition: SUMOXMLDefinitions.h:1230
SUMO_ATTR_ONROAD
@ SUMO_ATTR_ONROAD
Definition: SUMOXMLDefinitions.h:1240
SUMO_ATTR_LAT
@ SUMO_ATTR_LAT
Definition: SUMOXMLDefinitions.h:1299
SUMO_ATTR_TYPE
@ SUMO_ATTR_TYPE
Definition: SUMOXMLDefinitions.h:603
SUMO_ATTR_LENGTH
@ SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:654
SUMO_ATTR_COLOR
@ SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:1139
SUMO_ATTR_EFFICIENCY
@ SUMO_ATTR_EFFICIENCY
Eficiency of the charge in Charging Stations.
Definition: SUMOXMLDefinitions.h:776
SUMO_ATTR_ID
@ SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:639
SUMO_ATTR_VISIBLE
@ SUMO_ATTR_VISIBLE
Definition: SUMOXMLDefinitions.h:1380
SUMO_ATTR_IMGFILE
@ SUMO_ATTR_IMGFILE
Definition: SUMOXMLDefinitions.h:1271
SUMO_ATTR_WIDTH
@ SUMO_ATTR_WIDTH
Definition: SUMOXMLDefinitions.h:647
SUMO_ATTR_PERSON_CAPACITY
@ SUMO_ATTR_PERSON_CAPACITY
Definition: SUMOXMLDefinitions.h:1076
SUMO_ATTR_KEY
@ SUMO_ATTR_KEY
Definition: SUMOXMLDefinitions.h:666
SUMO_ATTR_POSITION
@ SUMO_ATTR_POSITION
Definition: SUMOXMLDefinitions.h:604
SUMO_ATTR_CHARGEDELAY
@ SUMO_ATTR_CHARGEDELAY
Delay in the charge of charging stations (different of waiting time)
Definition: SUMOXMLDefinitions.h:780
SUMO_ATTR_TIME
@ SUMO_ATTR_TIME
trigger: the time of the step
Definition: SUMOXMLDefinitions.h:1105
SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND
@ SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND
id of the overhead wire lane, to the end of which the overhead wire clamp is connected
Definition: SUMOXMLDefinitions.h:768
SUMO_ATTR_RELATIVEPATH
@ SUMO_ATTR_RELATIVEPATH
Definition: SUMOXMLDefinitions.h:1272
INVALID_DOUBLE
const double INVALID_DOUBLE
invalid double
Definition: StdDefs.h:64
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
AdditionalHandler::buildDestProbReroute
virtual void buildDestProbReroute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &newEdgeDestinationID, const double probability)=0
builds a dest prob reroute
AdditionalHandler::parseE1InstantAttributes
void parseE1InstantAttributes(const SUMOSAXAttributes &attrs)
parse E1 instant attributes
Definition: AdditionalHandler.cpp:1150
AdditionalHandler::parseCalibratorAttributes
void parseCalibratorAttributes(const SUMOSAXAttributes &attrs)
parse calibrator attributes
Definition: AdditionalHandler.cpp:1294
AdditionalHandler::buildMultiLaneDetectorE2
virtual void buildMultiLaneDetectorE2(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::vector< std::string > &lanes, const double pos, const double endPos, const SUMOTime period, const std::string &trafficLight, const std::string &filename, const std::vector< std::string > &vehicleTypes, const std::string &name, const SUMOTime timeThreshold, const double speedThreshold, const double jamThreshold, const bool friendlyPos, const Parameterised::Map &parameters)=0
Builds a multi-lane Area Detector (E2)
AdditionalHandler::parseChargingStationAttributes
void parseChargingStationAttributes(const SUMOSAXAttributes &attrs)
parse chargingStation attributes
Definition: AdditionalHandler.cpp:854
AdditionalHandler::buildRouteProbReroute
virtual void buildRouteProbReroute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &newRouteID, const double probability)=0
builds a route prob reroute
AdditionalHandler::buildVariableSpeedSign
virtual void buildVariableSpeedSign(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const Position &pos, const std::vector< std::string > &laneIDs, const std::string &name, const std::vector< std::string > &vTypes, const Parameterised::Map &parameters)=0
Builds a VariableSpeedSign (lane speed additional)
AdditionalHandler::buildTrainStop
virtual void buildTrainStop(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double startPos, const double endPos, const std::string &name, const std::vector< std::string > &lines, const int personCapacity, const double parkingLength, const RGBColor &color, const bool friendlyPosition, const Parameterised::Map &parameters)=0
Builds a train stop.
AdditionalHandler::parseSumoBaseObject
void parseSumoBaseObject(CommonXMLStructure::SumoBaseObject *obj)
parse SumoBaseObject (it's called recursivelly)
Definition: AdditionalHandler.cpp:246
AdditionalHandler::buildEdgeCalibrator
virtual void buildEdgeCalibrator(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &edgeID, const double pos, const std::string &name, const std::string &outfile, const SUMOTime period, const std::string &routeprobe, const double jamThreshold, const std::vector< std::string > &vTypes, const Parameterised::Map &parameters)=0
builds a microscopic calibrator over an edge
AdditionalHandler::buildRerouterInterval
virtual void buildRerouterInterval(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOTime begin, const SUMOTime end)=0
builds a rerouter interval
AdditionalHandler::buildParkingSpace
virtual void buildParkingSpace(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const double x, const double y, const double z, const std::string &name, const std::string &width, const std::string &length, const std::string &angle, const double slope, const Parameterised::Map &parameters)=0
Builds a Parking Space.
AdditionalHandler::parseRouteProbRerouteAttributes
void parseRouteProbRerouteAttributes(const SUMOSAXAttributes &attrs)
parse route prob reroute attributes
Definition: AdditionalHandler.cpp:1528
AdditionalHandler::buildRerouter
virtual void buildRerouter(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const Position &pos, const std::vector< std::string > &edgeIDs, const double prob, const std::string &name, const bool off, const bool optional, const SUMOTime timeThreshold, const std::vector< std::string > &vTypes, const Parameterised::Map &parameters)=0
builds a rerouter
AdditionalHandler::parseJpsWalkableAreaAttributes
void parseJpsWalkableAreaAttributes(const SUMOSAXAttributes &attrs)
parse juPedSim walkable area attributes
Definition: AdditionalHandler.cpp:1801
AdditionalHandler::parseCalibratorFlowAttributes
void parseCalibratorFlowAttributes(const SUMOSAXAttributes &attrs)
parse calibrator flow attributes
Definition: AdditionalHandler.cpp:1339
AdditionalHandler::buildSingleLaneDetectorE2
virtual void buildSingleLaneDetectorE2(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double pos, const double length, const SUMOTime period, const std::string &trafficLight, const std::string &filename, const std::vector< std::string > &vehicleTypes, const std::string &name, const SUMOTime timeThreshold, const double speedThreshold, const double jamThreshold, const bool friendlyPos, const Parameterised::Map &parameters)=0
Builds a single-lane Area Detector (E2)
AdditionalHandler::parseParkingAreaRerouteAttributes
void parseParkingAreaRerouteAttributes(const SUMOSAXAttributes &attrs)
parse parking area reroute attributes
Definition: AdditionalHandler.cpp:1501
AdditionalHandler::parseTAZAttributes
void parseTAZAttributes(const SUMOSAXAttributes &attrs)
parse TAZ attributes
Definition: AdditionalHandler.cpp:1179
AdditionalHandler::AdditionalHandler
AdditionalHandler()
Constructor.
Definition: AdditionalHandler.cpp:36
AdditionalHandler::buildPOILane
virtual void buildPOILane(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &type, const RGBColor &color, const std::string &laneID, const double posOverLane, const bool friendlyPosition, const double posLat, const std::string &icon, const double layer, const double angle, const std::string &imgFile, const bool relativePath, const double width, const double height, const std::string &name, const Parameterised::Map &parameters)=0
Builds a POI over lane using the given values.
AdditionalHandler::buildLaneCalibrator
virtual void buildLaneCalibrator(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double pos, const std::string &name, const std::string &outfile, const SUMOTime period, const std::string &routeprobe, const double jamThreshold, const std::vector< std::string > &vTypes, const Parameterised::Map &parameters)=0
builds a microscopic calibrator over a lane
AdditionalHandler::checkParent
void checkParent(const SumoXMLTag currentTag, const std::vector< SumoXMLTag > &parentTags, bool &ok)
check parents
Definition: AdditionalHandler.cpp:1877
AdditionalHandler::parseOverheadWire
void parseOverheadWire(const SUMOSAXAttributes &attrs)
parse overhead wire segment
Definition: AdditionalHandler.cpp:1625
AdditionalHandler::myCommonXMLStructure
CommonXMLStructure myCommonXMLStructure
common XML Structure
Definition: AdditionalHandler.h:615
AdditionalHandler::buildOverheadWireClamp
virtual void buildOverheadWireClamp(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &overheadWireIDStartClamp, const std::string &laneIDStartClamp, const std::string &overheadWireIDEndClamp, const std::string &laneIDEndClamp, const Parameterised::Map &parameters)=0
build overhead wire clamp
AdditionalHandler::parseTractionSubstation
void parseTractionSubstation(const SUMOSAXAttributes &attrs)
parse traction substation
Definition: AdditionalHandler.cpp:1602
AdditionalHandler::parseE3Attributes
void parseE3Attributes(const SUMOSAXAttributes &attrs)
parse E3 attributes
Definition: AdditionalHandler.cpp:1071
AdditionalHandler::parseE2Attributes
void parseE2Attributes(const SUMOSAXAttributes &attrs)
parse E2 attributes
Definition: AdditionalHandler.cpp:1011
AdditionalHandler::parseTAZSinkAttributes
void parseTAZSinkAttributes(const SUMOSAXAttributes &attrs)
parse TAZ sink attributes
Definition: AdditionalHandler.cpp:1228
AdditionalHandler::parseOverheadWireClamp
void parseOverheadWireClamp(const SUMOSAXAttributes &attrs)
parse overhead wire clamp
Definition: AdditionalHandler.cpp:1654
AdditionalHandler::writeError
void writeError(const std::string &error)
write error and enable error creating element
Definition: AdditionalHandler.cpp:717
AdditionalHandler::beginParseAttributes
bool beginParseAttributes(SumoXMLTag tag, const SUMOSAXAttributes &attrs)
begin parse attributes
Definition: AdditionalHandler.cpp:43
AdditionalHandler::parseTrainStopAttributes
void parseTrainStopAttributes(const SUMOSAXAttributes &attrs)
parse trainStop attributes
Definition: AdditionalHandler.cpp:759
AdditionalHandler::buildVariableSpeedSignStep
virtual void buildVariableSpeedSignStep(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOTime time, const std::string &speed)=0
Builds a VariableSpeedSign Step.
AdditionalHandler::buildDetectorE3
virtual void buildDetectorE3(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const Position &pos, const SUMOTime period, const std::string &filename, const std::vector< std::string > &vehicleTypes, const std::string &name, const SUMOTime timeThreshold, const double speedThreshold, const bool expectedArrival, const Parameterised::Map &parameters)=0
Builds a multi entry exit detector (E3)
AdditionalHandler::buildDetectorEntry
virtual void buildDetectorEntry(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &laneID, const double pos, const bool friendlyPos, const Parameterised::Map &parameters)=0
Builds a entry detector (E3)
AdditionalHandler::parsePOIAttributes
void parsePOIAttributes(const SUMOSAXAttributes &attrs)
parse POI attributes
Definition: AdditionalHandler.cpp:1719
AdditionalHandler::myErrorCreatingElement
bool myErrorCreatingElement
flag for check if a element wasn't created
Definition: AdditionalHandler.h:618
AdditionalHandler::endParseAttributes
void endParseAttributes()
end parse attributes
Definition: AdditionalHandler.cpp:190
AdditionalHandler::buildE1Detector
virtual void buildE1Detector(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double position, const SUMOTime period, const std::string &file, const std::vector< std::string > &vehicleTypes, const std::string &name, const bool friendlyPos, const Parameterised::Map &parameters)=0
Builds a induction loop detector (E1)
AdditionalHandler::buildJpsObstacle
virtual void buildJpsObstacle(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const PositionVector &shape, bool geo, const std::string &name, const Parameterised::Map &parameters)=0
Builds a JuPedSim obstacle using the given values.
AdditionalHandler::buildPOIGeo
virtual void buildPOIGeo(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &type, const RGBColor &color, const double lon, const double lat, const std::string &icon, const double layer, const double angle, const std::string &imgFile, bool relativePath, const double width, const double height, const std::string &name, const Parameterised::Map &parameters)=0
Builds a POI in GEO coordinaten using the given values.
AdditionalHandler::buildJpsWalkableArea
virtual void buildJpsWalkableArea(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const PositionVector &shape, bool geo, const std::string &name, const Parameterised::Map &parameters)=0
Builds a JuPedSim walkable area using the given values.
AdditionalHandler::parseJpsObstacleAttributes
void parseJpsObstacleAttributes(const SUMOSAXAttributes &attrs)
parse juPedSim obstacle attributes
Definition: AdditionalHandler.cpp:1822
AdditionalHandler::buildChargingStation
virtual void buildChargingStation(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double startPos, const double endPos, const std::string &name, const double chargingPower, const double efficiency, const bool chargeInTransit, const SUMOTime chargeDelay, const std::string &chargeType, const SUMOTime waitingTime, const bool friendlyPosition, const std::string &parkingAreaID, const Parameterised::Map &parameters)=0
Builds a charging Station.
AdditionalHandler::parseVariableSpeedSignAttributes
void parseVariableSpeedSignAttributes(const SUMOSAXAttributes &attrs)
parse variable speed sign attributes
Definition: AdditionalHandler.cpp:1248
AdditionalHandler::~AdditionalHandler
virtual ~AdditionalHandler()
Destructor.
Definition: AdditionalHandler.cpp:39
AdditionalHandler::buildParkingArea
virtual void buildParkingArea(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double startPos, const double endPos, const std::string &departPos, const std::string &name, const std::vector< std::string > &lines, const bool friendlyPosition, const int roadSideCapacity, const bool onRoad, const double width, const double length, const double angle, const bool lefthand, const Parameterised::Map &parameters)=0
Builds a Parking Area.
AdditionalHandler::buildTAZ
virtual void buildTAZ(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const PositionVector &shape, const Position &center, const bool fill, const RGBColor &color, const std::vector< std::string > &edgeIDs, const std::string &name, const Parameterised::Map &parameters)=0
Builds a TAZ (Traffic Assignment Zone)
AdditionalHandler::buildPOI
virtual void buildPOI(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &type, const RGBColor &color, const double x, const double y, const std::string &icon, const double layer, const double angle, const std::string &imgFile, bool relativePath, const double width, const double height, const std::string &name, const Parameterised::Map &parameters)=0
Builds a POI using the given values.
AdditionalHandler::parseDestProbRerouteAttributes
void parseDestProbRerouteAttributes(const SUMOSAXAttributes &attrs)
parse dest prob reroute attributes
Definition: AdditionalHandler.cpp:1477
AdditionalHandler::buildCalibratorFlow
virtual void buildCalibratorFlow(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameter)=0
builds a calibrator flow
AdditionalHandler::parseE1Attributes
void parseE1Attributes(const SUMOSAXAttributes &attrs)
parse E1 attributes
Definition: AdditionalHandler.cpp:980
AdditionalHandler::buildOverheadWire
virtual void buildOverheadWire(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &substationId, const std::vector< std::string > &laneIDs, const double startPos, const double endPos, const bool friendlyPos, const std::vector< std::string > &forbiddenInnerLanes, const Parameterised::Map &parameters)=0
build overhead wire
AdditionalHandler::parseVariableSpeedSignStepAttributes
void parseVariableSpeedSignStepAttributes(const SUMOSAXAttributes &attrs)
parse variable speed sign step attributes
Definition: AdditionalHandler.cpp:1273
AdditionalHandler::parseParameters
void parseParameters(const SUMOSAXAttributes &attrs)
parse generic parameters
Definition: AdditionalHandler.cpp:1843
AdditionalHandler::parseParkingSpaceAttributes
void parseParkingSpaceAttributes(const SUMOSAXAttributes &attrs)
parse parking space attributes
Definition: AdditionalHandler.cpp:947
AdditionalHandler::parseExitAttributes
void parseExitAttributes(const SUMOSAXAttributes &attrs)
parse exist attributes
Definition: AdditionalHandler.cpp:1127
AdditionalHandler::buildClosingLaneReroute
virtual void buildClosingLaneReroute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &closedLane, SVCPermissions permissions)=0
builds a closing lane reroute
AdditionalHandler::buildTAZSink
virtual void buildTAZSink(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &edgeID, const double arrivalWeight)=0
Builds a TAZSink (Traffic Assignment Zone)
AdditionalHandler::parseRerouterAttributes
void parseRerouterAttributes(const SUMOSAXAttributes &attrs)
parse rerouter attributes
Definition: AdditionalHandler.cpp:1378
AdditionalHandler::parseBusStopAttributes
void parseBusStopAttributes(const SUMOSAXAttributes &attrs)
Definition: AdditionalHandler.cpp:724
AdditionalHandler::buildClosingReroute
virtual void buildClosingReroute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &closedEdgeID, SVCPermissions permissions)=0
builds a closing edge reroute
AdditionalHandler::parseContainerStopAttributes
void parseContainerStopAttributes(const SUMOSAXAttributes &attrs)
parse containerStop attributes
Definition: AdditionalHandler.cpp:819
AdditionalHandler::parseParkingAreaAttributes
void parseParkingAreaAttributes(const SUMOSAXAttributes &attrs)
parse parking area attributes
Definition: AdditionalHandler.cpp:903
AdditionalHandler::buildDetectorE1Instant
virtual void buildDetectorE1Instant(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double pos, const std::string &filename, const std::vector< std::string > &vehicleTypes, const std::string &name, const bool friendlyPos, const Parameterised::Map &parameters)=0
Builds a Instant Induction Loop Detector (E1Instant)
AdditionalHandler::buildVaporizer
virtual void buildVaporizer(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &edgeID, const SUMOTime from, const SUMOTime endTime, const std::string &name, const Parameterised::Map &parameters)=0
Builds a vaporizer (lane speed additional)
AdditionalHandler::buildDetectorExit
virtual void buildDetectorExit(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &laneID, const double pos, const bool friendlyPos, const Parameterised::Map &parameters)=0
Builds a exit detector (E3)
AdditionalHandler::buildContainerStop
virtual void buildContainerStop(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double startPos, const double endPos, const std::string &name, const std::vector< std::string > &lines, const int containerCapacity, const double parkingLength, const RGBColor &color, const bool friendlyPosition, const Parameterised::Map &parameters)=0
Builds a container stop.
AdditionalHandler::buildTractionSubstation
virtual void buildTractionSubstation(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const Position &pos, const double voltage, const double currentLimit, const Parameterised::Map &parameters)=0
build traction substation
AdditionalHandler::buildBusStop
virtual void buildBusStop(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &laneID, const double startPos, const double endPos, const std::string &name, const std::vector< std::string > &lines, const int personCapacity, const double parkingLength, const RGBColor &color, const bool friendlyPosition, const Parameterised::Map &parameters)=0
Builds a bus stop.
AdditionalHandler::buildAccess
virtual void buildAccess(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &laneID, const std::string &pos, const double length, const bool friendlyPos, const Parameterised::Map &parameters)=0
Builds an Access.
AdditionalHandler::parseRouteProbeAttributes
void parseRouteProbeAttributes(const SUMOSAXAttributes &attrs)
parse route probe attributes
Definition: AdditionalHandler.cpp:1552
AdditionalHandler::parseAccessAttributes
void parseAccessAttributes(const SUMOSAXAttributes &attrs)
parse access attributes
Definition: AdditionalHandler.cpp:794
AdditionalHandler::parseTAZSourceAttributes
void parseTAZSourceAttributes(const SUMOSAXAttributes &attrs)
parse TAZ source attributes
Definition: AdditionalHandler.cpp:1208
AdditionalHandler::parseVaporizerAttributes
void parseVaporizerAttributes(const SUMOSAXAttributes &attrs)
parse vaporizer attributes
Definition: AdditionalHandler.cpp:1579
AdditionalHandler::buildParkingAreaReroute
virtual void buildParkingAreaReroute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &newParkignAreaID, const double probability, const bool visible)=0
builds a parking area reroute
AdditionalHandler::buildRouteProbe
virtual void buildRouteProbe(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &edgeID, const SUMOTime period, const std::string &name, const std::string &file, const SUMOTime begin, const Parameterised::Map &parameters)=0
builds a Route probe
AdditionalHandler::parseClosingLaneRerouteAttributes
void parseClosingLaneRerouteAttributes(const SUMOSAXAttributes &attrs)
parse closing lane reroute attributes
Definition: AdditionalHandler.cpp:1431
AdditionalHandler::parseRerouterIntervalAttributes
void parseRerouterIntervalAttributes(const SUMOSAXAttributes &attrs)
parse rerouter interval attributes
Definition: AdditionalHandler.cpp:1411
AdditionalHandler::isErrorCreatingElement
bool isErrorCreatingElement() const
get flag for check if a element wasn't created
Definition: AdditionalHandler.cpp:711
AdditionalHandler::parseEntryAttributes
void parseEntryAttributes(const SUMOSAXAttributes &attrs)
parse entry attributes
Definition: AdditionalHandler.cpp:1104
AdditionalHandler::buildTAZSource
virtual void buildTAZSource(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &edgeID, const double departWeight)=0
Builds a TAZSource (Traffic Assignment Zone)
AdditionalHandler::parsePolyAttributes
void parsePolyAttributes(const SUMOSAXAttributes &attrs)
Definition: AdditionalHandler.cpp:1680
AdditionalHandler::parseClosingRerouteAttributes
void parseClosingRerouteAttributes(const SUMOSAXAttributes &attrs)
parse closing reroute attributes
Definition: AdditionalHandler.cpp:1454
AdditionalHandler::buildPolygon
virtual void buildPolygon(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::string &type, const RGBColor &color, const double layer, const double angle, const std::string &imgFile, const bool relativePath, const PositionVector &shape, const bool geo, const bool fill, const double lineWidth, const std::string &name, const Parameterised::Map &parameters)=0
Builds a polygon using the given values.
CommonXMLStructure::SumoBaseObject::addIntAttribute
void addIntAttribute(const SumoXMLAttr attr, const int value)
add int attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:391
CommonXMLStructure::SumoBaseObject::getColorAttribute
const RGBColor & getColorAttribute(const SumoXMLAttr attr) const
get color attribute
Definition: CommonXMLStructure.cpp:232
CommonXMLStructure::SumoBaseObject::getTimeAttribute
SUMOTime getTimeAttribute(const SumoXMLAttr attr) const
get time attribute
Definition: CommonXMLStructure.cpp:204
CommonXMLStructure::SumoBaseObject::getPositionVectorAttribute
const PositionVector & getPositionVectorAttribute(const SumoXMLAttr attr) const
get PositionVector attribute
Definition: CommonXMLStructure.cpp:265
CommonXMLStructure::SumoBaseObject::hasStringAttribute
bool hasStringAttribute(const SumoXMLAttr attr) const
has function
Definition: CommonXMLStructure.cpp:325
CommonXMLStructure::SumoBaseObject::setTag
void setTag(const SumoXMLTag tag)
set SumoBaseObject tag
Definition: CommonXMLStructure.cpp:94
CommonXMLStructure::SumoBaseObject::getParentSumoBaseObject
SumoBaseObject * getParentSumoBaseObject() const
get pointer to mySumoBaseObjectParent SumoBaseObject (if is null, then is the root)
Definition: CommonXMLStructure.cpp:106
CommonXMLStructure::SumoBaseObject::getPositionAttribute
const Position & getPositionAttribute(const SumoXMLAttr attr) const
get Position attribute
Definition: CommonXMLStructure.cpp:193
CommonXMLStructure::SumoBaseObject::addPositionVectorAttribute
void addPositionVectorAttribute(const SumoXMLAttr attr, const PositionVector &value)
add PositionVector attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:439
CommonXMLStructure::SumoBaseObject::getParameters
const std::map< std::string, std::string > & getParameters() const
get parameters
Definition: CommonXMLStructure.cpp:313
CommonXMLStructure::SumoBaseObject::addBoolAttribute
void addBoolAttribute(const SumoXMLAttr attr, const bool value)
add bool attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:403
CommonXMLStructure::SumoBaseObject::getTag
SumoXMLTag getTag() const
get XML myTag
Definition: CommonXMLStructure.cpp:100
CommonXMLStructure::SumoBaseObject::addTimeAttribute
void addTimeAttribute(const SumoXMLAttr attr, const SUMOTime value)
add time attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:415
CommonXMLStructure::SumoBaseObject::addStringListAttribute
void addStringListAttribute(const SumoXMLAttr attr, const std::vector< std::string > &value)
add string list attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:427
CommonXMLStructure::SumoBaseObject::getIntAttribute
int getIntAttribute(const SumoXMLAttr attr) const
get int attribute
Definition: CommonXMLStructure.cpp:160
CommonXMLStructure::SumoBaseObject::addDoubleAttribute
void addDoubleAttribute(const SumoXMLAttr attr, const double value)
add double attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:397
CommonXMLStructure::SumoBaseObject::hasDoubleAttribute
bool hasDoubleAttribute(const SumoXMLAttr attr) const
check if current SumoBaseObject has the given double attribute
Definition: CommonXMLStructure.cpp:337
CommonXMLStructure::SumoBaseObject::addPositionAttribute
void addPositionAttribute(const SumoXMLAttr attr, const Position &value)
add Position attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:409
CommonXMLStructure::SumoBaseObject::getBoolAttribute
bool getBoolAttribute(const SumoXMLAttr attr) const
get bool attribute
Definition: CommonXMLStructure.cpp:182
CommonXMLStructure::SumoBaseObject::getPeriodAttribute
SUMOTime getPeriodAttribute() const
get 'period' attribute
Definition: CommonXMLStructure.cpp:215
CommonXMLStructure::SumoBaseObject::setVehicleParameter
void setVehicleParameter(const SUMOVehicleParameter *vehicleParameter)
set vehicle parameters
Definition: CommonXMLStructure.cpp:460
CommonXMLStructure::SumoBaseObject::addStringAttribute
void addStringAttribute(const SumoXMLAttr attr, const std::string &value)
add string attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:385
CommonXMLStructure::SumoBaseObject::getDoubleAttribute
double getDoubleAttribute(const SumoXMLAttr attr) const
get double attribute
Definition: CommonXMLStructure.cpp:171
CommonXMLStructure::SumoBaseObject::getVehicleParameter
const SUMOVehicleParameter & getVehicleParameter() const
get vehicle parameters
Definition: CommonXMLStructure.cpp:292
CommonXMLStructure::SumoBaseObject::getStringListAttribute
const std::vector< std::string > & getStringListAttribute(const SumoXMLAttr attr) const
get string list attribute
Definition: CommonXMLStructure.cpp:243
CommonXMLStructure::SumoBaseObject::addColorAttribute
void addColorAttribute(const SumoXMLAttr attr, const RGBColor &value)
add color attribute into current SumoBaseObject node
Definition: CommonXMLStructure.cpp:421
CommonXMLStructure::SumoBaseObject::getStringAttribute
const std::string & getStringAttribute(const SumoXMLAttr attr) const
get string attribute
Definition: CommonXMLStructure.cpp:149
CommonXMLStructure::SumoBaseObject::getSumoBaseObjectChildren
const std::vector< SumoBaseObject * > & getSumoBaseObjectChildren() const
get SumoBaseObject children
Definition: CommonXMLStructure.cpp:319
CommonXMLStructure::getCurrentSumoBaseObject
CommonXMLStructure::SumoBaseObject * getCurrentSumoBaseObject() const
get current editedSumoBaseObject
Definition: CommonXMLStructure.cpp:605
CommonXMLStructure::openSUMOBaseOBject
void openSUMOBaseOBject()
open SUMOBaseOBject
Definition: CommonXMLStructure.cpp:563
CommonXMLStructure::closeSUMOBaseOBject
void closeSUMOBaseOBject()
close myTag
Definition: CommonXMLStructure.cpp:582
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
Position::INVALID
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:317
PositionVector
A list of positions.
Definition: PositionVector.h:43
RGBColor::INVISIBLE
static const RGBColor INVISIBLE
Definition: RGBColor.h:195
RGBColor::RED
static const RGBColor RED
named colors
Definition: RGBColor.h:185
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:56
SUMOSAXAttributes::getString
virtual std::string getString(int id, bool *isPresent=nullptr) const =0
Returns the string-value of the named (by its enum-value) attribute.
SUMOSAXAttributes::getOptPeriod
SUMOTime getOptPeriod(const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read the SUMOTime 'period' attribute.
Definition: SUMOSAXAttributes.cpp:147
SUMOSAXAttributes::getOpt
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.
Definition: SUMOSAXAttributes.h:459
SUMOSAXAttributes::getOptSUMOTimeReporting
SUMOTime getOptSUMOTimeReporting(int attr, const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
Definition: SUMOSAXAttributes.cpp:123
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:433
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.
SUMOSAXAttributes::getSUMOTimeReporting
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
Definition: SUMOSAXAttributes.cpp:60
SUMOVehicleParameter
Structure representing possible vehicle parameter.
Definition: SUMOVehicleParameter.h:332
SUMOVehicleParameter::parametersSet
int parametersSet
Information for the router which parameter were set, TraCI may modify this (when changing color)
Definition: SUMOVehicleParameter.h:806
SUMOVehicleParameter::repetitionOffset
SUMOTime repetitionOffset
The time offset between vehicle reinsertions.
Definition: SUMOVehicleParameter.h:756
SUMOVehicleParameter::repetitionEnd
SUMOTime repetitionEnd
The time at which the flow ends (only needed when using repetitionProbability)
Definition: SUMOVehicleParameter.h:768
SUMOVehicleParameter::calibratorSpeed
double calibratorSpeed
speed (used by calibrator flows
Definition: SUMOVehicleParameter.h:800
SUMOVehicleParserHelper::parseVehicleAttributes
static SUMOVehicleParameter * parseVehicleAttributes(int element, const SUMOSAXAttributes &attrs, const bool hardFail, const bool optionalID=false, const bool skipDepart=false, const bool allowInternalRoutes=false)
Parses a vehicle's attributes.
Definition: SUMOVehicleParserHelper.cpp:333
SUMOXMLDefinitions::POIIcons
static StringBijection< POIIcon > POIIcons
POI icon values.
Definition: SUMOXMLDefinitions.h:2009
SUMOXMLDefinitions::isValidParameterKey
static bool isValidParameterKey(const std::string &value)
whether the given string is a valid key for a parameter
Definition: SUMOXMLDefinitions.cpp:1515
Shape::DEFAULT_RELATIVEPATH
static const bool DEFAULT_RELATIVEPATH
Definition: Shape.h:48
Shape::DEFAULT_LAYER
static const double DEFAULT_LAYER
Definition: Shape.h:43
Shape::DEFAULT_LAYER_POI
static const double DEFAULT_LAYER_POI
Definition: Shape.h:45
Shape::DEFAULT_IMG_WIDTH
static const double DEFAULT_IMG_WIDTH
Definition: Shape.h:49
Shape::DEFAULT_IMG_FILE
static const std::string DEFAULT_IMG_FILE
Definition: Shape.h:47
Shape::DEFAULT_LINEWIDTH
static const double DEFAULT_LINEWIDTH
Definition: Shape.h:44
Shape::DEFAULT_ANGLE
static const double DEFAULT_ANGLE
Definition: Shape.h:46
Shape::DEFAULT_IMG_HEIGHT
static const double DEFAULT_IMG_HEIGHT
Definition: Shape.h:50
Shape::DEFAULT_TYPE
static const std::string DEFAULT_TYPE
Definition: Shape.h:42
StringBijection::getString
const std::string & getString(const T key) const
Definition: StringBijection.h:104