Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2025 German Aerospace Center (DLR) and others.
4 : // This program and the accompanying materials are made available under the
5 : // terms of the Eclipse Public License 2.0 which is available at
6 : // https://www.eclipse.org/legal/epl-2.0/
7 : // This Source Code may also be made available under the following Secondary
8 : // Licenses when the conditions for such availability set forth in the Eclipse
9 : // Public License 2.0 are satisfied: GNU General Public License, version 2
10 : // or later which is available at
11 : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 : /****************************************************************************/
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(const std::string& filename) :
38 0 : CommonHandler(filename) {
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 0 : obj->getParameters())) {
712 0 : obj->markAsCreated();
713 : }
714 : break;
715 : // POI
716 0 : case SUMO_TAG_POI:
717 : // check if we want to create a POI, POILane or POIGEO
718 0 : if (obj->hasDoubleAttribute(SUMO_ATTR_X)) {
719 : // build POI over view
720 0 : if (buildPOI(obj,
721 : obj->getStringAttribute(SUMO_ATTR_ID),
722 : obj->getStringAttribute(SUMO_ATTR_TYPE),
723 : obj->getColorAttribute(SUMO_ATTR_COLOR),
724 : obj->getDoubleAttribute(SUMO_ATTR_X),
725 : obj->getDoubleAttribute(SUMO_ATTR_Y),
726 : obj->getStringAttribute(SUMO_ATTR_ICON),
727 : obj->getDoubleAttribute(SUMO_ATTR_LAYER),
728 : obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
729 : obj->getStringAttribute(SUMO_ATTR_IMGFILE),
730 : obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
731 : obj->getDoubleAttribute(SUMO_ATTR_HEIGHT),
732 : obj->getStringAttribute(SUMO_ATTR_NAME),
733 0 : obj->getParameters())) {
734 0 : obj->markAsCreated();
735 : }
736 0 : } else if (obj->hasStringAttribute(SUMO_ATTR_LANE)) {
737 : // build POI over Lane
738 0 : if (buildPOILane(obj,
739 : obj->getStringAttribute(SUMO_ATTR_ID),
740 : obj->getStringAttribute(SUMO_ATTR_TYPE),
741 : obj->getColorAttribute(SUMO_ATTR_COLOR),
742 : obj->getStringAttribute(SUMO_ATTR_LANE),
743 : obj->getDoubleAttribute(SUMO_ATTR_POSITION),
744 0 : obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
745 : obj->getDoubleAttribute(SUMO_ATTR_POSITION_LAT),
746 : obj->getStringAttribute(SUMO_ATTR_ICON),
747 : obj->getDoubleAttribute(SUMO_ATTR_LAYER),
748 : obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
749 : obj->getStringAttribute(SUMO_ATTR_IMGFILE),
750 : obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
751 : obj->getDoubleAttribute(SUMO_ATTR_HEIGHT),
752 : obj->getStringAttribute(SUMO_ATTR_NAME),
753 0 : obj->getParameters())) {
754 0 : obj->markAsCreated();
755 : }
756 : } else {
757 : // build POIGEO over view
758 0 : if (buildPOIGeo(obj,
759 : obj->getStringAttribute(SUMO_ATTR_ID),
760 : obj->getStringAttribute(SUMO_ATTR_TYPE),
761 : obj->getColorAttribute(SUMO_ATTR_COLOR),
762 : obj->getDoubleAttribute(SUMO_ATTR_LON),
763 : obj->getDoubleAttribute(SUMO_ATTR_LAT),
764 : obj->getStringAttribute(SUMO_ATTR_ICON),
765 : obj->getDoubleAttribute(SUMO_ATTR_LAYER),
766 : obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
767 : obj->getStringAttribute(SUMO_ATTR_IMGFILE),
768 : obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
769 : obj->getDoubleAttribute(SUMO_ATTR_HEIGHT),
770 : obj->getStringAttribute(SUMO_ATTR_NAME),
771 0 : obj->getParameters())) {
772 0 : obj->markAsCreated();
773 : }
774 : }
775 : break;
776 : // Jps WalkableArea
777 0 : case GNE_TAG_JPS_WALKABLEAREA:
778 0 : if (buildJpsWalkableArea(obj,
779 : obj->getStringAttribute(SUMO_ATTR_ID),
780 : obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
781 0 : obj->getBoolAttribute(SUMO_ATTR_GEO),
782 : obj->getStringAttribute(SUMO_ATTR_NAME),
783 0 : obj->getParameters())) {
784 0 : obj->markAsCreated();
785 : }
786 : break;
787 : // Jps Obstacle
788 0 : case GNE_TAG_JPS_OBSTACLE:
789 0 : if (buildJpsObstacle(obj,
790 : obj->getStringAttribute(SUMO_ATTR_ID),
791 : obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
792 0 : obj->getBoolAttribute(SUMO_ATTR_GEO),
793 : obj->getStringAttribute(SUMO_ATTR_NAME),
794 0 : obj->getParameters())) {
795 0 : obj->markAsCreated();
796 : }
797 : break;
798 : default:
799 : break;
800 : }
801 : // now iterate over childrens
802 0 : for (const auto& child : obj->getSumoBaseObjectChildren()) {
803 : // call this function recursively
804 0 : parseSumoBaseObject(child);
805 : }
806 : }
807 0 : }
808 :
809 :
810 : void
811 0 : AdditionalHandler::parseBusStopAttributes(const SUMOSAXAttributes& attrs) {
812 : // declare Ok Flag
813 0 : bool parsedOk = true;
814 : // needed attributes
815 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
816 0 : const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
817 : // optional attributes
818 0 : const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
819 0 : const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
820 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
821 0 : const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
822 0 : const int personCapacity = attrs.getOpt<int>(SUMO_ATTR_PERSON_CAPACITY, id.c_str(), parsedOk, 6);
823 0 : const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), parsedOk, 0);
824 0 : const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
825 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
826 0 : const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, 0);
827 : // continue if flag is ok
828 0 : if (parsedOk) {
829 : // set tag
830 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_BUS_STOP);
831 : // add all attributes
832 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
833 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
834 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
835 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
836 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
837 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
838 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_PERSON_CAPACITY, personCapacity);
839 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PARKING_LENGTH, parkingLength);
840 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
841 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
842 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
843 : } else {
844 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
845 : }
846 0 : }
847 :
848 :
849 : void
850 0 : AdditionalHandler::parseTrainStopAttributes(const SUMOSAXAttributes& attrs) {
851 : // declare Ok Flag
852 0 : bool parsedOk = true;
853 : // needed attributes
854 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
855 0 : const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
856 : // optional attributes
857 0 : const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
858 0 : const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
859 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
860 0 : const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
861 0 : const int personCapacity = attrs.getOpt<int>(SUMO_ATTR_PERSON_CAPACITY, id.c_str(), parsedOk, 6);
862 0 : const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), parsedOk, 0);
863 0 : const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
864 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
865 0 : const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, 0);
866 : // continue if flag is ok
867 0 : if (parsedOk) {
868 : // set tag
869 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TRAIN_STOP);
870 : // add all attributes
871 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
872 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
873 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
874 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
875 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
876 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
877 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_PERSON_CAPACITY, personCapacity);
878 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PARKING_LENGTH, parkingLength);
879 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
880 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
881 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
882 : } else {
883 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
884 : }
885 0 : }
886 :
887 :
888 : void
889 0 : AdditionalHandler::parseAccessAttributes(const SUMOSAXAttributes& attrs) {
890 : // declare Ok Flag
891 0 : bool parsedOk = true;
892 : // needed attributes
893 0 : const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, "", parsedOk);
894 0 : const std::string position = attrs.get<std::string>(SUMO_ATTR_POSITION, "", parsedOk);
895 : // optional attributes
896 0 : const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, "", parsedOk, -1.00, false); /* in future updates, INVALID_DOUBLE */
897 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "", parsedOk, false);
898 : // check parent
899 0 : checkParsedParent(SUMO_TAG_ACCESS, {SUMO_TAG_BUS_STOP, SUMO_TAG_TRAIN_STOP, SUMO_TAG_CONTAINER_STOP}, parsedOk);
900 : // continue if flag is ok
901 0 : if (parsedOk) {
902 : // set tag
903 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ACCESS);
904 : // add all attributes
905 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
906 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_POSITION, position);
907 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
908 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
909 : } else {
910 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
911 : }
912 0 : }
913 :
914 :
915 : void
916 0 : AdditionalHandler::parseContainerStopAttributes(const SUMOSAXAttributes& attrs) {
917 : // declare Ok Flag
918 0 : bool parsedOk = true;
919 : // needed attributes
920 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
921 0 : const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
922 : // optional attributes
923 0 : const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
924 0 : const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
925 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
926 0 : const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
927 0 : const int containerCapacity = attrs.getOpt<int>(SUMO_ATTR_CONTAINER_CAPACITY, id.c_str(), parsedOk, 6);
928 0 : const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), parsedOk, 0);
929 0 : const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
930 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
931 0 : const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, 0);
932 : // continue if flag is ok
933 0 : if (parsedOk) {
934 : // set tag
935 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CONTAINER_STOP);
936 : // add all attributes
937 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
938 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
939 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
940 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
941 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
942 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
943 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_CONTAINER_CAPACITY, containerCapacity);
944 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PARKING_LENGTH, parkingLength);
945 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
946 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
947 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
948 : } else {
949 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
950 : }
951 0 : }
952 :
953 :
954 : void
955 0 : AdditionalHandler::parseChargingStationAttributes(const SUMOSAXAttributes& attrs) {
956 : // declare Ok Flag
957 0 : bool parsedOk = true;
958 : // needed attributes
959 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
960 0 : const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
961 : // optional attributes
962 0 : const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
963 0 : const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
964 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
965 0 : const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
966 0 : const double chargingPower = attrs.getOpt<double>(SUMO_ATTR_CHARGINGPOWER, id.c_str(), parsedOk, 22000);
967 0 : const double totalPower = attrs.getOpt<double>(SUMO_ATTR_TOTALPOWER, id.c_str(), parsedOk, 0);
968 0 : const double efficiency = attrs.getOpt<double>(SUMO_ATTR_EFFICIENCY, id.c_str(), parsedOk, 0.95);
969 0 : const bool chargeInTransit = attrs.getOpt<bool>(SUMO_ATTR_CHARGEINTRANSIT, id.c_str(), parsedOk, 0);
970 0 : const SUMOTime chargeDelay = attrs.getOptSUMOTimeReporting(SUMO_ATTR_CHARGEDELAY, id.c_str(), parsedOk, 0);
971 0 : const std::string chargeType = attrs.getOpt<std::string>(SUMO_ATTR_CHARGETYPE, id.c_str(), parsedOk, SUMOXMLDefinitions::ChargeTypes.getString(ChargeType::NORMAL));
972 0 : const SUMOTime waitingTime = attrs.getOptSUMOTimeReporting(SUMO_ATTR_WAITINGTIME, id.c_str(), parsedOk, TIME2STEPS(900));
973 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
974 0 : const std::string parkingAreaID = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, id.c_str(), parsedOk, "");
975 : // check charge type
976 0 : if ((chargeType != "normal") && (chargeType != "battery-exchange") && (chargeType != "fuel")) {
977 0 : writeError(TLF("Invalid charge type '%' defined in chargingStation '%'.", chargeType, id));
978 0 : parsedOk = false;
979 : }
980 : // continue if flag is ok
981 0 : if (parsedOk) {
982 : // set tag
983 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CHARGING_STATION);
984 : // add all attributes
985 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
986 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
987 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
988 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
989 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
990 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
991 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_CHARGINGPOWER, chargingPower);
992 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_TOTALPOWER, totalPower);
993 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_EFFICIENCY, efficiency);
994 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_CHARGEINTRANSIT, chargeInTransit);
995 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_CHARGEDELAY, chargeDelay);
996 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_CHARGETYPE, chargeType);
997 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_WAITINGTIME, waitingTime);
998 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
999 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_PARKING_AREA, parkingAreaID);
1000 : } else {
1001 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1002 : }
1003 0 : }
1004 :
1005 :
1006 : void
1007 0 : AdditionalHandler::parseParkingAreaAttributes(const SUMOSAXAttributes& attrs) {
1008 : // declare Ok Flag
1009 0 : bool parsedOk = true;
1010 : // needed attributes
1011 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1012 0 : const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
1013 : // optional attributes
1014 0 : const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
1015 0 : const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
1016 0 : const std::string departPos = attrs.getOpt<std::string>(SUMO_ATTR_DEPARTPOS, id.c_str(), parsedOk, "");
1017 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1018 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>());
1019 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1020 0 : const int roadSideCapacity = attrs.getOpt<int>(SUMO_ATTR_ROADSIDE_CAPACITY, id.c_str(), parsedOk, 0);
1021 0 : const bool onRoad = attrs.getOpt<bool>(SUMO_ATTR_ONROAD, id.c_str(), parsedOk, false);
1022 0 : const double width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, id.c_str(), parsedOk, 0);
1023 0 : const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, id.c_str(), parsedOk, 0);
1024 0 : const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, 0);
1025 0 : const bool lefthand = attrs.getOpt<bool>(SUMO_ATTR_LEFTHAND, id.c_str(), parsedOk, false);
1026 : // continue if flag is ok
1027 0 : if (parsedOk) {
1028 : // set tag
1029 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_PARKING_AREA);
1030 : // add all attributes
1031 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1032 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1033 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
1034 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
1035 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DEPARTPOS, departPos);
1036 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1037 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_ACCEPTED_BADGES, badges);
1038 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1039 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_ROADSIDE_CAPACITY, roadSideCapacity);
1040 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_ONROAD, onRoad);
1041 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WIDTH, width);
1042 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
1043 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
1044 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_LEFTHAND, lefthand);
1045 : } else {
1046 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1047 : }
1048 0 : }
1049 :
1050 :
1051 : void
1052 0 : AdditionalHandler::parseParkingSpaceAttributes(const SUMOSAXAttributes& attrs) {
1053 : // declare Ok Flag
1054 0 : bool parsedOk = true;
1055 : // needed attributes
1056 0 : const double x = attrs.get<double>(SUMO_ATTR_X, "", parsedOk);
1057 0 : const double y = attrs.get<double>(SUMO_ATTR_Y, "", parsedOk);
1058 : // optional attributes
1059 0 : const double z = attrs.getOpt<double>(SUMO_ATTR_Z, "", parsedOk, 0);
1060 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, "", parsedOk, "");
1061 0 : const std::string width = attrs.getOpt<std::string>(SUMO_ATTR_WIDTH, "", parsedOk, "");
1062 0 : const std::string length = attrs.getOpt<std::string>(SUMO_ATTR_LENGTH, "", parsedOk, "");
1063 0 : const std::string angle = attrs.getOpt<std::string>(SUMO_ATTR_ANGLE, "", parsedOk, "");
1064 0 : const double slope = attrs.getOpt<double>(SUMO_ATTR_SLOPE, "", parsedOk, 0);
1065 : // check parent
1066 0 : checkParsedParent(SUMO_TAG_PARKING_SPACE, {SUMO_TAG_PARKING_AREA}, parsedOk);
1067 : // continue if flag is ok
1068 0 : if (parsedOk) {
1069 : // set tag
1070 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_PARKING_SPACE);
1071 : // add all attributes
1072 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_X, x);
1073 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_Y, y);
1074 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_Z, z);
1075 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1076 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_WIDTH, width);
1077 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LENGTH, length);
1078 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ANGLE, angle);
1079 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_SLOPE, slope);
1080 : } else {
1081 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1082 : }
1083 0 : }
1084 :
1085 :
1086 : void
1087 0 : AdditionalHandler::parseE1Attributes(const SUMOSAXAttributes& attrs) {
1088 : // declare Ok Flag
1089 0 : bool parsedOk = true;
1090 : // needed attributes
1091 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1092 0 : const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
1093 0 : const double position = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
1094 0 : const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1095 0 : const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1096 : // optional attributes
1097 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1098 0 : const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1099 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>());
1100 0 : const std::string detectPersons = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, "", parsedOk);
1101 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1102 : // continue if flag is ok
1103 0 : if (parsedOk && checkDetectPersons(SUMO_TAG_E1DETECTOR, id, detectPersons)) {
1104 : // set tag
1105 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_E1DETECTOR);
1106 : // add all attributes
1107 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1108 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1109 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1110 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1111 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1112 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1113 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1114 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_NEXT_EDGES, nextEdges);
1115 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);
1116 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1117 : } else {
1118 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1119 : }
1120 0 : }
1121 :
1122 :
1123 : void
1124 0 : AdditionalHandler::parseE2Attributes(const SUMOSAXAttributes& attrs) {
1125 : // declare Ok Flag
1126 0 : bool parsedOk = true;
1127 0 : const int positionDef = attrs.hasAttribute(SUMO_ATTR_POSITION) ? 1 : 0;
1128 0 : const int endPosDef = attrs.hasAttribute(SUMO_ATTR_ENDPOS) ? 1 : 0;
1129 0 : const int lengthDef = attrs.hasAttribute(SUMO_ATTR_LENGTH) ? 1 : 0;
1130 : // check attributes
1131 0 : if (attrs.hasAttribute(SUMO_ATTR_LANE) && ((positionDef + endPosDef + lengthDef) > 2)) {
1132 0 : writeError(TL("'pos', 'endPos' and 'length' cannot be defined together in a single lane area detector."));
1133 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1134 0 : } else if (attrs.hasAttribute(SUMO_ATTR_LANE) && ((positionDef + endPosDef + lengthDef) < 2)) {
1135 0 : writeError(TL("A single lane area detector requires two parameters of those 'pos', 'endPos' and 'length'."));
1136 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1137 : } else {
1138 : // needed attributes
1139 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1140 0 : const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1141 : // special attributes
1142 0 : const std::string laneId = attrs.getOpt<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk, "");
1143 0 : const std::vector<std::string> laneIds = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LANES, id.c_str(), parsedOk, std::vector<std::string>());
1144 0 : const double position = attrs.getOpt<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, 0);
1145 0 : const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, 0);
1146 0 : const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, id.c_str(), parsedOk, 0);
1147 : // optional attributes
1148 0 : const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1149 0 : const std::string trafficLight = attrs.getOpt<std::string>(SUMO_ATTR_TLID, id.c_str(), parsedOk, "");
1150 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1151 0 : const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), parsedOk, TIME2STEPS(1));
1152 0 : const double haltingSpeedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), parsedOk, 1.39);
1153 0 : const double jamDistThreshold = attrs.getOpt<double>(SUMO_ATTR_JAM_DIST_THRESHOLD, id.c_str(), parsedOk, 10);
1154 0 : const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1155 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>());
1156 0 : const std::string detectPersons = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, "", parsedOk);
1157 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1158 0 : const bool show = attrs.getOpt<bool>(SUMO_ATTR_SHOW_DETECTOR, id.c_str(), parsedOk, true);
1159 : // continue if flag is ok
1160 0 : if (parsedOk && checkDetectPersons(SUMO_TAG_E2DETECTOR, id, detectPersons)) {
1161 : // set tag
1162 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_E2DETECTOR);
1163 : // add attributes depending of Lane/Lanes
1164 0 : if (attrs.hasAttribute(SUMO_ATTR_LANE)) {
1165 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1166 0 : if (positionDef == 0) {
1167 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, endPos - length);
1168 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
1169 0 : } else if (endPosDef == 0) {
1170 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1171 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
1172 0 : } else if (lengthDef == 0) {
1173 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1174 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, endPos - position);
1175 : }
1176 : } else {
1177 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LANES, laneIds);
1178 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1179 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
1180 : }
1181 : // add all attributes
1182 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1183 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1184 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TLID, trafficLight);
1185 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1186 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1187 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_NEXT_EDGES, nextEdges);
1188 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);
1189 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1190 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD, haltingTimeThreshold);
1191 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD, haltingSpeedThreshold);
1192 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD, jamDistThreshold);
1193 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1194 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_SHOW_DETECTOR, show);
1195 : } else {
1196 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1197 : }
1198 0 : }
1199 0 : }
1200 :
1201 :
1202 : void
1203 0 : AdditionalHandler::parseE3Attributes(const SUMOSAXAttributes& attrs) {
1204 : // declare Ok Flag
1205 0 : bool parsedOk = true;
1206 : // needed attributes
1207 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1208 0 : const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1209 0 : const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1210 : // optional attributes
1211 0 : const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position());
1212 0 : const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1213 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>());
1214 0 : const std::string detectPersons = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, "", parsedOk);
1215 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1216 0 : const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), parsedOk, TIME2STEPS(1));
1217 0 : const double haltingSpeedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), parsedOk, 1.39);
1218 0 : const bool openEntry = attrs.getOpt<bool>(SUMO_ATTR_OPEN_ENTRY, id.c_str(), parsedOk, false);
1219 0 : const bool expectedArrival = attrs.getOpt<bool>(SUMO_ATTR_EXPECT_ARRIVAL, id.c_str(), parsedOk, false);
1220 : // continue if flag is ok
1221 0 : if (parsedOk && checkDetectPersons(SUMO_TAG_E3DETECTOR, id, detectPersons)) {
1222 : // set tag
1223 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_E3DETECTOR);
1224 : // add all attributes
1225 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1226 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1227 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1228 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1229 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1230 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_NEXT_EDGES, nextEdges);
1231 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);
1232 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1233 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD, haltingTimeThreshold);
1234 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD, haltingSpeedThreshold);
1235 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_OPEN_ENTRY, openEntry);
1236 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_EXPECT_ARRIVAL, expectedArrival);
1237 : } else {
1238 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1239 : }
1240 0 : }
1241 :
1242 :
1243 : void
1244 0 : AdditionalHandler::parseEntryAttributes(const SUMOSAXAttributes& attrs) {
1245 : // declare Ok Flag
1246 0 : bool parsedOk = true;
1247 : // needed attributes
1248 0 : const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, "", parsedOk);
1249 0 : const double position = attrs.get<double>(SUMO_ATTR_POSITION, "", parsedOk);
1250 : // optional attributes
1251 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "", parsedOk, false);
1252 : // check parent
1253 0 : checkParsedParent(SUMO_TAG_DET_ENTRY, {SUMO_TAG_E3DETECTOR}, parsedOk);
1254 : // continue if flag is ok
1255 0 : if (parsedOk) {
1256 : // set tag
1257 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_DET_ENTRY);
1258 : // add all attributes
1259 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1260 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1261 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1262 : } else {
1263 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1264 : }
1265 0 : }
1266 :
1267 :
1268 : void
1269 0 : AdditionalHandler::parseExitAttributes(const SUMOSAXAttributes& attrs) {
1270 : // declare Ok Flag
1271 0 : bool parsedOk = true;
1272 : // needed attributes
1273 0 : const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, "", parsedOk);
1274 0 : const double position = attrs.get<double>(SUMO_ATTR_POSITION, "", parsedOk);
1275 : // optional attributes
1276 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "", parsedOk, false);
1277 : // check parent
1278 0 : checkParsedParent(SUMO_TAG_DET_EXIT, {SUMO_TAG_E3DETECTOR}, parsedOk);
1279 : // continue if flag is ok
1280 0 : if (parsedOk) {
1281 : // set tag
1282 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_DET_EXIT);
1283 : // add all attributes
1284 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1285 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1286 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1287 : } else {
1288 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1289 : }
1290 0 : }
1291 :
1292 :
1293 : void
1294 0 : AdditionalHandler::parseE1InstantAttributes(const SUMOSAXAttributes& attrs) {
1295 : // declare Ok Flag
1296 0 : bool parsedOk = true;
1297 : // needed attributes
1298 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1299 0 : const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
1300 0 : const double position = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
1301 0 : const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1302 : // optional attributes
1303 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1304 0 : const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1305 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>());
1306 0 : const std::string detectPersons = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, "", parsedOk);
1307 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1308 : // continue if flag is ok
1309 0 : if (parsedOk && checkDetectPersons(SUMO_TAG_INSTANT_INDUCTION_LOOP, id, detectPersons)) {
1310 : // set tag
1311 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_INSTANT_INDUCTION_LOOP);
1312 : // add all attributes
1313 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1314 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1315 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1316 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1317 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1318 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_NEXT_EDGES, nextEdges);
1319 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);
1320 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1321 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1322 : } else {
1323 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1324 : }
1325 0 : }
1326 :
1327 :
1328 : void
1329 0 : AdditionalHandler::parseTAZAttributes(const SUMOSAXAttributes& attrs) {
1330 : // declare Ok Flag
1331 0 : bool parsedOk = true;
1332 : // needed attributes
1333 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1334 : // optional attributes
1335 0 : const PositionVector shape = attrs.getOpt<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk, PositionVector());
1336 0 : const Position center = attrs.getOpt<Position>(SUMO_ATTR_CENTER, id.c_str(), parsedOk, shape.size() > 0 ? shape.getCentroid() : Position::INVALID);
1337 0 : const bool fill = attrs.getOpt<bool>(SUMO_ATTR_FILL, id.c_str(), parsedOk, false);
1338 0 : const std::vector<std::string> edges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk, std::vector<std::string>());
1339 0 : const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::RED);
1340 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1341 : // continue if flag is ok
1342 0 : if (parsedOk) {
1343 : // set tag
1344 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZ);
1345 : // add all attributes
1346 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1347 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shape);
1348 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_CENTER, center);
1349 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FILL, fill);
1350 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_EDGES, edges);
1351 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
1352 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1353 : } else {
1354 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1355 : }
1356 0 : }
1357 :
1358 :
1359 : void
1360 0 : AdditionalHandler::parseTAZSourceAttributes(const SUMOSAXAttributes& attrs) {
1361 : // declare Ok Flag
1362 0 : bool parsedOk = true;
1363 : // needed attributes
1364 0 : const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1365 0 : const double weight = attrs.get<double>(SUMO_ATTR_WEIGHT, edgeID.c_str(), parsedOk);
1366 : // check parent
1367 0 : checkParsedParent(SUMO_TAG_TAZSOURCE, {SUMO_TAG_TAZ}, parsedOk);
1368 : // continue if flag is ok
1369 0 : if (parsedOk) {
1370 : // set tag
1371 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZSOURCE);
1372 : // add all attributes
1373 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1374 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WEIGHT, weight);
1375 : } else {
1376 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1377 : }
1378 0 : }
1379 :
1380 :
1381 : void
1382 0 : AdditionalHandler::parseTAZSinkAttributes(const SUMOSAXAttributes& attrs) {
1383 : // declare Ok Flag
1384 0 : bool parsedOk = true;
1385 : // needed attributes
1386 0 : const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1387 0 : const double weight = attrs.get<double>(SUMO_ATTR_WEIGHT, edgeID.c_str(), parsedOk);
1388 : // check parent
1389 0 : checkParsedParent(SUMO_TAG_TAZSINK, {SUMO_TAG_TAZ}, parsedOk);
1390 : // continue if flag is ok
1391 0 : if (parsedOk) {
1392 : // set tag
1393 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZSINK);
1394 : // add all attributes
1395 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1396 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WEIGHT, weight);
1397 : } else {
1398 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1399 : }
1400 0 : }
1401 :
1402 :
1403 : void
1404 0 : AdditionalHandler::parseVariableSpeedSignAttributes(const SUMOSAXAttributes& attrs) {
1405 : // declare Ok Flag
1406 0 : bool parsedOk = true;
1407 : // needed attributes
1408 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1409 0 : const std::vector<std::string> lanes = attrs.get<std::vector<std::string> >(SUMO_ATTR_LANES, id.c_str(), parsedOk);
1410 : // optional attributes
1411 0 : const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position());
1412 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1413 0 : const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1414 : // continue if flag is ok
1415 0 : if (parsedOk) {
1416 : // set tag
1417 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_VSS);
1418 : // add all attributes
1419 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1420 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LANES, lanes);
1421 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1422 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1423 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1424 : } else {
1425 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1426 : }
1427 0 : }
1428 :
1429 :
1430 : void
1431 0 : AdditionalHandler::parseVariableSpeedSignStepAttributes(const SUMOSAXAttributes& attrs) {
1432 : // declare Ok Flag
1433 0 : bool parsedOk = true;
1434 : // needed attributes
1435 0 : const SUMOTime time = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME, "", parsedOk);
1436 : // optional attributes
1437 0 : const double speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, "", parsedOk, OptionsCont::getOptions().getFloat("default.speed"));
1438 : // check parent
1439 0 : checkParsedParent(SUMO_TAG_STEP, {SUMO_TAG_VSS}, parsedOk);
1440 : // continue if flag is ok
1441 0 : if (parsedOk) {
1442 : // set tag
1443 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_STEP);
1444 : // add all attributes
1445 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_TIME, time);
1446 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_SPEED, speed);
1447 : } else {
1448 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1449 : }
1450 0 : }
1451 :
1452 :
1453 : void
1454 0 : AdditionalHandler::parseCalibratorAttributes(const SUMOSAXAttributes& attrs) {
1455 : // declare Ok Flag
1456 0 : bool parsedOk = true;
1457 : // check that frecuency and trafficLight aren't defined together
1458 0 : if ((attrs.hasAttribute(SUMO_ATTR_EDGE) && attrs.hasAttribute(SUMO_ATTR_LANE)) ||
1459 0 : (!attrs.hasAttribute(SUMO_ATTR_EDGE) && !attrs.hasAttribute(SUMO_ATTR_LANE))) {
1460 0 : writeError(TL("Calibrators need either an edge or a lane"));
1461 0 : parsedOk = false;
1462 : }
1463 : // needed attributes
1464 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1465 0 : const double pos = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
1466 : // special attributes
1467 0 : const std::string edge = attrs.getOpt<std::string>(SUMO_ATTR_EDGE, id.c_str(), parsedOk, "");
1468 0 : const std::string lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk, "");
1469 : // optional attributes
1470 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1471 0 : const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, DELTA_T);
1472 0 : const std::string routeProbe = attrs.getOpt<std::string>(SUMO_ATTR_ROUTEPROBE, id.c_str(), parsedOk, "");
1473 0 : const double jamThreshold = attrs.getOpt<double>(SUMO_ATTR_JAM_DIST_THRESHOLD, id.c_str(), parsedOk, 0.5);
1474 0 : const std::string output = attrs.getOpt<std::string>(SUMO_ATTR_OUTPUT, id.c_str(), parsedOk, "");
1475 0 : const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1476 : // continue if flag is ok
1477 0 : if (parsedOk) {
1478 : // set tag depending of edge/lane
1479 0 : if (attrs.hasAttribute(SUMO_ATTR_EDGE)) {
1480 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CALIBRATOR);
1481 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EDGE, edge);
1482 : } else {
1483 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(GNE_TAG_CALIBRATOR_LANE);
1484 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, lane);
1485 : }
1486 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1487 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, pos);
1488 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1489 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1490 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ROUTEPROBE, routeProbe);
1491 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD, jamThreshold);
1492 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OUTPUT, output);
1493 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1494 : } else {
1495 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1496 : }
1497 0 : }
1498 :
1499 :
1500 : void
1501 0 : AdditionalHandler::parseCalibratorFlowAttributes(const SUMOSAXAttributes& attrs) {
1502 : // declare Ok Flag
1503 0 : bool parsedOk = true;
1504 : // check parent
1505 0 : if (checkCalibratorFlowParents()) {
1506 : // check that frecuency and trafficLight aren't defined together
1507 0 : if (!attrs.hasAttribute(SUMO_ATTR_TYPE) && !attrs.hasAttribute(SUMO_ATTR_VEHSPERHOUR) && !attrs.hasAttribute(SUMO_ATTR_SPEED)) {
1508 0 : writeError(TL("CalibratorFlows need either the attribute vehsPerHour or speed or type (or any combination of these)"));
1509 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1510 : } else {
1511 0 : SUMOVehicleParameter* flowParameter = SUMOVehicleParserHelper::parseVehicleAttributes(SUMO_TAG_FLOW, attrs, false, true, true);
1512 0 : if (flowParameter) {
1513 : // set VPH and speed
1514 0 : if (attrs.hasAttribute(SUMO_ATTR_VEHSPERHOUR)) {
1515 0 : flowParameter->repetitionOffset = TIME2STEPS(3600. / attrs.get<double>(SUMO_ATTR_VEHSPERHOUR, "", parsedOk));
1516 0 : flowParameter->parametersSet |= VEHPARS_VPH_SET;
1517 : }
1518 0 : if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
1519 0 : flowParameter->calibratorSpeed = attrs.get<double>(SUMO_ATTR_SPEED, "", parsedOk);
1520 0 : flowParameter->parametersSet |= VEHPARS_CALIBRATORSPEED_SET;
1521 : }
1522 : // set begin and end
1523 0 : flowParameter->depart = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, "", parsedOk);
1524 0 : flowParameter->repetitionEnd = attrs.getSUMOTimeReporting(SUMO_ATTR_END, "", parsedOk);
1525 0 : if (parsedOk) {
1526 : // set tag
1527 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_FLOW);
1528 : // set vehicle parameters
1529 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setVehicleParameter(flowParameter);
1530 : // delete flow parameter (because in XMLStructure we have a copy)
1531 0 : delete flowParameter;
1532 : } else {
1533 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1534 : }
1535 : } else {
1536 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1537 : }
1538 : }
1539 : } else {
1540 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1541 : }
1542 0 : }
1543 :
1544 :
1545 : void
1546 0 : AdditionalHandler::parseRerouterAttributes(const SUMOSAXAttributes& attrs) {
1547 : // declare Ok Flag
1548 0 : bool parsedOk = true;
1549 : // needed attributes
1550 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1551 0 : const std::vector<std::string> edges = attrs.get<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk);
1552 : // optional attributes
1553 0 : const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position::INVALID);
1554 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1555 0 : const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, id.c_str(), parsedOk, 1);
1556 0 : SUMOTime timeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), parsedOk, 0);
1557 0 : const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1558 0 : const bool off = attrs.getOpt<bool>(SUMO_ATTR_OFF, id.c_str(), parsedOk, false);
1559 0 : const bool optional = attrs.getOpt<bool>(SUMO_ATTR_OPTIONAL, id.c_str(), parsedOk, false);
1560 : // check attributes
1561 0 : if (!checkNegative(SUMO_TAG_REROUTER, id, SUMO_ATTR_PROB, probability, true)) {
1562 0 : parsedOk = false;
1563 : }
1564 : // continue if flag is ok
1565 0 : if (parsedOk) {
1566 : // set tag
1567 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_REROUTER);
1568 : // add all attributes
1569 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1570 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_EDGES, edges);
1571 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1572 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1573 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1574 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD, timeThreshold);
1575 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1576 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_OFF, off);
1577 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_OPTIONAL, optional);
1578 : } else {
1579 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1580 : }
1581 0 : }
1582 :
1583 :
1584 : void
1585 0 : AdditionalHandler::parseRerouterIntervalAttributes(const SUMOSAXAttributes& attrs) {
1586 : // declare Ok Flag
1587 0 : bool parsedOk = true;
1588 : // needed attributes
1589 0 : const SUMOTime begin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, "", parsedOk);
1590 0 : const SUMOTime end = attrs.getSUMOTimeReporting(SUMO_ATTR_END, "", parsedOk);
1591 : // check parent
1592 0 : checkParsedParent(SUMO_TAG_INTERVAL, {SUMO_TAG_REROUTER}, parsedOk);
1593 : // continue if flag is ok
1594 0 : if (parsedOk) {
1595 : // set tag
1596 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_INTERVAL);
1597 : // add all attributes
1598 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);
1599 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_END, end);
1600 : } else {
1601 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1602 : }
1603 0 : }
1604 :
1605 :
1606 : void
1607 0 : AdditionalHandler::parseClosingLaneRerouteAttributes(const SUMOSAXAttributes& attrs) {
1608 : // declare Ok Flag
1609 0 : bool parsedOk = true;
1610 : // needed attributes
1611 0 : const std::string laneID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1612 : // optional attributes
1613 0 : const std::string disallow = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, "", parsedOk, "");
1614 0 : const std::string allow = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, "", parsedOk, !disallow.size() ? "authority" : "");
1615 : // check parent
1616 0 : checkParsedParent(SUMO_TAG_CLOSING_LANE_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1617 : // continue if flag is ok
1618 0 : if (parsedOk) {
1619 : // set tag
1620 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CLOSING_LANE_REROUTE);
1621 : // add all attributes
1622 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, laneID);
1623 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ALLOW, allow);
1624 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DISALLOW, disallow);
1625 : } else {
1626 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1627 : }
1628 0 : }
1629 :
1630 :
1631 : void
1632 0 : AdditionalHandler::parseClosingRerouteAttributes(const SUMOSAXAttributes& attrs) {
1633 : // declare Ok Flag
1634 0 : bool parsedOk = true;
1635 : // needed attributes
1636 0 : const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1637 : // optional attributes
1638 0 : const std::string disallow = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, "", parsedOk, "");
1639 0 : const std::string allow = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, "", parsedOk, "");
1640 : // check parent
1641 0 : checkParsedParent(SUMO_TAG_CLOSING_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1642 : // continue if flag is ok
1643 0 : if (parsedOk) {
1644 : // set tag
1645 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CLOSING_REROUTE);
1646 : // add all attributes
1647 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1648 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ALLOW, allow);
1649 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DISALLOW, disallow);
1650 : } else {
1651 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1652 : }
1653 0 : }
1654 :
1655 :
1656 : void
1657 0 : AdditionalHandler::parseDestProbRerouteAttributes(const SUMOSAXAttributes& attrs) {
1658 : // declare Ok Flag
1659 0 : bool parsedOk = true;
1660 : // needed attributes
1661 0 : const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1662 0 : const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, "", parsedOk, 1);
1663 : // check attributes
1664 0 : if (!checkNegative(SUMO_TAG_DEST_PROB_REROUTE, edgeID, SUMO_ATTR_PROB, probability, true)) {
1665 0 : parsedOk = false;
1666 : }
1667 : // check parent
1668 0 : checkParsedParent(SUMO_TAG_DEST_PROB_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1669 : // continue if flag is ok
1670 0 : if (parsedOk) {
1671 : // set tag
1672 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_DEST_PROB_REROUTE);
1673 : // add all attributes
1674 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1675 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1676 : } else {
1677 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1678 : }
1679 0 : }
1680 :
1681 :
1682 : void
1683 0 : AdditionalHandler::parseParkingAreaRerouteAttributes(const SUMOSAXAttributes& attrs) {
1684 : // declare Ok Flag
1685 0 : bool parsedOk = true;
1686 : // needed attributes
1687 0 : const std::string parkingAreaID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1688 0 : const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, "", parsedOk, 1);
1689 : // check attributes
1690 0 : if (!checkNegative(SUMO_TAG_PARKING_AREA_REROUTE, parkingAreaID, SUMO_ATTR_PROB, probability, true)) {
1691 0 : parsedOk = false;
1692 : }
1693 : // optional attributes
1694 0 : const bool visible = attrs.getOpt<bool>(SUMO_ATTR_VISIBLE, "", parsedOk, false);
1695 : // check parent
1696 0 : checkParsedParent(SUMO_TAG_PARKING_AREA_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1697 : // continue if flag is ok
1698 0 : if (parsedOk) {
1699 : // set tag
1700 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_PARKING_AREA_REROUTE);
1701 : // add all attributes
1702 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, parkingAreaID);
1703 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1704 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_VISIBLE, visible);
1705 : } else {
1706 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1707 : }
1708 0 : }
1709 :
1710 :
1711 : void
1712 0 : AdditionalHandler::parseRouteProbRerouteAttributes(const SUMOSAXAttributes& attrs) {
1713 : // declare Ok Flag
1714 0 : bool parsedOk = true;
1715 : // needed attributes
1716 0 : const std::string routeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1717 0 : const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, "", parsedOk, 1);
1718 : // check attributes
1719 0 : if (!checkNegative(SUMO_TAG_ROUTE_PROB_REROUTE, routeID, SUMO_ATTR_PROB, probability, true)) {
1720 0 : parsedOk = false;
1721 : }
1722 : // check parent
1723 0 : checkParsedParent(SUMO_TAG_ROUTE_PROB_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1724 : // continue if flag is ok
1725 0 : if (parsedOk) {
1726 : // set tag
1727 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ROUTE_PROB_REROUTE);
1728 : // add all attributes
1729 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, routeID);
1730 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1731 : } else {
1732 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1733 : }
1734 0 : }
1735 :
1736 :
1737 : void
1738 0 : AdditionalHandler::parseRouteProbeAttributes(const SUMOSAXAttributes& attrs) {
1739 : // declare Ok Flag
1740 0 : bool parsedOk = true;
1741 : // needed attributes
1742 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1743 0 : const std::string edge = attrs.get<std::string>(SUMO_ATTR_EDGE, id.c_str(), parsedOk);
1744 0 : const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1745 0 : const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1746 0 : const SUMOTime begin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, id.c_str(), parsedOk, -1);
1747 : // optional attributes
1748 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1749 0 : const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1750 : // continue if flag is ok
1751 0 : if (parsedOk) {
1752 : // set tag
1753 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ROUTEPROBE);
1754 : // add all attributes
1755 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1756 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EDGE, edge);
1757 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1758 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1759 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1760 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);
1761 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1762 : } else {
1763 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1764 : }
1765 0 : }
1766 :
1767 :
1768 : void
1769 0 : AdditionalHandler::parseVaporizerAttributes(const SUMOSAXAttributes& attrs) {
1770 : // declare Ok Flag
1771 0 : bool parsedOk = true;
1772 : // needed attributes
1773 0 : const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1774 0 : SUMOTime begin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, nullptr, parsedOk);
1775 0 : SUMOTime end = attrs.getSUMOTimeReporting(SUMO_ATTR_END, nullptr, parsedOk);
1776 : // optional attributes
1777 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, edgeID.c_str(), parsedOk, "");
1778 : // continue if flag is ok
1779 0 : if (parsedOk) {
1780 : // set tag
1781 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_VAPORIZER);
1782 : // add all attributes
1783 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EDGE, edgeID);
1784 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);
1785 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_END, end);
1786 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1787 : } else {
1788 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1789 : }
1790 0 : }
1791 :
1792 :
1793 : void
1794 0 : AdditionalHandler::parseTractionSubstation(const SUMOSAXAttributes& attrs) {
1795 : // declare Ok Flag
1796 0 : bool parsedOk = true;
1797 : // needed attributes
1798 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1799 : // optional attributes
1800 0 : const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position::INVALID);
1801 0 : const double voltage = attrs.getOpt<double>(SUMO_ATTR_VOLTAGE, id.c_str(), parsedOk, 600);
1802 0 : const double currentLimit = attrs.getOpt<double>(SUMO_ATTR_CURRENTLIMIT, id.c_str(), parsedOk, 400);
1803 : // continue if flag is ok
1804 0 : if (parsedOk) {
1805 : // set tag
1806 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TRACTION_SUBSTATION);
1807 : // add all attributes
1808 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1809 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1810 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_VOLTAGE, voltage);
1811 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_CURRENTLIMIT, currentLimit);
1812 : } else {
1813 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1814 : }
1815 0 : }
1816 :
1817 :
1818 : void
1819 0 : AdditionalHandler::parseOverheadWire(const SUMOSAXAttributes& attrs) {
1820 : // declare Ok Flag
1821 0 : bool parsedOk = true;
1822 : // needed attributes
1823 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1824 0 : const std::string substationID = attrs.get<std::string>(SUMO_ATTR_SUBSTATIONID, id.c_str(), parsedOk);
1825 0 : const std::vector<std::string> laneIDs = attrs.get<std::vector<std::string> >(SUMO_ATTR_LANES, id.c_str(), parsedOk);
1826 : // optional attributes
1827 0 : const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, 0);
1828 0 : const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
1829 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1830 0 : const std::vector<std::string> forbiddenInnerLanes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN, "", parsedOk);
1831 : // continue if flag is ok
1832 0 : if (parsedOk) {
1833 : // set tag
1834 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_OVERHEAD_WIRE_SECTION);
1835 : // add all attributes
1836 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1837 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_SUBSTATIONID, substationID);
1838 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LANES, laneIDs);
1839 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
1840 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
1841 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1842 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN, forbiddenInnerLanes);
1843 : } else {
1844 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1845 : }
1846 0 : }
1847 :
1848 :
1849 : void
1850 0 : AdditionalHandler::parseOverheadWireClamp(const SUMOSAXAttributes& attrs) {
1851 : // declare Ok Flag
1852 0 : bool parsedOk = true;
1853 : // needed attributes
1854 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1855 0 : const std::string substationId = attrs.get<std::string>(SUMO_ATTR_SUBSTATIONID, id.c_str(), parsedOk);
1856 0 : const std::string wireClampStart = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_START, id.c_str(), parsedOk);
1857 0 : const std::string wireClampLaneStart = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART, id.c_str(), parsedOk);
1858 0 : const std::string wireClampEnd = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_END, id.c_str(), parsedOk);
1859 0 : const std::string wireClampLaneEnd = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND, id.c_str(), parsedOk);
1860 : // continue if flag is ok
1861 0 : if (parsedOk) {
1862 : // set tag
1863 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_OVERHEAD_WIRE_CLAMP);
1864 : // add all attributes
1865 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1866 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_SUBSTATIONID, substationId);
1867 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_START, wireClampStart);
1868 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART, wireClampLaneStart);
1869 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_END, wireClampEnd);
1870 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND, wireClampLaneEnd);
1871 : } else {
1872 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1873 : }
1874 0 : }
1875 :
1876 :
1877 : void
1878 0 : AdditionalHandler::parsePolyAttributes(const SUMOSAXAttributes& attrs) {
1879 : // declare Ok Flag
1880 0 : bool parsedOk = true;
1881 : // needed attributes
1882 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1883 0 : const PositionVector shapeStr = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk);
1884 : // optional attributes
1885 0 : const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::RED);
1886 0 : const bool geo = attrs.getOpt<bool>(SUMO_ATTR_GEO, id.c_str(), parsedOk, false);
1887 0 : const bool fill = attrs.getOpt<bool>(SUMO_ATTR_FILL, id.c_str(), parsedOk, false);
1888 0 : const double lineWidth = attrs.getOpt<double>(SUMO_ATTR_LINEWIDTH, id.c_str(), parsedOk, Shape::DEFAULT_LINEWIDTH);
1889 0 : const double layer = attrs.getOpt<double>(SUMO_ATTR_LAYER, id.c_str(), parsedOk, Shape::DEFAULT_LAYER);
1890 0 : const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), parsedOk, Shape::DEFAULT_TYPE);
1891 0 : const std::string imgFile = attrs.getOpt<std::string>(SUMO_ATTR_IMGFILE, id.c_str(), parsedOk, Shape::DEFAULT_IMG_FILE);
1892 0 : const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, Shape::DEFAULT_ANGLE);
1893 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1894 : // continue if flag is ok
1895 0 : if (parsedOk) {
1896 : // set tag
1897 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_POLY);
1898 : // add all attributes
1899 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1900 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shapeStr);
1901 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
1902 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_GEO, geo);
1903 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FILL, fill);
1904 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LINEWIDTH, lineWidth);
1905 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LAYER, layer);
1906 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TYPE, type);
1907 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_IMGFILE, imgFile);
1908 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
1909 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1910 : } else {
1911 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1912 : }
1913 0 : }
1914 :
1915 :
1916 : void
1917 0 : AdditionalHandler::parsePOIAttributes(const SUMOSAXAttributes& attrs) {
1918 : // declare Ok Flag
1919 0 : bool parsedOk = true;
1920 : // check that x and y are defined together
1921 0 : if ((attrs.hasAttribute(SUMO_ATTR_X) && !attrs.hasAttribute(SUMO_ATTR_Y)) ||
1922 0 : (!attrs.hasAttribute(SUMO_ATTR_X) && attrs.hasAttribute(SUMO_ATTR_Y))) {
1923 0 : writeError(TL("X and Y must be be defined together in POIs"));
1924 0 : parsedOk = false;
1925 : }
1926 : // check that lane and pos are defined together
1927 0 : if ((attrs.hasAttribute(SUMO_ATTR_LANE) && !attrs.hasAttribute(SUMO_ATTR_POSITION)) ||
1928 0 : (!attrs.hasAttribute(SUMO_ATTR_LANE) && attrs.hasAttribute(SUMO_ATTR_POSITION))) {
1929 0 : writeError(TL("lane and position must be defined together in POIs"));
1930 0 : parsedOk = false;
1931 : }
1932 : // check that lon and lat are defined together
1933 0 : if ((attrs.hasAttribute(SUMO_ATTR_LON) && !attrs.hasAttribute(SUMO_ATTR_LAT)) ||
1934 0 : (!attrs.hasAttribute(SUMO_ATTR_LON) && attrs.hasAttribute(SUMO_ATTR_LAT))) {
1935 0 : writeError(TL("lon and lat must be be defined together in POIs"));
1936 0 : parsedOk = false;
1937 : }
1938 : // needed attributes
1939 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1940 : // special attributes
1941 0 : const double x = attrs.getOpt<double>(SUMO_ATTR_X, id.c_str(), parsedOk, 0);
1942 0 : const double y = attrs.getOpt<double>(SUMO_ATTR_Y, id.c_str(), parsedOk, 0);
1943 0 : const std::string lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, "", parsedOk, "");
1944 0 : const double pos = attrs.getOpt<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, 0);
1945 0 : const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1946 0 : const double posLat = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, id.c_str(), parsedOk, 0);
1947 0 : const double lon = attrs.getOpt<double>(SUMO_ATTR_LON, id.c_str(), parsedOk, 0);
1948 0 : const double lat = attrs.getOpt<double>(SUMO_ATTR_LAT, id.c_str(), parsedOk, 0);
1949 : // optional attributes
1950 0 : const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::RED);
1951 0 : const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, "", parsedOk, Shape::DEFAULT_TYPE);
1952 0 : std::string icon = attrs.getOpt<std::string>(SUMO_ATTR_ICON, "", parsedOk, SUMOXMLDefinitions::POIIcons.getString(POIIcon::NONE));
1953 0 : const double layer = attrs.getOpt<double>(SUMO_ATTR_LAYER, id.c_str(), parsedOk, Shape::DEFAULT_LAYER_POI);
1954 0 : const std::string imgFile = attrs.getOpt<std::string>(SUMO_ATTR_IMGFILE, "", parsedOk, Shape::DEFAULT_IMG_FILE);
1955 0 : const double width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, id.c_str(), parsedOk, Shape::DEFAULT_IMG_WIDTH);
1956 0 : const double height = attrs.getOpt<double>(SUMO_ATTR_HEIGHT, id.c_str(), parsedOk, Shape::DEFAULT_IMG_HEIGHT);
1957 0 : const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, Shape::DEFAULT_ANGLE);
1958 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1959 : // check icon
1960 0 : if (!SUMOXMLDefinitions::POIIcons.hasString(icon)) {
1961 0 : WRITE_WARNING(TLF("Invalid icon % for POI '%', using default", icon, id));
1962 : icon = "none";
1963 : }
1964 : // continue if flag is ok
1965 0 : if (parsedOk) {
1966 : // set tag
1967 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_POI);
1968 : // add attributes depending of Lane/Lanes
1969 0 : if (attrs.hasAttribute(SUMO_ATTR_X) && attrs.hasAttribute(SUMO_ATTR_Y)) {
1970 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_X, x);
1971 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_Y, y);
1972 0 : } else if (attrs.hasAttribute(SUMO_ATTR_LANE) && attrs.hasAttribute(SUMO_ATTR_POSITION)) {
1973 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, lane);
1974 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, pos);
1975 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1976 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION_LAT, posLat);
1977 : } else {
1978 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LON, lon);
1979 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LAT, lat);
1980 : }
1981 : // add rest attributes
1982 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1983 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
1984 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TYPE, type);
1985 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ICON, icon);
1986 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LAYER, layer);
1987 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_IMGFILE, imgFile);
1988 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WIDTH, width);
1989 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HEIGHT, height);
1990 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
1991 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1992 : } else {
1993 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1994 : }
1995 0 : }
1996 :
1997 :
1998 : void
1999 0 : AdditionalHandler::parseJpsWalkableAreaAttributes(const SUMOSAXAttributes& attrs) {
2000 : // declare Ok Flag
2001 0 : bool parsedOk = true;
2002 : // needed attributes
2003 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
2004 0 : const PositionVector shapeStr = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk);
2005 : // optional attributes
2006 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
2007 : // continue if flag is ok
2008 0 : if (parsedOk) {
2009 : // set tag
2010 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(GNE_TAG_JPS_WALKABLEAREA);
2011 : // add all attributes
2012 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
2013 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shapeStr);
2014 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
2015 : } else {
2016 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
2017 : }
2018 0 : }
2019 :
2020 :
2021 : void
2022 0 : AdditionalHandler::parseJpsObstacleAttributes(const SUMOSAXAttributes& attrs) {
2023 : // declare Ok Flag
2024 0 : bool parsedOk = true;
2025 : // needed attributes
2026 0 : const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
2027 0 : const PositionVector shapeStr = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk);
2028 : // optional attributes
2029 0 : const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
2030 : // continue if flag is ok
2031 0 : if (parsedOk) {
2032 : // set tag
2033 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(GNE_TAG_JPS_OBSTACLE);
2034 : // add all attributes
2035 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
2036 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shapeStr);
2037 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
2038 : } else {
2039 0 : myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
2040 : }
2041 0 : }
2042 :
2043 :
2044 : bool
2045 0 : AdditionalHandler::checkCalibratorFlowParents() {
2046 0 : const auto parentCalibrator = myCommonXMLStructure.getCurrentSumoBaseObject()->getParentSumoBaseObject();
2047 0 : if (parentCalibrator == nullptr) {
2048 : return false;
2049 : }
2050 0 : const auto parentRootFile = parentCalibrator->getParentSumoBaseObject();
2051 0 : if (parentRootFile != nullptr) {
2052 : return false;
2053 : }
2054 0 : if ((parentCalibrator->getTag() == SUMO_TAG_CALIBRATOR) || (parentCalibrator->getTag() == GNE_TAG_CALIBRATOR_LANE)) {
2055 0 : return true;
2056 : } else {
2057 0 : return writeError(TLF("Calibrator Flows have to be defined within a %.", toString(SUMO_TAG_CALIBRATOR)));
2058 : }
2059 : }
2060 :
2061 :
2062 : bool
2063 0 : AdditionalHandler::checkDetectPersons(const SumoXMLTag currentTag, const std::string& id, const std::string& detectPersons) {
2064 0 : if (detectPersons.empty() || SUMOXMLDefinitions::PersonModeValues.hasString(detectPersons)) {
2065 0 : return true;
2066 : } else {
2067 0 : writeError(TLF("Attribute '%' defined in % with id '%' doesn't have a valid value (given '%').", toString(SUMO_ATTR_DETECT_PERSONS), toString(currentTag), id, detectPersons));
2068 0 : return false;
2069 : }
2070 : }
2071 :
2072 : /****************************************************************************/
|
