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