CoCalc -- AdditionalHandler.cpp

GitHub Repository: eclipse/sumo
Path: blob/main/src/utils/handlers/AdditionalHandler.cpp
¹⁶⁹⁶⁷⁸ views
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
AdditionalHandler::AdditionalHandler(const std::string& filename) :
38
    CommonHandler(filename) {
39
}
40

41

42
AdditionalHandler::~AdditionalHandler() {}
43

44

45
bool
46
AdditionalHandler::beginParseAttributes(SumoXMLTag tag, const SUMOSAXAttributes& attrs) {
47
    // open SUMOBaseOBject
48
    myCommonXMLStructure.openSUMOBaseOBject();
49
    // check tag
50
    try {
51
        switch (tag) {
52
            // Stopping Places
53
            case SUMO_TAG_BUS_STOP:
54
                parseBusStopAttributes(attrs);
55
                break;
56
            case SUMO_TAG_TRAIN_STOP:
57
                parseTrainStopAttributes(attrs);
58
                break;
59
            case SUMO_TAG_ACCESS:
60
                parseAccessAttributes(attrs);
61
                break;
62
            case SUMO_TAG_CONTAINER_STOP:
63
                parseContainerStopAttributes(attrs);
64
                break;
65
            case SUMO_TAG_CHARGING_STATION:
66
                parseChargingStationAttributes(attrs);
67
                break;
68
            case SUMO_TAG_PARKING_AREA:
69
                parseParkingAreaAttributes(attrs);
70
                break;
71
            case SUMO_TAG_PARKING_SPACE:
72
                parseParkingSpaceAttributes(attrs);
73
                break;
74
            // Detectors
75
            case SUMO_TAG_E1DETECTOR:
76
            case SUMO_TAG_INDUCTION_LOOP:
77
                parseE1Attributes(attrs);
78
                break;
79
            case SUMO_TAG_E2DETECTOR:
80
            case SUMO_TAG_LANE_AREA_DETECTOR:
81
                parseE2Attributes(attrs);
82
                break;
83
            case SUMO_TAG_E3DETECTOR:
84
            case SUMO_TAG_ENTRY_EXIT_DETECTOR:
85
                parseE3Attributes(attrs);
86
                break;
87
            case SUMO_TAG_DET_ENTRY:
88
                parseEntryAttributes(attrs);
89
                break;
90
            case SUMO_TAG_DET_EXIT:
91
                parseExitAttributes(attrs);
92
                break;
93
            case SUMO_TAG_INSTANT_INDUCTION_LOOP:
94
                parseE1InstantAttributes(attrs);
95
                break;
96
            // TAZs
97
            case SUMO_TAG_TAZ:
98
                parseTAZAttributes(attrs);
99
                break;
100
            case SUMO_TAG_TAZSOURCE:
101
                parseTAZSourceAttributes(attrs);
102
                break;
103
            case SUMO_TAG_TAZSINK:
104
                parseTAZSinkAttributes(attrs);
105
                break;
106
            // Variable Speed Sign
107
            case SUMO_TAG_VSS:
108
                parseVariableSpeedSignAttributes(attrs);
109
                break;
110
            case SUMO_TAG_STEP:
111
                parseVariableSpeedSignStepAttributes(attrs);
112
                break;
113
            // Calibrator
114
            case SUMO_TAG_CALIBRATOR:
115
            case GNE_TAG_CALIBRATOR_LANE:
116
                parseCalibratorAttributes(attrs);
117
                break;
118
            // flow (calibrator)
119
            case SUMO_TAG_FLOW:
120
                parseCalibratorFlowAttributes(attrs);
121
                break;
122
            // Rerouter
123
            case SUMO_TAG_REROUTER:
124
                parseRerouterAttributes(attrs);
125
                break;
126
            case SUMO_TAG_INTERVAL:
127
                parseRerouterIntervalAttributes(attrs);
128
                break;
129
            case SUMO_TAG_CLOSING_LANE_REROUTE:
130
                parseClosingLaneRerouteAttributes(attrs);
131
                break;
132
            case SUMO_TAG_CLOSING_REROUTE:
133
                parseClosingRerouteAttributes(attrs);
134
                break;
135
            case SUMO_TAG_DEST_PROB_REROUTE:
136
                parseDestProbRerouteAttributes(attrs);
137
                break;
138
            case SUMO_TAG_PARKING_AREA_REROUTE:
139
                parseParkingAreaRerouteAttributes(attrs);
140
                break;
141
            case SUMO_TAG_ROUTE_PROB_REROUTE:
142
                parseRouteProbRerouteAttributes(attrs);
143
                break;
144
            // Route probe
145
            case SUMO_TAG_ROUTEPROBE:
146
                parseRouteProbeAttributes(attrs);
147
                break;
148
            // Vaporizer (deprecated)
149
            case SUMO_TAG_VAPORIZER:
150
                parseVaporizerAttributes(attrs);
151
                break;
152
            // wires
153
            case SUMO_TAG_TRACTION_SUBSTATION:
154
                parseTractionSubstation(attrs);
155
                break;
156
            case SUMO_TAG_OVERHEAD_WIRE_CLAMP:
157
                parseOverheadWireClamp(attrs);
158
                break;
159
            case SUMO_TAG_OVERHEAD_WIRE_SECTION:
160
                parseOverheadWire(attrs);
161
                break;
162
            // Poly
163
            case SUMO_TAG_POLY:
164
                parsePolyAttributes(attrs);
165
                break;
166
            case SUMO_TAG_POI:
167
                parsePOIAttributes(attrs);
168
                break;
169
            // JuPedSim
170
            case GNE_TAG_JPS_WALKABLEAREA:
171
                parseJpsWalkableAreaAttributes(attrs);
172
                break;
173
            case GNE_TAG_JPS_OBSTACLE:
174
                parseJpsObstacleAttributes(attrs);
175
                break;
176
            // parameters
177
            case SUMO_TAG_PARAM:
178
                parseParameters(attrs);
179
                break;
180
            default:
181
                // tag cannot be parsed in AdditionalHandler
182
                myCommonXMLStructure.abortSUMOBaseOBject();
183
                return false;
184
        }
185
    } catch (InvalidArgument& e) {
186
        writeError(e.what());
187
    }
188
    return true;
189
}
190

191

192
void
193
AdditionalHandler::endParseAttributes() {
194
    // get last inserted object
195
    CommonXMLStructure::SumoBaseObject* obj = myCommonXMLStructure.getCurrentSumoBaseObject();
196
    if (obj) {
197
        // close SUMOBaseOBject
198
        myCommonXMLStructure.closeSUMOBaseOBject();
199
        // check tag
200
        switch (obj->getTag()) {
201
            // Stopping Places
202
            case SUMO_TAG_BUS_STOP:
203
            case SUMO_TAG_TRAIN_STOP:
204
            case SUMO_TAG_CONTAINER_STOP:
205
            case SUMO_TAG_CHARGING_STATION:
206
            case SUMO_TAG_PARKING_AREA:
207
            // detectors
208
            case SUMO_TAG_E1DETECTOR:
209
            case SUMO_TAG_INDUCTION_LOOP:
210
            case SUMO_TAG_E2DETECTOR:
211
            case SUMO_TAG_LANE_AREA_DETECTOR:
212
            case SUMO_TAG_E3DETECTOR:
213
            case SUMO_TAG_ENTRY_EXIT_DETECTOR:
214
            case SUMO_TAG_INSTANT_INDUCTION_LOOP:
215
            // TAZs
216
            case SUMO_TAG_TAZ:
217
            // Variable Speed Sign
218
            case SUMO_TAG_VSS:
219
            // Calibrator
220
            case SUMO_TAG_CALIBRATOR:
221
            case GNE_TAG_CALIBRATOR_LANE:
222
            // Rerouter
223
            case SUMO_TAG_REROUTER:
224
            // Route probe
225
            case SUMO_TAG_ROUTEPROBE:
226
            // Vaporizer (deprecated)
227
            case SUMO_TAG_VAPORIZER:
228
            // wires
229
            case SUMO_TAG_TRACTION_SUBSTATION:
230
            case SUMO_TAG_OVERHEAD_WIRE_SECTION:
231
            case SUMO_TAG_OVERHEAD_WIRE_CLAMP:
232
            // Shapes
233
            case SUMO_TAG_POLY:
234
            case SUMO_TAG_POI:
235
            // JuPedSim
236
            case GNE_TAG_JPS_WALKABLEAREA:
237
            case GNE_TAG_JPS_OBSTACLE:
238
                // parse object and all their childrens
239
                parseSumoBaseObject(obj);
240
                // delete object (and all of their childrens)
241
                delete obj;
242
                break;
243
            default:
244
                break;
245
        }
246
    }
247
}
248

249

