SUMO - Simulation of Urban MObility
SUMORouteHandler.cpp
Go to the documentation of this file.
1 /****************************************************************************/
10 // Parser for routes during their loading
11 /****************************************************************************/
12 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
13 // Copyright (C) 2001-2016 DLR (http://www.dlr.de/) and contributors
14 /****************************************************************************/
15 //
16 // This file is part of SUMO.
17 // SUMO is free software: you can redistribute it and/or modify
18 // it under the terms of the GNU General Public License as published by
19 // the Free Software Foundation, either version 3 of the License, or
20 // (at your option) any later version.
21 //
22 /****************************************************************************/
23 
24 
25 // ===========================================================================
26 // included modules
27 // ===========================================================================
28 #ifdef _MSC_VER
29 #include <windows_config.h>
30 #else
31 #include <config.h>
32 #endif
33 
34 #include <string>
35 #include <map>
36 #include <vector>
40 #include <utils/common/ToString.h>
44 #include "SUMORouteHandler.h"
45 
46 #ifdef CHECK_MEMORY_LEAKS
47 #include <foreign/nvwa/debug_new.h>
48 #endif // CHECK_MEMORY_LEAKS
49 
50 
51 // ===========================================================================
52 // method definitions
53 // ===========================================================================
54 SUMORouteHandler::SUMORouteHandler(const std::string& file) :
55  SUMOSAXHandler(file),
56  myVehicleParameter(0),
57  myLastDepart(-1),
58  myActiveRouteColor(0),
59  myCurrentVType(0),
60  myBeginDefault(string2time(OptionsCont::getOptions().getString("begin"))),
61  myEndDefault(string2time(OptionsCont::getOptions().getString("end"))),
62  myFirstDepart(-1), myInsertStopEdgesAt(-1) {
63 }
64 
65 
67  delete myCurrentVType;
68 }
69 
70 
73  return myLastDepart;
74 }
75 
76 
77 bool
81  WRITE_WARNING("Route file should be sorted by departure time, ignoring '" + myVehicleParameter->id + "'!");
82  return false;
83  }
84  }
85  return true;
86 }
87 
88 
89 void
91  // register only non public transport to parse all public transport lines in advance
94  if (myFirstDepart == -1) {
96  }
97  }
98  // else: we don't know when this vehicle will depart. keep the previous known depart time
99 }
100 
101 
102 void
104  const SUMOSAXAttributes& attrs) {
105  switch (element) {
106  case SUMO_TAG_VEHICLE:
107  delete myVehicleParameter;
109  break;
110  case SUMO_TAG_PERSON:
111  delete myVehicleParameter;
113  break;
114  case SUMO_TAG_CONTAINER:
115  delete myVehicleParameter;
117  break;
118  case SUMO_TAG_FLOW:
119  delete myVehicleParameter;
121  break;
122  case SUMO_TAG_VTYPE:
124  break;
127  break;
128  case SUMO_TAG_ROUTE:
129  openRoute(attrs);
130  break;
132  openRouteDistribution(attrs);
133  break;
134  case SUMO_TAG_STOP:
135  addStop(attrs);
136  break;
137  case SUMO_TAG_TRIP: {
139  if (myVehicleParameter->id == "") {
140  //@todo warn about deprecation of missing trip ids
142  }
145  break;
146  }
147  case SUMO_TAG_INTERVAL: {
148  bool ok;
151  break;
152  }
153  case SUMO_TAG_PARAM:
154  addParam(attrs);
155  break;
156  default:
157  break;
158  }
159 }
160 
161 
162 void
164  switch (element) {
165  case SUMO_TAG_ROUTE:
166  closeRoute();
167  break;
168  case SUMO_TAG_PERSON:
169  closePerson();
170  delete myVehicleParameter;
171  myVehicleParameter = 0;
172  break;
173  case SUMO_TAG_CONTAINER:
174  closeContainer();
175  delete myVehicleParameter;
176  myVehicleParameter = 0;
177  break;
178  case SUMO_TAG_VEHICLE:
180  myVehicleParameter->repetitionNumber++; // for backwards compatibility
181  // it is a flow, thus no break here
182  } else {
183  closeVehicle();
184  delete myVehicleParameter;
185  myVehicleParameter = 0;
186  break;
187  }
188  case SUMO_TAG_FLOW:
189  closeFlow();
190  break;
193  break;
196  break;
197  case SUMO_TAG_VTYPE:
199  break;
200  case SUMO_TAG_INTERVAL:
201  myBeginDefault = string2time(OptionsCont::getOptions().getString("begin"));
202  myEndDefault = string2time(OptionsCont::getOptions().getString("end"));
203  break;
204  default:
205  break;
206  }
207 }
208 
209 
210 bool
211 SUMORouteHandler::checkStopPos(SUMOReal& startPos, SUMOReal& endPos, const SUMOReal laneLength,
212  const SUMOReal minLength, const bool friendlyPos) {
213  if (minLength > laneLength) {
214  return false;
215  }
216  if (startPos < 0) {
217  startPos += laneLength;
218  }
219  if (endPos < 0) {
220  endPos += laneLength;
221  }
222  if (endPos < minLength || endPos > laneLength) {
223  if (!friendlyPos) {
224  return false;
225  }
226  if (endPos < minLength) {
227  endPos = minLength;
228  }
229  if (endPos > laneLength) {
230  endPos = laneLength;
231  }
232  }
233  if (startPos < 0 || startPos > endPos - minLength) {
234  if (!friendlyPos) {
235  return false;
236  }
237  if (startPos < 0) {
238  startPos = 0;
239  }
240  if (startPos > endPos - minLength) {
241  startPos = endPos - minLength;
242  }
243  }
244  return true;
245 }
246 
247 
248 void
250  bool ok = true;
251  const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, 0, ok);
252  // circumventing empty string test
253  const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
254  if (myVehicleParameter != 0) {
255  myVehicleParameter->addParameter(key, val);
256  } else if (myCurrentVType != 0) {
257  myCurrentVType->addParameter(key, val);
258  }
259 }
260 
261 
262 bool
263 SUMORouteHandler::parseStop(SUMOVehicleParameter::Stop& stop, const SUMOSAXAttributes& attrs, std::string errorSuffix, MsgHandler* const errorOutput) {
264  stop.setParameter = 0;
265  if (attrs.hasAttribute(SUMO_ATTR_ENDPOS)) {
266  stop.setParameter |= STOP_END_SET;
267  }
268  if (attrs.hasAttribute(SUMO_ATTR_STARTPOS)) {
270  }
271  if (attrs.hasAttribute(SUMO_ATTR_TRIGGERED)) {
273  }
276  }
277  if (attrs.hasAttribute(SUMO_ATTR_PARKING)) {
279  }
280  if (attrs.hasAttribute(SUMO_ATTR_EXPECTED)) {
282  }
285  }
286  bool ok = true;
287  stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, 0, ok, "");
288  stop.chargingStation = attrs.getOpt<std::string>(SUMO_ATTR_CHARGING_STATION, 0, ok, "");
289  stop.containerstop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, 0, ok, "");
290  if (stop.busstop != "") {
291  errorSuffix = " at '" + stop.busstop + "'" + errorSuffix;
292  } else if (stop.chargingStation != "") {
293  errorSuffix = " at '" + stop.chargingStation + "'" + errorSuffix;
294  } else if (stop.containerstop != "") {
295  errorSuffix = " at '" + stop.containerstop + "'" + errorSuffix;
296  } else {
297  errorSuffix = " on lane '" + stop.lane + "'" + errorSuffix;
298  }
299  // get the standing duration
302  stop.containerTriggered = attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, 0, ok, true);
303  stop.triggered = attrs.getOpt<bool>(SUMO_ATTR_TRIGGERED, 0, ok, false);
304  } else {
305  stop.triggered = attrs.getOpt<bool>(SUMO_ATTR_TRIGGERED, 0, ok, true);
306  stop.containerTriggered = attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, 0, ok, false);
307  }
308  stop.duration = -1;
309  stop.until = -1;
310  } else {
311  stop.duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, 0, ok, -1);
312  stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, 0, ok, -1);
313  if (!ok || (stop.duration < 0 && stop.until < 0)) {
314  errorOutput->inform("Invalid duration or end time is given for a stop" + errorSuffix);
315  return false;
316  }
317  stop.triggered = attrs.getOpt<bool>(SUMO_ATTR_TRIGGERED, 0, ok, false);
318  stop.containerTriggered = attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, 0, ok, false);
319  }
320  stop.parking = attrs.getOpt<bool>(SUMO_ATTR_PARKING, 0, ok, stop.triggered || stop.containerTriggered);
321  if (!ok) {
322  errorOutput->inform("Invalid bool for 'triggered', 'containerTriggered' or 'parking' for stop" + errorSuffix);
323  return false;
324  }
325 
326  // expected persons
327  std::string expectedStr = attrs.getOpt<std::string>(SUMO_ATTR_EXPECTED, 0, ok, "");
328  std::set<std::string> personIDs;
329  SUMOSAXAttributes::parseStringSet(expectedStr, personIDs);
330  stop.awaitedPersons = personIDs;
331 
332  // expected containers
333  std::string expectedContainersStr = attrs.getOpt<std::string>(SUMO_ATTR_EXPECTED_CONTAINERS, 0, ok, "");
334  std::set<std::string> containerIDs;
335  SUMOSAXAttributes::parseStringSet(expectedContainersStr, containerIDs);
336  stop.awaitedContainers = containerIDs;
337 
338  const std::string idx = attrs.getOpt<std::string>(SUMO_ATTR_INDEX, 0, ok, "end");
339  if (idx == "end") {
340  stop.index = STOP_INDEX_END;
341  } else if (idx == "fit") {
342  stop.index = STOP_INDEX_FIT;
343  } else {
344  stop.index = attrs.get<int>(SUMO_ATTR_INDEX, 0, ok);
345  if (!ok || stop.index < 0) {
346  errorOutput->inform("Invalid 'index' for stop" + errorSuffix);
347  return false;
348  }
349  }
350  return true;
351 }
352 
353 /****************************************************************************/
const int STOP_CONTAINER_TRIGGER_SET
virtual void openVehicleTypeDistribution(const SUMOSAXAttributes &attrs)=0
virtual void myEndElement(int element)
Called when a closing tag occurs.
long long int SUMOTime
Definition: SUMOTime.h:43
const int VEHPARS_FORCE_REROUTE
static void parseStringSet(const std::string &def, std::set< std::string > &into)
Splits the given string, stores it in a set.
The time is given.
std::string containerstop
(Optional) container stop if one is assigned to the stop
int repetitionNumber
The number of times the vehicle shall be repeatedly inserted.
bool parking
whether the vehicle is removed from the net while stopping
SUMOTime myFirstDepart
the first read departure time
SUMOTime duration
The stopping duration.
SUMOVehicleParameter * myVehicleParameter
Parameter of the current vehicle, trip, person, container or flow.
SUMOTime myEndDefault
The default value for flow ends.
virtual void addStop(const SUMOSAXAttributes &attrs)=0
Processing of a stop.
static SUMOVehicleParameter * parseVehicleAttributes(const SUMOSAXAttributes &attrs, const bool optionalID=false, const bool skipDepart=false, const bool isPerson=false)
Parses a vehicle&#39;s attributes.
static bool checkStopPos(SUMOReal &startPos, SUMOReal &endPos, const SUMOReal laneLength, const SUMOReal minLength, const bool friendlyPos)
check start and end position of a stop
SUMOVTypeParameter * myCurrentVType
The currently parsed vehicle type.
SUMOTime until
The time at which the vehicle may continue its journey.
virtual void openRouteDistribution(const SUMOSAXAttributes &attrs)=0
const int STOP_INDEX_FIT
void registerLastDepart()
save last depart (only to be used if vehicle is not discarded)
std::set< std::string > awaitedPersons
IDs of persons the vehicle has to wait for until departing.
std::string myActiveRouteID
The id of the current route.
SAX-handler base for SUMO-files.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list...
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:200
IDSupplier myIdSupplier
generates numerical ids
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:69
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
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.
std::string busstop
(Optional) bus stop if one is assigned to the stop
const int STOP_START_SET
SUMOTime myBeginDefault
The default value for flow begins.
const std::string & getFileName() const
returns the current file name
std::string getNext()
Returns the next id.
Definition: IDSupplier.cpp:63
virtual void closeVehicle()=0
Ends the processing of a vehicle.
virtual void closeContainer()=0
Ends the processing of a container.
Encapsulated SAX-Attributes.
static SUMOVehicleParameter * parseFlowAttributes(const SUMOSAXAttributes &attrs, const SUMOTime beginDefault, const SUMOTime endDefault)
Parses a flow&#39;s attributes.
std::set< std::string > awaitedContainers
IDs of containers the vehicle has to wait for until departing.
std::string chargingStation
(Optional) charging station if one is assigned to the stop
void addParam(const SUMOSAXAttributes &attrs)
assign arbitrary vehicle parameters
bool triggered
whether an arriving person lets the vehicle continue
virtual ~SUMORouteHandler()
standard destructor
const int STOP_INDEX_END
SUMOTime depart
The vehicle&#39;s departure time.
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
SUMOTime string2time(const std::string &r)
Definition: SUMOTime.cpp:46
const int STOP_EXPECTED_SET
SUMORouteHandler(const std::string &file)
standard constructor
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
bool containerTriggered
whether an arriving container lets the vehicle continue
std::string line
The vehicle&#39;s line (mainly for public transport)
std::string lane
The lane to stop at.
virtual void closeRoute(const bool mayBeDisconnected=false)=0
const int STOP_END_SET
void addParameter(const std::string &key, const std::string &value)
Adds a parameter.
const int STOP_PARKING_SET
const int STOP_TRIGGER_SET
static void closeVTypeParsing(SUMOVTypeParameter &vtype)
Closes parsing of the vehicle type.
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Called on the opening of a tag;.
virtual void closeVehicleTypeDistribution()=0
const int STOP_EXPECTED_CONTAINERS_SET
SUMOTime myLastDepart
The insertion time of the vehicle read last.
int setParameter
Information for the router which parameter were set.
Definition of vehicle stop (position and duration)
bool parseStop(SUMOVehicleParameter::Stop &stop, const SUMOSAXAttributes &attrs, std::string errorSuffix, MsgHandler *const errorOutput)
parses attributes common to all stops
void inform(std::string msg, bool addType=true)
adds a new error to the list
Definition: MsgHandler.cpp:89
A storage for options typed value containers)
Definition: OptionsCont.h:99
int index
at which position in the stops list
virtual void closeRouteDistribution()=0
int setParameter
Information for the output which parameter were set.
virtual void closeFlow()=0
Ends the processing of a flow.
virtual void closePerson()=0
Ends the processing of a person.
#define SUMOReal
Definition: config.h:213
SUMOTime getLastDepart() const
Returns the last loaded depart time.
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.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
static SUMOVTypeParameter * beginVTypeParsing(const SUMOSAXAttributes &attrs, const std::string &file)
Starts to parse a vehicle type.
bool checkLastDepart()
Checks whether the route file is sorted by departure time if needed.
std::string id
The vehicle&#39;s id.
virtual void openRoute(const SUMOSAXAttributes &attrs)=0