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 
38 SUMORouteHandler::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 myCurrentVType;
55 }
56 
57 
58 bool
62  WRITE_WARNINGF("Route file should be sorted by departure time, ignoring '%'!", myVehicleParameter->id);
63  return false;
64  }
65  }
66  return true;
67 }
68 
69 
70 void
72  // register only non public transport to parse all public transport lines in advance
75  if (myFirstDepart == -1) {
77  }
78  }
79  // else: we don't know when this vehicle will depart. keep the previous known depart time
80 }
81 
82 
83 void
85  switch (element) {
86  case SUMO_TAG_VEHICLE:
87  // delete if myVehicleParameter isn't null
88  if (myVehicleParameter) {
89  delete myVehicleParameter;
90  }
91  // create a new vehicle
93  break;
94  case SUMO_TAG_PERSON:
95  // delete if myVehicleParameter isn't null
96  if (myVehicleParameter) {
97  delete myVehicleParameter;
98  }
99  // create a new person
101  addPerson(attrs);
102  break;
103  case SUMO_TAG_CONTAINER:
104  // delete if myVehicleParameter isn't null
105  if (myVehicleParameter) {
106  delete myVehicleParameter;
107  }
108  // create a new container
110  addContainer(attrs);
111  break;
112  case SUMO_TAG_FLOW:
113  // delete if myVehicleParameter isn't null
114  if (myVehicleParameter) {
115  delete myVehicleParameter;
116  }
117  // parse vehicle parameters
119  // check if myVehicleParameter was sucesfully created
120  if (myVehicleParameter) {
121  // check tag
122  if (myVehicleParameter->routeid.empty()) {
123  // open a route flow (It could be a flow with embebbed route)
124  openFlow(attrs);
125  } else {
126  // open a route flow
127  openRouteFlow(attrs);
128  }
129  }
130  break;
131  case SUMO_TAG_PERSONFLOW:
132  // delete if myVehicleParameter isn't null
133  if (myVehicleParameter) {
134  delete myVehicleParameter;
135  }
136  // create a new flow
138  break;
140  // delete if myVehicleParameter isn't null
141  if (myVehicleParameter) {
142  delete myVehicleParameter;
143  }
144  // create a new flow
146  break;
147  case SUMO_TAG_VTYPE:
148  // delete if myCurrentVType isn't null
149  if (myCurrentVType != nullptr) {
150  delete myCurrentVType;
151  myCurrentVType = nullptr;
152  }
153  // create a new vType
155  break;
158  break;
159  case SUMO_TAG_ROUTE:
160  openRoute(attrs);
161  break;
163  openRouteDistribution(attrs);
164  break;
165  case SUMO_TAG_STOP:
166  addStop(attrs);
167  break;
168  case SUMO_TAG_TRIP: {
169  // delete if myVehicleParameter isn't null
170  if (myVehicleParameter) {
171  delete myVehicleParameter;
172  }
173  // parse vehicle parameters
175  // check if myVehicleParameter was sucesfully created
176  if (myVehicleParameter) {
179  // open trip
180  openTrip(attrs);
181  }
182  break;
183  }
184  case SUMO_TAG_PERSONTRIP:
185  addPersonTrip(attrs);
186  break;
187  case SUMO_TAG_WALK:
188  addWalk(attrs);
189  break;
190  case SUMO_TAG_INTERVAL: {
191  bool ok;
193  myEndDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_END, nullptr, ok);
194  break;
195  }
196  case SUMO_TAG_RIDE:
197  addRide(attrs);
198  break;
199  case SUMO_TAG_TRANSPORT:
200  addTransport(attrs);
201  break;
202  case SUMO_TAG_TRANSHIP:
203  addTranship(attrs);
204  break;
205  case SUMO_TAG_PARAM:
206  addParam(attrs);
207  break;
208  default:
209  // parse embedded car following model information
210  if (myCurrentVType != nullptr) {
211  WRITE_WARNING("Defining car following parameters in a nested element is deprecated in vType '" + myCurrentVType->id + "', use attributes instead!");
213  if (myHardFail) {
214  throw ProcessError("Invalid parsing embedded VType");
215  } else {
216  WRITE_ERROR("Invalid parsing embedded VType");
217  }
218  }
219  }
220  break;
221  }
222 }
223 
224 
225 void
227  switch (element) {
228  case SUMO_TAG_ROUTE:
229  closeRoute();
230  break;
231  case SUMO_TAG_VTYPE:
232  closeVType();
233  delete myCurrentVType;
234  myCurrentVType = nullptr;
235  break;
236  case SUMO_TAG_PERSON:
237  closePerson();
238  delete myVehicleParameter;
239  myVehicleParameter = nullptr;
240  break;
241  case SUMO_TAG_PERSONFLOW:
242  closePersonFlow();
243  delete myVehicleParameter;
244  myVehicleParameter = nullptr;
245  break;
246  case SUMO_TAG_CONTAINER:
247  closeContainer();
248  delete myVehicleParameter;
249  myVehicleParameter = nullptr;
250  break;
253  delete myVehicleParameter;
254  myVehicleParameter = nullptr;
255  break;
256  case SUMO_TAG_VEHICLE:
257  if (myVehicleParameter == nullptr) {
258  break;
259  }
261  myVehicleParameter->repetitionNumber++; // for backwards compatibility
262  // it is a flow, thus no break here
263  FALLTHROUGH;
264  } else {
265  closeVehicle();
266  delete myVehicleParameter;
267  myVehicleParameter = nullptr;
268  break;
269  }
270  case SUMO_TAG_FLOW:
271  closeFlow();
272  delete myVehicleParameter;
273  myVehicleParameter = nullptr;
274  myInsertStopEdgesAt = -1;
275  break;
276  case SUMO_TAG_TRIP:
277  closeTrip();
278  delete myVehicleParameter;
279  myVehicleParameter = nullptr;
280  myInsertStopEdgesAt = -1;
281  break;
284  break;
287  break;
288  case SUMO_TAG_INTERVAL:
289  myBeginDefault = string2time(OptionsCont::getOptions().getString("begin"));
290  myEndDefault = string2time(OptionsCont::getOptions().getString("end"));
291  break;
292  default:
293  break;
294  }
295 }
296 
297 
299 SUMORouteHandler::checkStopPos(double& startPos, double& endPos, const double laneLength, const double minLength, const bool friendlyPos) {
300  if (minLength > laneLength) {
302  }
303  if (startPos < 0) {
304  startPos += laneLength;
305  }
306  if (endPos < 0) {
307  endPos += laneLength;
308  }
309  if ((endPos < minLength) || (endPos > laneLength)) {
310  if (!friendlyPos) {
311  return STOPPOS_INVALID_ENDPOS;
312  }
313  if (endPos < minLength) {
314  endPos = minLength;
315  }
316  if (endPos > laneLength) {
317  endPos = laneLength;
318  }
319  }
320  if ((startPos < 0) || (startPos > (endPos - minLength))) {
321  if (!friendlyPos) {
323  }
324  if (startPos < 0) {
325  startPos = 0;
326  }
327  if (startPos > (endPos - minLength)) {
328  startPos = endPos - minLength;
329  }
330  }
331  return STOPPOS_VALID;
332 }
333 
334 
335 bool
336 SUMORouteHandler::isStopPosValid(const double startPos, const double endPos, const double laneLength, const double minLength, const bool friendlyPos) {
337  // declare dummy start and end positions
338  double dummyStartPos = startPos;
339  double dummyEndPos = endPos;
340  // return checkStopPos
341  return (checkStopPos(dummyStartPos, dummyEndPos, laneLength, minLength, friendlyPos) == STOPPOS_VALID);
342 }
343 
344 
345 SUMOTime
347  return myFirstDepart;
348 }
349 
350 
351 SUMOTime
353  return myLastDepart;
354 }
355 
356 
357 void
359  bool ok = true;
360  const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, ok);
361  // only continue if key isn't empty
362  if (ok && (key.size() > 0)) {
363  // circumventing empty string test
364  const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
365  // add parameter in current created element, or in myLoadedParameterised
366  if (myVehicleParameter != nullptr) {
367  myVehicleParameter->setParameter(key, val);
368  } else if (myCurrentVType != nullptr) {
369  myCurrentVType->setParameter(key, val);
370  } else {
372  }
373  }
374 }
375 
376 
377 bool
378 SUMORouteHandler::parseStop(SUMOVehicleParameter::Stop& stop, const SUMOSAXAttributes& attrs, std::string errorSuffix, MsgHandler* const errorOutput) {
379  stop.parametersSet = 0;
380  if (attrs.hasAttribute(SUMO_ATTR_ARRIVAL)) {
382  }
383  if (attrs.hasAttribute(SUMO_ATTR_DURATION)) {
385  }
386  if (attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
388  }
389  if (attrs.hasAttribute(SUMO_ATTR_STARTED)) {
391  }
392  if (attrs.hasAttribute(SUMO_ATTR_ENDED)) {
394  }
395  if (attrs.hasAttribute(SUMO_ATTR_EXTENSION)) {
397  }
398  if (attrs.hasAttribute(SUMO_ATTR_ENDPOS)) {
399  stop.parametersSet |= STOP_END_SET;
400  }
401  if (attrs.hasAttribute(SUMO_ATTR_STARTPOS)) {
403  }
406  }
407  if (attrs.hasAttribute(SUMO_ATTR_TRIGGERED)) {
409  }
410  // legacy attribute
413  }
414  if (attrs.hasAttribute(SUMO_ATTR_PARKING)) {
416  }
417  if (attrs.hasAttribute(SUMO_ATTR_EXPECTED)) {
419  }
420  if (attrs.hasAttribute(SUMO_ATTR_PERMITTED)) {
422  }
425  }
426  if (attrs.hasAttribute(SUMO_ATTR_TRIP_ID)) {
428  }
429  if (attrs.hasAttribute(SUMO_ATTR_SPLIT)) {
431  }
432  if (attrs.hasAttribute(SUMO_ATTR_JOIN)) {
434  }
435  if (attrs.hasAttribute(SUMO_ATTR_LINE)) {
437  }
438  if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
440  }
441  bool ok = true;
442  stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, nullptr, ok, "");
443  stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_TRAIN_STOP, nullptr, ok, stop.busstop);
444  stop.chargingStation = attrs.getOpt<std::string>(SUMO_ATTR_CHARGING_STATION, nullptr, ok, "");
445  stop.overheadWireSegment = attrs.getOpt<std::string>(SUMO_ATTR_OVERHEAD_WIRE_SEGMENT, nullptr, ok, "");
446  stop.containerstop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, nullptr, ok, "");
447  stop.parkingarea = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, nullptr, ok, "");
448  if (stop.busstop != "") {
449  errorSuffix = " at '" + stop.busstop + "'" + errorSuffix;
450  } else if (stop.chargingStation != "") {
451  errorSuffix = " at '" + stop.chargingStation + "'" + errorSuffix;
452  } else if (stop.overheadWireSegment != "") {
453  errorSuffix = " at '" + stop.overheadWireSegment + "'" + errorSuffix;
454  } else if (stop.containerstop != "") {
455  errorSuffix = " at '" + stop.containerstop + "'" + errorSuffix;
456  } else if (stop.parkingarea != "") {
457  errorSuffix = " at '" + stop.parkingarea + "'" + errorSuffix;
458  } else {
459  errorSuffix = " on lane '" + stop.lane + "'" + errorSuffix;
460  }
461  // speed for counting as stopped
462  stop.speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, nullptr, ok, 0);
463  if (stop.speed < 0) {
464  errorOutput->inform("Speed cannot be negative for stop" + errorSuffix);
465  return false;
466  }
467 
468  // get the standing duration
469  bool expectTrigger = !attrs.hasAttribute(SUMO_ATTR_DURATION) && !attrs.hasAttribute(SUMO_ATTR_UNTIL) && !attrs.hasAttribute(SUMO_ATTR_SPEED);
470  std::vector<std::string> triggers = attrs.getOptStringVector(SUMO_ATTR_TRIGGERED, nullptr, ok);
471  // legacy
472  if (attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, nullptr, ok, false)) {
473  triggers.push_back(toString(SUMO_TAG_CONTAINER));
474  };
475  SUMOVehicleParameter::parseStopTriggers(triggers, expectTrigger, stop);
476  stop.arrival = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ARRIVAL, nullptr, ok, -1);
477  stop.duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, nullptr, ok, -1);
478  stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, nullptr, ok, -1);
479  if (!expectTrigger && (!ok || (stop.duration < 0 && stop.until < 0 && stop.speed == 0))) {
480  errorOutput->inform("Invalid duration or end time is given for a stop" + errorSuffix);
481  return false;
482  }
483  stop.extension = attrs.getOptSUMOTimeReporting(SUMO_ATTR_EXTENSION, nullptr, ok, -1);
484  stop.parking = attrs.getOpt<bool>(SUMO_ATTR_PARKING, nullptr, ok, stop.triggered || stop.containerTriggered || stop.parkingarea != "");
485  if (stop.parkingarea != "" && !stop.parking) {
486  WRITE_WARNING("Stop at parkingarea overrides attribute 'parking' for stop" + errorSuffix);
487  stop.parking = true;
488  }
489  if (!ok) {
490  errorOutput->inform("Invalid bool for 'triggered', 'containerTriggered' or 'parking' for stop" + errorSuffix);
491  return false;
492  }
493 
494  // expected persons
495  const std::vector<std::string>& expected = attrs.getOptStringVector(SUMO_ATTR_EXPECTED, nullptr, ok);
496  stop.awaitedPersons.insert(expected.begin(), expected.end());
497  if (stop.awaitedPersons.size() > 0 && (stop.parametersSet & STOP_TRIGGER_SET) == 0) {
498  stop.triggered = true;
499  if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
500  stop.parking = true;
501  }
502  }
503 
504  // permitted transportables
505  const std::vector<std::string>& permitted = attrs.getOptStringVector(SUMO_ATTR_PERMITTED, nullptr, ok);
506  stop.permitted.insert(permitted.begin(), permitted.end());
507 
508  // expected containers
509  const std::vector<std::string>& expectedContainers = attrs.getOptStringVector(SUMO_ATTR_EXPECTED_CONTAINERS, nullptr, ok);
510  stop.awaitedContainers.insert(expectedContainers.begin(), expectedContainers.end());
511  if (stop.awaitedContainers.size() > 0 && (stop.parametersSet & STOP_CONTAINER_TRIGGER_SET) == 0) {
512  stop.containerTriggered = true;
513  if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
514  stop.parking = true;
515  }
516  }
517  // public transport trip id
518  stop.tripId = attrs.getOpt<std::string>(SUMO_ATTR_TRIP_ID, nullptr, ok, "");
519  stop.split = attrs.getOpt<std::string>(SUMO_ATTR_SPLIT, nullptr, ok, "");
520  stop.join = attrs.getOpt<std::string>(SUMO_ATTR_JOIN, nullptr, ok, "");
521  stop.line = attrs.getOpt<std::string>(SUMO_ATTR_LINE, nullptr, ok, "");
522 
523  const std::string idx = attrs.getOpt<std::string>(SUMO_ATTR_INDEX, nullptr, ok, "end");
524  if (idx == "end") {
525  stop.index = STOP_INDEX_END;
526  } else if (idx == "fit") {
527  stop.index = STOP_INDEX_FIT;
528  } else {
529  stop.index = attrs.get<int>(SUMO_ATTR_INDEX, nullptr, ok);
530  if (!ok || stop.index < 0) {
531  errorOutput->inform("Invalid 'index' for stop" + errorSuffix);
532  return false;
533  }
534  }
535  stop.started = attrs.getOptSUMOTimeReporting(SUMO_ATTR_STARTED, nullptr, ok, -1);
536  stop.ended = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ENDED, nullptr, ok, -1);
537  stop.posLat = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, nullptr, ok, INVALID_DOUBLE);
538  stop.actType = attrs.getOpt<std::string>(SUMO_ATTR_ACTTYPE, nullptr, ok, "");
539  return true;
540 }
541 
542 
543 /****************************************************************************/
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:281
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:288
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:280
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition: SUMOTime.cpp:45
long long int SUMOTime
Definition: SUMOTime.h:32
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_END_SET
const int STOP_STARTED_SET
const int STOP_EXPECTED_CONTAINERS_SET
@ DEPART_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_PERSONFLOW
@ SUMO_TAG_TRIP
a single trip definition (used by router)
@ SUMO_ATTR_CONTAINER_TRIGGERED
@ SUMO_ATTR_STARTPOS
@ SUMO_ATTR_PARKING
@ SUMO_ATTR_EXTENSION
@ 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_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:63
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:117
A storage for options typed value containers)
Definition: OptionsCont.h:89
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:58
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.
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.
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
const std::vector< std::string > getOptStringVector(int attr, const char *objectid, bool &ok, bool report=true) const
convenience function to avoid the default argument and the template stuff at getOpt<>
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.
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
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
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
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
bool parking
whether the vehicle is removed from the net while stopping
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
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.