250
void
251
AdditionalHandler::parseSumoBaseObject(CommonXMLStructure::SumoBaseObject* obj) {
252
    // check if loading was aborted
253
    if (!myAbortLoading) {
254
        // switch tag
255
        switch (obj->getTag()) {
256
            // Stopping Places
257
            case SUMO_TAG_BUS_STOP:
258
                if (buildBusStop(obj,
259
                                 obj->getStringAttribute(SUMO_ATTR_ID),
260
                                 obj->getStringAttribute(SUMO_ATTR_LANE),
261
                                 obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
262
                                 obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
263
                                 obj->getStringAttribute(SUMO_ATTR_NAME),
264
                                 obj->getStringListAttribute(SUMO_ATTR_LINES),
265
                                 obj->getIntAttribute(SUMO_ATTR_PERSON_CAPACITY),
266
                                 obj->getDoubleAttribute(SUMO_ATTR_PARKING_LENGTH),
267
                                 obj->getColorAttribute(SUMO_ATTR_COLOR),
268
                                 obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
269
                                 obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
270
                                 obj->getParameters())) {
271
                    obj->markAsCreated();
272
                }
273
                break;
274
            case SUMO_TAG_TRAIN_STOP:
275
                if (buildTrainStop(obj,
276
                                   obj->getStringAttribute(SUMO_ATTR_ID),
277
                                   obj->getStringAttribute(SUMO_ATTR_LANE),
278
                                   obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
279
                                   obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
280
                                   obj->getStringAttribute(SUMO_ATTR_NAME),
281
                                   obj->getStringListAttribute(SUMO_ATTR_LINES),
282
                                   obj->getIntAttribute(SUMO_ATTR_PERSON_CAPACITY),
283
                                   obj->getDoubleAttribute(SUMO_ATTR_PARKING_LENGTH),
284
                                   obj->getColorAttribute(SUMO_ATTR_COLOR),
285
                                   obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
286
                                   obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
287
                                   obj->getParameters())) {
288
                    obj->markAsCreated();
289
                }
290
                break;
291
            case SUMO_TAG_ACCESS:
292
                if (buildAccess(obj,
293
                                obj->getStringAttribute(SUMO_ATTR_LANE),
294
                                obj->getStringAttribute(SUMO_ATTR_POSITION),
295
                                obj->getDoubleAttribute(SUMO_ATTR_LENGTH),
296
                                obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
297
                                obj->getParameters())) {
298
                    obj->markAsCreated();
299
                }
300
                break;
301
            case SUMO_TAG_CONTAINER_STOP:
302
                if (buildContainerStop(obj,
303
                                       obj->getStringAttribute(SUMO_ATTR_ID),
304
                                       obj->getStringAttribute(SUMO_ATTR_LANE),
305
                                       obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
306
                                       obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
307
                                       obj->getStringAttribute(SUMO_ATTR_NAME),
308
                                       obj->getStringListAttribute(SUMO_ATTR_LINES),
309
                                       obj->getIntAttribute(SUMO_ATTR_CONTAINER_CAPACITY),
310
                                       obj->getDoubleAttribute(SUMO_ATTR_PARKING_LENGTH),
311
                                       obj->getColorAttribute(SUMO_ATTR_COLOR),
312
                                       obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
313
                                       obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
314
                                       obj->getParameters())) {
315
                    obj->markAsCreated();
316
                }
317
                break;
318
            case SUMO_TAG_CHARGING_STATION:
319
                if (buildChargingStation(obj,
320
                                         obj->getStringAttribute(SUMO_ATTR_ID),
321
                                         obj->getStringAttribute(SUMO_ATTR_LANE),
322
                                         obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
323
                                         obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
324
                                         obj->getStringAttribute(SUMO_ATTR_NAME),
325
                                         obj->getDoubleAttribute(SUMO_ATTR_CHARGINGPOWER),
326
                                         obj->getDoubleAttribute(SUMO_ATTR_EFFICIENCY),
327
                                         obj->getBoolAttribute(SUMO_ATTR_CHARGEINTRANSIT),
328
                                         obj->getTimeAttribute(SUMO_ATTR_CHARGEDELAY),
329
                                         obj->getStringAttribute(SUMO_ATTR_CHARGETYPE),
330
                                         obj->getTimeAttribute(SUMO_ATTR_WAITINGTIME),
331
                                         obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
332
                                         obj->getStringAttribute(SUMO_ATTR_PARKING_AREA),
333
                                         obj->getParameters())) {
334
                    obj->markAsCreated();
335
                }
336
                break;
337
            case SUMO_TAG_PARKING_AREA:
338
                if (buildParkingArea(obj,
339
                                     obj->getStringAttribute(SUMO_ATTR_ID),
340
                                     obj->getStringAttribute(SUMO_ATTR_LANE),
341
                                     obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
342
                                     obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
343
                                     obj->getStringAttribute(SUMO_ATTR_DEPARTPOS),
344
                                     obj->getStringAttribute(SUMO_ATTR_NAME),
345
                                     obj->getStringListAttribute(SUMO_ATTR_ACCEPTED_BADGES),
346
                                     obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
347
                                     obj->getIntAttribute(SUMO_ATTR_ROADSIDE_CAPACITY),
348
                                     obj->getBoolAttribute(SUMO_ATTR_ONROAD),
349
                                     obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
350
                                     obj->getDoubleAttribute(SUMO_ATTR_LENGTH),
351
                                     obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
352
                                     obj->getBoolAttribute(SUMO_ATTR_LEFTHAND),
353
                                     obj->getParameters())) {
354
                    obj->markAsCreated();
355
                }
356
                break;
357
            case SUMO_TAG_PARKING_SPACE:
358
                if (buildParkingSpace(obj,
359
                                      obj->getDoubleAttribute(SUMO_ATTR_X),
360
                                      obj->getDoubleAttribute(SUMO_ATTR_Y),
361
                                      obj->getDoubleAttribute(SUMO_ATTR_Z),
362
                                      obj->getStringAttribute(SUMO_ATTR_NAME),
363
                                      obj->getStringAttribute(SUMO_ATTR_WIDTH),
364
                                      obj->getStringAttribute(SUMO_ATTR_LENGTH),
365
                                      obj->getStringAttribute(SUMO_ATTR_ANGLE),
366
                                      obj->getDoubleAttribute(SUMO_ATTR_SLOPE),
367
                                      obj->getParameters())) {
368
                    obj->markAsCreated();
369
                }
370
                break;
371
            // Detectors
372
            case SUMO_TAG_E1DETECTOR:
373
            case SUMO_TAG_INDUCTION_LOOP:
374
                // build E1
375
                if (buildE1Detector(obj,
376
                                    obj->getStringAttribute(SUMO_ATTR_ID),
377
                                    obj->getStringAttribute(SUMO_ATTR_LANE),
378
                                    obj->getDoubleAttribute(SUMO_ATTR_POSITION),
379
                                    obj->getPeriodAttribute(),
380
                                    obj->getStringAttribute(SUMO_ATTR_FILE),
381
                                    obj->getStringListAttribute(SUMO_ATTR_VTYPES),
382
                                    obj->getStringListAttribute(SUMO_ATTR_NEXT_EDGES),
383
                                    obj->getStringAttribute(SUMO_ATTR_DETECT_PERSONS),
384
                                    obj->getStringAttribute(SUMO_ATTR_NAME),
385
                                    obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
386
                                    obj->getParameters())) {
387
                    obj->markAsCreated();
388
                }
389
                break;
390
            case SUMO_TAG_E2DETECTOR:
391
            case SUMO_TAG_LANE_AREA_DETECTOR:
392
                if (obj->hasStringAttribute(SUMO_ATTR_LANE)) {
393
                    if (buildSingleLaneDetectorE2(obj,
394
                                                  obj->getStringAttribute(SUMO_ATTR_ID),
395
                                                  obj->getStringAttribute(SUMO_ATTR_LANE),
396
                                                  obj->getDoubleAttribute(SUMO_ATTR_POSITION),
397
                                                  obj->getDoubleAttribute(SUMO_ATTR_LENGTH),
398
                                                  obj->getPeriodAttribute(),
399
                                                  obj->getStringAttribute(SUMO_ATTR_TLID),
400
                                                  obj->getStringAttribute(SUMO_ATTR_FILE),
401
                                                  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
402
                                                  obj->getStringListAttribute(SUMO_ATTR_NEXT_EDGES),
403
                                                  obj->getStringAttribute(SUMO_ATTR_DETECT_PERSONS),
404
                                                  obj->getStringAttribute(SUMO_ATTR_NAME),
405
                                                  obj->getTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD),
406
                                                  obj->getDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD),
407
                                                  obj->getDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD),
408
                                                  obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
409
                                                  obj->getBoolAttribute(SUMO_ATTR_SHOW_DETECTOR),
410
                                                  obj->getParameters())) {
411
                        obj->markAsCreated();
412
                    }
413
                } else {
414
                    if (buildMultiLaneDetectorE2(obj,
415
                                                 obj->getStringAttribute(SUMO_ATTR_ID),
416
                                                 obj->getStringListAttribute(SUMO_ATTR_LANES),
417
                                                 obj->getDoubleAttribute(SUMO_ATTR_POSITION),
418
                                                 obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
419
                                                 obj->getPeriodAttribute(),
420
                                                 obj->getStringAttribute(SUMO_ATTR_TLID),
421
                                                 obj->getStringAttribute(SUMO_ATTR_FILE),
422
                                                 obj->getStringListAttribute(SUMO_ATTR_VTYPES),
423
                                                 obj->getStringListAttribute(SUMO_ATTR_NEXT_EDGES),
424
                                                 obj->getStringAttribute(SUMO_ATTR_DETECT_PERSONS),
425
                                                 obj->getStringAttribute(SUMO_ATTR_NAME),
426
                                                 obj->getTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD),
427
                                                 obj->getDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD),
428
                                                 obj->getDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD),
429
                                                 obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
430
                                                 obj->getBoolAttribute(SUMO_ATTR_SHOW_DETECTOR),
431
                                                 obj->getParameters())) {
432
                        obj->markAsCreated();
433
                    }
434
                }
435
                break;
436
            case SUMO_TAG_E3DETECTOR:
437
            case SUMO_TAG_ENTRY_EXIT_DETECTOR:
438
                if (buildDetectorE3(obj,
439
                                    obj->getStringAttribute(SUMO_ATTR_ID),
440
                                    obj->getPositionAttribute(SUMO_ATTR_POSITION),
441
                                    obj->getPeriodAttribute(),
442
                                    obj->getStringAttribute(SUMO_ATTR_FILE),
443
                                    obj->getStringListAttribute(SUMO_ATTR_VTYPES),
444
                                    obj->getStringListAttribute(SUMO_ATTR_NEXT_EDGES),
445
                                    obj->getStringAttribute(SUMO_ATTR_DETECT_PERSONS),
446
                                    obj->getStringAttribute(SUMO_ATTR_NAME),
447
                                    obj->getTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD),
448
                                    obj->getDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD),
449
                                    obj->getBoolAttribute(SUMO_ATTR_OPEN_ENTRY),
450
                                    obj->getBoolAttribute(SUMO_ATTR_EXPECT_ARRIVAL),
451
                                    obj->getParameters())) {
452
                    obj->markAsCreated();
453
                }
454
                break;
455
            case SUMO_TAG_DET_ENTRY:
456
                if (buildDetectorEntry(obj,
457
                                       obj->getStringAttribute(SUMO_ATTR_LANE),
458
                                       obj->getDoubleAttribute(SUMO_ATTR_POSITION),
459
                                       obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
460
                                       obj->getParameters())) {
461
                    obj->markAsCreated();
462
                }
463
                break;
464
            case SUMO_TAG_DET_EXIT:
465
                if (buildDetectorExit(obj,
466
                                      obj->getStringAttribute(SUMO_ATTR_LANE),
467
                                      obj->getDoubleAttribute(SUMO_ATTR_POSITION),
468
                                      obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
469
                                      obj->getParameters())) {
470
                    obj->markAsCreated();
471
                }
472
                break;
473
            case SUMO_TAG_INSTANT_INDUCTION_LOOP:
474
                if (buildDetectorE1Instant(obj,
475
                                           obj->getStringAttribute(SUMO_ATTR_ID),
476
                                           obj->getStringAttribute(SUMO_ATTR_LANE),
477
                                           obj->getDoubleAttribute(SUMO_ATTR_POSITION),
478
                                           obj->getStringAttribute(SUMO_ATTR_FILE),
479
                                           obj->getStringListAttribute(SUMO_ATTR_VTYPES),
480
                                           obj->getStringListAttribute(SUMO_ATTR_NEXT_EDGES),
481
                                           obj->getStringAttribute(SUMO_ATTR_DETECT_PERSONS),
482
                                           obj->getStringAttribute(SUMO_ATTR_NAME),
483
                                           obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
484
                                           obj->getParameters())) {
485
                    obj->markAsCreated();
486
                }
487
                break;
488
            // TAZs
489
            case SUMO_TAG_TAZ:
490
                if (buildTAZ(obj,
491
                             obj->getStringAttribute(SUMO_ATTR_ID),
492
                             obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
493
                             obj->getPositionAttribute(SUMO_ATTR_CENTER),
494
                             obj->getBoolAttribute(SUMO_ATTR_FILL),
495
                             obj->getColorAttribute(SUMO_ATTR_COLOR),
496
                             obj->getStringListAttribute(SUMO_ATTR_EDGES),
497
                             obj->getStringAttribute(SUMO_ATTR_NAME),
498
                             obj->getParameters())) {
499
                    obj->markAsCreated();
500
                }
