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-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
17 // Parser for routes during their loading
18 /****************************************************************************/
19 
20 
21 // ===========================================================================
22 // included modules
23 // ===========================================================================
24 #include <config.h>
25 
30 #include <utils/xml/XMLSubSys.h>
31 
32 #include "SUMORouteHandler.h"
33 
34 
35 // ===========================================================================
36 // method definitions
37 // ===========================================================================
38 
39 SUMORouteHandler::SUMORouteHandler(const std::string& file, const std::string& expectedRoot, const bool hardFail) :
40  SUMOSAXHandler(file, XMLSubSys::isValidating() ? expectedRoot : ""),
41  myHardFail(hardFail),
42  myVehicleParameter(nullptr),
43  myLastDepart(-1),
44  myActiveRouteColor(nullptr),
45  myCurrentCosts(0.),
46  myCurrentVType(nullptr),
47  myBeginDefault(string2time(OptionsCont::getOptions().getString("begin"))),
48  myEndDefault(string2time(OptionsCont::getOptions().getString("end"))),
49  myFirstDepart(-1),
50  myInsertStopEdgesAt(-1) {
51 }
52 
53 
55  delete myCurrentVType;
56 }
57 
58 
59 bool
63  WRITE_WARNING("Route file should be sorted by departure time, ignoring '" + myVehicleParameter->id + "'!");
64  return false;
65  }
66  }
67  return true;
68 }
69 
70 
71 void
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 
84 void
86  switch (element) {
87  case SUMO_TAG_VEHICLE:
88  // delete if myVehicleParameter isn't null
89  if (myVehicleParameter) {
90  delete myVehicleParameter;
91  }
92  // create a new vehicle
94  break;
95  case SUMO_TAG_PERSON:
96  // delete if myVehicleParameter isn't null
97  if (myVehicleParameter) {
98  delete myVehicleParameter;
99  }
100  // create a new person
102  addPerson(attrs);
103  break;
104  case SUMO_TAG_CONTAINER:
105  // delete if myVehicleParameter isn't null
106  if (myVehicleParameter) {
107  delete myVehicleParameter;
108  }
109  // create a new container
111  addContainer(attrs);
112  break;
113  case SUMO_TAG_FLOW:
114  // delete if myVehicleParameter isn't null
115  if (myVehicleParameter) {
116  delete myVehicleParameter;
117  }
118  // parse vehicle parameters
120  // check if myVehicleParameter was sucesfully created
121  if (myVehicleParameter) {
122  // open a flow (using openTrip function)
123  openTrip(attrs);
124  }
125  break;
126  case SUMO_TAG_PERSONFLOW:
127  // delete if myVehicleParameter isn't null
128  if (myVehicleParameter) {
129  delete myVehicleParameter;
130  }
131  // create a new flow
133  break;
134  case SUMO_TAG_VTYPE:
135  // delete if myCurrentVType isn't null
136  if (myCurrentVType != nullptr) {
137  delete myCurrentVType;
138  myCurrentVType = nullptr;
139  }
140  // create a new vType
142  break;
145  break;
146  case SUMO_TAG_ROUTE:
147  openRoute(attrs);
148  break;
150  openRouteDistribution(attrs);
151  break;
152  case SUMO_TAG_STOP:
153  addStop(attrs);
154  break;
155  case SUMO_TAG_TRIP: {
156  // delete if myVehicleParameter isn't null
157  if (myVehicleParameter) {
158  delete myVehicleParameter;
159  }
160  // parse vehicle parameters
162  // check if myVehicleParameter was sucesfully created
163  if (myVehicleParameter) {
166  // open trip
167  openTrip(attrs);
168  }
169  break;
170  }
171  case SUMO_TAG_PERSONTRIP:
172  case SUMO_TAG_WALK:
174  addWalk(attrs);
175  } else {
176  addPersonTrip(attrs);
177  }
178  break;
179  case SUMO_TAG_INTERVAL: {
180  bool ok;
182  myEndDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_END, nullptr, ok);
183  break;
184  }
185  case SUMO_TAG_RIDE:
186  addRide(attrs);
187  break;
188  case SUMO_TAG_TRANSPORT:
189  addTransport(attrs);
190  break;
191  case SUMO_TAG_TRANSHIP:
192  addTranship(attrs);
193  break;
194  case SUMO_TAG_PARAM:
195  addParam(attrs);
196  break;
197  default:
198  // parse embedded car following model information
199  if (myCurrentVType != nullptr) {
200  WRITE_WARNING("Defining car following parameters in a nested element is deprecated in vType '" + myCurrentVType->id + "', use attributes instead!");
202  if (myHardFail) {
203  throw ProcessError("Invalid parsing embedded VType");
204  } else {
205  WRITE_ERROR("Invalid parsing embedded VType");
206  }
207  }
208  }
209  break;
210  }
211 }
212 
213 
214 void
216  switch (element) {
217  case SUMO_TAG_ROUTE:
218  closeRoute();
219  break;
220  case SUMO_TAG_VTYPE:
221  closeVType();
222  delete myCurrentVType;
223  myCurrentVType = nullptr;
224  break;
225  case SUMO_TAG_PERSON:
226  closePerson();
227  delete myVehicleParameter;
228  myVehicleParameter = nullptr;
229  break;
230  case SUMO_TAG_PERSONFLOW:
231  closePersonFlow();
232  delete myVehicleParameter;
233  myVehicleParameter = nullptr;
234  break;
235  case SUMO_TAG_CONTAINER:
236  closeContainer();
237  delete myVehicleParameter;
238  myVehicleParameter = nullptr;
239  break;
240  case SUMO_TAG_VEHICLE:
241  if (myVehicleParameter == nullptr) {
242  break;
243  }
245  myVehicleParameter->repetitionNumber++; // for backwards compatibility
246  // it is a flow, thus no break here
247  FALLTHROUGH;
248  } else {
249  closeVehicle();
250  delete myVehicleParameter;
251  myVehicleParameter = nullptr;
252  break;
253  }
254  case SUMO_TAG_FLOW:
255  closeFlow();
256  delete myVehicleParameter;
257  myVehicleParameter = nullptr;
258  myInsertStopEdgesAt = -1;
259  break;
260  case SUMO_TAG_TRIP:
261  closeTrip();
262  delete myVehicleParameter;
263  myVehicleParameter = nullptr;
264  myInsertStopEdgesAt = -1;
265  break;
268  break;
271  break;
272  case SUMO_TAG_INTERVAL:
273  myBeginDefault = string2time(OptionsCont::getOptions().getString("begin"));
274  myEndDefault = string2time(OptionsCont::getOptions().getString("end"));
275  break;
276  default:
277  break;
278  }
279 }
280 
281 
283 SUMORouteHandler::checkStopPos(double& startPos, double& endPos, const double laneLength, const double minLength, const bool friendlyPos) {
284  if (minLength > laneLength) {
286  }
287  if (startPos < 0) {
288  startPos += laneLength;
289  }
290  if (endPos < 0) {
291  endPos += laneLength;
292  }
293  if ((endPos < minLength) || (endPos > laneLength)) {
294  if (!friendlyPos) {
295  return STOPPOS_INVALID_ENDPOS;
296  }
297  if (endPos < minLength) {
298  endPos = minLength;
299  }
300  if (endPos > laneLength) {
301  endPos = laneLength;
302  }
303  }
304  if ((startPos < 0) || (startPos > (endPos - minLength))) {
305  if (!friendlyPos) {
307  }
308  if (startPos < 0) {
309  startPos = 0;
310  }
311  if (startPos > (endPos - minLength)) {
312  startPos = endPos - minLength;
313  }
314  }
315  return STOPPOS_VALID;
316 }
317 
318 
319 bool
320 SUMORouteHandler::isStopPosValid(const double startPos, const double endPos, const double laneLength, const double minLength, const bool friendlyPos) {
321  // declare dummy start and end positions
322  double dummyStartPos = startPos;
323  double dummyEndPos = endPos;
324  // return checkStopPos
325  return (checkStopPos(dummyStartPos, dummyEndPos, laneLength, minLength, friendlyPos) == STOPPOS_VALID);
326 }
327 
328 
329 SUMOTime
331  return myFirstDepart;
332 }
333 
334 
335 SUMOTime
337  return myLastDepart;
338 }
339 
340 
341 void
343  bool ok = true;
344  const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, ok);
345  // only continue if key isn't empty
346  if (ok && (key.size() > 0)) {
347  // circumventing empty string test
348  const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
349  // add parameter in current created element, or in myLoadedParameterised
350  if (myVehicleParameter != nullptr) {
351  myVehicleParameter->setParameter(key, val);
352  } else if (myCurrentVType != nullptr) {
353  myCurrentVType->setParameter(key, val);
354  } else {
356  }
357  }
358 }
359 
360 
361 bool
362 SUMORouteHandler::parseStop(SUMOVehicleParameter::Stop& stop, const SUMOSAXAttributes& attrs, std::string errorSuffix, MsgHandler* const errorOutput) {
363  stop.parametersSet = 0;
364  if (attrs.hasAttribute(SUMO_ATTR_DURATION)) {
366  }
367  if (attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
369  }
370  if (attrs.hasAttribute(SUMO_ATTR_EXTENSION)) {
372  }
373  if (attrs.hasAttribute(SUMO_ATTR_ENDPOS)) {
374  stop.parametersSet |= STOP_END_SET;
375  }
376  if (attrs.hasAttribute(SUMO_ATTR_STARTPOS)) {
378  }
379  if (attrs.hasAttribute(SUMO_ATTR_TRIGGERED)) {
381  }
384  }
385  if (attrs.hasAttribute(SUMO_ATTR_PARKING)) {
387  }
388  if (attrs.hasAttribute(SUMO_ATTR_EXPECTED)) {
390  }
393  }
394  if (attrs.hasAttribute(SUMO_ATTR_TRIP_ID)) {
396  }
397  if (attrs.hasAttribute(SUMO_ATTR_LINE)) {
399  }
400  if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
402  }
403  bool ok = true;
404  stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, nullptr, ok, "");
405  stop.chargingStation = attrs.getOpt<std::string>(SUMO_ATTR_CHARGING_STATION, nullptr, ok, "");
406  stop.containerstop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, nullptr, ok, "");
407  stop.parkingarea = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, nullptr, ok, "");
408  if (stop.busstop != "") {
409  errorSuffix = " at '" + stop.busstop + "'" + errorSuffix;
410  } else if (stop.chargingStation != "") {
411  errorSuffix = " at '" + stop.chargingStation + "'" + errorSuffix;
412  } else if (stop.containerstop != "") {
413  errorSuffix = " at '" + stop.containerstop + "'" + errorSuffix;
414  } else if (stop.parkingarea != "") {
415  errorSuffix = " at '" + stop.parkingarea + "'" + errorSuffix;
416  } else {
417  errorSuffix = " on lane '" + stop.lane + "'" + errorSuffix;
418  }
419  // speed for counting as stopped
420  stop.speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, nullptr, ok, 0);
421  if (stop.speed < 0) {
422  errorOutput->inform("Speed cannot be negative for stop" + errorSuffix);
423  return false;
424  }
425 
426  // get the standing duration
429  stop.containerTriggered = attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, nullptr, ok, true);
430  stop.triggered = attrs.getOpt<bool>(SUMO_ATTR_TRIGGERED, nullptr, ok, false);
431  } else {
432  stop.triggered = attrs.getOpt<bool>(SUMO_ATTR_TRIGGERED, nullptr, ok, true);
433  stop.containerTriggered = attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, nullptr, ok, false);
434  }
435  stop.duration = -1;
436  stop.until = -1;
437  } else {
438  stop.duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, nullptr, ok, -1);
439  stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, nullptr, ok, -1);
440  if (!ok || (stop.duration < 0 && stop.until < 0 && stop.speed == 0)) {
441  errorOutput->inform("Invalid duration or end time is given for a stop" + errorSuffix);
442  return false;
443  }
444  stop.triggered = attrs.getOpt<bool>(SUMO_ATTR_TRIGGERED, nullptr, ok, false);
445  stop.containerTriggered = attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, nullptr, ok, false);
446  }
447  stop.extension = attrs.getOptSUMOTimeReporting(SUMO_ATTR_EXTENSION, nullptr, ok, -1);
448  stop.parking = attrs.getOpt<bool>(SUMO_ATTR_PARKING, nullptr, ok, stop.triggered || stop.containerTriggered || stop.parkingarea != "");
449  if (stop.parkingarea != "" && !stop.parking) {
450  WRITE_WARNING("Stop at parkingarea overrides attribute 'parking' for stop" + errorSuffix);
451  stop.parking = true;
452  }
453  if (!ok) {
454  errorOutput->inform("Invalid bool for 'triggered', 'containerTriggered' or 'parking' for stop" + errorSuffix);
455  return false;
456  }
457 
458  // expected persons
459  const std::vector<std::string>& expected = attrs.getOptStringVector(SUMO_ATTR_EXPECTED, nullptr, ok);
460  stop.awaitedPersons.insert(expected.begin(), expected.end());
461  if (stop.awaitedPersons.size() > 0 && (stop.parametersSet & STOP_TRIGGER_SET) == 0) {
462  stop.triggered = true;
463  if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
464  stop.parking = true;
465  }
466  }
467 
468  // expected containers
469  const std::vector<std::string>& expectedContainers = attrs.getOptStringVector(SUMO_ATTR_EXPECTED_CONTAINERS, nullptr, ok);
470  stop.awaitedContainers.insert(expectedContainers.begin(), expectedContainers.end());
471  if (stop.awaitedContainers.size() > 0 && (stop.parametersSet & STOP_CONTAINER_TRIGGER_SET) == 0) {
472  stop.containerTriggered = true;
473  if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
474  stop.parking = true;
475  }
476  }
477  // public transport trip id
478  stop.tripId = attrs.getOpt<std::string>(SUMO_ATTR_TRIP_ID, nullptr, ok, "");
479  stop.line = attrs.getOpt<std::string>(SUMO_ATTR_LINE, nullptr, ok, "");
480 
481  const std::string idx = attrs.getOpt<std::string>(SUMO_ATTR_INDEX, nullptr, ok, "end");
482  if (idx == "end") {
483  stop.index = STOP_INDEX_END;
484  } else if (idx == "fit") {
485  stop.index = STOP_INDEX_FIT;
486  } else {
487  stop.index = attrs.get<int>(SUMO_ATTR_INDEX, nullptr, ok);
488  if (!ok || stop.index < 0) {
489  errorOutput->inform("Invalid 'index' for stop" + errorSuffix);
490  return false;
491  }
492  }
493  return true;
494 }
495 
496 /****************************************************************************/
SUMOVehicleParameter::Stop::awaitedPersons
std::set< std::string > awaitedPersons
IDs of persons the vehicle has to wait for until departing.
Definition: SUMOVehicleParameter.h:625
SUMORouteHandler::closeContainer
virtual void closeContainer()=0
Ends the processing of a container.
SUMOSAXAttributes::hasAttribute
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SUMOVehicleParameter::parametersSet
int parametersSet
Information for the router which parameter were set, TraCI may modify this (whe changing color)
Definition: SUMOVehicleParameter.h:671
SUMORouteHandler::~SUMORouteHandler
virtual ~SUMORouteHandler()
standard destructor
Definition: SUMORouteHandler.cpp:54
SUMORouteHandler::myStartElement
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
Definition: SUMORouteHandler.cpp:85
SUMORouteHandler::addRide
virtual void addRide(const SUMOSAXAttributes &attrs)=0
Processing of a ride.
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:275
SUMO_ATTR_PARKING_AREA
Definition: SUMOXMLDefinitions.h:771
SUMO_ATTR_CONTAINER_STOP
Definition: SUMOXMLDefinitions.h:770
SUMOSAXAttributes::getString
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
SUMOVehicleParserHelper::parseVTypeEmbedded
static bool parseVTypeEmbedded(SUMOVTypeParameter &into, const SumoXMLTag element, const SUMOSAXAttributes &attrs, const bool hardFail, const bool fromVType=false)
Parses an element embedded in vtype definition.
Definition: SUMOVehicleParserHelper.cpp:878
SUMOSAXHandler
SAX-handler base for SUMO-files.
Definition: SUMOSAXHandler.h:41
SUMOVehicleParameter::Stop::lane
std::string lane
The lane to stop at.
Definition: SUMOVehicleParameter.h:586
SUMORouteHandler::closeRoute
virtual void closeRoute(const bool mayBeDisconnected=false)=0
SUMORouteHandler::parseStop
bool parseStop(SUMOVehicleParameter::Stop &stop, const SUMOSAXAttributes &attrs, std::string errorSuffix, MsgHandler *const errorOutput)
parses attributes common to all stops
Definition: SUMORouteHandler.cpp:362
SUMO_ATTR_UNTIL
Definition: SUMOXMLDefinitions.h:668
SUMORouteHandler::STOPPOS_INVALID_ENDPOS
Definition: SUMORouteHandler.h:56
SUMOVehicleParserHelper.h
SUMO_TAG_ROUTE_DISTRIBUTION
distribution of a route
Definition: SUMOXMLDefinitions.h:214
OptionsCont.h
SUMO_TAG_PARAM
parameter associated to a certain key
Definition: SUMOXMLDefinitions.h:169
SUMO_ATTR_LINE
Definition: SUMOXMLDefinitions.h:775
SUMOSAXAttributes::get
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:492
SUMORouteHandler::addParam
void addParam(const SUMOSAXAttributes &attrs)
assign arbitrary vehicle parameters
Definition: SUMORouteHandler.cpp:342
VEHPARS_FORCE_REROUTE
const int VEHPARS_FORCE_REROUTE
Definition: SUMOVehicleParameter.h:62
MsgHandler.h
SUMOVehicleParameter::Stop::busstop
std::string busstop
(Optional) bus stop if one is assigned to the stop
Definition: SUMOVehicleParameter.h:589
STOP_UNTIL_SET
const int STOP_UNTIL_SET
Definition: SUMOVehicleParameter.h:77
SUMORouteHandler::myLastDepart
SUMOTime myLastDepart
The insertion time of the vehicle read last.
Definition: SUMORouteHandler.h:209
SUMOVehicleParameter::Stop::parametersSet
int parametersSet
Information for the output which parameter were set.
Definition: SUMOVehicleParameter.h:652
STOP_SPEED_SET
const int STOP_SPEED_SET
Definition: SUMOVehicleParameter.h:86
SUMO_TAG_PERSON
Definition: SUMOXMLDefinitions.h:295
MsgHandler::inform
virtual void inform(std::string msg, bool addType=true)
adds a new error to the list
Definition: MsgHandler.cpp:118
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:34
SUMO_TAG_PERSONTRIP
Definition: SUMOXMLDefinitions.h:296
OptionsCont::getOptions
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:57
SUMOVehicleParameter::departProcedure
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
Definition: SUMOVehicleParameter.h:485
SUMORouteHandler::closeRouteDistribution
virtual void closeRouteDistribution()=0
closes (ends) the building of a distribution
SUMOVehicleParameter::Stop::line
std::string line
the new line id of the trip within a cyclical public transport route
Definition: SUMOVehicleParameter.h:640
SUMORouteHandler::addPerson
virtual void addPerson(const SUMOSAXAttributes &attrs)=0
Processing of a person.
SUMO_ATTR_SPEED
Definition: SUMOXMLDefinitions.h:384
SUMOVehicleParameter::Stop::parkingarea
std::string parkingarea
(Optional) parking area if one is assigned to the stop
Definition: SUMOVehicleParameter.h:595
SUMO_TAG_VTYPE
description of a vehicle type
Definition: SUMOXMLDefinitions.h:121
SUMO_ATTR_CHARGING_STATION
Definition: SUMOXMLDefinitions.h:774
STOP_EXTENSION_SET
const int STOP_EXTENSION_SET
Definition: SUMOVehicleParameter.h:78
SUMO_ATTR_ENDPOS
Definition: SUMOXMLDefinitions.h:798
SUMOSAXAttributes::getSUMOTimeReporting
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
Definition: SUMOSAXAttributes.cpp:63
SUMORouteHandler::closeFlow
virtual void closeFlow()=0
Ends the processing of a flow.
SUMO_TAG_CONTAINER
Definition: SUMOXMLDefinitions.h:316
STOP_TRIP_ID_SET
const int STOP_TRIP_ID_SET
Definition: SUMOVehicleParameter.h:84
SUMOVehicleParameter::Stop::triggered
bool triggered
whether an arriving person lets the vehicle continue
Definition: SUMOVehicleParameter.h:616
SUMORouteHandler::myHardFail
const bool myHardFail
flag to enable or disable hard fails
Definition: SUMORouteHandler.h:203
FALLTHROUGH
#define FALLTHROUGH
Definition: StdDefs.h:36
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:41
SUMOVehicleParameter::depart
SUMOTime depart
Definition: SUMOVehicleParameter.h:482
STOP_START_SET
const int STOP_START_SET
Definition: SUMOVehicleParameter.h:74
XMLSubSys
Utility methods for initialising, closing and using the XML-subsystem.
Definition: XMLSubSys.h:66
SUMORouteHandler::checkStopPos
static StopPos checkStopPos(double &startPos, double &endPos, const double laneLength, const double minLength, const bool friendlyPos)
check start and end position of a stop
Definition: SUMORouteHandler.cpp:283
SUMOVehicleParserHelper::parseVehicleAttributes
static SUMOVehicleParameter * parseVehicleAttributes(const SUMOSAXAttributes &attrs, const bool hardFail, const bool optionalID=false, const bool skipDepart=false, const bool isPerson=false)
Parses a vehicle's attributes.
Definition: SUMOVehicleParserHelper.cpp:231
SUMO_ATTR_BEGIN
weights: time range begin
Definition: SUMOXMLDefinitions.h:678
SUMORouteHandler::STOPPOS_VALID
Definition: SUMORouteHandler.h:54
SUMORouteHandler::closeVehicleTypeDistribution
virtual void closeVehicleTypeDistribution()=0
closes (ends) the building of a distribution
SUMORouteHandler::myLoadedParameterised
Parameterised myLoadedParameterised
Parameterised used for saving loaded generic parameters that aren't saved in Vehicles or Vehicle Type...
Definition: SUMORouteHandler.h:233
SUMOVehicleParameter::line
std::string line
The vehicle's line (mainly for public transport)
Definition: SUMOVehicleParameter.h:561
SUMORouteHandler::openVehicleTypeDistribution
virtual void openVehicleTypeDistribution(const SUMOSAXAttributes &attrs)=0
opens a type distribution for reading
SUMORouteHandler::checkLastDepart
bool checkLastDepart()
Checks whether the route file is sorted by departure time if needed.
Definition: SUMORouteHandler.cpp:60
SUMO_ATTR_TRIP_ID
Definition: SUMOXMLDefinitions.h:777
SUMORouteHandler::STOPPOS_INVALID_STARTPOS
Definition: SUMORouteHandler.h:55
SUMOVehicleParameter::Stop::tripId
std::string tripId
id of the trip within a cyclical public transport route
Definition: SUMOVehicleParameter.h:637
SUMO_TAG_TRANSPORT
Definition: SUMOXMLDefinitions.h:317
SUMO_TAG_FLOW
a flow definitio nusing a from-to edges instead of a route (used by router)
Definition: SUMOXMLDefinitions.h:149
MsgHandler
Definition: MsgHandler.h:38
SUMOVehicleParserHelper::beginVTypeParsing
static SUMOVTypeParameter * beginVTypeParsing(const SUMOSAXAttributes &attrs, const bool hardFail, const std::string &file)
Starts to parse a vehicle type.
Definition: SUMOVehicleParserHelper.cpp:501
SUMO_ATTR_STARTPOS
Definition: SUMOXMLDefinitions.h:797
SUMO_TAG_RIDE
Definition: SUMOXMLDefinitions.h:297
SUMOSAXAttributes::getOptStringVector
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<>
Definition: SUMOSAXAttributes.cpp:123
SUMOVehicleParameter::Stop::until
SUMOTime until
The time at which the vehicle may continue its journey.
Definition: SUMOVehicleParameter.h:610
SUMO_TAG_STOP
stop for vehicles
Definition: SUMOXMLDefinitions.h:178
SUMORouteHandler::closePerson
virtual void closePerson()=0
Ends the processing of a person.
SUMORouteHandler::addWalk
virtual void addWalk(const SUMOSAXAttributes &attrs)=0
add a fully specified walk
STOP_INDEX_FIT
const int STOP_INDEX_FIT
Definition: SUMOVehicleParameter.h:72
SUMOVehicleParameter::id
std::string id
The vehicle's id.
Definition: SUMOVehicleParameter.h:468
SUMO_ATTR_ROUTE
Definition: SUMOXMLDefinitions.h:440
SUMO_ATTR_EDGES
the edges of a route
Definition: SUMOXMLDefinitions.h:427
SUMORouteHandler::myEndElement
virtual void myEndElement(int element)
Called when a closing tag occurs.
Definition: SUMORouteHandler.cpp:215
SUMORouteHandler::myEndDefault
SUMOTime myEndDefault
The default value for flow ends.
Definition: SUMORouteHandler.h:242
SUMO_ATTR_TRIGGERED
Definition: SUMOXMLDefinitions.h:799
ProcessError
Definition: UtilExceptions.h:39
SUMORouteHandler::openRoute
virtual void openRoute(const SUMOSAXAttributes &attrs)=0
opens a route for reading
SUMORouteHandler::SUMORouteHandler
SUMORouteHandler(const std::string &file, const std::string &expectedRoot, const bool hardFail)
standard constructor
Definition: SUMORouteHandler.cpp:39
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:89
SUMORouteHandler::closeTrip
virtual void closeTrip()=0
Ends the processing of a trip.
SUMOSAXAttributes::getOpt
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.
Definition: SUMOSAXAttributes.h:518
SUMORouteHandler::openTrip
virtual void openTrip(const SUMOSAXAttributes &attrs)=0
opens a trip for reading
SUMORouteHandler::myVehicleParameter
SUMOVehicleParameter * myVehicleParameter
Parameter of the current vehicle, trip, person, container or flow.
Definition: SUMORouteHandler.h:206
SUMO_TAG_VEHICLE
description of a vehicle
Definition: SUMOXMLDefinitions.h:119
string2time
SUMOTime string2time(const std::string &r)
Definition: SUMOTime.cpp:44
SUMO_ATTR_EXTENSION
Definition: SUMOXMLDefinitions.h:669
SUMORouteHandler::closeVType
virtual void closeVType()=0
Ends the processing of a vehicle type.
SUMO_ATTR_INDEX
Definition: SUMOXMLDefinitions.h:804
SUMORouteHandler::registerLastDepart
void registerLastDepart()
save last depart (only to be used if vehicle is not discarded)
Definition: SUMORouteHandler.cpp:72
SUMORouteHandler::myFirstDepart
SUMOTime myFirstDepart
the first read departure time
Definition: SUMORouteHandler.h:245
SUMORouteHandler::addContainer
virtual void addContainer(const SUMOSAXAttributes &attrs)=0
Processing of a container.
SUMORouteHandler::addTranship
virtual void addTranship(const SUMOSAXAttributes &attrs)=0
Processing of a tranship.
SUMORouteHandler::addPersonTrip
virtual void addPersonTrip(const SUMOSAXAttributes &attrs)=0
add a routing request for a walking or intermodal person
SUMOVehicleParameter::Stop::containerTriggered
bool containerTriggered
whether an arriving container lets the vehicle continue
Definition: SUMOVehicleParameter.h:619
SUMO_ATTR_DURATION
Definition: SUMOXMLDefinitions.h:667
SUMOVehicleParserHelper::parseFlowAttributes
static SUMOVehicleParameter * parseFlowAttributes(const SUMOSAXAttributes &attrs, const bool hardFail, const SUMOTime beginDefault, const SUMOTime endDefault, bool isPerson=false)
Parses a flow's attributes.
Definition: SUMOVehicleParserHelper.cpp:56
SUMO_TAG_TRANSHIP
Definition: SUMOXMLDefinitions.h:318
SUMOSAXAttributes::getOptSUMOTimeReporting
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.
Definition: SUMOSAXAttributes.cpp:90
SUMO_ATTR_EXPECTED
Definition: SUMOXMLDefinitions.h:802
SUMOVehicleParameter::Stop::index
int index
at which position in the stops list
Definition: SUMOVehicleParameter.h:649
SUMOVTypeParameter::id
std::string id
The vehicle type's id.
Definition: SUMOVTypeParameter.h:212
SUMO_ATTR_EXPECTED_CONTAINERS
Definition: SUMOXMLDefinitions.h:803
SUMORouteHandler::STOPPOS_INVALID_LANELENGTH
Definition: SUMORouteHandler.h:57
SUMO_TAG_WALK
Definition: SUMOXMLDefinitions.h:298
GenericSAXHandler::getFileName
const std::string & getFileName() const
returns the current file name
Definition: GenericSAXHandler.cpp:74
SUMO_ATTR_KEY
Definition: SUMOXMLDefinitions.h:408
SUMOVehicleParameter::Stop::extension
SUMOTime extension
The maximum time extension for boarding / loading.
Definition: SUMOVehicleParameter.h:613
SUMO_ATTR_CONTAINER_TRIGGERED
Definition: SUMOXMLDefinitions.h:800
SUMORouteHandler.h
SUMO_ATTR_VALUE
Definition: SUMOXMLDefinitions.h:779
STOP_DURATION_SET
const int STOP_DURATION_SET
Definition: SUMOVehicleParameter.h:76
DEPART_GIVEN
The time is given.
Definition: SUMOVehicleParameter.h:100
STOP_INDEX_END
const int STOP_INDEX_END
Definition: SUMOVehicleParameter.h:71
STOP_EXPECTED_SET
const int STOP_EXPECTED_SET
Definition: SUMOVehicleParameter.h:81
Parameterised::setParameter
void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
Definition: Parameterised.cpp:46
SUMORouteHandler::closePersonFlow
virtual void closePersonFlow()=0
Ends the processing of a person.
SUMO_ATTR_PARKING
Definition: SUMOXMLDefinitions.h:801
STOP_TRIGGER_SET
const int STOP_TRIGGER_SET
Definition: SUMOVehicleParameter.h:79
STOP_CONTAINER_TRIGGER_SET
const int STOP_CONTAINER_TRIGGER_SET
Definition: SUMOVehicleParameter.h:82
SUMO_TAG_ROUTE
begin/end of the description of a route
Definition: SUMOXMLDefinitions.h:125
SUMORouteHandler::addStop
virtual void addStop(const SUMOSAXAttributes &attrs)=0
Processing of a stop.
config.h
SUMORouteHandler::openRouteDistribution
virtual void openRouteDistribution(const SUMOSAXAttributes &attrs)=0
opens a route distribution for reading
SUMO_TAG_PERSONFLOW
Definition: SUMOXMLDefinitions.h:299
STOP_EXPECTED_CONTAINERS_SET
const int STOP_EXPECTED_CONTAINERS_SET
Definition: SUMOVehicleParameter.h:83
STOP_PARKING_SET
const int STOP_PARKING_SET
Definition: SUMOVehicleParameter.h:80
SUMORouteHandler::myCurrentVType
SUMOVTypeParameter * myCurrentVType
The currently parsed vehicle type.
Definition: SUMORouteHandler.h:230
SUMO_ATTR_END
weights: time range end
Definition: SUMOXMLDefinitions.h:680
STOP_END_SET
const int STOP_END_SET
Definition: SUMOVehicleParameter.h:75
SUMO_TAG_INTERVAL
an aggreagated-output interval
Definition: SUMOXMLDefinitions.h:159
SUMORouteHandler::StopPos
StopPos
enum for stops
Definition: SUMORouteHandler.h:53
SUMOVehicleParameter::Stop::speed
double speed
the speed at which this stop counts as reached (waypoint mode)
Definition: SUMOVehicleParameter.h:643
SUMOVehicleParameter::Stop::duration
SUMOTime duration
The stopping duration.
Definition: SUMOVehicleParameter.h:607
SUMORouteHandler::myBeginDefault
SUMOTime myBeginDefault
The default value for flow begins.
Definition: SUMORouteHandler.h:239
SUMOVehicleParameter::repetitionNumber
int repetitionNumber
Definition: SUMOVehicleParameter.h:544
SUMORouteHandler::closeVehicle
virtual void closeVehicle()=0
Ends the processing of a vehicle.
SUMO_ATTR_BUS_STOP
Definition: SUMOXMLDefinitions.h:769
SUMORouteHandler::addTransport
virtual void addTransport(const SUMOSAXAttributes &attrs)=0
Processing of a transport.
SUMOVTypeParameter.h
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:56
SUMOVehicleParameter::Stop::awaitedContainers
std::set< std::string > awaitedContainers
IDs of containers the vehicle has to wait for until departing.
Definition: SUMOVehicleParameter.h:628
SUMOVehicleParameter::Stop::parking
bool parking
whether the vehicle is removed from the net while stopping
Definition: SUMOVehicleParameter.h:622
SUMOVehicleParameter::Stop::chargingStation
std::string chargingStation
(Optional) charging station if one is assigned to the stop
Definition: SUMOVehicleParameter.h:598
SUMOVehicleParameter::Stop::containerstop
std::string containerstop
(Optional) container stop if one is assigned to the stop
Definition: SUMOVehicleParameter.h:592
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:283
SUMORouteHandler::getFirstDepart
SUMOTime getFirstDepart() const
returns the first departure time that was ever read
Definition: SUMORouteHandler.cpp:330
SUMO_TAG_VTYPE_DISTRIBUTION
distribution of a vehicle type
Definition: SUMOXMLDefinitions.h:216
SUMORouteHandler::myActiveRouteID
std::string myActiveRouteID
The id of the current route.
Definition: SUMORouteHandler.h:212
SUMORouteHandler::myInsertStopEdgesAt
int myInsertStopEdgesAt
where stop edges can be inserted into the current route (-1 means no insertion)
Definition: SUMORouteHandler.h:248
SUMORouteHandler::isStopPosValid
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
Definition: SUMORouteHandler.cpp:320
STOP_LINE_SET
const int STOP_LINE_SET
Definition: SUMOVehicleParameter.h:85
SUMO_TAG_TRIP
a single trip definition (used by router)
Definition: SUMOXMLDefinitions.h:145
SUMOVehicleParameter::Stop
Definition of vehicle stop (position and duration)
Definition: SUMOVehicleParameter.h:572
XMLSubSys.h
SUMORouteHandler::getLastDepart
SUMOTime getLastDepart() const
Returns the last loaded depart time.
Definition: SUMORouteHandler.cpp:336