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
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
38RouteHandler::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
49bool
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;
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
104 parseContainer(attrs);
105 break;
107 parseContainerFlow(attrs);
108 break;
109 // container plans
111 parseTransport(attrs);
112 break;
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
136void
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
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
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:
174 // parse object and all their childrens
176 // delete object (and all of their childrens)
177 delete obj;
178 break;
179 default:
180 break;
181 }
182 }
183}
184
185
186void
188 // switch tag
189 switch (obj->getTag()) {
190 // vTypes
191 case SUMO_TAG_VTYPE:
192 buildVType(obj,
194 break;
200 break;
201 // route
202 case SUMO_TAG_ROUTE:
203 if (obj->getStringAttribute(SUMO_ATTR_ID).empty()) {
209 obj->getParameters());
210 } else {
211 buildRoute(obj,
213 obj->getVClass(),
218 obj->getParameters());
219 }
220 break;
224 break;
225 // vehicles
226 case SUMO_TAG_TRIP:
229 // build trip with from-to edges
230 buildTrip(obj,
231 obj->getVehicleParameter(),
235 } else {
236 // build trip with from-to junctions
237 buildTrip(obj,
238 obj->getVehicleParameter(),
241 }
242 break;
243 case SUMO_TAG_VEHICLE:
246 obj->getVehicleParameter());
247 }
248 break;
249 // flows
250 case SUMO_TAG_FLOW:
252 // build flow over route
254 obj->getVehicleParameter());
255 } else if (obj->hasStringAttribute(SUMO_ATTR_FROM) &&
257 // build flow with from-to edges
258 buildFlow(obj,
259 obj->getVehicleParameter(),
265 // build flow with from-to junctions
266 buildFlow(obj,
267 obj->getVehicleParameter(),
270 }
271 break;
272 // persons
273 case SUMO_TAG_PERSON:
274 buildPerson(obj,
275 obj->getVehicleParameter());
276 break;
278 buildPersonFlow(obj,
279 obj->getVehicleParameter());
280 break;
281 // person plans
283 buildPersonTrip(obj,
293 break;
294 case SUMO_TAG_RIDE:
295 buildRide(obj,
301 break;
302 case SUMO_TAG_WALK:
303 buildWalk(obj,
312 break;
313 // container
315 buildContainer(obj,
316 obj->getVehicleParameter());
317 break;
320 obj->getVehicleParameter());
321 break;
322 // container plans
324 buildTransport(obj,
330 break;
332 buildTranship(obj,
340 break;
341 // stopss
342 case SUMO_TAG_STOP:
343 buildStop(obj,
344 obj->getStopParameter());
345 break;
346 default:
347 break;
348 }
349 // now iterate over childrens
350 for (const auto& child : obj->getSumoBaseObjectChildren()) {
351 // call this function recursively
352 parseSumoBaseObject(child);
353 }
354}
355
356
357bool
360}
361
362
363void
364RouteHandler::writeError(const std::string& error) {
365 WRITE_ERROR(error);
367}
368
369
370void
371RouteHandler::writeErrorInvalidID(const SumoXMLTag tag, const std::string& id) {
372 WRITE_ERROR("Could not build " + toString(tag) + " with ID '" + id + "' in netedit; ID contains invalid characters.");
374}
375
376
377void
379 // parse vehicleType
381 if (vehicleTypeParameter) {
382 // set tag
384 // add all attributes
386 // delete vehicleType parameter (because in XMLStructure we have a copy)
387 delete vehicleTypeParameter;
388 }
389}
390
391
392void
394 // declare Ok Flag
395 bool parsedOk = true;
396 // needed attributes
397 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
398 // optional attributes
399 const int deterministic = attrs.getOpt<int>(SUMO_ATTR_DETERMINISTIC, id.c_str(), parsedOk, -1);
400 const std::vector<std::string> vTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk);
401 if (parsedOk) {
404 } else {
405 // set tag
407 // add all attributes
411 }
412 }
413}
414
415
416void
418 // get embedded route flag
419 const bool embeddedRoute = isEmbeddedRoute(attrs);
420 // first check if this is an embedded route
421 if ((embeddedRoute && attrs.hasAttribute(SUMO_ATTR_ID)) || (!embeddedRoute && !attrs.hasAttribute(SUMO_ATTR_ID))) {
422 writeError("a route must be defined either within a vehicle/flow or with an ID attribute");
423 } else {
424 // declare Ok Flag
425 bool parsedOk = true;
426 // special case for ID
427 const std::string id = attrs.getOpt<std::string>(SUMO_ATTR_ID, "", parsedOk, "");
428 // needed attributes
429 const std::vector<std::string> edges = attrs.get<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk);
430 // optional attributes
432 const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
433 const int repeat = attrs.getOpt<int>(SUMO_ATTR_REPEAT, id.c_str(), parsedOk, 0);
434 const SUMOTime cycleTime = attrs.getOptSUMOTimeReporting(SUMO_ATTR_CYCLETIME, id.c_str(), parsedOk, 0);
435 if (parsedOk) {
436 if (!id.empty() && !SUMOXMLDefinitions::isValidVehicleID(id)) {
438 } else if (cycleTime < 0) {
439 writeError("cycleTime of " + toString(SUMO_TAG_DEST_PROB_REROUTE) + " must be equal or greater than 0");
440 } else {
441 // set tag
443 // add all attributes
450 }
451 }
452 }
453}
454
455
456void
458 // declare Ok Flag
459 bool parsedOk = true;
460 // needed attributes
461 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
462 if (parsedOk) {
465 } else {
466 // set tag
468 // add all attributes
470 }
471 }
472}
473
474
475void
477 // declare Ok Flag
478 bool parsedOk = true;
479 // parse vehicle
481 if (tripParameter) {
482 // check from/to edge/junction
484 writeError("Attributes 'from' and 'fromJunction' cannot be defined together");
485 } else if (attrs.hasAttribute(SUMO_ATTR_TO) && attrs.hasAttribute(SUMO_ATTR_TOJUNCTION)) {
486 writeError("Attributes 'to' and 'toJunction' cannot be defined together");
487 } else if (attrs.hasAttribute(SUMO_ATTR_FROM) && attrs.hasAttribute(SUMO_ATTR_TO)) {
488 // from-to attributes
489 const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, tripParameter->id.c_str(), parsedOk, "");
490 const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, tripParameter->id.c_str(), parsedOk, "");
491 // optional attributes
492 const std::vector<std::string> via = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VIA, tripParameter->id.c_str(), parsedOk);
493 if (parsedOk) {
494 // set tag
496 // set vehicle parameters
498 // add other attributes
502 }
504 // from-to attributes
505 const std::string fromJunction = attrs.getOpt<std::string>(SUMO_ATTR_FROMJUNCTION, tripParameter->id.c_str(), parsedOk, "");
506 const std::string toJunction = attrs.getOpt<std::string>(SUMO_ATTR_TOJUNCTION, tripParameter->id.c_str(), parsedOk, "");
507 if (parsedOk) {
508 // set tag
510 // set vehicle parameters
512 // add other attributes
515 }
516 } else {
517 writeError("trip definition needs either 'from/to' or 'fromJunction/toJunction'");
518 }
519 // delete trip parameter (because in XMLStructure we have a copy)
520 delete tripParameter;
521 }
522}
523
524
525void
527 // first parse vehicle
529 if (vehicleParameter) {
530 // set tag
532 // set vehicle parameters
534 // delete vehicle parameter (because in XMLStructure we have a copy)
535 delete vehicleParameter;
536 }
537}
538
539
540void
542 // declare Ok Flag
543 bool parsedOk = true;
544 // first parse flow
546 if (flowParameter) {
547 // set vehicle parameters
549 // check from/to edge/junction
551 writeError("Attributes 'from' and 'fromJunction' cannot be defined together");
552 } else if (attrs.hasAttribute(SUMO_ATTR_TO) && attrs.hasAttribute(SUMO_ATTR_TOJUNCTION)) {
553 writeError("Attributes 'to' and 'toJunction' cannot be defined together");
554 } else if (attrs.hasAttribute(SUMO_ATTR_FROM) && attrs.hasAttribute(SUMO_ATTR_TO)) {
555 // from-to attributes
556 const std::string from = attrs.get<std::string>(SUMO_ATTR_FROM, flowParameter->id.c_str(), parsedOk);
557 const std::string to = attrs.get<std::string>(SUMO_ATTR_TO, flowParameter->id.c_str(), parsedOk);
558 // optional attributes
559 const std::vector<std::string> via = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VIA, flowParameter->id.c_str(), parsedOk);
560 if (parsedOk) {
561 // set tag
563 // add other attributes
567 }
569 // from-to attributes
570 const std::string fromJunction = attrs.get<std::string>(SUMO_ATTR_FROMJUNCTION, flowParameter->id.c_str(), parsedOk);
571 const std::string toJunction = attrs.get<std::string>(SUMO_ATTR_TOJUNCTION, flowParameter->id.c_str(), parsedOk);
572 if (parsedOk) {
573 // set tag
575 // add other attributes
578 }
579 } else if (attrs.hasAttribute(SUMO_ATTR_ROUTE)) {
580 // from-to attributes
581 const std::string route = attrs.get<std::string>(SUMO_ATTR_ROUTE, flowParameter->id.c_str(), parsedOk);
582 if (parsedOk) {
583 // set tag
585 // add other attributes
587 }
588 } else {
589 // set tag
591 }
592 // delete flow parameter (because in XMLStructure we have a copy)
593 delete flowParameter;
594 }
595}
596
597
598void
600 // declare Ok Flag
601 bool parsedOk = true;
602 // declare stop
604 // check parents
606 // parse stop
607 if (parsedOk && parseStopParameters(stop, attrs)) {
608 // set tag
610 // add stop attributes
612 }
613}
614
615
616void
618 // first parse vehicle
620 if (personParameter) {
621 // set tag
623 // set vehicle parameter
625 // delete person parameter (because in XMLStructure we have a copy)
626 delete personParameter;
627 }
628}
629
630
631void
633 // first parse flow
635 if (personFlowParameter) {
636 // set tag
638 // set vehicle parameter
640 // delete person flow parameter (because in XMLStructure we have a copy)
641 delete personFlowParameter;
642 }
643}
644
645
646void
648 // declare Ok Flag
649 bool parsedOk = true;
650 // optional attributes
651 const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
652 const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
653 const std::string fromJunction = attrs.getOpt<std::string>(SUMO_ATTR_FROMJUNCTION, "", parsedOk, "");
654 const std::string toJunction = attrs.getOpt<std::string>(SUMO_ATTR_TOJUNCTION, "", parsedOk, "");
655 const std::vector<std::string> via = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VIA, "", parsedOk);
656 const std::string busStop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, "", parsedOk, "");
657 const std::vector<std::string> vTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, "", parsedOk);
658 const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, "", parsedOk);
659 std::vector<std::string> modes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_MODES, "", parsedOk);
660 const double departPos = attrs.getOpt<double>(SUMO_ATTR_DEPARTPOS, "", parsedOk, -1);
661 const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, -1);
662 // check modes
663 SVCPermissions dummyModeSet;
664 std::string dummyError;
665 if (!SUMOVehicleParameter::parsePersonModes(toString(modes), toString(SUMO_TAG_PERSONTRIP), "", dummyModeSet, dummyError)) {
666 WRITE_WARNING(dummyError);
667 modes.clear();
668 }
669 if (parsedOk) {
670 // set tag
672 // add all attributes
684 }
685}
686
687
688void
690 // declare Ok Flag
691 bool parsedOk = true;
692 // optional attributes
693 const std::string route = attrs.getOpt<std::string>(SUMO_ATTR_ROUTE, "", parsedOk, "");
694 const std::vector<std::string> edges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EDGES, "", parsedOk);
695 const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
696 const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
697 const std::string fromJunction = attrs.getOpt<std::string>(SUMO_ATTR_FROMJUNCTION, "", parsedOk, "");
698 const std::string toJunction = attrs.getOpt<std::string>(SUMO_ATTR_TOJUNCTION, "", parsedOk, "");
699 const std::string busStop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, "", parsedOk, "");
700 const double duration = attrs.getOpt<double>(SUMO_ATTR_DURATION, "", parsedOk, 0);
701 const double speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, "", parsedOk, 0);
702 const double departPos = attrs.getOpt<double>(SUMO_ATTR_DEPARTPOS, "", parsedOk, -1);
703 const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, -1);
704 const double departPosLat = attrs.getOpt<double>(SUMO_ATTR_DEPARTPOS_LAT, "", parsedOk, 0);
705 if (parsedOk) {
706 // set tag
708 // add all attributes
721 }
722}
723
724
725void
727 // declare Ok Flag
728 bool parsedOk = true;
729 // optional attributes
730 const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
731 const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
732 const std::string busStop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, "", parsedOk, "");
733 const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, "", parsedOk);
734 const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, -1);
735 if (parsedOk) {
736 // set tag
738 // add all attributes
744 }
745}
746
747
748void
750 // first parse container
752 if (containerParameter) {
753 // set tag
755 // set vehicle parameter
757 // delete container parameter (because in XMLStructure we have a copy)
758 delete containerParameter;
759 }
760}
761
762
763void
765 // first parse flow
767 if (containerFlowParameter) {
768 // set tag
770 // set vehicle parameter
772 // delete container flow parameter (because in XMLStructure we have a copy)
773 delete containerFlowParameter;
774 }
775}
776
777
778void
780 // declare Ok Flag
781 bool parsedOk = true;
782 // optional attributes
783 const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
784 const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
785 const std::string containerStop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, "", parsedOk, "");
786 const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, "", parsedOk);
787 const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, -1);
788 if (parsedOk) {
789 // set tag
791 // add all attributes
797 }
798}
799
800
801void
803 // declare Ok Flag
804 bool parsedOk = true;
805 // optional attributes
806 const std::vector<std::string> edges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EDGES, "", parsedOk);
807 const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
808 const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
809 const std::string containerStop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, "", parsedOk, "");
810 const double speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, "", parsedOk, 1.39);
811 const double departPos = attrs.getOpt<double>(SUMO_ATTR_DEPARTPOS, "", parsedOk, -1);
812 const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, -1);
813 if (parsedOk) {
814 // set tag
816 // add all attributes
824 }
825}
826
827
828void
830 // declare Ok Flag
831 bool parsedOk = true;
832 // just parse begin and end default
833 myFlowBeginDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, nullptr, parsedOk);
834 myFlowEndDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_END, nullptr, parsedOk);
835}
836
837
838void
840 // declare Ok Flag
841 bool parsedOk = true;
842 // get key
843 const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, parsedOk);
844 // get SumoBaseObject parent
846 // check parent
847 if (SumoBaseObjectParent == nullptr) {
848 writeError("Parameters must be defined within an object");
849 } else if (SumoBaseObjectParent->getTag() == SUMO_TAG_ROOTFILE) {
850 writeError("Parameters cannot be defined in the additional file's root.");
851 } else if (SumoBaseObjectParent->getTag() == SUMO_TAG_PARAM) {
852 writeError("Parameters cannot be defined within another parameter.");
853 } else if (parsedOk) {
854 // get tag str
855 const std::string parentTagStr = toString(SumoBaseObjectParent->getTag());
856 // circumventing empty string value
857 const std::string value = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
858 // show warnings if values are invalid
859 if (key.empty()) {
860 WRITE_WARNING("Error parsing key from " + parentTagStr + " generic parameter. Key cannot be empty");
862 WRITE_WARNING("Error parsing key from " + parentTagStr + " generic parameter. Key contains invalid characters");
863 } else {
864 WRITE_DEBUG("Inserting generic parameter '" + key + "|" + value + "' into " + parentTagStr);
865 // insert parameter in SumoBaseObjectParent
866 SumoBaseObjectParent->addParameter(key, value);
867 }
868 }
869}
870
871
872bool
874 // get vehicle type Base object
876 // parse embedded car following model information
877 if (vTypeObject && (vTypeObject->getTag() == SUMO_TAG_VTYPE)) {
878 WRITE_WARNING("Defining car following parameters in a nested element is deprecated in vType '" + vTypeObject->getStringAttribute(SUMO_ATTR_ID) + "', use attributes instead!");
879 // get vType to modify it
880 auto vType = vTypeObject->getVehicleTypeParameter();
881 // parse nested CFM attributes
882 if (SUMOVehicleParserHelper::parseCFMParams(&vType, tag, attrs, true)) {
883 vTypeObject->setVehicleTypeParameter(&vType);
884 return true;
885 } else if (myHardFail) {
886 throw ProcessError("Invalid parsing embedded VType");
887 } else {
888 writeError("Invalid parsing embedded VType");
889 }
890 }
891 return false;
892}
893
894
895bool
897 // check stop parameters
898 if (attrs.hasAttribute(SUMO_ATTR_ARRIVAL)) {
900 }
901 if (attrs.hasAttribute(SUMO_ATTR_DURATION)) {
903 }
904 if (attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
906 }
907 if (attrs.hasAttribute(SUMO_ATTR_STARTED)) {
909 }
910 if (attrs.hasAttribute(SUMO_ATTR_ENDED)) {
912 }
915 }
916 if (attrs.hasAttribute(SUMO_ATTR_ENDPOS)) {
918 }
919 if (attrs.hasAttribute(SUMO_ATTR_STARTPOS)) {
921 }
924 }
927 }
928 // legacy attribute
931 }
932 if (attrs.hasAttribute(SUMO_ATTR_PARKING)) {
934 }
935 if (attrs.hasAttribute(SUMO_ATTR_EXPECTED)) {
937 }
940 }
943 }
944 if (attrs.hasAttribute(SUMO_ATTR_TRIP_ID)) {
946 }
947 if (attrs.hasAttribute(SUMO_ATTR_SPLIT)) {
949 }
950 if (attrs.hasAttribute(SUMO_ATTR_JOIN)) {
952 }
953 if (attrs.hasAttribute(SUMO_ATTR_LINE)) {
955 }
956 if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
958 }
959 if (attrs.hasAttribute(SUMO_ATTR_ONDEMAND)) {
961 }
962 // get parameters
963 bool ok = true;
964 // edge/lane
965 stop.edge = attrs.getOpt<std::string>(SUMO_ATTR_EDGE, nullptr, ok, "");
966 stop.lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, nullptr, ok, stop.busstop);
967 // check errors
968 if (!stop.edge.empty() && !stop.lane.empty()) {
969 writeError("A stop must be defined either with an edge or with an lane, not both");
970 return false;
971 }
972 // stopping places
973 stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, nullptr, ok, "");
974 stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_TRAIN_STOP, nullptr, ok, stop.busstop);
975 stop.chargingStation = attrs.getOpt<std::string>(SUMO_ATTR_CHARGING_STATION, nullptr, ok, "");
976 stop.overheadWireSegment = attrs.getOpt<std::string>(SUMO_ATTR_OVERHEAD_WIRE_SEGMENT, nullptr, ok, "");
977 stop.containerstop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, nullptr, ok, "");
978 stop.parkingarea = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, nullptr, ok, "");
979 //check stopping places
980 const int numStoppingPlaces = !stop.busstop.empty() + !stop.chargingStation.empty() + !stop.overheadWireSegment.empty() +
981 !stop.containerstop.empty() + !stop.parkingarea.empty();
982 if (numStoppingPlaces > 1) {
983 writeError("A stop must be defined only in a StoppingPlace");
984 return false;
985 } else if ((numStoppingPlaces == 0) && stop.edge.empty() && stop.lane.empty()) {
986 writeError("A stop must be defined in an edge, a lane, or in a StoppingPlace");
987 return false;
988 }
989 // declare error suffix
990 std::string errorSuffix;
991 if (stop.busstop != "") {
992 errorSuffix = " at '" + stop.busstop + "'" + errorSuffix;
993 } else if (stop.chargingStation != "") {
994 errorSuffix = " at '" + stop.chargingStation + "'" + errorSuffix;
995 } else if (stop.overheadWireSegment != "") {
996 errorSuffix = " at '" + stop.overheadWireSegment + "'" + errorSuffix;
997 } else if (stop.containerstop != "") {
998 errorSuffix = " at '" + stop.containerstop + "'" + errorSuffix;
999 } else if (stop.parkingarea != "") {
1000 errorSuffix = " at '" + stop.parkingarea + "'" + errorSuffix;
1001 } else if (stop.edge != "") {
1002 errorSuffix = " at '" + stop.edge + "'" + errorSuffix;
1003 } else {
1004 errorSuffix = " on lane '" + stop.lane + "'" + errorSuffix;
1005 }
1006 // speed for counting as stopped
1007 stop.speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, nullptr, ok, 0);
1008 if (stop.speed < 0) {
1009 writeError("Speed cannot be negative for stop" + errorSuffix);
1010 return false;
1011 }
1012 // get the standing duration
1013 bool expectTrigger = !attrs.hasAttribute(SUMO_ATTR_DURATION) && !attrs.hasAttribute(SUMO_ATTR_UNTIL) && !attrs.hasAttribute(SUMO_ATTR_SPEED);
1014 std::vector<std::string> triggers = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_TRIGGERED, nullptr, ok);
1015 // legacy
1016 if (attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, nullptr, ok, false)) {
1017 triggers.push_back(toString(SUMO_TAG_CONTAINER));
1018 };
1019 SUMOVehicleParameter::parseStopTriggers(triggers, expectTrigger, stop);
1020 stop.startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, nullptr, ok, 0);
1021 stop.endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, nullptr, ok, 0);
1022 stop.friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, nullptr, ok, false);
1023 stop.arrival = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ARRIVAL, nullptr, ok, -1);
1024 stop.duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, nullptr, ok, -1);
1025 stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, nullptr, ok, -1);
1026 if (!expectTrigger && (!ok || (stop.duration < 0 && stop.until < 0 && stop.speed == 0))) {
1027 writeError("Invalid duration or end time is given for a stop" + errorSuffix);
1028 return false;
1029 }
1030 stop.extension = attrs.getOptSUMOTimeReporting(SUMO_ATTR_EXTENSION, nullptr, ok, -1);
1031 const bool defaultParking = (stop.triggered || stop.containerTriggered || stop.parkingarea != "");
1032 stop.parking = attrs.getOpt<ParkingType>(SUMO_ATTR_PARKING, nullptr, ok, defaultParking ? ParkingType::OFFROAD : ParkingType::ONROAD);
1033 if ((stop.parkingarea != "") && (stop.parking == ParkingType::ONROAD)) {
1034 WRITE_WARNING("Stop at parkingarea overrides attribute 'parking' for stop" + errorSuffix);
1036 }
1037 if (!ok) {
1038 writeError("Invalid bool for 'triggered', 'containerTriggered' or 'parking' for stop" + errorSuffix);
1039 return false;
1040 }
1041 // expected persons
1042 const std::vector<std::string>& expected = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EXPECTED, nullptr, ok);
1043 stop.awaitedPersons.insert(expected.begin(), expected.end());
1044 if (stop.awaitedPersons.size() > 0 && (stop.parametersSet & STOP_TRIGGER_SET) == 0) {
1045 stop.triggered = true;
1046 if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
1048 }
1049 }
1050 // permitted transportables
1051 const std::vector<std::string>& permitted = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_PERMITTED, nullptr, ok);
1052 stop.permitted.insert(permitted.begin(), permitted.end());
1053 // expected containers
1054 const std::vector<std::string>& expectedContainers = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EXPECTED_CONTAINERS, nullptr, ok);
1055 stop.awaitedContainers.insert(expectedContainers.begin(), expectedContainers.end());
1056 if (stop.awaitedContainers.size() > 0 && (stop.parametersSet & STOP_CONTAINER_TRIGGER_SET) == 0) {
1057 stop.containerTriggered = true;
1058 if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
1060 }
1061 }
1062 // public transport trip id
1063 stop.tripId = attrs.getOpt<std::string>(SUMO_ATTR_TRIP_ID, nullptr, ok, "");
1064 stop.split = attrs.getOpt<std::string>(SUMO_ATTR_SPLIT, nullptr, ok, "");
1065 stop.join = attrs.getOpt<std::string>(SUMO_ATTR_JOIN, nullptr, ok, "");
1066 stop.line = attrs.getOpt<std::string>(SUMO_ATTR_LINE, nullptr, ok, "");
1067 // index
1068 const std::string idx = attrs.getOpt<std::string>(SUMO_ATTR_INDEX, nullptr, ok, "end");
1069 if (idx == "end") {
1070 stop.index = STOP_INDEX_END;
1071 } else if (idx == "fit") {
1072 stop.index = STOP_INDEX_FIT;
1073 } else {
1074 stop.index = attrs.get<int>(SUMO_ATTR_INDEX, nullptr, ok);
1075 if (!ok || stop.index < 0) {
1076 writeError("Invalid 'index' for stop" + errorSuffix);
1077 return false;
1078 }
1079 }
1080 stop.started = attrs.getOptSUMOTimeReporting(SUMO_ATTR_STARTED, nullptr, ok, -1);
1081 stop.ended = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ENDED, nullptr, ok, -1);
1082 stop.posLat = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, nullptr, ok, INVALID_DOUBLE);
1083 stop.actType = attrs.getOpt<std::string>(SUMO_ATTR_ACTTYPE, nullptr, ok, "");
1084 stop.onDemand = attrs.getOpt<bool>(SUMO_ATTR_ONDEMAND, nullptr, ok, false);
1085 return true;
1086}
1087
1088
1089bool
1091 // check conditions
1092 if (attrs.hasAttribute(SUMO_ATTR_ID)) {
1093 return false;
1095 return false;
1097 return false;
1099 return true;
1101 return true;
1102 } else {
1103 return false;
1104 }
1105}
1106
1107
1108void
1109RouteHandler::checkParent(const SumoXMLTag currentTag, const std::vector<SumoXMLTag>& parentTags, bool& ok) {
1110 // check that parent SUMOBaseObject's tag is the parentTag
1112 // set parent string
1113 std::string parentStrings;
1114 for (const auto& tag : parentTags) {
1115 if (tag == parentTags.back()) {
1116 parentStrings.append(toString(tag));
1117 } else {
1118 parentStrings.append(toString(tag) + ", ");
1119 }
1120 }
1121 if ((parent != nullptr) &&
1122 (parentTags.size() > 0) &&
1123 (std::find(parentTags.begin(), parentTags.end(), parent->getTag()) == parentTags.end())) {
1124 const std::string id = parent->hasStringAttribute(SUMO_ATTR_ID) ? ", id: '" + parent->getStringAttribute(SUMO_ATTR_ID) + "'" : "";
1125 writeError("'" + toString(currentTag) + "' must be defined within the definition of a '" + parentStrings + "' (found '" + toString(parent->getTag()) + "'" + id + ").");
1126 ok = false;
1127 }
1128}
1129
1130/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
#define WRITE_DEBUG(msg)
Definition: MsgHandler.h:276
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:274
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition: SUMOTime.cpp:45
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
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_ONDEMAND_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_DEST_PROB_REROUTE
probability of destiny of a reroute
@ 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)
ParkingType
Numbers representing special SUMO-XML-attribute values Information on whether a car is parking on the...
@ SUMO_ATTR_CONTAINER_TRIGGERED
@ SUMO_ATTR_STARTPOS
@ SUMO_ATTR_PARKING
@ SUMO_ATTR_EXTENSION
@ SUMO_ATTR_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_ACTTYPE
@ 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_ONDEMAND
@ 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_DETERMINISTIC
@ 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:60
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 buildVTypeDistribution(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &id, const int deterministic, const std::vector< std::string > &vTypes)=0
build vType distribution
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:157
virtual void buildFlowOverRoute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters)=0
build a flow over an existent route
bool isErrorCreatingElement() const
get flag for check if a element wasn't created
bool isEmbeddedRoute(const SUMOSAXAttributes &attrs) const
check embedded route
void parsePerson(const SUMOSAXAttributes &attrs)
parse person
virtual void buildEmbeddedRoute(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::vector< std::string > &edgeIDs, const RGBColor &color, const int repeat, const SUMOTime cycleTime, const Parameterised::Map &routeParameters)=0
build embedded route
void parseTransport(const SUMOSAXAttributes &attrs)
parse transport
void endParseAttributes()
end parse attributes
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, const std::vector< std::string > &lines)=0
build person trip
void parseVTypeDistribution(const SUMOSAXAttributes &attrs)
parse vType distribution
void writeErrorInvalidID(const SumoXMLTag tag, const std::string &id)
write error "invalid id"
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:145
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.
void parsePersonTrip(const SUMOSAXAttributes &attrs)
parse person trip
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)
void parseTrip(const SUMOSAXAttributes &attrs)
parse trip
SUMOTime myFlowEndDefault
The default value for flow ends.
Definition: RouteHandler.h:154
virtual ~RouteHandler()
Destructor.
void parseParameters(const SUMOSAXAttributes &attrs)
parse generic parameters
void parseSumoBaseObject(CommonXMLStructure::SumoBaseObject *obj)
parse SumoBaseObject (it's called recursivelly)
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
bool myErrorCreatingElement
flag for check if a element wasn't created
Definition: RouteHandler.h:160
void parseVType(const SUMOSAXAttributes &attrs)
void writeError(const std::string &error)
write error and enable error creating element
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:151
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 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 Parameterised::Map &routeParameters)=0
build route
void checkParent(const SumoXMLTag currentTag, const std::vector< SumoXMLTag > &parentTags, bool &ok)
check parents
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
bool parseStopParameters(SUMOVehicleParameter::Stop &stop, const SUMOSAXAttributes &attrs)
parse stop parameters
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:148
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.
virtual std::string getString(int id, bool *isPresent=nullptr) const =0
Returns the string-value of the named (by its enum-value) attribute.
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue=T(), bool report=true) const
Tries to read given attribute assuming it is an int.
SUMOTime getOptSUMOTimeReporting(int attr, const char *objectid, bool &ok, SUMOTime defaultValue, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
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)
ParkingType parking
whether the vehicle is removed from the net while stopping
std::string lane
The lane to stop at.
SUMOTime extension
The maximum time extension for boarding / loading.
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
bool onDemand
whether the stop may be skipped
std::string chargingStation
(Optional) charging station if one is assigned to the stop
std::string overheadWireSegment
(Optional) overhead line segment if one is assigned to the stop
std::set< std::string > permitted
IDs of persons or containers that may board/load at this stop.
int parametersSet
Information for the output which parameter were set.
int index
at which position in the stops list
std::string join
the id of the vehicle (train portion) to which this vehicle shall be joined
SUMOTime until
The time at which the vehicle may continue its journey.
std::string actType
act Type (only used by Persons) (used by NETEDIT)
bool triggered
whether an arriving person lets the vehicle continue
SUMOTime ended
the time at which this stop was ended
double endPos
The stopping position end.
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 bool parsePersonModes(const std::string &modes, const std::string &element, const std::string &id, SVCPermissions &modeSet, std::string &error)
Validates a given person modes value.
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 isValidVehicleID(const std::string &value)
whether the given string is a valid id for a vehicle or flow
static bool isValidParameterKey(const std::string &value)
whether the given string is a valid key for a parameter