501
                break;
502
            case SUMO_TAG_TAZSOURCE:
503
                if (buildTAZSource(obj,
504
                                   obj->getStringAttribute(SUMO_ATTR_ID),
505
                                   obj->getDoubleAttribute(SUMO_ATTR_WEIGHT))) {
506
                    obj->markAsCreated();
507
                }
508
                break;
509
            case SUMO_TAG_TAZSINK:
510
                if (buildTAZSink(obj,
511
                                 obj->getStringAttribute(SUMO_ATTR_ID),
512
                                 obj->getDoubleAttribute(SUMO_ATTR_WEIGHT))) {
513
                    obj->markAsCreated();
514
                }
515
                break;
516
            // Variable Speed Sign
517
            case SUMO_TAG_VSS:
518
                if (buildVariableSpeedSign(obj,
519
                                           obj->getStringAttribute(SUMO_ATTR_ID),
520
                                           obj->getPositionAttribute(SUMO_ATTR_POSITION),
521
                                           obj->getStringListAttribute(SUMO_ATTR_LANES),
522
                                           obj->getStringAttribute(SUMO_ATTR_NAME),
523
                                           obj->getStringListAttribute(SUMO_ATTR_VTYPES),
524
                                           obj->getParameters())) {
525
                    obj->markAsCreated();
526
                }
527
                break;
528
            case SUMO_TAG_STEP:
529
                if (buildVariableSpeedSignStep(obj,
530
                                               obj->getTimeAttribute(SUMO_ATTR_TIME),
531
                                               obj->getDoubleAttribute(SUMO_ATTR_SPEED))) {
532
                    obj->markAsCreated();
533
                }
534
                break;
535
            // Calibrator
536
            case SUMO_TAG_CALIBRATOR:
537
                if (buildEdgeCalibrator(obj,
538
                                        obj->getStringAttribute(SUMO_ATTR_ID),
539
                                        obj->getStringAttribute(SUMO_ATTR_EDGE),
540
                                        obj->getDoubleAttribute(SUMO_ATTR_POSITION),
541
                                        obj->getStringAttribute(SUMO_ATTR_NAME),
542
                                        obj->getStringAttribute(SUMO_ATTR_OUTPUT),
543
                                        obj->getPeriodAttribute(),
544
                                        obj->getStringAttribute(SUMO_ATTR_ROUTEPROBE),
545
                                        obj->getDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD),
546
                                        obj->getStringListAttribute(SUMO_ATTR_VTYPES),
547
                                        obj->getParameters())) {
548
                    obj->markAsCreated();
549
                }
550
                break;
551
            case GNE_TAG_CALIBRATOR_LANE:
552
                if (buildLaneCalibrator(obj,
553
                                        obj->getStringAttribute(SUMO_ATTR_ID),
554
                                        obj->getStringAttribute(SUMO_ATTR_LANE),
555
                                        obj->getDoubleAttribute(SUMO_ATTR_POSITION),
556
                                        obj->getStringAttribute(SUMO_ATTR_NAME),
557
                                        obj->getStringAttribute(SUMO_ATTR_OUTPUT),
558
                                        obj->getPeriodAttribute(),
559
                                        obj->getStringAttribute(SUMO_ATTR_ROUTEPROBE),
560
                                        obj->getDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD),
561
                                        obj->getStringListAttribute(SUMO_ATTR_VTYPES),
562
                                        obj->getParameters())) {
563
                    obj->markAsCreated();
564
                }
565
                break;
566
            case SUMO_TAG_FLOW:
567
                if (buildCalibratorFlow(obj,
568
                                        obj->getVehicleParameter())) {
569
                    obj->markAsCreated();
570
                }
571
                break;
572
            // Rerouter
573
            case SUMO_TAG_REROUTER:
574
                if (buildRerouter(obj,
575
                                  obj->getStringAttribute(SUMO_ATTR_ID),
576
                                  obj->getPositionAttribute(SUMO_ATTR_POSITION),
577
                                  obj->getStringListAttribute(SUMO_ATTR_EDGES),
578
                                  obj->getDoubleAttribute(SUMO_ATTR_PROB),
579
                                  obj->getStringAttribute(SUMO_ATTR_NAME),
580
                                  obj->getBoolAttribute(SUMO_ATTR_OFF),
581
                                  obj->getBoolAttribute(SUMO_ATTR_OPTIONAL),
582
                                  obj->getTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD),
583
                                  obj->getStringListAttribute(SUMO_ATTR_VTYPES),
584
                                  obj->getParameters())) {
585
                    obj->markAsCreated();
586
                }
587
                break;
588
            case SUMO_TAG_CLOSING_LANE_REROUTE:
589
                if (buildClosingLaneReroute(obj,
590
                                            obj->getStringAttribute(SUMO_ATTR_ID),
591
                                            parseVehicleClasses(obj->getStringAttribute(SUMO_ATTR_ALLOW),
592
                                                    obj->getStringAttribute(SUMO_ATTR_DISALLOW)))) {
593
                    obj->markAsCreated();
594
                }
595
                break;
596
            case SUMO_TAG_CLOSING_REROUTE:
597
                if (buildClosingReroute(obj,
598
                                        obj->getStringAttribute(SUMO_ATTR_ID),
599
                                        parseVehicleClasses(obj->getStringAttribute(SUMO_ATTR_ALLOW),
600
                                                obj->getStringAttribute(SUMO_ATTR_DISALLOW)))) {
601
                    obj->markAsCreated();
602
                }
603
                break;
604
            case SUMO_TAG_DEST_PROB_REROUTE:
605
                if (buildDestProbReroute(obj,
606
                                         obj->getStringAttribute(SUMO_ATTR_ID),
607
                                         obj->getDoubleAttribute(SUMO_ATTR_PROB))) {
608
                    obj->markAsCreated();
609
                }
610
                break;
611
            case SUMO_TAG_PARKING_AREA_REROUTE:
612
                if (buildParkingAreaReroute(obj,
613
                                            obj->getStringAttribute(SUMO_ATTR_ID),
614
                                            obj->getDoubleAttribute(SUMO_ATTR_PROB),
615
                                            obj->getBoolAttribute(SUMO_ATTR_VISIBLE))) {
616
                    obj->markAsCreated();
617
                }
618
                break;
619
            case SUMO_TAG_ROUTE_PROB_REROUTE:
620
                if (buildRouteProbReroute(obj,
621
                                          obj->getStringAttribute(SUMO_ATTR_ID),
622
                                          obj->getDoubleAttribute(SUMO_ATTR_PROB))) {
623
                    obj->markAsCreated();
624
                }
625
                break;
626
            case SUMO_TAG_INTERVAL:
627
                // check if is aREROUTER interval
628
                if (obj->getParentSumoBaseObject()->getTag() == SUMO_TAG_REROUTER) {
629
                    if (buildRerouterInterval(obj,
630
                                              obj->getTimeAttribute(SUMO_ATTR_BEGIN),
631
                                              obj->getTimeAttribute(SUMO_ATTR_END))) {
632
                        obj->markAsCreated();
633
                    }
634
                }
635
                break;
636
            // Route probe
637
            case SUMO_TAG_ROUTEPROBE:
638
                if (buildRouteProbe(obj,
639
                                    obj->getStringAttribute(SUMO_ATTR_ID),
640
                                    obj->getStringAttribute(SUMO_ATTR_EDGE),
641
                                    obj->getPeriodAttribute(),
642
                                    obj->getStringAttribute(SUMO_ATTR_NAME),
643
                                    obj->getStringAttribute(SUMO_ATTR_FILE),
644
                                    obj->getTimeAttribute(SUMO_ATTR_BEGIN),
645
                                    obj->getStringListAttribute(SUMO_ATTR_VTYPES),
646
                                    obj->getParameters())) {
647
                    obj->markAsCreated();
648
                }
649
                break;
650
            // Vaporizer (deprecated)
651
            case SUMO_TAG_VAPORIZER:
652
                if (buildVaporizer(obj,
653
                                   obj->getStringAttribute(SUMO_ATTR_EDGE),
654
                                   obj->getTimeAttribute(SUMO_ATTR_BEGIN),
655
                                   obj->getTimeAttribute(SUMO_ATTR_END),
656
                                   obj->getStringAttribute(SUMO_ATTR_NAME),
657
                                   obj->getParameters())) {
658
                    obj->markAsCreated();
659
                }
660
                break;
661
            // wire elements
662
            case SUMO_TAG_TRACTION_SUBSTATION:
663
                if (buildTractionSubstation(obj,
664
                                            obj->getStringAttribute(SUMO_ATTR_ID),
665
                                            obj->getPositionAttribute(SUMO_ATTR_POSITION),
666
                                            obj->getDoubleAttribute(SUMO_ATTR_VOLTAGE),
667
                                            obj->getDoubleAttribute(SUMO_ATTR_CURRENTLIMIT),
668
                                            obj->getParameters())) {
669
                    obj->markAsCreated();
670
                }
671
                break;
672
            case SUMO_TAG_OVERHEAD_WIRE_SECTION:
673
                if (buildOverheadWire(obj,
674
                                      obj->getStringAttribute(SUMO_ATTR_ID),
675
                                      obj->getStringAttribute(SUMO_ATTR_SUBSTATIONID),
676
                                      obj->getStringListAttribute(SUMO_ATTR_LANES),
677
                                      obj->getDoubleAttribute(SUMO_ATTR_STARTPOS),
678
                                      obj->getDoubleAttribute(SUMO_ATTR_ENDPOS),
679
                                      obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
680
                                      obj->getStringListAttribute(SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN),
681
                                      obj->getParameters())) {
682
                    obj->markAsCreated();
683
                }
684
                break;
685
            case SUMO_TAG_OVERHEAD_WIRE_CLAMP:
686
                if (buildOverheadWireClamp(obj,
687
                                           obj->getStringAttribute(SUMO_ATTR_ID),
688
                                           obj->getStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_START),
689
                                           obj->getStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART),
690
                                           obj->getStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_END),
691
                                           obj->getStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND),
692
                                           obj->getParameters())) {
693
                    obj->markAsCreated();
694
                }
695
                break;
696
            // Polygon
697
            case SUMO_TAG_POLY:
698
                if (buildPolygon(obj,
699
                                 obj->getStringAttribute(SUMO_ATTR_ID),
700
                                 obj->getStringAttribute(SUMO_ATTR_TYPE),
701
                                 obj->getColorAttribute(SUMO_ATTR_COLOR),
702
                                 obj->getDoubleAttribute(SUMO_ATTR_LAYER),
703
                                 obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
704
                                 obj->getStringAttribute(SUMO_ATTR_IMGFILE),
705
                                 obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
706
                                 obj->getBoolAttribute(SUMO_ATTR_GEO),
707
                                 obj->getBoolAttribute(SUMO_ATTR_FILL),
708
                                 obj->getDoubleAttribute(SUMO_ATTR_LINEWIDTH),
709
                                 obj->getStringAttribute(SUMO_ATTR_NAME),
710
                                 obj->getParameters())) {
711
                    obj->markAsCreated();
712
                }
713
                break;
714
            // POI
715
            case SUMO_TAG_POI:
