Eclipse SUMO - Simulation of Urban MObility
SUMORouteHandler.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 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/****************************************************************************/
21// Parser for routes during their loading
22/****************************************************************************/
23#include <config.h>
24
29#include <utils/xml/XMLSubSys.h>
30
31#include "SUMORouteHandler.h"
32
33
34// ===========================================================================
35// method definitions
36// ===========================================================================
37
38SUMORouteHandler::SUMORouteHandler(const std::string& file, const std::string& expectedRoot, const bool hardFail) :
39 SUMOSAXHandler(file, expectedRoot),
40 myHardFail(hardFail),
41 myVehicleParameter(nullptr),
42 myLastDepart(-1),
43 myActiveRouteColor(nullptr),
44 myCurrentCosts(0.),
45 myCurrentVType(nullptr),
46 myBeginDefault(string2time(OptionsCont::getOptions().getString("begin"))),
47 myEndDefault(string2time(OptionsCont::getOptions().getString("end"))),
48 myFirstDepart(-1),
49 myInsertStopEdgesAt(-1) {
50}
51
52
54 delete myVehicleParameter;
55 delete myCurrentVType;
56}
57
58
59bool
63 WRITE_WARNINGF(TL("Route file should be sorted by departure time, ignoring '%'!"), myVehicleParameter->id);
64 return false;
65 }
66 }
67 return true;
68}
69
70
71void
73 // register only non public transport to parse all public transport lines in advance
76 if (myFirstDepart == -1) {
78 }
79 }
80 // else: we don't know when this vehicle will depart. keep the previous known depart time
81}
82
83
84void
86 myElementStack.push_back(element);
87 switch (element) {
89 // delete if myVehicleParameter isn't null
91 delete myVehicleParameter;
92 myVehicleParameter = nullptr;
93 }
94 // create a new vehicle
96 break;
97 case SUMO_TAG_PERSON:
98 // delete if myVehicleParameter isn't null
100 delete myVehicleParameter;
101 myVehicleParameter = nullptr;
102 }
103 // create a new person
105 addPerson(attrs);
106 break;
108 // delete if myVehicleParameter isn't null
109 if (myVehicleParameter) {
110 delete myVehicleParameter;
111 myVehicleParameter = nullptr;
112 }
113 // create a new container
115 addContainer(attrs);
116 break;
117 case SUMO_TAG_FLOW:
118 // delete if myVehicleParameter isn't null
119 if (myVehicleParameter) {
120 delete myVehicleParameter;
121 myVehicleParameter = nullptr;
122 }
123 // parse vehicle parameters
124 // might be called to parse vehicles from additional file in the
125 // context of quickReload. In this case, rerouter flows must be ignored
126 if (myElementStack.size() == 1 || myElementStack[myElementStack.size() - 2] != SUMO_TAG_CALIBRATOR) {
128 }
129 // check if myVehicleParameter was successfully created
130 if (myVehicleParameter) {
131 // check tag
132 if (myVehicleParameter->routeid.empty()) {
133 // open a route flow (It could be a flow with embedded route)
134 openFlow(attrs);
135 } else {
136 // open a route flow
137 openRouteFlow(attrs);
138 }
139 }
140 break;
142 // delete if myVehicleParameter isn't null
143 if (myVehicleParameter) {
144 delete myVehicleParameter;
145 myVehicleParameter = nullptr;
146 }
147 // create a new flow
149 break;
151 // delete if myVehicleParameter isn't null
152 if (myVehicleParameter) {
153 delete myVehicleParameter;
154 myVehicleParameter = nullptr;
155 }
156 // create a new flow
158 break;
159 case SUMO_TAG_VTYPE:
160 // delete if myCurrentVType isn't null
161 if (myCurrentVType != nullptr) {
162 delete myCurrentVType;
163 myCurrentVType = nullptr;
164 }
165 // create a new vType
167 break;
170 break;
171 case SUMO_TAG_ROUTE:
172 openRoute(attrs);
173 break;
176 break;
177 case SUMO_TAG_STOP:
178 addStop(attrs);
179 break;
180 case SUMO_TAG_TRIP: {
181 // delete if myVehicleParameter isn't null
182 if (myVehicleParameter) {
183 delete myVehicleParameter;
184 myVehicleParameter = nullptr;
185 }
186 // parse vehicle parameters
188 // check if myVehicleParameter was successfully created
189 if (myVehicleParameter) {
192 // open trip
193 openTrip(attrs);
194 }
195 break;
196 }
198 addPersonTrip(attrs);
199 break;
200 case SUMO_TAG_WALK:
201 addWalk(attrs);
202 break;
203 case SUMO_TAG_INTERVAL: {
204 bool ok;
206 myEndDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_END, nullptr, ok);
207 break;
208 }
209 case SUMO_TAG_RIDE:
210 addRide(attrs);
211 break;
213 addTransport(attrs);
214 break;
216 addTranship(attrs);
217 break;
218 case SUMO_TAG_PARAM:
219 addParam(attrs);
220 break;
221 default:
222 // parse embedded car following model information
223 if (myCurrentVType != nullptr) {
224 WRITE_WARNING("Defining car following parameters in a nested element is deprecated in vType '" + myCurrentVType->id + "', use attributes instead!");
226 if (myHardFail) {
227 throw ProcessError("Invalid parsing embedded VType");
228 } else {
229 WRITE_ERROR(TL("Invalid parsing embedded VType"));
230 }
231 }
232 }
233 break;
234 }
235}
236
237
238void
240 switch (element) {
241 case SUMO_TAG_ROUTE:
242 closeRoute();
243 break;
244 case SUMO_TAG_VTYPE:
245 closeVType();
246 delete myCurrentVType;
247 myCurrentVType = nullptr;
248 break;
249 case SUMO_TAG_PERSON:
250 closePerson();
251 delete myVehicleParameter;
252 myVehicleParameter = nullptr;
253 break;
256 delete myVehicleParameter;
257 myVehicleParameter = nullptr;
258 break;
261 delete myVehicleParameter;
262 myVehicleParameter = nullptr;
263 break;
266 delete myVehicleParameter;
267 myVehicleParameter = nullptr;
268 break;
269 case SUMO_TAG_VEHICLE:
270 if (myVehicleParameter == nullptr) {
271 break;
272 }
274 myVehicleParameter->repetitionNumber++; // for backwards compatibility
275 // it is a flow, thus no break here
277 } else {
278 closeVehicle();
279 delete myVehicleParameter;
280 myVehicleParameter = nullptr;
281 break;
282 }
283 case SUMO_TAG_FLOW:
284 if (myVehicleParameter) {
285 closeFlow();
286 delete myVehicleParameter;
287 }
288 myVehicleParameter = nullptr;
290 break;
291 case SUMO_TAG_TRIP:
292 closeTrip();
293 delete myVehicleParameter;
294 myVehicleParameter = nullptr;
296 break;
299 break;
302 break;
304 myBeginDefault = string2time(OptionsCont::getOptions().getString("begin"));
306 break;
307 default:
308 break;
309 }
310 myElementStack.pop_back();
311}
312
313
315SUMORouteHandler::checkStopPos(double& startPos, double& endPos, const double laneLength, const double minLength, const bool friendlyPos) {
316 if (minLength > laneLength) {
318 }
319 if (startPos < 0) {
320 startPos += laneLength;
321 }
322 if (endPos < 0) {
323 endPos += laneLength;
324 }
325 if ((endPos < minLength) || (endPos > laneLength)) {
326 if (!friendlyPos) {
328 }
329 if (endPos < minLength) {
330 endPos = minLength;
331 }
332 if (endPos > laneLength) {
333 endPos = laneLength;
334 }
335 }
336 if ((startPos < 0) || (startPos > (endPos - minLength))) {
337 if (!friendlyPos) {
339 }
340 if (startPos < 0) {
341 startPos = 0;
342 }
343 if (startPos > (endPos - minLength)) {
344 startPos = endPos - minLength;
345 }
346 }
347 return STOPPOS_VALID;
348}
349
350
351bool
352SUMORouteHandler::isStopPosValid(const double startPos, const double endPos, const double laneLength, const double minLength, const bool friendlyPos) {
353 // declare dummy start and end positions
354 double dummyStartPos = startPos;
355 double dummyEndPos = endPos;
356 // return checkStopPos
357 return (checkStopPos(dummyStartPos, dummyEndPos, laneLength, minLength, friendlyPos) == STOPPOS_VALID);
358}
359
360
363 return myFirstDepart;
364}
365
366
369 return myLastDepart;
370}
371
372
373void
375 bool ok = true;
376 const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, ok);
377 // only continue if key isn't empty
378 if (ok && (key.size() > 0)) {
379 // circumventing empty string test
380 const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
381 // add parameter in current created element, or in myLoadedParameterised
382 if (myVehicleParameter != nullptr) {
384 } else if (myCurrentVType != nullptr) {
385 myCurrentVType->setParameter(key, val);
386 } else {
388 }
389 }
390}
391
392
393bool
394SUMORouteHandler::parseStop(SUMOVehicleParameter::Stop& stop, const SUMOSAXAttributes& attrs, std::string errorSuffix, MsgHandler* const errorOutput) {
395 stop.parametersSet = 0;
396 if (attrs.hasAttribute(SUMO_ATTR_ARRIVAL)) {
398 }
399 if (attrs.hasAttribute(SUMO_ATTR_DURATION)) {
401 }
402 if (attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
404 }
405 if (attrs.hasAttribute(SUMO_ATTR_STARTED)) {
407 }
408 if (attrs.hasAttribute(SUMO_ATTR_ENDED)) {
410 }
413 }
414 if (attrs.hasAttribute(SUMO_ATTR_ENDPOS)) {
416 }
417 if (attrs.hasAttribute(SUMO_ATTR_STARTPOS)) {
419 }
422 }
425 }
426 // legacy attribute
429 }
430 if (attrs.hasAttribute(SUMO_ATTR_PARKING)) {
432 }
433 if (attrs.hasAttribute(SUMO_ATTR_EXPECTED)) {
435 }
438 }
441 }
442 if (attrs.hasAttribute(SUMO_ATTR_TRIP_ID)) {
444 }
445 if (attrs.hasAttribute(SUMO_ATTR_SPLIT)) {
447 }
448 if (attrs.hasAttribute(SUMO_ATTR_JOIN)) {
450 }
451 if (attrs.hasAttribute(SUMO_ATTR_LINE)) {
453 }
454 if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
456 }
457 if (attrs.hasAttribute(SUMO_ATTR_ONDEMAND)) {
459 }
460 bool ok = true;
461 stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, nullptr, ok, "");
462 stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_TRAIN_STOP, nullptr, ok, stop.busstop);
463 stop.chargingStation = attrs.getOpt<std::string>(SUMO_ATTR_CHARGING_STATION, nullptr, ok, "");
464 stop.overheadWireSegment = attrs.getOpt<std::string>(SUMO_ATTR_OVERHEAD_WIRE_SEGMENT, nullptr, ok, "");
465 stop.containerstop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, nullptr, ok, "");
466 stop.parkingarea = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, nullptr, ok, "");
467 if (stop.busstop != "") {
468 errorSuffix = " at '" + stop.busstop + "'" + errorSuffix;
469 } else if (stop.chargingStation != "") {
470 errorSuffix = " at '" + stop.chargingStation + "'" + errorSuffix;
471 } else if (stop.overheadWireSegment != "") {
472 errorSuffix = " at '" + stop.overheadWireSegment + "'" + errorSuffix;
473 } else if (stop.containerstop != "") {
474 errorSuffix = " at '" + stop.containerstop + "'" + errorSuffix;
475 } else if (stop.parkingarea != "") {
476 errorSuffix = " at '" + stop.parkingarea + "'" + errorSuffix;
477 } else {
478 errorSuffix = " on lane '" + stop.lane + "'" + errorSuffix;
479 }
480 // speed for counting as stopped
481 stop.speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, nullptr, ok, 0);
482 if (stop.speed < 0) {
483 errorOutput->inform("Speed cannot be negative for stop" + errorSuffix);
484 return false;
485 }
486
487 // get the standing duration
488 bool expectTrigger = !attrs.hasAttribute(SUMO_ATTR_DURATION) && !attrs.hasAttribute(SUMO_ATTR_UNTIL) && !attrs.hasAttribute(SUMO_ATTR_SPEED);
489 std::vector<std::string> triggers = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_TRIGGERED, nullptr, ok);
490 // legacy
491 if (attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, nullptr, ok, false)) {
492 triggers.push_back(toString(SUMO_TAG_CONTAINER));
493 }
494 SUMOVehicleParameter::parseStopTriggers(triggers, expectTrigger, stop);
495 stop.arrival = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ARRIVAL, nullptr, ok, -1);
496 stop.duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, nullptr, ok, -1);
497 stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, nullptr, ok, -1);
498 if (!expectTrigger && (!ok || (stop.duration < 0 && stop.until < 0 && stop.speed == 0))) {
499 errorOutput->inform("Invalid duration or end time is given for a stop" + errorSuffix);
500 return false;
501 }
502 stop.extension = attrs.getOptSUMOTimeReporting(SUMO_ATTR_EXTENSION, nullptr, ok, -1);
503 const bool defaultParking = (stop.triggered || stop.containerTriggered || stop.parkingarea != "");
504 stop.parking = attrs.getOpt<ParkingType>(SUMO_ATTR_PARKING, nullptr, ok, defaultParking ? ParkingType::OFFROAD : ParkingType::ONROAD);
505 if ((stop.parkingarea != "") && (stop.parking == ParkingType::ONROAD)) {
506 WRITE_WARNING("Stop at parkingarea overrides attribute 'parking' for stop" + errorSuffix);
508 }
509 if (!ok) {
510 errorOutput->inform("Invalid bool for 'triggered', 'containerTriggered' or 'parking' for stop" + errorSuffix);
511 return false;
512 }
513
514 // expected persons
515 const std::vector<std::string>& expected = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EXPECTED, nullptr, ok);
516 stop.awaitedPersons.insert(expected.begin(), expected.end());
517 if (stop.awaitedPersons.size() > 0 && (stop.parametersSet & STOP_TRIGGER_SET) == 0) {
518 stop.triggered = true;
519 if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
521 }
522 }
523
524 // permitted transportables
525 const std::vector<std::string>& permitted = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_PERMITTED, nullptr, ok);
526 stop.permitted.insert(permitted.begin(), permitted.end());
527
528 // expected containers
529 const std::vector<std::string>& expectedContainers = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EXPECTED_CONTAINERS, nullptr, ok);
530 stop.awaitedContainers.insert(expectedContainers.begin(), expectedContainers.end());
531 if (stop.awaitedContainers.size() > 0 && (stop.parametersSet & STOP_CONTAINER_TRIGGER_SET) == 0) {
532 stop.containerTriggered = true;
533 if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
535 }
536 }
537 // public transport trip id
538 stop.tripId = attrs.getOpt<std::string>(SUMO_ATTR_TRIP_ID, nullptr, ok, "");
539 stop.split = attrs.getOpt<std::string>(SUMO_ATTR_SPLIT, nullptr, ok, "");
540 stop.join = attrs.getOpt<std::string>(SUMO_ATTR_JOIN, nullptr, ok, "");
541 stop.line = attrs.getOpt<std::string>(SUMO_ATTR_LINE, nullptr, ok, "");
542
543 const std::string idx = attrs.getOpt<std::string>(SUMO_ATTR_INDEX, nullptr, ok, "end");
544 if (idx == "end") {
545 stop.index = STOP_INDEX_END;
546 } else if (idx == "fit") {
547 stop.index = STOP_INDEX_FIT;
548 } else {
549 stop.index = attrs.get<int>(SUMO_ATTR_INDEX, nullptr, ok);
550 if (!ok || stop.index < 0) {
551 errorOutput->inform("Invalid 'index' for stop" + errorSuffix);
552 return false;
553 }
554 }
555 stop.started = attrs.getOptSUMOTimeReporting(SUMO_ATTR_STARTED, nullptr, ok, -1);
556 stop.ended = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ENDED, nullptr, ok, -1);
557 stop.posLat = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, nullptr, ok, INVALID_DOUBLE);
558 stop.actType = attrs.getOpt<std::string>(SUMO_ATTR_ACTTYPE, nullptr, ok, "");
559 stop.onDemand = attrs.getOpt<bool>(SUMO_ATTR_ONDEMAND, nullptr, ok, false);
560 stop.collision = attrs.getOpt<bool>(SUMO_ATTR_COLLISION, nullptr, ok, false);
561 return true;
562}
563
564
565/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:266
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:274
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
#define TL(string)
Definition: MsgHandler.h:282
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition: SUMOTime.cpp:45
const int STOP_ARRIVAL_SET
const int STOP_DURATION_SET
const int STOP_INDEX_END
const int STOP_POSLAT_SET
const int STOP_EXPECTED_SET
const int STOP_SPEED_SET
const int STOP_UNTIL_SET
const int STOP_LINE_SET
const int STOP_PARKING_SET
const int STOP_TRIP_ID_SET
const int STOP_PERMITTED_SET
const int STOP_SPLIT_SET
const int STOP_START_SET
const int STOP_JOIN_SET
const int STOP_CONTAINER_TRIGGER_SET
const int STOP_EXTENSION_SET
const int VEHPARS_FORCE_REROUTE
const int STOP_INDEX_FIT
const int STOP_ENDED_SET
const int STOP_TRIGGER_SET
const int STOP_ONDEMAND_SET
const int STOP_END_SET
const int STOP_STARTED_SET
const int STOP_EXPECTED_CONTAINERS_SET
@ GIVEN
The time is given.
SumoXMLTag
Numbers representing SUMO-XML - element names.
@ SUMO_TAG_INTERVAL
an aggreagated-output interval
@ SUMO_TAG_VTYPE
description of a vehicle/person/container type
@ SUMO_TAG_WALK
@ SUMO_TAG_TRANSHIP
@ SUMO_TAG_CONTAINERFLOW
@ SUMO_TAG_STOP
stop for vehicles
@ SUMO_TAG_VEHICLE
description of a vehicle
@ SUMO_TAG_ROUTE_DISTRIBUTION
distribution of a route
@ SUMO_TAG_FLOW
a flow definitio nusing a from-to edges instead of a route (used by router)
@ SUMO_TAG_TRANSPORT
@ SUMO_TAG_CONTAINER
@ SUMO_TAG_ROUTE
begin/end of the description of a route
@ SUMO_TAG_RIDE
@ SUMO_TAG_VTYPE_DISTRIBUTION
distribution of a vehicle type
@ SUMO_TAG_PARAM
parameter associated to a certain key
@ SUMO_TAG_PERSON
@ SUMO_TAG_PERSONTRIP
@ SUMO_TAG_CALIBRATOR
A calibrator placed over edge.
@ SUMO_TAG_PERSONFLOW
@ SUMO_TAG_TRIP
a single trip definition (used by router)
ParkingType
Numbers representing special SUMO-XML-attribute values Information on whether a car is parking on the...
@ SUMO_ATTR_CONTAINER_TRIGGERED
@ SUMO_ATTR_STARTPOS
@ SUMO_ATTR_PARKING
@ SUMO_ATTR_EXTENSION
@ SUMO_ATTR_COLLISION
@ SUMO_ATTR_SPEED
@ SUMO_ATTR_STARTED
@ SUMO_ATTR_VALUE
@ SUMO_ATTR_CONTAINER_STOP
@ SUMO_ATTR_PARKING_AREA
@ SUMO_ATTR_BUS_STOP
@ SUMO_ATTR_TRAIN_STOP
@ SUMO_ATTR_ENDPOS
@ SUMO_ATTR_SPLIT
@ SUMO_ATTR_ACTTYPE
@ SUMO_ATTR_BEGIN
weights: time range begin
@ SUMO_ATTR_POSITION_LAT
@ SUMO_ATTR_EXPECTED
@ SUMO_ATTR_LINE
@ SUMO_ATTR_CHARGING_STATION
@ SUMO_ATTR_OVERHEAD_WIRE_SEGMENT
@ SUMO_ATTR_ENDED
@ SUMO_ATTR_ONDEMAND
@ SUMO_ATTR_INDEX
@ SUMO_ATTR_ARRIVAL
@ SUMO_ATTR_TRIP_ID
@ SUMO_ATTR_END
weights: time range end
@ SUMO_ATTR_PERMITTED
@ SUMO_ATTR_JOIN
@ SUMO_ATTR_EXPECTED_CONTAINERS
@ SUMO_ATTR_UNTIL
@ SUMO_ATTR_TRIGGERED
@ SUMO_ATTR_DURATION
@ SUMO_ATTR_KEY
#define FALLTHROUGH
Definition: StdDefs.h:35
const double INVALID_DOUBLE
Definition: StdDefs.h:60
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
const std::string & getFileName() const
returns the current file name
virtual void inform(std::string msg, bool addType=true)
adds a new error to the list
Definition: MsgHandler.cpp:116
A storage for options typed value containers)
Definition: OptionsCont.h:89
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:59
virtual void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
bool parseStop(SUMOVehicleParameter::Stop &stop, const SUMOSAXAttributes &attrs, std::string errorSuffix, MsgHandler *const errorOutput)
parses attributes common to all stops
virtual void openTrip(const SUMOSAXAttributes &attrs)=0
opens a trip for reading
StopPos
enum for stops
void registerLastDepart()
save last depart (only to be used if vehicle is not discarded)
virtual void openFlow(const SUMOSAXAttributes &attrs)=0
opens a flow for reading
virtual void closeContainer()=0
Ends the processing of a container.
SUMOTime myFirstDepart
the first read departure time
virtual void addWalk(const SUMOSAXAttributes &attrs)=0
add a fully specified walk
static bool isStopPosValid(const double startPos, const double endPos, const double laneLength, const double minLength, const bool friendlyPos)
check if start and end position of a stop is valid
SUMOTime myBeginDefault
The default value for flow begins.
SUMORouteHandler(const std::string &file, const std::string &expectedRoot, const bool hardFail)
standard constructor
virtual void openRouteDistribution(const SUMOSAXAttributes &attrs)=0
opens a route distribution for reading
std::string myActiveRouteID
The id of the current route.
virtual void addPerson(const SUMOSAXAttributes &attrs)=0
Processing of a person.
virtual void openRoute(const SUMOSAXAttributes &attrs)=0
opens a route for reading
virtual void openVehicleTypeDistribution(const SUMOSAXAttributes &attrs)=0
opens a type distribution for reading
virtual ~SUMORouteHandler()
standard destructor
virtual void closeVehicle()=0
Ends the processing of a vehicle.
virtual void closeFlow()=0
Ends the processing of a flow.
Parameterised myLoadedParameterised
Parameterised used for saving loaded generic parameters that aren't saved in Vehicles or Vehicle Type...
virtual void closePersonFlow()=0
Ends the processing of a person flow.
SUMOVehicleParameter * myVehicleParameter
Parameter of the current vehicle, trip, person, container or flow.
virtual void addRide(const SUMOSAXAttributes &attrs)=0
Processing of a ride.
virtual void addTranship(const SUMOSAXAttributes &attrs)=0
Processing of a tranship.
SUMOTime getLastDepart() const
Returns the last loaded depart time.
const bool myHardFail
flag to enable or disable hard fails
virtual void addContainer(const SUMOSAXAttributes &attrs)=0
Processing of a container.
std::vector< int > myElementStack
hierachy of elements being parsed
SUMOVTypeParameter * myCurrentVType
The currently parsed vehicle type.
virtual void addTransport(const SUMOSAXAttributes &attrs)=0
Processing of a transport.
virtual void closeRoute(const bool mayBeDisconnected=false)=0
virtual void closePerson()=0
Ends the processing of a person.
SUMOTime myLastDepart
The insertion time of the vehicle read last.
SUMOTime myEndDefault
The default value for flow ends.
virtual void closeVehicleTypeDistribution()=0
closes (ends) the building of a distribution
static StopPos checkStopPos(double &startPos, double &endPos, const double laneLength, const double minLength, const bool friendlyPos)
check start and end position of a stop
virtual void addStop(const SUMOSAXAttributes &attrs)=0
Processing of a stop.
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
void addParam(const SUMOSAXAttributes &attrs)
assign arbitrary vehicle parameters
virtual void closeContainerFlow()=0
Ends the processing of a container flow.
virtual void closeTrip()=0
Ends the processing of a trip.
SUMOTime getFirstDepart() const
returns the first departure time that was ever read
virtual void openRouteFlow(const SUMOSAXAttributes &attrs)=0
opens a route flow for reading
int myInsertStopEdgesAt
where stop edges can be inserted into the current route (-1 means no insertion)
virtual void addPersonTrip(const SUMOSAXAttributes &attrs)=0
add a routing request for a walking or intermodal person
virtual void myEndElement(int element)
Called when a closing tag occurs.
virtual void closeVType()=0
Ends the processing of a vehicle type.
virtual void closeRouteDistribution()=0
closes (ends) the building of a distribution
virtual bool checkLastDepart()
Checks whether the route file is sorted by departure time if needed.
Encapsulated SAX-Attributes.
virtual std::string getString(int id, bool *isPresent=nullptr) const =0
Returns the string-value of the named (by its enum-value) attribute.
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue=T(), bool report=true) const
Tries to read given attribute assuming it is an int.
SUMOTime getOptSUMOTimeReporting(int attr, const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
SAX-handler base for SUMO-files.
std::string id
The vehicle type's id.
Definition of vehicle stop (position and duration)
SUMOTime started
the time at which this stop was reached
ParkingType parking
whether the vehicle is removed from the net while stopping
std::string lane
The lane to stop at.
SUMOTime extension
The maximum time extension for boarding / loading.
double speed
the speed at which this stop counts as reached (waypoint mode)
std::string parkingarea
(Optional) parking area if one is assigned to the stop
std::string split
the id of the vehicle (train portion) that splits of upon reaching this stop
std::string line
the new line id of the trip within a cyclical public transport route
double posLat
the lateral offset when stopping
bool onDemand
whether the stop may be skipped
std::string chargingStation
(Optional) charging station if one is assigned to the stop
std::string overheadWireSegment
(Optional) overhead line segment if one is assigned to the stop
std::set< std::string > permitted
IDs of persons or containers that may board/load at this stop.
int parametersSet
Information for the output which parameter were set.
int index
at which position in the stops list
std::string join
the id of the vehicle (train portion) to which this vehicle shall be joined
SUMOTime until
The time at which the vehicle may continue its journey.
std::string actType
act Type (only used by Persons) (used by NETEDIT)
bool triggered
whether an arriving person lets the vehicle continue
SUMOTime ended
the time at which this stop was ended
std::set< std::string > awaitedPersons
IDs of persons the vehicle has to wait for until departing.
std::set< std::string > awaitedContainers
IDs of containers the vehicle has to wait for until departing.
std::string busstop
(Optional) bus stop if one is assigned to the stop
std::string tripId
id of the trip within a cyclical public transport route
std::string containerstop
(Optional) container stop if one is assigned to the stop
bool containerTriggered
whether an arriving container lets the vehicle continue
bool collision
Whether this stop was triggered by a collision.
SUMOTime arrival
The (expected) time at which the vehicle reaches the stop.
SUMOTime duration
The stopping duration.
int parametersSet
Information for the router which parameter were set, TraCI may modify this (when changing color)
std::string routeid
The vehicle's route id.
std::string id
The vehicle's id.
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
std::string line
The vehicle's line (mainly for public transport)
static void parseStopTriggers(const std::vector< std::string > &triggers, bool expectTrigger, Stop &stop)
parses stop trigger values
static SUMOVTypeParameter * beginVTypeParsing(const SUMOSAXAttributes &attrs, const bool hardFail, const std::string &file)
Starts to parse a vehicle type.
static bool parseCFMParams(SUMOVTypeParameter *into, const SumoXMLTag element, const SUMOSAXAttributes &attrs, const bool nestedCFM)
Parses Car Following Mode params.
static SUMOVehicleParameter * parseFlowAttributes(SumoXMLTag tag, const SUMOSAXAttributes &attrs, const bool hardFail, const bool needID, const SUMOTime beginDefault, const SUMOTime endDefault)
Parses a flow's attributes.
static SUMOVehicleParameter * parseVehicleAttributes(int element, const SUMOSAXAttributes &attrs, const bool hardFail, const bool optionalID=false, const bool skipDepart=false)
Parses a vehicle's attributes.