Eclipse SUMO - Simulation of Urban MObility
RouteHandler.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 /****************************************************************************/
18 // The XML-Handler for route elements loading
19 /****************************************************************************/
20 #include <config.h>
21 
23 #include <utils/common/RGBColor.h>
26 #include <utils/shapes/Shape.h>
29 #include <utils/xml/XMLSubSys.h>
30 
31 #include "RouteHandler.h"
32 
33 
34 // ===========================================================================
35 // method definitions
36 // ===========================================================================
37 
38 RouteHandler::RouteHandler(const std::string& filename, const bool hardFail) :
39  myFilename(filename),
40  myHardFail(hardFail),
41  myFlowBeginDefault(string2time(OptionsCont::getOptions().getString("begin"))),
42  myFlowEndDefault(string2time(OptionsCont::getOptions().getString("end"))) {
43 }
44 
45 
47 
48 
49 bool
51  // open SUMOBaseOBject
53  // check tag
54  try {
55  switch (tag) {
56  // vTypes
57  case SUMO_TAG_VTYPE:
58  parseVType(attrs);
59  break;
62  break;
63  // routes
64  case SUMO_TAG_ROUTE:
65  parseRoute(attrs);
66  break;
69  break;
70  // vehicles
71  case SUMO_TAG_TRIP:
72  parseTrip(attrs);
73  break;
74  case SUMO_TAG_VEHICLE:
75  parseVehicle(attrs);
76  break;
77  // flows
78  case SUMO_TAG_FLOW:
79  parseFlow(attrs);
80  break;
81  // stop
82  case SUMO_TAG_STOP:
83  parseStop(attrs);
84  break;
85  // persons
86  case SUMO_TAG_PERSON:
87  parsePerson(attrs);
88  break;
90  parsePersonFlow(attrs);
91  break;
92  // person plans
94  parsePersonTrip(attrs);
95  break;
96  case SUMO_TAG_RIDE:
97  parseRide(attrs);
98  break;
99  case SUMO_TAG_WALK:
100  parseWalk(attrs);
101  break;
102  // container
103  case SUMO_TAG_CONTAINER:
104  parseContainer(attrs);
105  break;
107  parseContainerFlow(attrs);
108  break;
109  // container plans
110  case SUMO_TAG_TRANSPORT:
111  parseTransport(attrs);
112  break;
113  case SUMO_TAG_TRANSHIP:
114  parseTranship(attrs);
115  break;
116  // parameters
117  case SUMO_TAG_PARAM:
118  parseParameters(attrs);
119  break;
120  // other
121  case SUMO_TAG_INTERVAL: {
122  parseInterval(attrs);
123  break;
124  }
125  default:
126  // nested CFM attributes
127  return parseNestedCFM(tag, attrs);
128  }
129  } catch (InvalidArgument& e) {
130  WRITE_ERROR(e.what());
131  }
132  return true;
133 }
134 
135 
136 void
138  // get last inserted object
140  // close SUMOBaseOBject
142  // check tag
143  if (obj) {
144  switch (obj->getTag()) {
145  // specia case for route (because can be embedded)
146  case SUMO_TAG_ROUTE:
147  // only parse non-embedded routes
148  if (!obj->getStringAttribute(SUMO_ATTR_ID).empty()) {
149  // parse route and all their childrens
150  parseSumoBaseObject(obj);
151  // delete object (and all of their childrens)
152  delete obj;
153  }
154  break;
155  // demand elements
156  case SUMO_TAG_VTYPE:
157  // only parse vTypes without distributions
158  if (obj->getParentSumoBaseObject() &&
160  // parse vType and all their childrens
161  parseSumoBaseObject(obj);
162  // delete object (and all of their childrens)
163  delete obj;
164  }
165  break;
167  case SUMO_TAG_TRIP:
168  case SUMO_TAG_VEHICLE:
169  case SUMO_TAG_FLOW:
170  case SUMO_TAG_PERSON:
171  case SUMO_TAG_PERSONFLOW:
172  case SUMO_TAG_CONTAINER:
174  // parse object and all their childrens
175  parseSumoBaseObject(obj);
176  // delete object (and all of their childrens)
177  delete obj;
178  break;
179  default:
180  break;
181  }
182  }
183 }
184 
185 
186 void
188  // switch tag
189  switch (obj->getTag()) {
190  // vTypes
191  case SUMO_TAG_VTYPE:
192  buildVType(obj,
193  obj->getVehicleTypeParameter());
194  break;
199  break;
200  // route
201  case SUMO_TAG_ROUTE:
202  if (obj->getStringAttribute(SUMO_ATTR_ID).empty()) {
203  buildEmbeddedRoute(obj,
208  obj->getParameters());
209  } else {
210  buildRoute(obj,
212  obj->getVClass(),
217  obj->getParameters());
218  }
219  break;
223  break;
224  // vehicles
225  case SUMO_TAG_TRIP:
228  // build trip with from-to edges
229  buildTrip(obj,
230  obj->getVehicleParameter(),
234  } else {
235  // build trip with from-to junctions
236  buildTrip(obj,
237  obj->getVehicleParameter(),
240  }
241  break;
242  case SUMO_TAG_VEHICLE:
245  obj->getVehicleParameter());
246  }
247  break;
248  // flows
249  case SUMO_TAG_FLOW:
251  // build flow over route
252  buildFlowOverRoute(obj,
253  obj->getVehicleParameter());
254  } else if (obj->hasStringAttribute(SUMO_ATTR_FROM) &&
256  // build flow with from-to edges
257  buildFlow(obj,
258  obj->getVehicleParameter(),
262  } else if (obj->hasStringAttribute(SUMO_ATTR_FROMJUNCTION) &&
264  // build flow with from-to junctions
265  buildFlow(obj,
266  obj->getVehicleParameter(),
269  }
270  break;
271  // persons
272  case SUMO_TAG_PERSON:
273  buildPerson(obj,
274  obj->getVehicleParameter());
275  break;
276  case SUMO_TAG_PERSONFLOW:
277  buildPersonFlow(obj,
278  obj->getVehicleParameter());
279  break;
280  // person plans
281  case SUMO_TAG_PERSONTRIP:
282  buildPersonTrip(obj,
291  break;
292  case SUMO_TAG_RIDE:
293  buildRide(obj,
299  break;
300  case SUMO_TAG_WALK:
301  buildWalk(obj,
310  break;
311  // container
312  case SUMO_TAG_CONTAINER:
313  buildContainer(obj,
314  obj->getVehicleParameter());
315  break;
317  buildContainerFlow(obj,
318  obj->getVehicleParameter());
319  break;
320  // container plans
321  case SUMO_TAG_TRANSPORT:
322  buildTransport(obj,
328  break;
329  case SUMO_TAG_TRANSHIP:
330  buildTranship(obj,
338  break;
339  // stopss
340  case SUMO_TAG_STOP:
341  buildStop(obj,
342  obj->getStopParameter());
343  break;
344  default:
345  break;
346  }
347  // now iterate over childrens
348  for (const auto& child : obj->getSumoBaseObjectChildren()) {
349  // call this function recursively
350  parseSumoBaseObject(child);
351  }
352 }
353 
354 
355 void
357  // parse vehicleType
359  if (vehicleTypeParameter) {
360  // set tag
362  // add all attributes
364  // delete vehicleType parameter (because in XMLStructure we have a copy)
365  delete vehicleTypeParameter;
366  }
367 }
368 
369 
370 void
372  // declare Ok Flag
373  bool parsedOk = true;
374  // needed attributes
375  const std::string ID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
376  // optional attributes
377  const std::vector<std::string> vTypes = attrs.getOptStringVector(SUMO_ATTR_VTYPES, ID.c_str(), parsedOk);
378  if (parsedOk) {
379  // set tag
381  // add all attributes
384  }
385 }
386 
387 
388 void
390  // get embedded route flag
391  const bool embeddedRoute = isEmbeddedRoute(attrs);
392  // first check if this is an embedded route
393  if ((embeddedRoute && attrs.hasAttribute(SUMO_ATTR_ID)) || (!embeddedRoute && !attrs.hasAttribute(SUMO_ATTR_ID))) {
394  WRITE_ERROR("a route must be defined either within a vehicle/flow or with an ID attribute");
395  } else {
396  // declare Ok Flag
397  bool parsedOk = true;
398  // special case for ID
399  const std::string id = attrs.getOpt<std::string>(SUMO_ATTR_ID, "", parsedOk, "");
400  // needed attributes
401  const std::vector<std::string> edges = attrs.get<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk);
402  // optional attributes
404  const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
405  const int repeat = attrs.getOpt<int>(SUMO_ATTR_REPEAT, id.c_str(), parsedOk, 0);
406  const SUMOTime cycleTime = attrs.getOptSUMOTimeReporting(SUMO_ATTR_CYCLETIME, id.c_str(), parsedOk, 0);
407  if (parsedOk) {
408  // set tag
410  // add all attributes
417  }
418  }
419 }
420 
421 
422 void
424  // declare Ok Flag
425  bool parsedOk = true;
426  // needed attributes
427  const std::string ID = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
428  if (parsedOk) {
429  // set tag
431  // add all attributes
433  }
434 }
435 
436 
437 void
439  // declare Ok Flag
440  bool parsedOk = true;
441  // parse vehicle
443  if (tripParameter) {
444  // check from/to edge/junction
446  WRITE_ERROR("Attributes 'from' and 'fromJunction' cannot be defined together");
447  } else if (attrs.hasAttribute(SUMO_ATTR_TO) && attrs.hasAttribute(SUMO_ATTR_TOJUNCTION)) {
448  WRITE_ERROR("Attributes 'to' and 'toJunction' cannot be defined together");
449  } else if (attrs.hasAttribute(SUMO_ATTR_FROM) && attrs.hasAttribute(SUMO_ATTR_TO)) {
450  // from-to attributes
451  const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, tripParameter->id.c_str(), parsedOk, "");
452  const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, tripParameter->id.c_str(), parsedOk, "");
453  // optional attributes
454  const std::vector<std::string> via = attrs.getOptStringVector(SUMO_ATTR_VIA, tripParameter->id.c_str(), parsedOk);
455  if (parsedOk) {
456  // set tag
458  // set vehicle parameters
460  // add other attributes
464  }
466  // from-to attributes
467  const std::string fromJunction = attrs.getOpt<std::string>(SUMO_ATTR_FROMJUNCTION, tripParameter->id.c_str(), parsedOk, "");
468  const std::string toJunction = attrs.getOpt<std::string>(SUMO_ATTR_TOJUNCTION, tripParameter->id.c_str(), parsedOk, "");
469  if (parsedOk) {
470  // set tag
472  // set vehicle parameters
474  // add other attributes
477  }
478  } else {
479  WRITE_ERROR("trip definition needs either 'from/to' or 'fromJunction/toJunction'");
480  }
481  // delete trip parameter (because in XMLStructure we have a copy)
482  delete tripParameter;
483  }
484 }
485 
486 
487 void
489  // first parse vehicle
491  if (vehicleParameter) {
492  // set tag
494  // set vehicle parameters
496  // delete vehicle parameter (because in XMLStructure we have a copy)
497  delete vehicleParameter;
498  }
499 }
500 
501 
502 void
504  // declare Ok Flag
505  bool parsedOk = true;
506  // first parse flow
508  if (flowParameter) {
509  // set vehicle parameters
511  // check from/to edge/junction
513  WRITE_ERROR("Attributes 'from' and 'fromJunction' cannot be defined together");
514  } else if (attrs.hasAttribute(SUMO_ATTR_TO) && attrs.hasAttribute(SUMO_ATTR_TOJUNCTION)) {
515  WRITE_ERROR("Attributes 'to' and 'toJunction' cannot be defined together");
516  } else if (attrs.hasAttribute(SUMO_ATTR_FROM) && attrs.hasAttribute(SUMO_ATTR_TO)) {
517  // from-to attributes
518  const std::string from = attrs.get<std::string>(SUMO_ATTR_FROM, flowParameter->id.c_str(), parsedOk);
519  const std::string to = attrs.get<std::string>(SUMO_ATTR_TO, flowParameter->id.c_str(), parsedOk);
520  // optional attributes
521  const std::vector<std::string> via = attrs.getOptStringVector(SUMO_ATTR_VIA, flowParameter->id.c_str(), parsedOk);
522  if (parsedOk) {
523  // set tag
525  // add other attributes
529  }
531  // from-to attributes
532  const std::string fromJunction = attrs.get<std::string>(SUMO_ATTR_FROMJUNCTION, flowParameter->id.c_str(), parsedOk);
533  const std::string toJunction = attrs.get<std::string>(SUMO_ATTR_TOJUNCTION, flowParameter->id.c_str(), parsedOk);
534  if (parsedOk) {
535  // set tag
537  // add other attributes
540  }
541  } else if (attrs.hasAttribute(SUMO_ATTR_ROUTE)) {
542  // from-to attributes
543  const std::string route = attrs.get<std::string>(SUMO_ATTR_ROUTE, flowParameter->id.c_str(), parsedOk);
544  if (parsedOk) {
545  // set tag
547  // add other attributes
549  }
550  } else {
551  // set tag
553  }
554  // delete flow parameter (because in XMLStructure we have a copy)
555  delete flowParameter;
556  }
557 }
558 
559 
560 void
562  // declare Ok Flag
563  bool parsedOk = true;
564  // declare stop
566  // check parents
568  // parse stop
569  if (parsedOk && parseStopParameters(stop, attrs)) {
570  // set tag
572  // add stop attributes
574  }
575 }
576 
577 
578 void
580  // first parse vehicle
582  if (personParameter) {
583  // set tag
585  // set vehicle parameter
587  // delete person parameter (because in XMLStructure we have a copy)
588  delete personParameter;
589  }
590 }
591 
592 
593 void
595  // first parse flow
597  if (personFlowParameter) {
598  // set tag
600  // set vehicle parameter
602  // delete person flow parameter (because in XMLStructure we have a copy)
603  delete personFlowParameter;
604  }
605 }
606 
607 
608 void
610  // declare Ok Flag
611  bool parsedOk = true;
612  // optional attributes
613  const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
614  const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
615  const std::string fromJunction = attrs.getOpt<std::string>(SUMO_ATTR_FROMJUNCTION, "", parsedOk, "");
616  const std::string toJunction = attrs.getOpt<std::string>(SUMO_ATTR_TOJUNCTION, "", parsedOk, "");
617  const std::vector<std::string> via = attrs.getOptStringVector(SUMO_ATTR_VIA, "", parsedOk);
618  const std::string busStop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, "", parsedOk, "");
619  const std::vector<std::string> vTypes = attrs.getOptStringVector(SUMO_ATTR_VTYPES, "", parsedOk);
620  const std::vector<std::string> modes = attrs.getOptStringVector(SUMO_ATTR_MODES, "", parsedOk);
621  const double departPos = attrs.getOpt<double>(SUMO_ATTR_DEPARTPOS, "", parsedOk, 0);
622  const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, 0);
623  if (parsedOk) {
624  // set tag
626  // add all attributes
637  }
638 }
639 
640 
641 void
643  // declare Ok Flag
644  bool parsedOk = true;
645  // optional attributes
646  const std::string route = attrs.getOpt<std::string>(SUMO_ATTR_ROUTE, "", parsedOk, "");
647  const std::vector<std::string> edges = attrs.getOptStringVector(SUMO_ATTR_EDGES, "", parsedOk);
648  const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
649  const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
650  const std::string fromJunction = attrs.getOpt<std::string>(SUMO_ATTR_FROMJUNCTION, "", parsedOk, "");
651  const std::string toJunction = attrs.getOpt<std::string>(SUMO_ATTR_TOJUNCTION, "", parsedOk, "");
652  const std::string busStop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, "", parsedOk, "");
653  const double duration = attrs.getOpt<double>(SUMO_ATTR_DURATION, "", parsedOk, 0);
654  const double speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, "", parsedOk, 0);
655  const double departPos = attrs.getOpt<double>(SUMO_ATTR_DEPARTPOS, "", parsedOk, 0);
656  const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, 0);
657  const double departPosLat = attrs.getOpt<double>(SUMO_ATTR_DEPARTPOS_LAT, "", parsedOk, 0);
658  if (parsedOk) {
659  // set tag
661  // add all attributes
674  }
675 }
676 
677 
678 void
680  // declare Ok Flag
681  bool parsedOk = true;
682  // optional attributes
683  const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
684  const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
685  const std::string busStop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, "", parsedOk, "");
686  const std::vector<std::string> lines = attrs.getOptStringVector(SUMO_ATTR_LINES, "", parsedOk);
687  const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, 0);
688  if (parsedOk) {
689  // set tag
691  // add all attributes
697  }
698 }
699 
700 
701 void
703  // first parse container
705  if (containerParameter) {
706  // set tag
708  // set vehicle parameter
710  // delete container parameter (because in XMLStructure we have a copy)
711  delete containerParameter;
712  }
713 }
714 
715 
716 void
718  // first parse flow
720  if (containerFlowParameter) {
721  // set tag
723  // set vehicle parameter
725  // delete container flow parameter (because in XMLStructure we have a copy)
726  delete containerFlowParameter;
727  }
728 }
729 
730 
731 void
733  // declare Ok Flag
734  bool parsedOk = true;
735  // optional attributes
736  const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
737  const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
738  const std::string containerStop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, "", parsedOk, "");
739  const std::vector<std::string> lines = attrs.getOptStringVector(SUMO_ATTR_LINES, "", parsedOk);
740  const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, 0);
741  if (parsedOk) {
742  // set tag
744  // add all attributes
750  }
751 }
752 
753 
754 void
756  // declare Ok Flag
757  bool parsedOk = true;
758  // optional attributes
759  const std::vector<std::string> edges = attrs.getOptStringVector(SUMO_ATTR_EDGES, "", parsedOk);
760  const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
761  const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
762  const std::string containerStop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, "", parsedOk, "");
763  const double speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, "", parsedOk, 0);
764  const double departPos = attrs.getOpt<double>(SUMO_ATTR_DEPARTPOS, "", parsedOk, 0);
765  const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, 0);
766  if (parsedOk) {
767  // set tag
769  // add all attributes
777  }
778 }
779 
780 
781 void
783  // declare Ok Flag
784  bool parsedOk = true;
785  // just parse begin and end default
786  myFlowBeginDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, nullptr, parsedOk);
787  myFlowEndDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_END, nullptr, parsedOk);
788 }
789 
790 
791 void
793  // declare Ok Flag
794  bool parsedOk = true;
795  // get key
796  const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, parsedOk);
797  // get SumoBaseObject parent
799  // check parent
800  if (SumoBaseObjectParent == nullptr) {
801  WRITE_ERROR("Parameters must be defined within an object");
802  } else if (SumoBaseObjectParent->getTag() == SUMO_TAG_ROOTFILE) {
803  WRITE_ERROR("Parameters cannot be defined in the additional file's root.");
804  } else if (SumoBaseObjectParent->getTag() == SUMO_TAG_PARAM) {
805  WRITE_ERROR("Parameters cannot be defined within another parameter.");
806  } else if (parsedOk) {
807  // get tag str
808  const std::string parentTagStr = toString(SumoBaseObjectParent->getTag());
809  // circumventing empty string value
810  const std::string value = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
811  // show warnings if values are invalid
812  if (key.empty()) {
813  WRITE_WARNING("Error parsing key from " + parentTagStr + " generic parameter. Key cannot be empty");
814  } else if (!SUMOXMLDefinitions::isValidParameterKey(key)) {
815  WRITE_WARNING("Error parsing key from " + parentTagStr + " generic parameter. Key contains invalid characters");
816  } else {
817  WRITE_DEBUG("Inserting generic parameter '" + key + "|" + value + "' into " + parentTagStr);
818  // insert parameter in SumoBaseObjectParent
819  SumoBaseObjectParent->addParameter(key, value);
820  }
821  }
822 }
823 
824 
825 bool
827  // get vehicle type Base object
829  // parse embedded car following model information
830  if (vTypeObject && (vTypeObject->getTag() == SUMO_TAG_VTYPE)) {
831  WRITE_WARNING("Defining car following parameters in a nested element is deprecated in vType '" + vTypeObject->getStringAttribute(SUMO_ATTR_ID) + "', use attributes instead!");
832  // get vType to modify it
833  auto vType = vTypeObject->getVehicleTypeParameter();
834  // parse nested CFM attributes
835  if (SUMOVehicleParserHelper::parseCFMParams(&vType, tag, attrs, true)) {
836  vTypeObject->setVehicleTypeParameter(&vType);
837  return true;
838  } else if (myHardFail) {
839  throw ProcessError("Invalid parsing embedded VType");
840  } else {
841  WRITE_ERROR("Invalid parsing embedded VType");
842  }
843  }
844  return false;
845 }
846 
847 
848 bool
850  // check stop parameters
851  if (attrs.hasAttribute(SUMO_ATTR_ARRIVAL)) {
853  }
854  if (attrs.hasAttribute(SUMO_ATTR_DURATION)) {
856  }
857  if (attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
859  }
860  if (attrs.hasAttribute(SUMO_ATTR_STARTED)) {
862  }
863  if (attrs.hasAttribute(SUMO_ATTR_ENDED)) {
865  }
866  if (attrs.hasAttribute(SUMO_ATTR_EXTENSION)) {
868  }
869  if (attrs.hasAttribute(SUMO_ATTR_ENDPOS)) {
870  stop.parametersSet |= STOP_END_SET;
871  }
872  if (attrs.hasAttribute(SUMO_ATTR_STARTPOS)) {
874  }
877  }
878  if (attrs.hasAttribute(SUMO_ATTR_TRIGGERED)) {
880  }
881  // legacy attribute
884  }
885  if (attrs.hasAttribute(SUMO_ATTR_PARKING)) {
887  }
888  if (attrs.hasAttribute(SUMO_ATTR_EXPECTED)) {
890  }
891  if (attrs.hasAttribute(SUMO_ATTR_PERMITTED)) {
893  }
896  }
897  if (attrs.hasAttribute(SUMO_ATTR_TRIP_ID)) {
899  }
900  if (attrs.hasAttribute(SUMO_ATTR_SPLIT)) {
902  }
903  if (attrs.hasAttribute(SUMO_ATTR_JOIN)) {
905  }
906  if (attrs.hasAttribute(SUMO_ATTR_LINE)) {
908  }
909  if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
911  }
912  // get parameters
913  bool ok = true;
914  // edge/lane
915  stop.edge = attrs.getOpt<std::string>(SUMO_ATTR_EDGE, nullptr, ok, "");
916  stop.lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, nullptr, ok, stop.busstop);
917  // check errors
918  if (!stop.edge.empty() && !stop.lane.empty()) {
919  WRITE_ERROR("A stop must be defined either with an edge or with an lane, not both");
920  return false;
921  }
922  // stopping places
923  stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, nullptr, ok, "");
924  stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_TRAIN_STOP, nullptr, ok, stop.busstop);
925  stop.chargingStation = attrs.getOpt<std::string>(SUMO_ATTR_CHARGING_STATION, nullptr, ok, "");
926  stop.overheadWireSegment = attrs.getOpt<std::string>(SUMO_ATTR_OVERHEAD_WIRE_SEGMENT, nullptr, ok, "");
927  stop.containerstop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, nullptr, ok, "");
928  stop.parkingarea = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, nullptr, ok, "");
929  //check stopping places
930  const int numStoppingPlaces = !stop.busstop.empty() + !stop.chargingStation.empty() + !stop.overheadWireSegment.empty() +
931  !stop.containerstop.empty() + !stop.parkingarea.empty();
932  if (numStoppingPlaces > 1) {
933  WRITE_ERROR("A stop must be defined only in a StoppingPlace");
934  return false;
935  } else if ((numStoppingPlaces == 0) && stop.edge.empty() && stop.lane.empty()) {
936  WRITE_ERROR("A stop must be defined in an edge, a lane, or in a StoppingPlace");
937  return false;
938  }
939  // declare error suffix
940  std::string errorSuffix;
941  if (stop.busstop != "") {
942  errorSuffix = " at '" + stop.busstop + "'" + errorSuffix;
943  } else if (stop.chargingStation != "") {
944  errorSuffix = " at '" + stop.chargingStation + "'" + errorSuffix;
945  } else if (stop.overheadWireSegment != "") {
946  errorSuffix = " at '" + stop.overheadWireSegment + "'" + errorSuffix;
947  } else if (stop.containerstop != "") {
948  errorSuffix = " at '" + stop.containerstop + "'" + errorSuffix;
949  } else if (stop.parkingarea != "") {
950  errorSuffix = " at '" + stop.parkingarea + "'" + errorSuffix;
951  } else if (stop.edge != "") {
952  errorSuffix = " at '" + stop.edge + "'" + errorSuffix;
953  } else {
954  errorSuffix = " on lane '" + stop.lane + "'" + errorSuffix;
955  }
956  // speed for counting as stopped
957  stop.speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, nullptr, ok, 0);
958  if (stop.speed < 0) {
959  WRITE_ERROR("Speed cannot be negative for stop" + errorSuffix);
960  return false;
961  }
962  // get the standing duration
963  bool expectTrigger = !attrs.hasAttribute(SUMO_ATTR_DURATION) && !attrs.hasAttribute(SUMO_ATTR_UNTIL) && !attrs.hasAttribute(SUMO_ATTR_SPEED);
964  std::vector<std::string> triggers = attrs.getOptStringVector(SUMO_ATTR_TRIGGERED, nullptr, ok);
965  // legacy
966  if (attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, nullptr, ok, false)) {
967  triggers.push_back(toString(SUMO_TAG_CONTAINER));
968  };
969  SUMOVehicleParameter::parseStopTriggers(triggers, expectTrigger, stop);
970  stop.startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, nullptr, ok, 0);
971  stop.endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, nullptr, ok, 0);
972  stop.friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, nullptr, ok, false);
973  stop.arrival = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ARRIVAL, nullptr, ok, -1);
974  stop.duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, nullptr, ok, -1);
975  stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, nullptr, ok, -1);
976  if (!expectTrigger && (!ok || (stop.duration < 0 && stop.until < 0 && stop.speed == 0))) {
977  WRITE_ERROR("Invalid duration or end time is given for a stop" + errorSuffix);
978  return false;
979  }
980  stop.extension = attrs.getOptSUMOTimeReporting(SUMO_ATTR_EXTENSION, nullptr, ok, -1);
981  stop.parking = attrs.getOpt<bool>(SUMO_ATTR_PARKING, nullptr, ok, stop.triggered || stop.containerTriggered || stop.parkingarea != "");
982  if (stop.parkingarea != "" && !stop.parking) {
983  WRITE_WARNING("Stop at parkingarea overrides attribute 'parking' for stop" + errorSuffix);
984  stop.parking = true;
985  }
986  if (!ok) {
987  WRITE_ERROR("Invalid bool for 'triggered', 'containerTriggered' or 'parking' for stop" + errorSuffix);
988  return false;
989  }
990  // expected persons
991  const std::vector<std::string>& expected = attrs.getOptStringVector(SUMO_ATTR_EXPECTED, nullptr, ok);
992  stop.awaitedPersons.insert(expected.begin(), expected.end());
993  if (stop.awaitedPersons.size() > 0 && (stop.parametersSet & STOP_TRIGGER_SET) == 0) {
994  stop.triggered = true;
995  if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
996  stop.parking = true;
997  }
998  }
999  // permitted transportables
1000  const std::vector<std::string>& permitted = attrs.getOptStringVector(SUMO_ATTR_PERMITTED, nullptr, ok);
1001  stop.permitted.insert(permitted.begin(), permitted.end());
1002  // expected containers
1003  const std::vector<std::string>& expectedContainers = attrs.getOptStringVector(SUMO_ATTR_EXPECTED_CONTAINERS, nullptr, ok);
1004  stop.awaitedContainers.insert(expectedContainers.begin(), expectedContainers.end());
1005  if (stop.awaitedContainers.size() > 0 && (stop.parametersSet & STOP_CONTAINER_TRIGGER_SET) == 0) {
1006  stop.containerTriggered = true;
1007  if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
1008  stop.parking = true;
1009  }
1010  }
1011  // public transport trip id
1012  stop.tripId = attrs.getOpt<std::string>(SUMO_ATTR_TRIP_ID, nullptr, ok, "");
1013  stop.split = attrs.getOpt<std::string>(SUMO_ATTR_SPLIT, nullptr, ok, "");
1014  stop.join = attrs.getOpt<std::string>(SUMO_ATTR_JOIN, nullptr, ok, "");
1015  stop.line = attrs.getOpt<std::string>(SUMO_ATTR_LINE, nullptr, ok, "");
1016  // index
1017  const std::string idx = attrs.getOpt<std::string>(SUMO_ATTR_INDEX, nullptr, ok, "end");
1018  if (idx == "end") {
1019  stop.index = STOP_INDEX_END;
1020  } else if (idx == "fit") {
1021  stop.index = STOP_INDEX_FIT;
1022  } else {
1023  stop.index = attrs.get<int>(SUMO_ATTR_INDEX, nullptr, ok);
1024  if (!ok || stop.index < 0) {
1025  WRITE_ERROR("Invalid 'index' for stop" + errorSuffix);
1026  return false;
1027  }
1028  }
1029  stop.started = attrs.getOptSUMOTimeReporting(SUMO_ATTR_STARTED, nullptr, ok, -1);
1030  stop.ended = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ENDED, nullptr, ok, -1);
1031  stop.posLat = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, nullptr, ok, INVALID_DOUBLE);
1032  return true;
1033 }
1034 
1035 
1036 bool
1038  // check conditions
1039  if (attrs.hasAttribute(SUMO_ATTR_ID)) {
1040  return false;
1042  return false;
1044  return false;
1046  return true;
1048  return true;
1049  } else {
1050  return false;
1051  }
1052 }
1053 
1054 
1055 void
1056 RouteHandler::checkParent(const SumoXMLTag currentTag, const std::vector<SumoXMLTag>& parentTags, bool& ok) const {
1057  // check that parent SUMOBaseObject's tag is the parentTag
1059  // set parent string
1060  std::string parentStrings;
1061  for (const auto& tag : parentTags) {
1062  if (tag == parentTags.back()) {
1063  parentStrings.append(toString(tag));
1064  } else {
1065  parentStrings.append(toString(tag) + ", ");
1066  }
1067  }
1068  if ((parent != nullptr) &&
1069  (parentTags.size() > 0) &&
1070  (std::find(parentTags.begin(), parentTags.end(), parent->getTag()) == parentTags.end())) {
1071  const std::string id = parent->hasStringAttribute(SUMO_ATTR_ID) ? ", id: '" + parent->getStringAttribute(SUMO_ATTR_ID) + "'" : "";
1072  WRITE_ERROR("'" + toString(currentTag) + "' must be defined within the definition of a '" + parentStrings + "' (found '" + toString(parent->getTag()) + "'" + id + ").");
1073  ok = false;
1074  }
1075 }
1076 
1077 /****************************************************************************/
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:290
#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
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
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 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
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_ROOTFILE
root file
@ 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_LINES
@ SUMO_ATTR_LANE
@ SUMO_ATTR_SPEED
@ SUMO_ATTR_STARTED
@ SUMO_ATTR_VALUE
@ SUMO_ATTR_VIA
@ SUMO_ATTR_CONTAINER_STOP
@ SUMO_ATTR_PARKING_AREA
@ SUMO_ATTR_EDGE
@ SUMO_ATTR_FROMJUNCTION
@ SUMO_ATTR_DEPARTPOS_LAT
@ SUMO_ATTR_BUS_STOP
@ SUMO_ATTR_TRAIN_STOP
@ SUMO_ATTR_ENDPOS
@ SUMO_ATTR_ARRIVALPOS
@ SUMO_ATTR_SPLIT
@ SUMO_ATTR_BEGIN
weights: time range begin
@ SUMO_ATTR_EDGES
the edges of a route
@ SUMO_ATTR_POSITION_LAT
@ SUMO_ATTR_EXPECTED
@ SUMO_ATTR_LINE
@ SUMO_ATTR_CHARGING_STATION
@ SUMO_ATTR_MODES
@ SUMO_ATTR_VTYPES
@ SUMO_ATTR_OVERHEAD_WIRE_SEGMENT
@ SUMO_ATTR_DEPARTPOS
@ SUMO_ATTR_ENDED
@ SUMO_ATTR_INDEX
@ SUMO_ATTR_ARRIVAL
@ SUMO_ATTR_TRIP_ID
@ SUMO_ATTR_TO
@ SUMO_ATTR_FROM
@ SUMO_ATTR_END
weights: time range end
@ SUMO_ATTR_PERMITTED
@ SUMO_ATTR_JOIN
@ SUMO_ATTR_FRIENDLY_POS
@ SUMO_ATTR_EXPECTED_CONTAINERS
@ SUMO_ATTR_ROUTE
@ SUMO_ATTR_COLOR
A color information.
@ SUMO_ATTR_ID
@ SUMO_ATTR_UNTIL
@ SUMO_ATTR_TRIGGERED
@ SUMO_ATTR_DURATION
@ SUMO_ATTR_KEY
@ SUMO_ATTR_REPEAT
@ SUMO_ATTR_CYCLETIME
@ SUMO_ATTR_TOJUNCTION
const double INVALID_DOUBLE
Definition: StdDefs.h:63
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
void addIntAttribute(const SumoXMLAttr attr, const int value)
add int attribute into current SumoBaseObject node
void setVehicleTypeParameter(const SUMOVTypeParameter *vehicleTypeParameter)
set vehicle type parameters
const SUMOVehicleParameter::Stop & getStopParameter() const
get stop parameters
const RGBColor & getColorAttribute(const SumoXMLAttr attr) const
get color attribute
SUMOTime getTimeAttribute(const SumoXMLAttr attr) const
get time attribute
bool hasStringAttribute(const SumoXMLAttr attr) const
has function
void setTag(const SumoXMLTag tag)
set SumoBaseObject tag
SumoBaseObject * getParentSumoBaseObject() const
get pointer to mySumoBaseObjectParent SumoBaseObject (if is null, then is the root)
const std::map< std::string, std::string > & getParameters() const
get parameters
SUMOVehicleClass getVClass() const
vehicle class
const SUMOVTypeParameter & getVehicleTypeParameter() const
get current vType
void addTimeAttribute(const SumoXMLAttr attr, const SUMOTime value)
add time attribute into current SumoBaseObject node
void addStringListAttribute(const SumoXMLAttr attr, const std::vector< std::string > &value)
add string list attribute into current SumoBaseObject node
int getIntAttribute(const SumoXMLAttr attr) const
get int attribute
void addDoubleAttribute(const SumoXMLAttr attr, const double value)
add double attribute into current SumoBaseObject node
void setVClass(SUMOVehicleClass vClass)
set vehicle class
void setVehicleParameter(const SUMOVehicleParameter *vehicleParameter)
set vehicle parameters
void addStringAttribute(const SumoXMLAttr attr, const std::string &value)
void setStopParameter(const SUMOVehicleParameter::Stop &stopParameter)
add stop parameters
double getDoubleAttribute(const SumoXMLAttr attr) const
get double attribute
const SUMOVehicleParameter & getVehicleParameter() const
get vehicle parameters
const std::vector< std::string > & getStringListAttribute(const SumoXMLAttr attr) const
get string list attribute
void addColorAttribute(const SumoXMLAttr attr, const RGBColor &value)
add color attribute into current SumoBaseObject node
const std::string & getStringAttribute(const SumoXMLAttr attr) const
get string attribute
const std::vector< SumoBaseObject * > & getSumoBaseObjectChildren() const
get SumoBaseObject children
CommonXMLStructure::SumoBaseObject * getCurrentSumoBaseObject() const
get current editedSumoBaseObject
void openSUMOBaseOBject()
open SUMOBaseOBject
void closeSUMOBaseOBject()
close myTag
A storage for options typed value containers)
Definition: OptionsCont.h:89
static const RGBColor INVISIBLE
Definition: RGBColor.h:195
void parseWalk(const SUMOSAXAttributes &attrs)
parse walk
virtual void buildContainer(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &containerParameters)=0
build container
virtual void buildTransport(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &fromEdgeID, const std::string &toEdgeID, const std::string &toBusStopID, const std::vector< std::string > &lines, const double arrivalPos)=0
build transport
void parseContainerFlow(const SUMOSAXAttributes &attrs)
parse container flow
void parseFlow(const SUMOSAXAttributes &attrs)
parse flow (including flows, flows over routes and flows with embedded routes)
bool beginParseAttributes(SumoXMLTag tag, const SUMOSAXAttributes &attrs)
begin parse attributes
CommonXMLStructure myCommonXMLStructure
common XML Structure
Definition: RouteHandler.h:150
virtual void buildFlowOverRoute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters)=0
build a flow over an existent route
bool isEmbeddedRoute(const SUMOSAXAttributes &attrs) const
check embedded route
void checkParent(const SumoXMLTag currentTag, const std::vector< SumoXMLTag > &parentTags, bool &ok) const
check parents
void parsePerson(const SUMOSAXAttributes &attrs)
parse person
void parseTransport(const SUMOSAXAttributes &attrs)
parse transport
void endParseAttributes()
end parse attributes
void parseVTypeDistribution(const SUMOSAXAttributes &attrs)
parse vType distribution
virtual void buildTranship(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &fromEdgeID, const std::string &toEdgeID, const std::string &toBusStopID, const std::vector< std::string > &edgeIDs, const double speed, const double departPosition, const double arrivalPosition)=0
build tranship
virtual void buildRouteDistribution(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id)=0
build route distribution
const std::string myFilename
filename (needed for parsing vTypes)
Definition: RouteHandler.h:138
virtual void buildRide(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &fromEdgeID, const std::string &toEdgeID, const std::string &toBusStopID, double arrivalPos, const std::vector< std::string > &lines)=0
build ride
void parseStop(const SUMOSAXAttributes &attrs)
parse stop
void parseContainer(const SUMOSAXAttributes &attrs)
parse container
RouteHandler(const std::string &filename, const bool hardFail)
Constructor.
virtual void buildPersonTrip(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &fromEdgeID, const std::string &toEdgeID, const std::string &fromJunctionID, const std::string &toJunctionID, const std::string &toBusStopID, double arrivalPos, const std::vector< std::string > &types, const std::vector< std::string > &modes)=0
build person trip
virtual void buildVTypeDistribution(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const std::vector< std::string > &vTypes)=0
build vType distribution
void parsePersonTrip(const SUMOSAXAttributes &attrs)
parse person trip
bool parseStopParameters(SUMOVehicleParameter::Stop &stop, const SUMOSAXAttributes &attrs) const
parse stop parameters
virtual void buildVType(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVTypeParameter &vTypeParameter)=0
build vType
void parseRoute(const SUMOSAXAttributes &attrs)
parse route
virtual void buildTrip(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters, const std::string &fromEdgeID, const std::string &toEdgeID, const std::vector< std::string > &viaIDs)=0
build trip (from-to edges)
virtual void buildRoute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, SUMOVehicleClass vClass, const std::vector< std::string > &edgeIDs, const RGBColor &color, const int repeat, const SUMOTime cycleTime, const std::map< std::string, std::string > &routeParameters)=0
build route
void parseTrip(const SUMOSAXAttributes &attrs)
parse trip
SUMOTime myFlowEndDefault
The default value for flow ends.
Definition: RouteHandler.h:147
~RouteHandler()
Destructor.
void parseParameters(const SUMOSAXAttributes &attrs)
parse generic parameters
void parseSumoBaseObject(CommonXMLStructure::SumoBaseObject *obj)
parse SumoBaseObject (it's called recursivelly)
virtual void buildEmbeddedRoute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::vector< std::string > &edgeIDs, const RGBColor &color, const int repeat, const SUMOTime cycleTime, const std::map< std::string, std::string > &routeParameters)=0
build embedded route
virtual void buildPersonFlow(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &personFlowParameters)=0
build person flow
void parsePersonFlow(const SUMOSAXAttributes &attrs)
parse person flow
void parseInterval(const SUMOSAXAttributes &attrs)
parse interval
void parseVType(const SUMOSAXAttributes &attrs)
void parseRide(const SUMOSAXAttributes &attrs)
parse ride
bool parseNestedCFM(const SumoXMLTag tag, const SUMOSAXAttributes &attrs)
parse nested CarFollowingModel
virtual void buildStop(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter::Stop &stopParameters)=0
build stop
SUMOTime myFlowBeginDefault
The default value for flow begins.
Definition: RouteHandler.h:144
virtual void buildVehicleOverRoute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters)=0
build a vehicle over an existent route
void parseVehicle(const SUMOSAXAttributes &attrs)
parse vehicle (including vehicles over routes and vehicles with embedded routes)
virtual void buildContainerFlow(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &containerFlowParameters)=0
build container flow
virtual void buildPerson(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &personParameters)=0
build person
virtual void buildWalk(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &fromEdgeID, const std::string &toEdgeID, const std::string &fromJunctionID, const std::string &toJunctionID, const std::string &toBusStopID, const std::vector< std::string > &edgeIDs, const std::string &routeID, double arrivalPos)=0
build walk
const bool myHardFail
enable or disable hardFail (stop parsing if parameter aren't correct)
Definition: RouteHandler.h:141
virtual void buildFlow(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters, const std::string &fromEdgeID, const std::string &toEdgeID, const std::vector< std::string > &viaIDs)=0
build flow (from-to edges)
void parseRouteDistribution(const SUMOSAXAttributes &attrs)
parse route distribution
void parseTranship(const SUMOSAXAttributes &attrs)
parse tranship
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.
Structure representing possible vehicle parameter.
Definition of vehicle stop (position and duration)
SUMOTime started
the time at which this stop was reached
std::string edge
The edge to stop at (used only in NETEDIT)
std::string lane
The lane to stop at.
SUMOTime extension
The maximum time extension for boarding / loading.
bool friendlyPos
enable or disable friendly position (used by NETEDIT)
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
double startPos
The stopping position start.
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.
bool triggered
whether an arriving person lets the vehicle continue
SUMOTime ended
the time at which this stop was ended
double endPos
The stopping position end.
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.
Structure representing possible vehicle parameter.
std::string id
The vehicle's id.
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 SUMOVehicleClass parseVehicleClass(const SUMOSAXAttributes &attrs, const std::string &id)
Parses the vehicle class.
static SUMOVehicleParameter * parseVehicleAttributes(int element, const SUMOSAXAttributes &attrs, const bool hardFail, const bool optionalID=false, const bool skipDepart=false)
Parses a vehicle's attributes.
static bool isValidParameterKey(const std::string &value)
whether the given string is a valid key for a parameter