716
                // check if we want to create a POI, POILane or POIGEO
717
                if (obj->hasDoubleAttribute(SUMO_ATTR_X)) {
718
                    // build POI over view
719
                    if (buildPOI(obj,
720
                                 obj->getStringAttribute(SUMO_ATTR_ID),
721
                                 obj->getStringAttribute(SUMO_ATTR_TYPE),
722
                                 obj->getColorAttribute(SUMO_ATTR_COLOR),
723
                                 obj->getDoubleAttribute(SUMO_ATTR_X),
724
                                 obj->getDoubleAttribute(SUMO_ATTR_Y),
725
                                 obj->getStringAttribute(SUMO_ATTR_ICON),
726
                                 obj->getDoubleAttribute(SUMO_ATTR_LAYER),
727
                                 obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
728
                                 obj->getStringAttribute(SUMO_ATTR_IMGFILE),
729
                                 obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
730
                                 obj->getDoubleAttribute(SUMO_ATTR_HEIGHT),
731
                                 obj->getStringAttribute(SUMO_ATTR_NAME),
732
                                 obj->getParameters())) {
733
                        obj->markAsCreated();
734
                    }
735
                } else if (obj->hasStringAttribute(SUMO_ATTR_LANE)) {
736
                    // build POI over Lane
737
                    if (buildPOILane(obj,
738
                                     obj->getStringAttribute(SUMO_ATTR_ID),
739
                                     obj->getStringAttribute(SUMO_ATTR_TYPE),
740
                                     obj->getColorAttribute(SUMO_ATTR_COLOR),
741
                                     obj->getStringAttribute(SUMO_ATTR_LANE),
742
                                     obj->getDoubleAttribute(SUMO_ATTR_POSITION),
743
                                     obj->getBoolAttribute(SUMO_ATTR_FRIENDLY_POS),
744
                                     obj->getDoubleAttribute(SUMO_ATTR_POSITION_LAT),
745
                                     obj->getStringAttribute(SUMO_ATTR_ICON),
746
                                     obj->getDoubleAttribute(SUMO_ATTR_LAYER),
747
                                     obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
748
                                     obj->getStringAttribute(SUMO_ATTR_IMGFILE),
749
                                     obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
750
                                     obj->getDoubleAttribute(SUMO_ATTR_HEIGHT),
751
                                     obj->getStringAttribute(SUMO_ATTR_NAME),
752
                                     obj->getParameters())) {
753
                        obj->markAsCreated();
754
                    }
755
                } else {
756
                    // build POIGEO over view
757
                    if (buildPOIGeo(obj,
758
                                    obj->getStringAttribute(SUMO_ATTR_ID),
759
                                    obj->getStringAttribute(SUMO_ATTR_TYPE),
760
                                    obj->getColorAttribute(SUMO_ATTR_COLOR),
761
                                    obj->getDoubleAttribute(SUMO_ATTR_LON),
762
                                    obj->getDoubleAttribute(SUMO_ATTR_LAT),
763
                                    obj->getStringAttribute(SUMO_ATTR_ICON),
764
                                    obj->getDoubleAttribute(SUMO_ATTR_LAYER),
765
                                    obj->getDoubleAttribute(SUMO_ATTR_ANGLE),
766
                                    obj->getStringAttribute(SUMO_ATTR_IMGFILE),
767
                                    obj->getDoubleAttribute(SUMO_ATTR_WIDTH),
768
                                    obj->getDoubleAttribute(SUMO_ATTR_HEIGHT),
769
                                    obj->getStringAttribute(SUMO_ATTR_NAME),
770
                                    obj->getParameters())) {
771
                        obj->markAsCreated();
772
                    }
773
                }
774
                break;
775
            // Jps WalkableArea
776
            case GNE_TAG_JPS_WALKABLEAREA:
777
                if (buildJpsWalkableArea(obj,
778
                                         obj->getStringAttribute(SUMO_ATTR_ID),
779
                                         obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
780
                                         obj->getBoolAttribute(SUMO_ATTR_GEO),
781
                                         obj->getStringAttribute(SUMO_ATTR_NAME),
782
                                         obj->getParameters())) {
783
                    obj->markAsCreated();
784
                }
785
                break;
786
            // Jps Obstacle
787
            case GNE_TAG_JPS_OBSTACLE:
788
                if (buildJpsObstacle(obj,
789
                                     obj->getStringAttribute(SUMO_ATTR_ID),
790
                                     obj->getPositionVectorAttribute(SUMO_ATTR_SHAPE),
791
                                     obj->getBoolAttribute(SUMO_ATTR_GEO),
792
                                     obj->getStringAttribute(SUMO_ATTR_NAME),
793
                                     obj->getParameters())) {
794
                    obj->markAsCreated();
795
                }
796
                break;
797
            default:
798
                break;
799
        }
800
        // now iterate over childrens
801
        for (const auto& child : obj->getSumoBaseObjectChildren()) {
802
            // call this function recursively
803
            parseSumoBaseObject(child);
804
        }
805
    }
806
}
807

808

809
void
810
AdditionalHandler::parseBusStopAttributes(const SUMOSAXAttributes& attrs) {
811
    // declare Ok Flag
812
    bool parsedOk = true;
813
    // needed attributes
814
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
815
    const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
816
    // optional attributes
817
    const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
818
    const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
819
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
820
    const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
821
    const int personCapacity = attrs.getOpt<int>(SUMO_ATTR_PERSON_CAPACITY, id.c_str(), parsedOk, 6);
822
    const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), parsedOk, 0);
823
    const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
824
    const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
825
    const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, 0);
826
    // continue if flag is ok
827
    if (parsedOk) {
828
        // set tag
829
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_BUS_STOP);
830
        // add all attributes
831
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
832
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
833
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
834
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
835
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
836
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
837
        myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_PERSON_CAPACITY, personCapacity);
838
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PARKING_LENGTH, parkingLength);
839
        myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
840
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
841
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
842
    } else {
843
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
844
    }
845
}
846

847

848
void
849
AdditionalHandler::parseTrainStopAttributes(const SUMOSAXAttributes& attrs) {
850
    // declare Ok Flag
851
    bool parsedOk = true;
852
    // needed attributes
853
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
854
    const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
855
    // optional attributes
856
    const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
857
    const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
858
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
859
    const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
860
    const int personCapacity = attrs.getOpt<int>(SUMO_ATTR_PERSON_CAPACITY, id.c_str(), parsedOk, 6);
861
    const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), parsedOk, 0);
862
    const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
863
    const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
864
    const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, 0);
865
    // continue if flag is ok
866
    if (parsedOk) {
867
        // set tag
868
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TRAIN_STOP);
869
        // add all attributes
870
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
871
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
872
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
873
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
874
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
875
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
876
        myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_PERSON_CAPACITY, personCapacity);
877
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PARKING_LENGTH, parkingLength);
878
        myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
879
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
880
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
881
    } else {
882
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
883
    }
884
}
885

886

887
void
888
AdditionalHandler::parseAccessAttributes(const SUMOSAXAttributes& attrs) {
889
    // declare Ok Flag
890
    bool parsedOk = true;
891
    // needed attributes
892
    const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, "", parsedOk);
893
    const std::string position = attrs.get<std::string>(SUMO_ATTR_POSITION, "", parsedOk);
894
    // optional attributes
895
    const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, "", parsedOk, -1.00, false); /* in future updates, INVALID_DOUBLE */
896
    const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "", parsedOk, false);
897
    // check parent
898
    checkParsedParent(SUMO_TAG_ACCESS, {SUMO_TAG_BUS_STOP, SUMO_TAG_TRAIN_STOP, SUMO_TAG_CONTAINER_STOP}, parsedOk);
899
    // continue if flag is ok
900
    if (parsedOk) {
901
        // set tag
902
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ACCESS);
903
        // add all attributes
904
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
905
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_POSITION, position);
906
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
907
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
908
    } else {
909
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
910
    }
911
}
912

913

914
void
915
AdditionalHandler::parseContainerStopAttributes(const SUMOSAXAttributes& attrs) {
916
    // declare Ok Flag
917
    bool parsedOk = true;
918
    // needed attributes
919
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
920
    const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
921
    // optional attributes
922
    const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
923
    const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
924
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
925
    const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
926
    const int containerCapacity = attrs.getOpt<int>(SUMO_ATTR_CONTAINER_CAPACITY, id.c_str(), parsedOk, 6);
927
    const double parkingLength = attrs.getOpt<double>(SUMO_ATTR_PARKING_LENGTH, id.c_str(), parsedOk, 0);
928
    const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
929
    const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
930
    const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, 0);
931
    // continue if flag is ok
932
    if (parsedOk) {
933
        // set tag
934
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CONTAINER_STOP);
935
        // add all attributes
936
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
937
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
938
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
939
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
940
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
941
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
942
        myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_CONTAINER_CAPACITY, containerCapacity);
943
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PARKING_LENGTH, parkingLength);
944
        myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
945
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
946
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
947
    } else {
948
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
949
    }
950
}
951

952

953
void
954
AdditionalHandler::parseChargingStationAttributes(const SUMOSAXAttributes& attrs) {
955
    // declare Ok Flag
956
    bool parsedOk = true;
957
    // needed attributes
958
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
959
    const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
960
    // optional attributes
961
    const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
962
    const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
963
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
964
    const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, id.c_str(), parsedOk, std::vector<std::string>());
965
    const double chargingPower = attrs.getOpt<double>(SUMO_ATTR_CHARGINGPOWER, id.c_str(), parsedOk, 22000);
966
    const double efficiency = attrs.getOpt<double>(SUMO_ATTR_EFFICIENCY, id.c_str(), parsedOk, 0.95);
967
    const bool chargeInTransit = attrs.getOpt<bool>(SUMO_ATTR_CHARGEINTRANSIT, id.c_str(), parsedOk, 0);
968
    const SUMOTime chargeDelay = attrs.getOptSUMOTimeReporting(SUMO_ATTR_CHARGEDELAY, id.c_str(), parsedOk, 0);
969
    const std::string chargeType = attrs.getOpt<std::string>(SUMO_ATTR_CHARGETYPE, id.c_str(), parsedOk, SUMOXMLDefinitions::ChargeTypes.getString(ChargeType::NORMAL));
970
    const SUMOTime waitingTime = attrs.getOptSUMOTimeReporting(SUMO_ATTR_WAITINGTIME, id.c_str(), parsedOk, TIME2STEPS(900));
971
    const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
972
    const std::string parkingAreaID = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, id.c_str(), parsedOk, "");
973
    // check charge type
974
    if ((chargeType != "normal") && (chargeType != "battery-exchange") && (chargeType != "fuel")) {
975
        writeError(TLF("Invalid charge type '%' defined in chargingStation '%'.", chargeType, id));
976
        parsedOk = false;
977
    }
978
    // continue if flag is ok
979
    if (parsedOk) {
980
        // set tag
981
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CHARGING_STATION);
982
        // add all attributes
983
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
984
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
985
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
986
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
987
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
988
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LINES, lines);
989
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_CHARGINGPOWER, chargingPower);
990
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_EFFICIENCY, efficiency);
991
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_CHARGEINTRANSIT, chargeInTransit);
992
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_CHARGEDELAY, chargeDelay);
993
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_CHARGETYPE, chargeType);
994
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_WAITINGTIME, waitingTime);
995
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
996
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_PARKING_AREA, parkingAreaID);
997
    } else {
998
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
999
    }
