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