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