1000
}
1001

1002

1003
void
1004
AdditionalHandler::parseParkingAreaAttributes(const SUMOSAXAttributes& attrs) {
1005
    // declare Ok Flag
1006
    bool parsedOk = true;
1007
    // needed attributes
1008
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1009
    const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
1010
    // optional attributes
1011
    const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
1012
    const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
1013
    const std::string departPos = attrs.getOpt<std::string>(SUMO_ATTR_DEPARTPOS, id.c_str(), parsedOk, "");
1014
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1015
    const std::vector<std::string> badges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_ACCEPTED_BADGES, id.c_str(), parsedOk, std::vector<std::string>());
1016
    const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1017
    const int roadSideCapacity = attrs.getOpt<int>(SUMO_ATTR_ROADSIDE_CAPACITY, id.c_str(), parsedOk, 0);
1018
    const bool onRoad = attrs.getOpt<bool>(SUMO_ATTR_ONROAD, id.c_str(), parsedOk, false);
1019
    const double width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, id.c_str(), parsedOk, 0);
1020
    const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, id.c_str(), parsedOk, 0);
1021
    const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, 0);
1022
    const bool lefthand = attrs.getOpt<bool>(SUMO_ATTR_LEFTHAND, id.c_str(), parsedOk, false);
1023
    // continue if flag is ok
1024
    if (parsedOk) {
1025
        // set tag
1026
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_PARKING_AREA);
1027
        // add all attributes
1028
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1029
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1030
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
1031
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
1032
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DEPARTPOS, departPos);
1033
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1034
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_ACCEPTED_BADGES, badges);
1035
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1036
        myCommonXMLStructure.getCurrentSumoBaseObject()->addIntAttribute(SUMO_ATTR_ROADSIDE_CAPACITY, roadSideCapacity);
1037
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_ONROAD, onRoad);
1038
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WIDTH, width);
1039
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
1040
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
1041
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_LEFTHAND, lefthand);
1042
    } else {
1043
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1044
    }
1045
}
1046

1047

1048
void
1049
AdditionalHandler::parseParkingSpaceAttributes(const SUMOSAXAttributes& attrs) {
1050
    // declare Ok Flag
1051
    bool parsedOk = true;
1052
    // needed attributes
1053
    const double x = attrs.get<double>(SUMO_ATTR_X, "", parsedOk);
1054
    const double y = attrs.get<double>(SUMO_ATTR_Y, "", parsedOk);
1055
    // optional attributes
1056
    const double z = attrs.getOpt<double>(SUMO_ATTR_Z, "", parsedOk, 0);
1057
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, "", parsedOk, "");
1058
    const std::string width = attrs.getOpt<std::string>(SUMO_ATTR_WIDTH, "", parsedOk, "");
1059
    const std::string length = attrs.getOpt<std::string>(SUMO_ATTR_LENGTH, "", parsedOk, "");
1060
    const std::string angle = attrs.getOpt<std::string>(SUMO_ATTR_ANGLE, "", parsedOk, "");
1061
    const double slope = attrs.getOpt<double>(SUMO_ATTR_SLOPE, "", parsedOk, 0);
1062
    // check parent
1063
    checkParsedParent(SUMO_TAG_PARKING_SPACE, {SUMO_TAG_PARKING_AREA}, parsedOk);
1064
    // continue if flag is ok
1065
    if (parsedOk) {
1066
        // set tag
1067
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_PARKING_SPACE);
1068
        // add all attributes
1069
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_X, x);
1070
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_Y, y);
1071
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_Z, z);
1072
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1073
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_WIDTH, width);
1074
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LENGTH, length);
1075
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ANGLE, angle);
1076
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_SLOPE, slope);
1077
    } else {
1078
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1079
    }
1080
}
1081

1082

1083
void
1084
AdditionalHandler::parseE1Attributes(const SUMOSAXAttributes& attrs) {
1085
    // declare Ok Flag
1086
    bool parsedOk = true;
1087
    // needed attributes
1088
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1089
    const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
1090
    const double position = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
1091
    const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1092
    const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1093
    // optional attributes
1094
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1095
    const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1096
    const std::vector<std::string> nextEdges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_NEXT_EDGES, id.c_str(), parsedOk, std::vector<std::string>());
1097
    const std::string detectPersons = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, "", parsedOk);
1098
    const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1099
    // continue if flag is ok
1100
    if (parsedOk && checkDetectPersons(SUMO_TAG_E1DETECTOR, id, detectPersons)) {
1101
        // set tag
1102
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_E1DETECTOR);
1103
        // add all attributes
1104
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1105
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1106
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1107
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1108
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1109
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1110
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1111
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_NEXT_EDGES, nextEdges);
1112
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);
1113
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1114
    } else {
1115
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1116
    }
1117
}
1118

1119

1120
void
1121
AdditionalHandler::parseE2Attributes(const SUMOSAXAttributes& attrs) {
1122
    // declare Ok Flag
1123
    bool parsedOk = true;
1124
    const int positionDef = attrs.hasAttribute(SUMO_ATTR_POSITION) ? 1 : 0;
1125
    const int endPosDef = attrs.hasAttribute(SUMO_ATTR_ENDPOS) ? 1 : 0;
1126
    const int lengthDef = attrs.hasAttribute(SUMO_ATTR_LENGTH) ? 1 : 0;
1127
    // check attributes
1128
    if (attrs.hasAttribute(SUMO_ATTR_LANE) && ((positionDef + endPosDef + lengthDef) > 2)) {
1129
        writeError(TL("'pos', 'endPos' and 'length' cannot be defined together in a single lane area detector."));
1130
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1131
    } else if (attrs.hasAttribute(SUMO_ATTR_LANE) && ((positionDef + endPosDef + lengthDef) < 2)) {
1132
        writeError(TL("A single lane area detector requires two parameters of those 'pos', 'endPos' and 'length'."));
1133
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1134
    } else {
1135
        // needed attributes
1136
        const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1137
        const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1138
        // special attributes
1139
        const std::string laneId = attrs.getOpt<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk, "");
1140
        const std::vector<std::string> laneIds = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LANES, id.c_str(), parsedOk, std::vector<std::string>());
1141
        const double position = attrs.getOpt<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, 0);
1142
        const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, 0);
1143
        const double length = attrs.getOpt<double>(SUMO_ATTR_LENGTH, id.c_str(), parsedOk, 0);
1144
        // optional attributes
1145
        const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1146
        const std::string trafficLight = attrs.getOpt<std::string>(SUMO_ATTR_TLID, id.c_str(), parsedOk, "");
1147
        const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1148
        const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), parsedOk, TIME2STEPS(1));
1149
        const double haltingSpeedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), parsedOk, 1.39);
1150
        const double jamDistThreshold = attrs.getOpt<double>(SUMO_ATTR_JAM_DIST_THRESHOLD, id.c_str(), parsedOk, 10);
1151
        const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1152
        const std::vector<std::string> nextEdges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_NEXT_EDGES, id.c_str(), parsedOk, std::vector<std::string>());
1153
        const std::string detectPersons = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, "", parsedOk);
1154
        const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1155
        const bool show = attrs.getOpt<bool>(SUMO_ATTR_SHOW_DETECTOR, id.c_str(), parsedOk, true);
1156
        // continue if flag is ok
1157
        if (parsedOk && checkDetectPersons(SUMO_TAG_E2DETECTOR, id, detectPersons)) {
1158
            // set tag
1159
            myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_E2DETECTOR);
1160
            // add attributes depending of Lane/Lanes
1161
            if (attrs.hasAttribute(SUMO_ATTR_LANE)) {
1162
                myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1163
                if (positionDef == 0) {
1164
                    myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, endPos - length);
1165
                    myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
1166
                } else if (endPosDef == 0) {
1167
                    myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1168
                    myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, length);
1169
                } else if (lengthDef == 0) {
1170
                    myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1171
                    myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LENGTH, endPos - position);
1172
                }
1173
            } else {
1174
                myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LANES, laneIds);
1175
                myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1176
                myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
1177
            }
1178
            // add all attributes
1179
            myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1180
            myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1181
            myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TLID, trafficLight);
1182
            myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1183
            myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1184
            myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_NEXT_EDGES, nextEdges);
1185
            myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);
1186
            myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1187
            myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD, haltingTimeThreshold);
1188
            myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD, haltingSpeedThreshold);
1189
            myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD, jamDistThreshold);
1190
            myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1191
            myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_SHOW_DETECTOR, show);
1192
        } else {
1193
            myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1194
        }
1195
    }
1196
}
1197

1198

1199
void
1200
AdditionalHandler::parseE3Attributes(const SUMOSAXAttributes& attrs) {
1201
    // declare Ok Flag
1202
    bool parsedOk = true;
1203
    // needed attributes
1204
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1205
    const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1206
    const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1207
    // optional attributes
1208
    const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position());
1209
    const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1210
    const std::vector<std::string> nextEdges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_NEXT_EDGES, id.c_str(), parsedOk, std::vector<std::string>());
1211
    const std::string detectPersons = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, "", parsedOk);
1212
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1213
    const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), parsedOk, TIME2STEPS(1));
1214
    const double haltingSpeedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), parsedOk, 1.39);
1215
    const bool openEntry = attrs.getOpt<bool>(SUMO_ATTR_OPEN_ENTRY, id.c_str(), parsedOk, false);
1216
    const bool expectedArrival = attrs.getOpt<bool>(SUMO_ATTR_EXPECT_ARRIVAL, id.c_str(), parsedOk, false);
1217
    // continue if flag is ok
1218
    if (parsedOk && checkDetectPersons(SUMO_TAG_E3DETECTOR, id, detectPersons)) {
1219
        // set tag
1220
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_E3DETECTOR);
1221
        // add all attributes
1222
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1223
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1224
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1225
        myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1226
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1227
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_NEXT_EDGES, nextEdges);
1228
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);
1229
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1230
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD, haltingTimeThreshold);
1231
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD, haltingSpeedThreshold);
1232
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_OPEN_ENTRY, openEntry);
1233
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_EXPECT_ARRIVAL, expectedArrival);
1234
    } else {
1235
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1236
    }
1237
}
1238

1239

1240
void
1241
AdditionalHandler::parseEntryAttributes(const SUMOSAXAttributes& attrs) {
1242
    // declare Ok Flag
1243
    bool parsedOk = true;
1244
    // needed attributes
1245
    const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, "", parsedOk);
1246
    const double position = attrs.get<double>(SUMO_ATTR_POSITION, "", parsedOk);
1247
    // optional attributes
1248
    const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "", parsedOk, false);
1249
    // check parent
1250
    checkParsedParent(SUMO_TAG_DET_ENTRY, {SUMO_TAG_E3DETECTOR}, parsedOk);
1251
    // continue if flag is ok
1252
    if (parsedOk) {
1253
        // set tag
1254
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_DET_ENTRY);
1255
        // add all attributes
1256
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1257
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1258
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1259
    } else {
1260
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1261
    }
1262
}
1263

1264

