Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2026 German Aerospace Center (DLR) and others.
4 : // This program and the accompanying materials are made available under the
5 : // terms of the Eclipse Public License 2.0 which is available at
6 : // https://www.eclipse.org/legal/epl-2.0/
7 : // This Source Code may also be made available under the following Secondary
8 : // Licenses when the conditions for such availability set forth in the Eclipse
9 : // Public License 2.0 are satisfied: GNU General Public License, version 2
10 : // or later which is available at
11 : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 : /****************************************************************************/
14 : /// @file SUMORouteHandler.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Jakob Erdmann
17 : /// @author Sascha Krieg
18 : /// @author Michael Behrisch
19 : /// @date Mon, 9 Jul 2001
20 : ///
21 : // Parser for routes during their loading
22 : /****************************************************************************/
23 : #include <config.h>
24 :
25 : #include <utils/common/MsgHandler.h>
26 : #include <utils/common/FileHelpers.h>
27 : #include <utils/common/RandHelper.h>
28 : #include <utils/options/OptionsCont.h>
29 : #include <utils/vehicle/SUMOVTypeParameter.h>
30 : #include <utils/vehicle/SUMOVehicleParserHelper.h>
31 : #include <utils/xml/XMLSubSys.h>
32 :
33 : #include "SUMORouteHandler.h"
34 :
35 : // ===========================================================================
36 : // static members
37 : // ===========================================================================
38 : SumoRNG SUMORouteHandler::myParsingRNG("routehandler");
39 :
40 : // ===========================================================================
41 : // method definitions
42 : // ===========================================================================
43 :
44 85686 : SUMORouteHandler::SUMORouteHandler(const std::string& file, const std::string& expectedRoot, const bool hardFail) :
45 : SUMOSAXHandler(file, expectedRoot),
46 85686 : myHardFail(hardFail),
47 85686 : myVehicleParameter(nullptr),
48 85686 : myLastDepart(-1),
49 85686 : myActiveRouteColor(nullptr),
50 85686 : myCurrentCosts(0.),
51 85686 : myCurrentVType(nullptr),
52 85686 : myCurrentVTypeProbability(-1),
53 257056 : myBeginDefault(OptionsCont::getOptions().exists("begin") ? string2time(OptionsCont::getOptions().getString("begin")) : 0),
54 257056 : myEndDefault(OptionsCont::getOptions().exists("end") ? string2time(OptionsCont::getOptions().getString("end")) : -1),
55 85686 : myFirstDepart(-1),
56 85686 : myInsertStopEdgesAt(-1),
57 171372 : myAllowInternalRoutes(false) {
58 85686 : }
59 :
60 :
61 85237 : SUMORouteHandler::~SUMORouteHandler() {
62 85237 : delete myVehicleParameter;
63 85237 : delete myCurrentVType;
64 85237 : }
65 :
66 :
67 : bool
68 623735 : SUMORouteHandler::checkLastDepart() {
69 623735 : if (myVehicleParameter->departProcedure == DepartDefinition::GIVEN) {
70 622781 : if (myVehicleParameter->depart < myLastDepart) {
71 16 : WRITE_WARNINGF(TL("Route file should be sorted by departure time, ignoring '%'!"), myVehicleParameter->id);
72 8 : return false;
73 : }
74 : }
75 : return true;
76 : }
77 :
78 :
79 : void
80 672707 : SUMORouteHandler::registerLastDepart() {
81 : // register only non public transport to parse all public transport lines in advance
82 672707 : if (myVehicleParameter && myVehicleParameter->line == "" && myVehicleParameter->departProcedure == DepartDefinition::GIVEN) {
83 666651 : myLastDepart = myVehicleParameter->depart;
84 666651 : if (myFirstDepart == -1) {
85 43332 : myFirstDepart = myLastDepart;
86 : }
87 : }
88 : // else: we don't know when this vehicle will depart. keep the previous known depart time
89 672707 : }
90 :
91 :
92 : void
93 11873053 : SUMORouteHandler::myStartElement(int element, const SUMOSAXAttributes& attrs) {
94 11873053 : myElementStack.push_back(element);
95 11873053 : switch (element) {
96 407620 : case SUMO_TAG_VEHICLE:
97 : case SUMO_TAG_PERSON:
98 : case SUMO_TAG_CONTAINER:
99 : // if myVehicleParameter is nullptr this will do nothing
100 407620 : delete myVehicleParameter;
101 : // we set to nullptr to have a consistent state if the parsing fails
102 407620 : myVehicleParameter = nullptr;
103 407620 : myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(element, attrs, myHardFail, false, false, myAllowInternalRoutes);
104 407301 : myParamStack.push_back(myVehicleParameter);
105 407301 : if (element != SUMO_TAG_VEHICLE) {
106 47547 : addTransportable(attrs, element == SUMO_TAG_PERSON);
107 : }
108 : break;
109 22964 : case SUMO_TAG_FLOW:
110 : // delete if myVehicleParameter isn't null
111 22964 : if (myVehicleParameter) {
112 0 : delete myVehicleParameter;
113 0 : myVehicleParameter = nullptr;
114 : }
115 : // parse vehicle parameters
116 : // might be called to parse vehicles from additional file in the
117 : // context of quickReload. In this case, rerouter flows must be ignored
118 22964 : if (myElementStack.size() == 1 || myElementStack[myElementStack.size() - 2] != SUMO_TAG_CALIBRATOR) {
119 22964 : myVehicleParameter = SUMOVehicleParserHelper::parseFlowAttributes(SUMO_TAG_FLOW, attrs, myHardFail, true, myBeginDefault, myEndDefault, myAllowInternalRoutes);
120 : }
121 : // check if myVehicleParameter was successfully created
122 22834 : if (myVehicleParameter) {
123 : // check tag
124 22834 : if (myVehicleParameter->routeid.empty()) {
125 : // open a route flow (It could be a flow with embedded route)
126 13108 : openFlow(attrs);
127 : } else {
128 : // open a route flow
129 9726 : openRouteFlow(attrs);
130 : }
131 22834 : myParamStack.push_back(myVehicleParameter);
132 : }
133 : break;
134 2407 : case SUMO_TAG_PERSONFLOW:
135 : case SUMO_TAG_CONTAINERFLOW:
136 : // delete if myVehicleParameter isn't null
137 2407 : if (myVehicleParameter) {
138 0 : delete myVehicleParameter;
139 0 : myVehicleParameter = nullptr;
140 : }
141 : // create a new flow
142 2407 : myVehicleParameter = SUMOVehicleParserHelper::parseFlowAttributes((SumoXMLTag)element, attrs, myHardFail, true, myBeginDefault, myEndDefault, myAllowInternalRoutes);
143 2407 : myParamStack.push_back(myVehicleParameter);
144 2407 : break;
145 65563 : case SUMO_TAG_VTYPE:
146 : // delete if myCurrentVType isn't null
147 65563 : if (myCurrentVType != nullptr) {
148 5 : delete myCurrentVType;
149 5 : myCurrentVType = nullptr;
150 : }
151 : // create a new vType
152 65563 : if (attrs.hasAttribute(SUMO_ATTR_REFID) && !attrs.hasAttribute(SUMO_ATTR_ID)) {
153 132 : bool ok = true;
154 264 : myCurrentVTypeRef = attrs.get<std::string>(SUMO_ATTR_REFID, nullptr, ok);
155 132 : myCurrentVTypeProbability = attrs.getOpt<double>(SUMO_ATTR_PROB, myCurrentVTypeRef.c_str(), ok, -1);
156 : } else {
157 130830 : myCurrentVType = SUMOVehicleParserHelper::beginVTypeParsing(attrs, myHardFail, getFileName(), getVTypeParameter(attrs.getStringSecure(SUMO_ATTR_REFID, "")));
158 : }
159 65531 : myParamStack.push_back(myCurrentVType);
160 65531 : break;
161 644 : case SUMO_TAG_VTYPE_DISTRIBUTION:
162 644 : openVehicleTypeDistribution(attrs);
163 644 : break;
164 390900 : case SUMO_TAG_ROUTE:
165 390900 : openRoute(attrs);
166 390848 : break;
167 93325 : case SUMO_TAG_ROUTE_DISTRIBUTION:
168 93325 : openRouteDistribution(attrs);
169 93325 : break;
170 41938 : case SUMO_TAG_STOP:
171 41938 : myParamStack.push_back(addStop(attrs));
172 41869 : break;
173 243431 : case SUMO_TAG_TRIP: {
174 : // delete if myVehicleParameter isn't null
175 243431 : if (myVehicleParameter) {
176 0 : delete myVehicleParameter;
177 0 : myVehicleParameter = nullptr;
178 : }
179 : // parse vehicle parameters
180 243431 : myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(element, attrs, myHardFail, false, false, myAllowInternalRoutes);
181 : // check if myVehicleParameter was successfully created
182 243365 : if (myVehicleParameter) {
183 243365 : myVehicleParameter->parametersSet |= VEHPARS_FORCE_REROUTE;
184 243365 : myActiveRouteID = "!" + myVehicleParameter->id;
185 : // open trip
186 243365 : openTrip(attrs);
187 243365 : myParamStack.push_back(myVehicleParameter);
188 : }
189 : break;
190 : }
191 5412 : case SUMO_TAG_PERSONTRIP:
192 5412 : addPersonTrip(attrs);
193 5396 : break;
194 40647 : case SUMO_TAG_WALK:
195 40647 : addWalk(attrs);
196 40627 : break;
197 28 : case SUMO_TAG_INTERVAL: {
198 : bool ok;
199 28 : myBeginDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, nullptr, ok);
200 28 : myEndDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_END, nullptr, ok);
201 : break;
202 : }
203 5576 : case SUMO_TAG_RIDE:
204 5576 : addRide(attrs);
205 5536 : break;
206 1881 : case SUMO_TAG_TRANSPORT:
207 1881 : addTransport(attrs);
208 1864 : break;
209 1590 : case SUMO_TAG_TRANSHIP:
210 1590 : addTranship(attrs);
211 1590 : break;
212 57805 : case SUMO_TAG_PARAM:
213 57805 : addParam(attrs);
214 57805 : break;
215 10491322 : default:
216 : // parse embedded car following model information
217 10491322 : if (myCurrentVType != nullptr) {
218 38 : WRITE_WARNINGF(TL("Defining car-following parameters in a nested element is deprecated in vType '%', use attributes instead!"), myCurrentVType->id);
219 19 : if (!SUMOVehicleParserHelper::parseCFMParams(myCurrentVType, (SumoXMLTag)element, attrs, true)) {
220 0 : if (myHardFail) {
221 0 : throw ProcessError(TL("Invalid parsing embedded VType"));
222 : } else {
223 0 : WRITE_ERROR(TL("Invalid parsing embedded VType"));
224 : }
225 : }
226 : }
227 : break;
228 : }
229 11872292 : }
230 :
231 :
232 : void
233 11864482 : SUMORouteHandler::myEndElement(int element) {
234 11864482 : switch (element) {
235 41869 : case SUMO_TAG_STOP:
236 : myParamStack.pop_back();
237 : break;
238 390848 : case SUMO_TAG_ROUTE:
239 390848 : closeRoute();
240 390794 : break;
241 65526 : case SUMO_TAG_VTYPE:
242 65526 : closeVType();
243 65502 : if (myCurrentVTypeRef.empty()) {
244 65370 : delete myCurrentVType;
245 : }
246 65502 : myCurrentVType = nullptr;
247 65502 : myCurrentVTypeRef = "";
248 65502 : myCurrentVTypeProbability = -1;
249 : myParamStack.pop_back();
250 : break;
251 45336 : case SUMO_TAG_PERSON:
252 45336 : closePerson();
253 45310 : delete myVehicleParameter;
254 45310 : myVehicleParameter = nullptr;
255 : myParamStack.pop_back();
256 : break;
257 2060 : case SUMO_TAG_PERSONFLOW:
258 2060 : closePersonFlow();
259 2048 : delete myVehicleParameter;
260 2048 : myVehicleParameter = nullptr;
261 : myParamStack.pop_back();
262 : break;
263 2104 : case SUMO_TAG_CONTAINER:
264 2104 : closeContainer();
265 2096 : delete myVehicleParameter;
266 2096 : myVehicleParameter = nullptr;
267 : myParamStack.pop_back();
268 : break;
269 335 : case SUMO_TAG_CONTAINERFLOW:
270 335 : closeContainerFlow();
271 335 : delete myVehicleParameter;
272 335 : myVehicleParameter = nullptr;
273 : myParamStack.pop_back();
274 : break;
275 359641 : case SUMO_TAG_VEHICLE:
276 359641 : if (myVehicleParameter == nullptr) {
277 : break;
278 : }
279 359641 : if (myVehicleParameter->repetitionNumber <= 0) {
280 359641 : closeVehicle();
281 359512 : delete myVehicleParameter;
282 359512 : myVehicleParameter = nullptr;
283 : myParamStack.pop_back();
284 : break;
285 : }
286 0 : myVehicleParameter->repetitionNumber++; // for backwards compatibility
287 : // it is a flow, thus no break here
288 : FALLTHROUGH;
289 22834 : case SUMO_TAG_FLOW:
290 22834 : if (myVehicleParameter) {
291 22834 : closeFlow();
292 22827 : delete myVehicleParameter;
293 : myParamStack.pop_back();
294 : }
295 22827 : myVehicleParameter = nullptr;
296 22827 : myInsertStopEdgesAt = -1;
297 22827 : break;
298 243319 : case SUMO_TAG_TRIP:
299 243319 : closeTrip();
300 243301 : delete myVehicleParameter;
301 243301 : myVehicleParameter = nullptr;
302 : myParamStack.pop_back();
303 243301 : myInsertStopEdgesAt = -1;
304 243301 : break;
305 644 : case SUMO_TAG_VTYPE_DISTRIBUTION:
306 644 : closeVehicleTypeDistribution();
307 644 : break;
308 93291 : case SUMO_TAG_ROUTE_DISTRIBUTION:
309 93291 : closeRouteDistribution();
310 93289 : break;
311 55008 : case SUMO_TAG_PERSONTRIP:
312 : case SUMO_TAG_RIDE:
313 : case SUMO_TAG_TRANSPORT:
314 : case SUMO_TAG_TRANSHIP:
315 : case SUMO_TAG_WALK:
316 55008 : if (myParamStack.size() == 2) {
317 : myParamStack.pop_back();
318 : }
319 : break;
320 28 : case SUMO_TAG_INTERVAL:
321 28 : myBeginDefault = string2time(OptionsCont::getOptions().getString("begin"));
322 28 : myEndDefault = string2time(OptionsCont::getOptions().getString("end"));
323 28 : break;
324 : default:
325 : break;
326 : }
327 : myElementStack.pop_back();
328 11864202 : }
329 :
330 :
331 : SUMORouteHandler::StopPos
332 103447 : SUMORouteHandler::checkStopPos(double& startPos, double& endPos, const double laneLength, const double minLength, const bool friendlyPos) {
333 103447 : if (minLength > laneLength) {
334 : return STOPPOS_INVALID_LANELENGTH;
335 : }
336 103447 : if (startPos < 0) {
337 172 : startPos += laneLength;
338 : }
339 103447 : if (endPos < 0) {
340 1706 : endPos += laneLength;
341 : }
342 103447 : if ((endPos < minLength) || (endPos > laneLength)) {
343 121 : if (!friendlyPos) {
344 : return STOPPOS_INVALID_ENDPOS;
345 : }
346 116 : if (endPos < minLength) {
347 3 : endPos = minLength;
348 : }
349 116 : if (endPos > laneLength) {
350 113 : endPos = laneLength;
351 : }
352 : }
353 103442 : if ((startPos < 0) || (startPos > (endPos - minLength))) {
354 41 : if (!friendlyPos) {
355 : return STOPPOS_INVALID_STARTPOS;
356 : }
357 41 : if (startPos < 0) {
358 13 : startPos = 0;
359 : }
360 41 : if (startPos > (endPos - minLength)) {
361 28 : startPos = endPos - minLength;
362 : }
363 : }
364 : return STOPPOS_VALID;
365 : }
366 :
367 :
368 : SUMOTime
369 106467 : SUMORouteHandler::getFirstDepart() const {
370 106467 : return myFirstDepart;
371 : }
372 :
373 :
374 : SUMOTime
375 3322207 : SUMORouteHandler::getLastDepart() const {
376 3322207 : return myLastDepart;
377 : }
378 :
379 :
380 : void
381 57805 : SUMORouteHandler::addParam(const SUMOSAXAttributes& attrs) {
382 57805 : bool ok = true;
383 57805 : const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, ok);
384 : // only continue if key isn't empty
385 57805 : if (ok && (key.size() > 0)) {
386 : // circumventing empty string test
387 57805 : std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
388 : // check special params that must be interpreted as relative paths
389 48843 : if ((myVehicleParameter != nullptr || myCurrentVType != nullptr)
390 64453 : && (key == "device.toc.file" || key == "device.ssm.file")) {
391 786 : val = FileHelpers::checkForRelativity(val, getFileName());
392 : }
393 : // add parameter in current created element
394 57805 : if (!myParamStack.empty()) {
395 15610 : if (!myCurrentVTypeRef.empty() && myParamStack.back() == myCurrentVType) {
396 0 : WRITE_WARNINGF(TL("Ignoring param for referenced vType %"), myCurrentVType->id);
397 : } else {
398 15610 : myParamStack.back()->setParameter(key, val);
399 : }
400 : }
401 : }
402 57805 : }
403 :
404 :
405 : bool
406 41918 : SUMORouteHandler::parseStop(SUMOVehicleParameter::Stop& stop, const SUMOSAXAttributes& attrs, std::string errorSuffix, MsgHandler* const errorOutput) {
407 41918 : stop.parametersSet = 0;
408 41918 : if (attrs.hasAttribute(SUMO_ATTR_ARRIVAL)) {
409 419 : stop.parametersSet |= STOP_ARRIVAL_SET;
410 : }
411 41918 : if (attrs.hasAttribute(SUMO_ATTR_DURATION)) {
412 23372 : stop.parametersSet |= STOP_DURATION_SET;
413 : }
414 41918 : if (attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
415 20507 : stop.parametersSet |= STOP_UNTIL_SET;
416 : }
417 41918 : if (attrs.hasAttribute(SUMO_ATTR_STARTED)) {
418 6744 : stop.parametersSet |= STOP_STARTED_SET;
419 : }
420 41918 : if (attrs.hasAttribute(SUMO_ATTR_ENDED)) {
421 6226 : stop.parametersSet |= STOP_ENDED_SET;
422 : }
423 41918 : if (attrs.hasAttribute(SUMO_ATTR_EXTENSION)) {
424 464 : stop.parametersSet |= STOP_EXTENSION_SET;
425 : }
426 41918 : if (attrs.hasAttribute(SUMO_ATTR_ENDPOS)) {
427 9169 : stop.parametersSet |= STOP_END_SET;
428 : }
429 41918 : if (attrs.hasAttribute(SUMO_ATTR_STARTPOS)) {
430 1498 : stop.parametersSet |= STOP_START_SET;
431 : }
432 41918 : if (attrs.hasAttribute(SUMO_ATTR_POSITION_LAT)) {
433 128 : stop.parametersSet |= STOP_POSLAT_SET;
434 : }
435 41918 : if (attrs.hasAttribute(SUMO_ATTR_TRIGGERED)) {
436 1595 : stop.parametersSet |= STOP_TRIGGER_SET;
437 : }
438 : // legacy attribute
439 41918 : if (attrs.hasAttribute(SUMO_ATTR_CONTAINER_TRIGGERED)) {
440 56 : stop.parametersSet |= STOP_TRIGGER_SET;
441 : }
442 41918 : if (attrs.hasAttribute(SUMO_ATTR_PARKING)) {
443 989 : stop.parametersSet |= STOP_PARKING_SET;
444 : }
445 41918 : if (attrs.hasAttribute(SUMO_ATTR_EXPECTED)) {
446 243 : stop.parametersSet |= STOP_EXPECTED_SET;
447 : }
448 41918 : if (attrs.hasAttribute(SUMO_ATTR_PERMITTED)) {
449 369 : stop.parametersSet |= STOP_PERMITTED_SET;
450 : }
451 41918 : if (attrs.hasAttribute(SUMO_ATTR_EXPECTED_CONTAINERS)) {
452 77 : stop.parametersSet |= STOP_EXPECTED_CONTAINERS_SET;
453 : }
454 41918 : if (attrs.hasAttribute(SUMO_ATTR_TRIP_ID)) {
455 432 : stop.parametersSet |= STOP_TRIP_ID_SET;
456 : }
457 41918 : if (attrs.hasAttribute(SUMO_ATTR_SPLIT)) {
458 356 : stop.parametersSet |= STOP_SPLIT_SET;
459 : }
460 41918 : if (attrs.hasAttribute(SUMO_ATTR_JOIN)) {
461 116 : stop.parametersSet |= STOP_JOIN_SET;
462 : }
463 41918 : if (attrs.hasAttribute(SUMO_ATTR_LINE)) {
464 387 : stop.parametersSet |= STOP_LINE_SET;
465 : }
466 41918 : if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
467 673 : stop.parametersSet |= STOP_SPEED_SET;
468 : }
469 41918 : if (attrs.hasAttribute(SUMO_ATTR_ONDEMAND)) {
470 178 : stop.parametersSet |= STOP_ONDEMAND_SET;
471 : }
472 41918 : if (attrs.hasAttribute(SUMO_ATTR_PRIORITY)) {
473 354 : stop.parametersSet |= STOP_PRIORITY_SET;
474 : }
475 41918 : if (attrs.hasAttribute(SUMO_ATTR_JUMP)) {
476 551 : stop.parametersSet |= STOP_JUMP_SET;
477 : }
478 41918 : if (attrs.hasAttribute(SUMO_ATTR_JUMP_UNTIL)) {
479 7 : stop.parametersSet |= STOP_JUMP_UNTIL_SET;
480 : }
481 41918 : bool ok = true;
482 83836 : stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, nullptr, ok, "");
483 41918 : stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_TRAIN_STOP, nullptr, ok, stop.busstop);
484 41918 : stop.chargingStation = attrs.getOpt<std::string>(SUMO_ATTR_CHARGING_STATION, nullptr, ok, "");
485 41918 : stop.overheadWireSegment = attrs.getOpt<std::string>(SUMO_ATTR_OVERHEAD_WIRE_SEGMENT, nullptr, ok, "");
486 41918 : stop.containerstop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, nullptr, ok, "");
487 83836 : stop.parkingarea = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, nullptr, ok, "");
488 41918 : if (stop.busstop != "") {
489 36429 : errorSuffix = " at '" + stop.busstop + "'" + errorSuffix;
490 29775 : } else if (stop.chargingStation != "") {
491 3681 : errorSuffix = " at '" + stop.chargingStation + "'" + errorSuffix;
492 28548 : } else if (stop.overheadWireSegment != "") {
493 0 : errorSuffix = " at '" + stop.overheadWireSegment + "'" + errorSuffix;
494 28548 : } else if (stop.containerstop != "") {
495 1914 : errorSuffix = " at '" + stop.containerstop + "'" + errorSuffix;
496 27910 : } else if (stop.parkingarea != "") {
497 47307 : errorSuffix = " at '" + stop.parkingarea + "'" + errorSuffix;
498 12141 : } else if (attrs.hasAttribute(SUMO_ATTR_LANE)) {
499 30372 : errorSuffix = " on lane '" + attrs.get<std::string>(SUMO_ATTR_LANE, nullptr, ok) + "'" + errorSuffix;
500 2017 : } else if (attrs.hasAttribute(SUMO_ATTR_EDGE)) {
501 5706 : errorSuffix = " on edge '" + attrs.get<std::string>(SUMO_ATTR_EDGE, nullptr, ok) + "'" + errorSuffix;
502 : } else {
503 230 : errorSuffix = " at undefined location" + errorSuffix;
504 : }
505 : // speed for counting as stopped
506 41918 : stop.speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, nullptr, ok, 0);
507 41918 : if (stop.speed < 0) {
508 12 : errorOutput->inform(TLF("Speed cannot be negative for stop%.", errorSuffix));
509 6 : return false;
510 : }
511 :
512 : // get the standing duration
513 41912 : bool expectTrigger = !attrs.hasAttribute(SUMO_ATTR_DURATION) && !attrs.hasAttribute(SUMO_ATTR_UNTIL) && !attrs.hasAttribute(SUMO_ATTR_SPEED);
514 41912 : std::vector<std::string> triggers = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_TRIGGERED, nullptr, ok);
515 : // legacy
516 41912 : if (attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, nullptr, ok, false)) {
517 112 : triggers.push_back(toString(SUMO_TAG_CONTAINER));
518 : }
519 41912 : SUMOVehicleParameter::parseStopTriggers(triggers, expectTrigger, stop);
520 41912 : stop.arrival = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ARRIVAL, nullptr, ok, -1);
521 41912 : if (attrs.hasAttribute(SUMO_ATTR_DURATION)) {
522 23372 : const std::string durationStr = attrs.get<std::string>(SUMO_ATTR_DURATION, nullptr, ok);
523 : std::string error;
524 23372 : if (!Distribution_Parameterized::isValidDescription(durationStr, error)) {
525 0 : errorOutput->inform(TLF("Invalid duration for a stop% (%).", errorSuffix, error));
526 : return false;
527 : }
528 46744 : stop.durationDist = Distribution_Parameterized(durationStr);
529 46744 : stop.duration = TIME2STEPS(stop.durationDist.sample(&myParsingRNG));
530 : }
531 41912 : stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, nullptr, ok, -1);
532 41912 : if (!expectTrigger && (!ok || (stop.duration < 0 && stop.until < 0 && stop.speed == 0))) {
533 36 : errorOutput->inform(TLF("Invalid duration or end time is given for a stop%.", errorSuffix));
534 12 : return false;
535 : }
536 41900 : if (triggers.size() > 0 && stop.speed > 0) {
537 9 : errorOutput->inform(TLF("Triggers and waypoints cannot be combined%.", errorSuffix));
538 3 : return false;
539 : }
540 41897 : stop.extension = attrs.getOptSUMOTimeReporting(SUMO_ATTR_EXTENSION, nullptr, ok, -1);
541 41897 : const bool defaultParking = (stop.triggered || stop.containerTriggered || stop.parkingarea != "");
542 41897 : stop.parking = attrs.getOpt<ParkingType>(SUMO_ATTR_PARKING, nullptr, ok, defaultParking ? ParkingType::OFFROAD : ParkingType::ONROAD);
543 41897 : if ((stop.parkingarea != "") && (stop.parking == ParkingType::ONROAD)) {
544 21 : WRITE_WARNINGF(TL("Stop at parkingArea overrides attribute 'parking' for stop%."), errorSuffix);
545 7 : stop.parking = ParkingType::OFFROAD;
546 : }
547 :
548 : // expected persons
549 41897 : const std::vector<std::string>& expected = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EXPECTED, nullptr, ok);
550 : stop.awaitedPersons.insert(expected.begin(), expected.end());
551 41897 : if (stop.awaitedPersons.size() > 0) {
552 243 : stop.triggered = true;
553 243 : if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
554 124 : stop.parking = ParkingType::OFFROAD;
555 : }
556 : }
557 :
558 : // permitted transportables
559 41897 : const std::vector<std::string>& permitted = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_PERMITTED, nullptr, ok);
560 : stop.permitted.insert(permitted.begin(), permitted.end());
561 :
562 : // expected containers
563 41897 : const std::vector<std::string>& expectedContainers = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EXPECTED_CONTAINERS, nullptr, ok);
564 : stop.awaitedContainers.insert(expectedContainers.begin(), expectedContainers.end());
565 41897 : if (stop.awaitedContainers.size() > 0) {
566 77 : stop.containerTriggered = true;
567 77 : if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
568 67 : stop.parking = ParkingType::OFFROAD;
569 : }
570 : }
571 : // public transport trip id
572 41897 : stop.tripId = attrs.getOpt<std::string>(SUMO_ATTR_TRIP_ID, nullptr, ok, "");
573 41897 : stop.split = attrs.getOpt<std::string>(SUMO_ATTR_SPLIT, nullptr, ok, "");
574 41897 : stop.join = attrs.getOpt<std::string>(SUMO_ATTR_JOIN, nullptr, ok, "");
575 41897 : stop.line = attrs.getOpt<std::string>(SUMO_ATTR_LINE, nullptr, ok, "");
576 :
577 41897 : const std::string idx = attrs.getOpt<std::string>(SUMO_ATTR_INDEX, nullptr, ok, "end");
578 41897 : if (idx == "end") {
579 41645 : stop.index = STOP_INDEX_END;
580 252 : } else if (idx == "fit") {
581 14 : stop.index = STOP_INDEX_FIT;
582 : } else {
583 238 : stop.index = attrs.get<int>(SUMO_ATTR_INDEX, nullptr, ok);
584 238 : if (!ok || stop.index < 0) {
585 18 : errorOutput->inform(TLF("Invalid 'index' for stop%.", errorSuffix));
586 6 : return false;
587 : }
588 : }
589 41891 : stop.started = attrs.getOptSUMOTimeReporting(SUMO_ATTR_STARTED, nullptr, ok, -1);
590 41891 : stop.ended = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ENDED, nullptr, ok, -1);
591 41891 : stop.posLat = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, nullptr, ok, INVALID_DOUBLE);
592 41891 : stop.actType = attrs.getOpt<std::string>(SUMO_ATTR_ACTTYPE, nullptr, ok, "");
593 41891 : stop.onDemand = attrs.getOpt<bool>(SUMO_ATTR_ONDEMAND, nullptr, ok, false);
594 41891 : stop.priority = attrs.getOpt<double>(SUMO_ATTR_PRIORITY, nullptr, ok, -1);
595 41891 : stop.jump = attrs.getOptSUMOTimeReporting(SUMO_ATTR_JUMP, nullptr, ok, -1);
596 41891 : stop.jumpUntil = attrs.getOptSUMOTimeReporting(SUMO_ATTR_JUMP_UNTIL, nullptr, ok, -1);
597 41891 : stop.collision = attrs.getOpt<bool>(SUMO_ATTR_COLLISION, nullptr, ok, false);
598 41891 : return true;
599 41912 : }
600 :
601 :
602 : /****************************************************************************/
|