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