1265
void
1266
AdditionalHandler::parseExitAttributes(const SUMOSAXAttributes& attrs) {
1267
    // declare Ok Flag
1268
    bool parsedOk = true;
1269
    // needed attributes
1270
    const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, "", parsedOk);
1271
    const double position = attrs.get<double>(SUMO_ATTR_POSITION, "", parsedOk);
1272
    // optional attributes
1273
    const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, "", parsedOk, false);
1274
    // check parent
1275
    checkParsedParent(SUMO_TAG_DET_EXIT, {SUMO_TAG_E3DETECTOR}, parsedOk);
1276
    // continue if flag is ok
1277
    if (parsedOk) {
1278
        // set tag
1279
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_DET_EXIT);
1280
        // add all attributes
1281
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1282
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1283
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1284
    } else {
1285
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1286
    }
1287
}
1288

1289

1290
void
1291
AdditionalHandler::parseE1InstantAttributes(const SUMOSAXAttributes& attrs) {
1292
    // declare Ok Flag
1293
    bool parsedOk = true;
1294
    // needed attributes
1295
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1296
    const std::string laneId = attrs.get<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk);
1297
    const double position = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
1298
    const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1299
    // optional attributes
1300
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1301
    const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1302
    const std::vector<std::string> nextEdges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_NEXT_EDGES, id.c_str(), parsedOk, std::vector<std::string>());
1303
    const std::string detectPersons = attrs.getOpt<std::string>(SUMO_ATTR_DETECT_PERSONS, "", parsedOk);
1304
    const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1305
    // continue if flag is ok
1306
    if (parsedOk && checkDetectPersons(SUMO_TAG_INSTANT_INDUCTION_LOOP, id, detectPersons)) {
1307
        // set tag
1308
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_INSTANT_INDUCTION_LOOP);
1309
        // add all attributes
1310
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1311
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, laneId);
1312
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, position);
1313
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1314
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1315
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_NEXT_EDGES, nextEdges);
1316
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);
1317
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1318
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1319
    } else {
1320
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1321
    }
1322
}
1323

1324

1325
void
1326
AdditionalHandler::parseTAZAttributes(const SUMOSAXAttributes& attrs) {
1327
    // declare Ok Flag
1328
    bool parsedOk = true;
1329
    // needed attributes
1330
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1331
    // optional attributes
1332
    const PositionVector shape = attrs.getOpt<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk, PositionVector());
1333
    const Position center = attrs.getOpt<Position>(SUMO_ATTR_CENTER, id.c_str(), parsedOk, shape.size() > 0 ? shape.getCentroid() : Position::INVALID);
1334
    const bool fill = attrs.getOpt<bool>(SUMO_ATTR_FILL, id.c_str(), parsedOk, false);
1335
    const std::vector<std::string> edges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk, std::vector<std::string>());
1336
    const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::RED);
1337
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1338
    // continue if flag is ok
1339
    if (parsedOk) {
1340
        // set tag
1341
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZ);
1342
        // add all attributes
1343
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1344
        myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shape);
1345
        myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_CENTER, center);
1346
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FILL, fill);
1347
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_EDGES, edges);
1348
        myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
1349
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1350
    } else {
1351
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1352
    }
1353
}
1354

1355

1356
void
1357
AdditionalHandler::parseTAZSourceAttributes(const SUMOSAXAttributes& attrs) {
1358
    // declare Ok Flag
1359
    bool parsedOk = true;
1360
    // needed attributes
1361
    const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1362
    const double weight = attrs.get<double>(SUMO_ATTR_WEIGHT, edgeID.c_str(), parsedOk);
1363
    // check parent
1364
    checkParsedParent(SUMO_TAG_TAZSOURCE, {SUMO_TAG_TAZ}, parsedOk);
1365
    // continue if flag is ok
1366
    if (parsedOk) {
1367
        // set tag
1368
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZSOURCE);
1369
        // add all attributes
1370
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1371
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WEIGHT, weight);
1372
    } else {
1373
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1374
    }
1375
}
1376

1377

1378
void
1379
AdditionalHandler::parseTAZSinkAttributes(const SUMOSAXAttributes& attrs) {
1380
    // declare Ok Flag
1381
    bool parsedOk = true;
1382
    // needed attributes
1383
    const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1384
    const double weight = attrs.get<double>(SUMO_ATTR_WEIGHT, edgeID.c_str(), parsedOk);
1385
    // check parent
1386
    checkParsedParent(SUMO_TAG_TAZSINK, {SUMO_TAG_TAZ}, parsedOk);
1387
    // continue if flag is ok
1388
    if (parsedOk) {
1389
        // set tag
1390
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TAZSINK);
1391
        // add all attributes
1392
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1393
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WEIGHT, weight);
1394
    } else {
1395
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1396
    }
1397
}
1398

1399

1400
void
1401
AdditionalHandler::parseVariableSpeedSignAttributes(const SUMOSAXAttributes& attrs) {
1402
    // declare Ok Flag
1403
    bool parsedOk = true;
1404
    // needed attributes
1405
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1406
    const std::vector<std::string> lanes = attrs.get<std::vector<std::string> >(SUMO_ATTR_LANES, id.c_str(), parsedOk);
1407
    // optional attributes
1408
    const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position());
1409
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1410
    const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1411
    // continue if flag is ok
1412
    if (parsedOk) {
1413
        // set tag
1414
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_VSS);
1415
        // add all attributes
1416
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1417
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LANES, lanes);
1418
        myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1419
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1420
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1421
    } else {
1422
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1423
    }
1424
}
1425

1426

1427
void
1428
AdditionalHandler::parseVariableSpeedSignStepAttributes(const SUMOSAXAttributes& attrs) {
1429
    // declare Ok Flag
1430
    bool parsedOk = true;
1431
    // needed attributes
1432
    const SUMOTime time = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME, "", parsedOk);
1433
    // optional attributes
1434
    const double speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, "", parsedOk, OptionsCont::getOptions().getFloat("default.speed"));
1435
    // check parent
1436
    checkParsedParent(SUMO_TAG_STEP, {SUMO_TAG_VSS}, parsedOk);
1437
    // continue if flag is ok
1438
    if (parsedOk) {
1439
        // set tag
1440
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_STEP);
1441
        // add all attributes
1442
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_TIME, time);
1443
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_SPEED, speed);
1444
    } else {
1445
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1446
    }
1447
}
1448

1449

1450
void
1451
AdditionalHandler::parseCalibratorAttributes(const SUMOSAXAttributes& attrs) {
1452
    // declare Ok Flag
1453
    bool parsedOk = true;
1454
    // check that frecuency and trafficLight aren't defined together
1455
    if ((attrs.hasAttribute(SUMO_ATTR_EDGE) && attrs.hasAttribute(SUMO_ATTR_LANE)) ||
1456
            (!attrs.hasAttribute(SUMO_ATTR_EDGE) && !attrs.hasAttribute(SUMO_ATTR_LANE))) {
1457
        writeError(TL("Calibrators need either an edge or a lane"));
1458
        parsedOk = false;
1459
    }
1460
    // needed attributes
1461
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1462
    const double pos = attrs.get<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk);
1463
    // special attributes
1464
    const std::string edge = attrs.getOpt<std::string>(SUMO_ATTR_EDGE, id.c_str(), parsedOk, "");
1465
    const std::string lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, id.c_str(), parsedOk, "");
1466
    // optional attributes
1467
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1468
    const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, DELTA_T);
1469
    const std::string routeProbe = attrs.getOpt<std::string>(SUMO_ATTR_ROUTEPROBE, id.c_str(), parsedOk, "");
1470
    const double jamThreshold = attrs.getOpt<double>(SUMO_ATTR_JAM_DIST_THRESHOLD, id.c_str(), parsedOk, 0.5);
1471
    const std::string output = attrs.getOpt<std::string>(SUMO_ATTR_OUTPUT, id.c_str(), parsedOk, "");
1472
    const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1473
    // continue if flag is ok
1474
    if (parsedOk) {
1475
        // set tag depending of edge/lane
1476
        if (attrs.hasAttribute(SUMO_ATTR_EDGE)) {
1477
            myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CALIBRATOR);
1478
            myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EDGE, edge);
1479
        } else {
1480
            myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(GNE_TAG_CALIBRATOR_LANE);
1481
            myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, lane);
1482
        }
1483
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1484
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, pos);
1485
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1486
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1487
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ROUTEPROBE, routeProbe);
1488
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_JAM_DIST_THRESHOLD, jamThreshold);
1489
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OUTPUT, output);
1490
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1491
    } else {
1492
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1493
    }
1494
}
1495

1496

1497
void
1498
AdditionalHandler::parseCalibratorFlowAttributes(const SUMOSAXAttributes& attrs) {
1499
    // declare Ok Flag
1500
    bool parsedOk = true;
1501
    // check parent
1502
    if (checkCalibratorFlowParents()) {
1503
        // check that frecuency and trafficLight aren't defined together
1504
        if (!attrs.hasAttribute(SUMO_ATTR_TYPE) && !attrs.hasAttribute(SUMO_ATTR_VEHSPERHOUR) && !attrs.hasAttribute(SUMO_ATTR_SPEED)) {
1505
            writeError(TL("CalibratorFlows need either the attribute vehsPerHour or speed or type (or any combination of these)"));
1506
            myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1507
        } else {
1508
            SUMOVehicleParameter* flowParameter = SUMOVehicleParserHelper::parseVehicleAttributes(SUMO_TAG_FLOW, attrs, false, true, true);
1509
            if (flowParameter) {
1510
                // set VPH and speed
1511
                if (attrs.hasAttribute(SUMO_ATTR_VEHSPERHOUR)) {
1512
                    flowParameter->repetitionOffset = TIME2STEPS(3600. / attrs.get<double>(SUMO_ATTR_VEHSPERHOUR, "", parsedOk));
1513
                    flowParameter->parametersSet |= VEHPARS_VPH_SET;
1514
                }
1515
                if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
1516
                    flowParameter->calibratorSpeed = attrs.get<double>(SUMO_ATTR_SPEED, "", parsedOk);
1517
                    flowParameter->parametersSet |= VEHPARS_CALIBRATORSPEED_SET;
1518
                }
1519
                // set begin and end
1520
                flowParameter->depart = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, "", parsedOk);
1521
                flowParameter->repetitionEnd = attrs.getSUMOTimeReporting(SUMO_ATTR_END, "", parsedOk);
1522
                if (parsedOk) {
1523
                    // set tag
1524
                    myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_FLOW);
1525
                    // set vehicle parameters
1526
                    myCommonXMLStructure.getCurrentSumoBaseObject()->setVehicleParameter(flowParameter);
1527
                    // delete flow parameter (because in XMLStructure we have a copy)
1528
                    delete flowParameter;
1529
                } else {
1530
                    myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1531
                }
1532
            } else {
1533
                myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1534
            }
1535
        }
1536
    } else {
1537
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1538
    }
1539
}
1540

1541

1542
void
1543
AdditionalHandler::parseRerouterAttributes(const SUMOSAXAttributes& attrs) {
1544
    // declare Ok Flag
1545
    bool parsedOk = true;
1546
    // needed attributes
1547
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1548
    const std::vector<std::string> edges = attrs.get<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk);
1549
    // optional attributes
1550
    const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position::INVALID);
1551
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1552
    const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, id.c_str(), parsedOk, 1);
1553
    SUMOTime timeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, id.c_str(), parsedOk, 0);
1554
    const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1555
    const bool off = attrs.getOpt<bool>(SUMO_ATTR_OFF, id.c_str(), parsedOk, false);
1556
    const bool optional = attrs.getOpt<bool>(SUMO_ATTR_OPTIONAL, id.c_str(), parsedOk, false);
1557
    // check attributes
1558
    if (!checkNegative(SUMO_TAG_REROUTER, id, SUMO_ATTR_PROB, probability, true)) {
1559
        parsedOk = false;
1560
    }
1561
    // continue if flag is ok
1562
    if (parsedOk) {
1563
        // set tag
1564
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_REROUTER);
1565
        // add all attributes
1566
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1567
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_EDGES, edges);
1568
        myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1569
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1570
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1571
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_HALTING_TIME_THRESHOLD, timeThreshold);
1572
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1573
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_OFF, off);
1574
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_OPTIONAL, optional);
1575
    } else {
1576
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1577
    }
1578
}
1579

1580

1581
void
1582
AdditionalHandler::parseRerouterIntervalAttributes(const SUMOSAXAttributes& attrs) {
1583
    // declare Ok Flag
1584
    bool parsedOk = true;
1585
    // needed attributes
1586
    const SUMOTime begin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, "", parsedOk);
1587
    const SUMOTime end = attrs.getSUMOTimeReporting(SUMO_ATTR_END, "", parsedOk);
1588
    // check parent
1589
    checkParsedParent(SUMO_TAG_INTERVAL, {SUMO_TAG_REROUTER}, parsedOk);
1590
    // continue if flag is ok
1591
    if (parsedOk) {
1592
        // set tag
1593
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_INTERVAL);
1594
        // add all attributes
1595
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);
1596
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_END, end);
1597
    } else {
1598
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1599
    }
1600
}
1601

1602

1603
void
1604
AdditionalHandler::parseClosingLaneRerouteAttributes(const SUMOSAXAttributes& attrs) {
1605
    // declare Ok Flag
1606
    bool parsedOk = true;
1607
    // needed attributes
1608
    const std::string laneID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1609
    // optional attributes
1610
    const std::string disallow = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, "", parsedOk, "");
1611
    const std::string allow = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, "", parsedOk, !disallow.size() ? "authority" : "");
1612
    // check parent
1613
    checkParsedParent(SUMO_TAG_CLOSING_LANE_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1614
    // continue if flag is ok
1615
    if (parsedOk) {
1616
        // set tag
1617
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CLOSING_LANE_REROUTE);
1618
        // add all attributes
1619
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, laneID);
1620
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ALLOW, allow);
1621
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DISALLOW, disallow);
1622
    } else {
1623
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1624
    }
1625
}
1626

1627

1628
void
1629
AdditionalHandler::parseClosingRerouteAttributes(const SUMOSAXAttributes& attrs) {
1630
    // declare Ok Flag
1631
    bool parsedOk = true;
1632
    // needed attributes
1633
    const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1634
    // optional attributes
1635
    const std::string disallow = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, "", parsedOk, "");
1636
    const std::string allow = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, "", parsedOk, !disallow.size() ? "authority" : "");
1637
    // check parent
1638
    checkParsedParent(SUMO_TAG_CLOSING_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1639
    // continue if flag is ok
1640
    if (parsedOk) {
1641
        // set tag
1642
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_CLOSING_REROUTE);
1643
        // add all attributes
1644
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1645
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ALLOW, allow);
1646
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_DISALLOW, disallow);
1647
    } else {
1648
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1649
    }
1650
}
1651

1652

1653
void
1654
AdditionalHandler::parseDestProbRerouteAttributes(const SUMOSAXAttributes& attrs) {
1655
    // declare Ok Flag
1656
    bool parsedOk = true;
1657
    // needed attributes
1658
    const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1659
    const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, "", parsedOk, 1);
1660
    // check attributes
1661
    if (!checkNegative(SUMO_TAG_DEST_PROB_REROUTE, edgeID, SUMO_ATTR_PROB, probability, true)) {
1662
        parsedOk = false;
1663
    }
1664
    // check parent
1665
    checkParsedParent(SUMO_TAG_DEST_PROB_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1666
    // continue if flag is ok
1667
    if (parsedOk) {
1668
        // set tag
1669
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_DEST_PROB_REROUTE);
1670
        // add all attributes
1671
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, edgeID);
1672
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1673
    } else {
1674
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1675
    }
1676
}
1677

1678

1679
void
1680
AdditionalHandler::parseParkingAreaRerouteAttributes(const SUMOSAXAttributes& attrs) {
1681
    // declare Ok Flag
1682
    bool parsedOk = true;
1683
    // needed attributes
1684
    const std::string parkingAreaID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1685
    const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, "", parsedOk, 1);
1686
    // check attributes
1687
    if (!checkNegative(SUMO_TAG_PARKING_AREA_REROUTE, parkingAreaID, SUMO_ATTR_PROB, probability, true)) {
1688
        parsedOk = false;
1689
    }
1690
    // optional attributes
1691
    const bool visible = attrs.getOpt<bool>(SUMO_ATTR_VISIBLE, "", parsedOk, false);
1692
    // check parent
1693
    checkParsedParent(SUMO_TAG_PARKING_AREA_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1694
    // continue if flag is ok
1695
    if (parsedOk) {
1696
        // set tag
1697
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_PARKING_AREA_REROUTE);
1698
        // add all attributes
1699
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, parkingAreaID);
1700
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1701
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_VISIBLE, visible);
1702
    } else {
1703
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1704
    }
1705
}
1706

1707

1708
void
1709
AdditionalHandler::parseRouteProbRerouteAttributes(const SUMOSAXAttributes& attrs) {
1710
    // declare Ok Flag
1711
    bool parsedOk = true;
1712
    // needed attributes
1713
    const std::string routeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1714
    const double probability = attrs.getOpt<double>(SUMO_ATTR_PROB, "", parsedOk, 1);
1715
    // check attributes
1716
    if (!checkNegative(SUMO_TAG_ROUTE_PROB_REROUTE, routeID, SUMO_ATTR_PROB, probability, true)) {
1717
        parsedOk = false;
1718
    }
1719
    // check parent
1720
    checkParsedParent(SUMO_TAG_ROUTE_PROB_REROUTE, {SUMO_TAG_INTERVAL}, parsedOk);
1721
    // continue if flag is ok
1722
    if (parsedOk) {
1723
        // set tag
1724
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ROUTE_PROB_REROUTE);
1725
        // add all attributes
1726
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, routeID);
1727
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_PROB, probability);
1728
    } else {
1729
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1730
    }
1731
}
1732

1733

1734
void
1735
AdditionalHandler::parseRouteProbeAttributes(const SUMOSAXAttributes& attrs) {
1736
    // declare Ok Flag
1737
    bool parsedOk = true;
1738
    // needed attributes
1739
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1740
    const std::string edge = attrs.get<std::string>(SUMO_ATTR_EDGE, id.c_str(), parsedOk);
1741
    const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);
1742
    const SUMOTime period = attrs.getOptPeriod(id.c_str(), parsedOk, SUMOTime_MAX_PERIOD);
1743
    const SUMOTime begin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, id.c_str(), parsedOk, -1);
1744
    // optional attributes
1745
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1746
    const std::vector<std::string> vehicleTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, std::vector<std::string>());
1747
    // continue if flag is ok
1748
    if (parsedOk) {
1749
        // set tag
1750
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ROUTEPROBE);
1751
        // add all attributes
1752
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1753
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EDGE, edge);
1754
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);
1755
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);
1756
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1757
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);
1758
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vehicleTypes);
1759
    } else {
1760
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1761
    }
1762
}
1763

1764

1765
void
1766
AdditionalHandler::parseVaporizerAttributes(const SUMOSAXAttributes& attrs) {
1767
    // declare Ok Flag
1768
    bool parsedOk = true;
1769
    // needed attributes
1770
    const std::string edgeID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1771
    SUMOTime begin = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, nullptr, parsedOk);
1772
    SUMOTime end = attrs.getSUMOTimeReporting(SUMO_ATTR_END, nullptr, parsedOk);
1773
    // optional attributes
1774
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, edgeID.c_str(), parsedOk, "");
1775
    // continue if flag is ok
1776
    if (parsedOk) {
1777
        // set tag
1778
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_VAPORIZER);
1779
        // add all attributes
1780
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EDGE, edgeID);
1781
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);
1782
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_END, end);
1783
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1784
    } else {
1785
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1786
    }
1787
}
1788

1789

1790
void
1791
AdditionalHandler::parseTractionSubstation(const SUMOSAXAttributes& attrs) {
1792
    // declare Ok Flag
1793
    bool parsedOk = true;
1794
    // needed attributes
1795
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1796
    // optional attributes
1797
    const Position pos = attrs.getOpt<Position>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, Position::INVALID);
1798
    const double voltage = attrs.getOpt<double>(SUMO_ATTR_VOLTAGE, id.c_str(), parsedOk, 600);
1799
    const double currentLimit = attrs.getOpt<double>(SUMO_ATTR_CURRENTLIMIT, id.c_str(), parsedOk, 400);
1800
    // continue if flag is ok
1801
    if (parsedOk) {
1802
        // set tag
1803
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_TRACTION_SUBSTATION);
1804
        // add all attributes
1805
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1806
        myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionAttribute(SUMO_ATTR_POSITION, pos);
1807
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_VOLTAGE, voltage);
1808
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_CURRENTLIMIT, currentLimit);
1809
    } else {
1810
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1811
    }
1812
}
1813

1814

1815
void
1816
AdditionalHandler::parseOverheadWire(const SUMOSAXAttributes& attrs) {
1817
    // declare Ok Flag
1818
    bool parsedOk = true;
1819
    // needed attributes
1820
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1821
    const std::string substationID = attrs.get<std::string>(SUMO_ATTR_SUBSTATIONID, id.c_str(), parsedOk);
1822
    const std::vector<std::string> laneIDs = attrs.get<std::vector<std::string> >(SUMO_ATTR_LANES, id.c_str(), parsedOk);
1823
    // optional attributes
1824
    const double startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, id.c_str(), parsedOk, 0);
1825
    const double endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, id.c_str(), parsedOk, INVALID_DOUBLE);
1826
    const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1827
    const std::vector<std::string> forbiddenInnerLanes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN, "", parsedOk);
1828
    // continue if flag is ok
1829
    if (parsedOk) {
1830
        // set tag
1831
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_OVERHEAD_WIRE_SECTION);
1832
        // add all attributes
1833
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1834
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_SUBSTATIONID, substationID);
1835
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_LANES, laneIDs);
1836
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_STARTPOS, startPos);
1837
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ENDPOS, endPos);
1838
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1839
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_OVERHEAD_WIRE_FORBIDDEN, forbiddenInnerLanes);
1840
    } else {
1841
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1842
    }
1843
}
1844

1845

1846
void
1847
AdditionalHandler::parseOverheadWireClamp(const SUMOSAXAttributes& attrs) {
1848
    // declare Ok Flag
1849
    bool parsedOk = true;
1850
    // needed attributes
1851
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1852
    const std::string substationId = attrs.get<std::string>(SUMO_ATTR_SUBSTATIONID, id.c_str(), parsedOk);
1853
    const std::string wireClampStart = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_START, id.c_str(), parsedOk);
1854
    const std::string wireClampLaneStart = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART, id.c_str(), parsedOk);
1855
    const std::string wireClampEnd = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_END, id.c_str(), parsedOk);
1856
    const std::string wireClampLaneEnd = attrs.get<std::string>(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND, id.c_str(), parsedOk);
1857
    // continue if flag is ok
1858
    if (parsedOk) {
1859
        // set tag
1860
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_OVERHEAD_WIRE_CLAMP);
1861
        // add all attributes
1862
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1863
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_SUBSTATIONID, substationId);
1864
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_START, wireClampStart);
1865
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANESTART, wireClampLaneStart);
1866
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_END, wireClampEnd);
1867
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_OVERHEAD_WIRECLAMP_LANEEND, wireClampLaneEnd);
1868
    } else {
1869
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1870
    }
1871
}
1872

1873

1874
void
1875
AdditionalHandler::parsePolyAttributes(const SUMOSAXAttributes& attrs) {
1876
    // declare Ok Flag
1877
    bool parsedOk = true;
1878
    // needed attributes
1879
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1880
    const PositionVector shapeStr = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk);
1881
    // optional attributes
1882
    const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::RED);
1883
    const bool geo = attrs.getOpt<bool>(SUMO_ATTR_GEO, id.c_str(), parsedOk, false);
1884
    const bool fill = attrs.getOpt<bool>(SUMO_ATTR_FILL, id.c_str(), parsedOk, false);
1885
    const double lineWidth = attrs.getOpt<double>(SUMO_ATTR_LINEWIDTH, id.c_str(), parsedOk, Shape::DEFAULT_LINEWIDTH);
1886
    const double layer = attrs.getOpt<double>(SUMO_ATTR_LAYER, id.c_str(), parsedOk, Shape::DEFAULT_LAYER);
1887
    const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), parsedOk, Shape::DEFAULT_TYPE);
1888
    const std::string imgFile = attrs.getOpt<std::string>(SUMO_ATTR_IMGFILE, id.c_str(), parsedOk, Shape::DEFAULT_IMG_FILE);
1889
    const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, Shape::DEFAULT_ANGLE);
1890
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1891
    // continue if flag is ok
1892
    if (parsedOk) {
1893
        // set tag
1894
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_POLY);
1895
        // add all attributes
1896
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1897
        myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shapeStr);
1898
        myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
1899
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_GEO, geo);
1900
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FILL, fill);
1901
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LINEWIDTH, lineWidth);
1902
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LAYER, layer);
1903
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TYPE, type);
1904
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_IMGFILE, imgFile);
1905
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
1906
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1907
    } else {
1908
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1909
    }
1910
}
1911

1912

1913
void
1914
AdditionalHandler::parsePOIAttributes(const SUMOSAXAttributes& attrs) {
1915
    // declare Ok Flag
1916
    bool parsedOk = true;
1917
    // check that x and y are defined together
1918
    if ((attrs.hasAttribute(SUMO_ATTR_X) && !attrs.hasAttribute(SUMO_ATTR_Y)) ||
1919
            (!attrs.hasAttribute(SUMO_ATTR_X) && attrs.hasAttribute(SUMO_ATTR_Y))) {
1920
        writeError(TL("X and Y must be be defined together in POIs"));
1921
        parsedOk = false;
1922
    }
1923
    // check that lane and pos are defined together
1924
    if ((attrs.hasAttribute(SUMO_ATTR_LANE) && !attrs.hasAttribute(SUMO_ATTR_POSITION)) ||
1925
            (!attrs.hasAttribute(SUMO_ATTR_LANE) && attrs.hasAttribute(SUMO_ATTR_POSITION))) {
1926
        writeError(TL("lane and position must be defined together in POIs"));
1927
        parsedOk = false;
1928
    }
1929
    // check that lon and lat are defined together
1930
    if ((attrs.hasAttribute(SUMO_ATTR_LON) && !attrs.hasAttribute(SUMO_ATTR_LAT)) ||
1931
            (!attrs.hasAttribute(SUMO_ATTR_LON) && attrs.hasAttribute(SUMO_ATTR_LAT))) {
1932
        writeError(TL("lon and lat must be be defined together in POIs"));
1933
        parsedOk = false;
1934
    }
1935
    // needed attributes
1936
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
1937
    // special attributes
1938
    const double x = attrs.getOpt<double>(SUMO_ATTR_X, id.c_str(), parsedOk, 0);
1939
    const double y = attrs.getOpt<double>(SUMO_ATTR_Y, id.c_str(), parsedOk, 0);
1940
    const std::string lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, "", parsedOk, "");
1941
    const double pos = attrs.getOpt<double>(SUMO_ATTR_POSITION, id.c_str(), parsedOk, 0);
1942
    const bool friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, id.c_str(), parsedOk, false);
1943
    const double posLat = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, id.c_str(), parsedOk, 0);
1944
    const double lon = attrs.getOpt<double>(SUMO_ATTR_LON, id.c_str(), parsedOk, 0);
1945
    const double lat = attrs.getOpt<double>(SUMO_ATTR_LAT, id.c_str(), parsedOk, 0);
1946
    // optional attributes
1947
    const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::RED);
1948
    const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, "", parsedOk, Shape::DEFAULT_TYPE);
1949
    std::string icon = attrs.getOpt<std::string>(SUMO_ATTR_ICON, "", parsedOk, SUMOXMLDefinitions::POIIcons.getString(POIIcon::NONE));
1950
    const double layer = attrs.getOpt<double>(SUMO_ATTR_LAYER, id.c_str(), parsedOk, Shape::DEFAULT_LAYER_POI);
1951
    const std::string imgFile = attrs.getOpt<std::string>(SUMO_ATTR_IMGFILE, "", parsedOk, Shape::DEFAULT_IMG_FILE);
1952
    const double width = attrs.getOpt<double>(SUMO_ATTR_WIDTH, id.c_str(), parsedOk, Shape::DEFAULT_IMG_WIDTH);
1953
    const double height = attrs.getOpt<double>(SUMO_ATTR_HEIGHT, id.c_str(), parsedOk, Shape::DEFAULT_IMG_HEIGHT);
1954
    const double angle = attrs.getOpt<double>(SUMO_ATTR_ANGLE, id.c_str(), parsedOk, Shape::DEFAULT_ANGLE);
1955
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
1956
    // check icon
1957
    if (!SUMOXMLDefinitions::POIIcons.hasString(icon)) {
1958
        WRITE_WARNING(TLF("Invalid icon % for POI '%', using default", icon, id));
1959
        icon = "none";
1960
    }
1961
    // continue if flag is ok
1962
    if (parsedOk) {
1963
        // set tag
1964
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_POI);
1965
        // add attributes depending of Lane/Lanes
1966
        if (attrs.hasAttribute(SUMO_ATTR_X) && attrs.hasAttribute(SUMO_ATTR_Y)) {
1967
            myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_X, x);
1968
            myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_Y, y);
1969
        } else if (attrs.hasAttribute(SUMO_ATTR_LANE) && attrs.hasAttribute(SUMO_ATTR_POSITION)) {
1970
            myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_LANE, lane);
1971
            myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION, pos);
1972
            myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
1973
            myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_POSITION_LAT, posLat);
1974
        } else {
1975
            myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LON, lon);
1976
            myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LAT, lat);
1977
        }
1978
        // add rest attributes
1979
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
1980
        myCommonXMLStructure.getCurrentSumoBaseObject()->addColorAttribute(SUMO_ATTR_COLOR, color);
1981
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TYPE, type);
1982
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ICON, icon);
1983
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_LAYER, layer);
1984
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_IMGFILE, imgFile);
1985
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_WIDTH, width);
1986
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HEIGHT, height);
1987
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_ANGLE, angle);
1988
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
1989
    } else {
1990
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
1991
    }
1992
}
1993

1994

1995
void
1996
AdditionalHandler::parseJpsWalkableAreaAttributes(const SUMOSAXAttributes& attrs) {
1997
    // declare Ok Flag
1998
    bool parsedOk = true;
1999
    // needed attributes
2000
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
2001
    const PositionVector shapeStr = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk);
2002
    // optional attributes
2003
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
2004
    // continue if flag is ok
2005
    if (parsedOk) {
2006
        // set tag
2007
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(GNE_TAG_JPS_WALKABLEAREA);
2008
        // add all attributes
2009
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
2010
        myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shapeStr);
2011
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
2012
    } else {
2013
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
2014
    }
2015
}
2016

2017

2018
void
2019
AdditionalHandler::parseJpsObstacleAttributes(const SUMOSAXAttributes& attrs) {
2020
    // declare Ok Flag
2021
    bool parsedOk = true;
2022
    // needed attributes
2023
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
2024
    const PositionVector shapeStr = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), parsedOk);
2025
    // optional attributes
2026
    const std::string name = attrs.getOpt<std::string>(SUMO_ATTR_NAME, id.c_str(), parsedOk, "");
2027
    // continue if flag is ok
2028
    if (parsedOk) {
2029
        // set tag
2030
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(GNE_TAG_JPS_OBSTACLE);
2031
        // add all attributes
2032
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);
2033
        myCommonXMLStructure.getCurrentSumoBaseObject()->addPositionVectorAttribute(SUMO_ATTR_SHAPE, shapeStr);
2034
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_NAME, name);
2035
    } else {
2036
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);
2037
    }
2038
}
2039

2040

2041
bool
2042
AdditionalHandler::checkCalibratorFlowParents() {
2043
    const auto parentCalibrator = myCommonXMLStructure.getCurrentSumoBaseObject()->getParentSumoBaseObject();
2044
    if (parentCalibrator == nullptr) {
2045
        return false;
2046
    }
2047
    const auto parentRootFile = parentCalibrator->getParentSumoBaseObject();
2048
    if (parentRootFile != nullptr) {
2049
        return false;
2050
    }
2051
    if ((parentCalibrator->getTag() == SUMO_TAG_CALIBRATOR) || (parentCalibrator->getTag() == GNE_TAG_CALIBRATOR_LANE)) {
2052
        return true;
2053
    } else {
2054
        return writeError(TLF("Calibrator Flows have to be defined within a %.", toString(SUMO_TAG_CALIBRATOR)));
2055
    }
2056
}
2057

2058

2059
bool
2060
AdditionalHandler::checkDetectPersons(const SumoXMLTag currentTag, const std::string& id, const std::string& detectPersons) {
2061
    if (detectPersons.empty() || SUMOXMLDefinitions::PersonModeValues.hasString(detectPersons)) {
2062
        return true;
2063
    } else {
2064
        writeError(TLF("Attribute '%' defined in % with id '%' doesn't have a valid value (given '%').", toString(SUMO_ATTR_DETECT_PERSONS), toString(currentTag), id, detectPersons));
2065
        return false;
2066
    }
2067
}
2068

2069
/****************************************************************************/
2070

2071
Product

Resources

Company
