Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
RouteHandler.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 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(),
236 // build trip with from-to junctions
238 obj->getVehicleParameter(),
241 } else if (obj->hasStringAttribute(SUMO_ATTR_FROM_TAZ) &&
243 // build trip with from-to TAZs
244 buildTripTAZs(obj,
245 obj->getVehicleParameter(),
248 } else {
249 throw ProcessError("Invalid from-to values in trips");
250 }
251 break;
252 case SUMO_TAG_VEHICLE:
255 obj->getVehicleParameter());
256 }
257 break;
258 // flows
259 case SUMO_TAG_FLOW:
261 // build flow over route
263 obj->getVehicleParameter());
264 } else if (obj->hasStringAttribute(SUMO_ATTR_FROM) &&
266 // build flow with from-to edges
267 buildFlow(obj,
268 obj->getVehicleParameter(),
273 // build flow with from-to junctions
275 obj->getVehicleParameter(),
278 } else if (obj->hasStringAttribute(SUMO_ATTR_FROM_TAZ) &&
280 // build flow with from-to TAZs
281 buildFlowTAZs(obj,
282 obj->getVehicleParameter(),
285 }
286 break;
287 // persons
288 case SUMO_TAG_PERSON:
289 buildPerson(obj,
290 obj->getVehicleParameter());
291 break;
293 buildPersonFlow(obj,
294 obj->getVehicleParameter());
295 break;
296 // person plans
298 buildPersonTrip(obj,
309 break;
310 case SUMO_TAG_RIDE:
311 buildRide(obj,
318 break;
319 case SUMO_TAG_WALK:
320 buildWalk(obj,
330 break;
331 // container
333 buildContainer(obj,
334 obj->getVehicleParameter());
335 break;
338 obj->getVehicleParameter());
339 break;
340 // container plans
342 buildTransport(obj,
348 break;
350 buildTranship(obj,
358 break;
359 // stopss
360 case SUMO_TAG_STOP:
361 buildStop(obj,
362 obj->getStopParameter());
363 break;
364 default:
365 break;
366 }
367 // now iterate over childrens
368 for (const auto& child : obj->getSumoBaseObjectChildren()) {
369 // call this function recursively
370 parseSumoBaseObject(child);
371 }
372}
373
374
375bool
379
380
381void
382RouteHandler::writeError(const std::string& error) {
383 WRITE_ERROR(error);
385}
386
387
388void
389RouteHandler::writeErrorInvalidID(const SumoXMLTag tag, const std::string& id) {
390 WRITE_ERRORF(TL("Could not build % with ID '%' in netedit; ID contains invalid characters."), toString(tag), id);
392}
393
394
395void
397 // parse vehicleType
399 if (vehicleTypeParameter) {
400 // set tag
402 // add all attributes
404 // delete vehicleType parameter (because in XMLStructure we have a copy)
405 delete vehicleTypeParameter;
406 }
407}
408
409
410void
412 // declare Ok Flag
413 bool parsedOk = true;
414 // needed attributes
415 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
416 // optional attributes
417 const int deterministic = attrs.getOpt<int>(SUMO_ATTR_DETERMINISTIC, id.c_str(), parsedOk, -1);
418 const std::vector<std::string> vTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk);
419 if (parsedOk) {
422 } else {
423 // set tag
425 // add all attributes
429 }
430 }
431}
432
433
434void
436 // get embedded route flag
437 const bool embeddedRoute = isEmbeddedRoute(attrs);
438 // first check if this is an embedded route
439 if ((embeddedRoute && attrs.hasAttribute(SUMO_ATTR_ID)) || (!embeddedRoute && !attrs.hasAttribute(SUMO_ATTR_ID))) {
440 writeError(TL("a route must be defined either within a vehicle/flow or with an ID attribute"));
441 } else {
442 // declare Ok Flag
443 bool parsedOk = true;
444 // special case for ID
445 const std::string id = attrs.getOpt<std::string>(SUMO_ATTR_ID, "", parsedOk, "");
446 // needed attributes
447 const std::vector<std::string> edges = attrs.get<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk);
448 // optional attributes
450 const RGBColor color = attrs.getOpt<RGBColor>(SUMO_ATTR_COLOR, id.c_str(), parsedOk, RGBColor::INVISIBLE);
451 const int repeat = attrs.getOpt<int>(SUMO_ATTR_REPEAT, id.c_str(), parsedOk, 0);
452 const SUMOTime cycleTime = attrs.getOptSUMOTimeReporting(SUMO_ATTR_CYCLETIME, id.c_str(), parsedOk, 0);
453 if (parsedOk) {
454 if (!id.empty() && !SUMOXMLDefinitions::isValidVehicleID(id)) {
456 } else if (cycleTime < 0) {
457 writeError(TLF("cycleTime of % must be equal or greater than 0", toString(SUMO_TAG_DEST_PROB_REROUTE)));
458 } else {
459 // set tag
461 // add all attributes
468 }
469 }
470 }
471}
472
473
474void
476 // declare Ok Flag
477 bool parsedOk = true;
478 // needed attributes
479 const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);
480 if (parsedOk) {
483 } else {
484 // set tag
486 // add all attributes
488 }
489 }
490}
491
492
493void
495 // declare Ok Flag
496 bool parsedOk = true;
497 // parse vehicle
499 if (tripParameter) {
500 // check from/to edge/junction
502 writeError(TL("Attributes 'from', 'fromJunction' and 'fromTaz' cannot be defined together"));
504 writeError(TL("Attributes 'to', 'toJunction' and 'toTaz' cannot be defined together"));
505 } else if (attrs.hasAttribute(SUMO_ATTR_FROM) && attrs.hasAttribute(SUMO_ATTR_TO)) {
506 // from-to attributes
507 const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, tripParameter->id.c_str(), parsedOk, "");
508 const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, tripParameter->id.c_str(), parsedOk, "");
509 // optional attributes
510 const std::vector<std::string> via = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VIA, tripParameter->id.c_str(), parsedOk);
511 if (parsedOk) {
512 // set tag
514 // set vehicle parameters
516 // add other attributes
520 }
522 // from-to attributes
523 const std::string fromJunction = attrs.getOpt<std::string>(SUMO_ATTR_FROMJUNCTION, tripParameter->id.c_str(), parsedOk, "");
524 const std::string toJunction = attrs.getOpt<std::string>(SUMO_ATTR_TOJUNCTION, tripParameter->id.c_str(), parsedOk, "");
525 if (parsedOk) {
526 // set tag
528 // set vehicle parameters
530 // add other attributes
533 }
534 } else if (attrs.hasAttribute(SUMO_ATTR_FROM_TAZ) && attrs.hasAttribute(SUMO_ATTR_TO_TAZ)) {
535 // from-to attributes
536 const std::string fromJunction = attrs.getOpt<std::string>(SUMO_ATTR_FROM_TAZ, tripParameter->id.c_str(), parsedOk, "");
537 const std::string toJunction = attrs.getOpt<std::string>(SUMO_ATTR_TO_TAZ, tripParameter->id.c_str(), parsedOk, "");
538 if (parsedOk) {
539 // set tag
541 // set vehicle parameters
543 // add other attributes
546 }
547 } else {
548 writeError(TL("trip definition needs either 'from/to' or 'fromJunction/toJunction' or 'fromTaz/toTaz'"));
549 }
550 // delete trip parameter (because in XMLStructure we have a copy)
551 delete tripParameter;
552 }
553}
554
555
556void
558 // first parse vehicle
560 if (vehicleParameter) {
561 // set tag
563 // set vehicle parameters
565 // delete vehicle parameter (because in XMLStructure we have a copy)
566 delete vehicleParameter;
567 }
568}
569
570
571void
573 // declare Ok Flag
574 bool parsedOk = true;
575 // first parse flow
577 if (flowParameter) {
578 // set vehicle parameters
580 // check from/to edge/junction
582 writeError(TL("Attributes 'from', 'fromJunction' and 'fromTaz' cannot be defined together"));
584 writeError(TL("Attributes 'to', 'toJunction' and 'toTaz' cannot be defined together"));
585 } else if (attrs.hasAttribute(SUMO_ATTR_FROM) && attrs.hasAttribute(SUMO_ATTR_TO)) {
586 // from-to attributes
587 const std::string from = attrs.get<std::string>(SUMO_ATTR_FROM, flowParameter->id.c_str(), parsedOk);
588 const std::string to = attrs.get<std::string>(SUMO_ATTR_TO, flowParameter->id.c_str(), parsedOk);
589 // optional attributes
590 const std::vector<std::string> via = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VIA, flowParameter->id.c_str(), parsedOk);
591 if (parsedOk) {
592 // set tag
594 // add other attributes
598 }
600 // from-to attributes
601 const std::string fromJunction = attrs.get<std::string>(SUMO_ATTR_FROMJUNCTION, flowParameter->id.c_str(), parsedOk);
602 const std::string toJunction = attrs.get<std::string>(SUMO_ATTR_TOJUNCTION, flowParameter->id.c_str(), parsedOk);
603 if (parsedOk) {
604 // set tag
606 // add other attributes
609 }
610 } else if (attrs.hasAttribute(SUMO_ATTR_FROM_TAZ) && attrs.hasAttribute(SUMO_ATTR_TO_TAZ)) {
611 // from-to attributes
612 const std::string fromJunction = attrs.get<std::string>(SUMO_ATTR_FROM_TAZ, flowParameter->id.c_str(), parsedOk);
613 const std::string toJunction = attrs.get<std::string>(SUMO_ATTR_TO_TAZ, flowParameter->id.c_str(), parsedOk);
614 if (parsedOk) {
615 // set tag
617 // add other attributes
620 }
621 } else if (attrs.hasAttribute(SUMO_ATTR_ROUTE)) {
622 // from-to attributes
623 const std::string route = attrs.get<std::string>(SUMO_ATTR_ROUTE, flowParameter->id.c_str(), parsedOk);
624 if (parsedOk) {
625 // set tag
627 // add other attributes
629 }
630 } else {
631 // set tag
633 }
634 // delete flow parameter (because in XMLStructure we have a copy)
635 delete flowParameter;
636 }
637}
638
639
640void
642 // declare Ok Flag
643 bool parsedOk = true;
644 // declare stop
646 // check parents
648 // parse stop
649 if (parsedOk && parseStopParameters(stop, attrs)) {
650 // set tag
652 // add stop attributes
654 }
655}
656
657
658void
660 // first parse vehicle
662 if (personParameter) {
663 // set tag
665 // set vehicle parameter
667 // delete person parameter (because in XMLStructure we have a copy)
668 delete personParameter;
669 }
670}
671
672
673void
675 // first parse flow
677 if (personFlowParameter) {
678 // set tag
680 // set vehicle parameter
682 // delete person flow parameter (because in XMLStructure we have a copy)
683 delete personFlowParameter;
684 }
685}
686
687
688void
690 // declare Ok Flag
691 bool parsedOk = true;
692 // optional attributes
693 const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
694 const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
695 const std::string fromJunction = attrs.getOpt<std::string>(SUMO_ATTR_FROMJUNCTION, "", parsedOk, "");
696 const std::string toJunction = attrs.getOpt<std::string>(SUMO_ATTR_TOJUNCTION, "", parsedOk, "");
697 const std::vector<std::string> via = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VIA, "", parsedOk);
698 const std::string busStop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, "", parsedOk, "");
699 const std::string trainStop = attrs.getOpt<std::string>(SUMO_ATTR_TRAIN_STOP, "", parsedOk, "");
700 const std::vector<std::string> vTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, "", parsedOk);
701 const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, "", parsedOk);
702 std::vector<std::string> modes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_MODES, "", parsedOk);
703 const double departPos = attrs.getOpt<double>(SUMO_ATTR_DEPARTPOS, "", parsedOk, -1);
704 const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, -1);
705 // check modes
706 SVCPermissions dummyModeSet;
707 std::string dummyError;
708 if (!SUMOVehicleParameter::parsePersonModes(toString(modes), toString(SUMO_TAG_PERSONTRIP), "", dummyModeSet, dummyError)) {
709 WRITE_WARNING(dummyError);
710 modes.clear();
711 }
712 if (parsedOk) {
713 // set tag
715 // add all attributes
728 }
729}
730
731
732void
734 // declare Ok Flag
735 bool parsedOk = true;
736 // optional attributes
737 const std::string route = attrs.getOpt<std::string>(SUMO_ATTR_ROUTE, "", parsedOk, "");
738 const std::vector<std::string> edges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EDGES, "", parsedOk);
739 const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
740 const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
741 const std::string fromJunction = attrs.getOpt<std::string>(SUMO_ATTR_FROMJUNCTION, "", parsedOk, "");
742 const std::string toJunction = attrs.getOpt<std::string>(SUMO_ATTR_TOJUNCTION, "", parsedOk, "");
743 const std::string busStop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, "", parsedOk, "");
744 const std::string trainStop = attrs.getOpt<std::string>(SUMO_ATTR_TRAIN_STOP, "", parsedOk, "");
745 const double duration = attrs.getOpt<double>(SUMO_ATTR_DURATION, "", parsedOk, 0);
746 const double speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, "", parsedOk, 0);
747 const double departPos = attrs.getOpt<double>(SUMO_ATTR_DEPARTPOS, "", parsedOk, -1);
748 const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, -1);
749 const double departPosLat = attrs.getOpt<double>(SUMO_ATTR_DEPARTPOS_LAT, "", parsedOk, 0);
750 if (parsedOk) {
751 // set tag
753 // add all attributes
767 }
768}
769
770
771void
773 // declare Ok Flag
774 bool parsedOk = true;
775 // optional attributes
776 const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
777 const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
778 const std::string busStop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, "", parsedOk, "");
779 const std::string trainStop = attrs.getOpt<std::string>(SUMO_ATTR_TRAIN_STOP, "", parsedOk, "");
780 const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, "", parsedOk);
781 const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, -1);
782 if (parsedOk) {
783 // set tag
785 // add all attributes
792 }
793}
794
795
796void
798 // first parse container
800 if (containerParameter) {
801 // set tag
803 // set vehicle parameter
805 // delete container parameter (because in XMLStructure we have a copy)
806 delete containerParameter;
807 }
808}
809
810
811void
813 // first parse flow
815 if (containerFlowParameter) {
816 // set tag
818 // set vehicle parameter
820 // delete container flow parameter (because in XMLStructure we have a copy)
821 delete containerFlowParameter;
822 }
823}
824
825
826void
828 // declare Ok Flag
829 bool parsedOk = true;
830 // optional attributes
831 const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
832 const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
833 const std::string containerStop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, "", parsedOk, "");
834 const std::vector<std::string> lines = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_LINES, "", parsedOk);
835 const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, -1);
836 if (parsedOk) {
837 // set tag
839 // add all attributes
845 }
846}
847
848
849void
851 // declare Ok Flag
852 bool parsedOk = true;
853 // optional attributes
854 const std::vector<std::string> edges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EDGES, "", parsedOk);
855 const std::string from = attrs.getOpt<std::string>(SUMO_ATTR_FROM, "", parsedOk, "");
856 const std::string to = attrs.getOpt<std::string>(SUMO_ATTR_TO, "", parsedOk, "");
857 const std::string containerStop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, "", parsedOk, "");
858 const double speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, "", parsedOk, 1.39);
859 const double departPos = attrs.getOpt<double>(SUMO_ATTR_DEPARTPOS, "", parsedOk, -1);
860 const double arrivalPos = attrs.getOpt<double>(SUMO_ATTR_ARRIVALPOS, "", parsedOk, -1);
861 if (parsedOk) {
862 // set tag
864 // add all attributes
872 }
873}
874
875
876void
878 // declare Ok Flag
879 bool parsedOk = true;
880 // just parse begin and end default
881 myFlowBeginDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, nullptr, parsedOk);
882 myFlowEndDefault = attrs.getSUMOTimeReporting(SUMO_ATTR_END, nullptr, parsedOk);
883}
884
885
886void
888 // declare Ok Flag
889 bool parsedOk = true;
890 // get key
891 const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, nullptr, parsedOk);
892 // get SumoBaseObject parent
894 // check parent
895 if (SumoBaseObjectParent == nullptr) {
896 writeError(TL("Parameters must be defined within an object"));
897 } else if (SumoBaseObjectParent->getTag() == SUMO_TAG_ROOTFILE) {
898 writeError(TL("Parameters cannot be defined in the additional file's root."));
899 } else if (SumoBaseObjectParent->getTag() == SUMO_TAG_PARAM) {
900 writeError(TL("Parameters cannot be defined within another parameter."));
901 } else if (parsedOk) {
902 // get tag str
903 const std::string parentTagStr = toString(SumoBaseObjectParent->getTag());
904 // circumventing empty string value
905 const std::string value = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
906 // show warnings if values are invalid
907 if (key.empty()) {
908 WRITE_WARNINGF(TL("Error parsing key from % generic parameter. Key cannot be empty"), parentTagStr);
910 WRITE_WARNINGF(TL("Error parsing key from % generic parameter. Key contains invalid characters"), parentTagStr);
911 } else {
912 WRITE_DEBUG("Inserting generic parameter '" + key + "|" + value + "' into " + parentTagStr);
913 // insert parameter in SumoBaseObjectParent
914 SumoBaseObjectParent->addParameter(key, value);
915 }
916 }
917}
918
919
920bool
922 // get vehicle type Base object
924 // parse embedded car following model information
925 if (vTypeObject && (vTypeObject->getTag() == SUMO_TAG_VTYPE)) {
926 WRITE_WARNINGF(TL("Defining car-following parameters in a nested element is deprecated in vType '%', use attributes instead!"), vTypeObject->getStringAttribute(SUMO_ATTR_ID));
927 // get vType to modify it
928 auto vType = vTypeObject->getVehicleTypeParameter();
929 // parse nested CFM attributes
930 if (SUMOVehicleParserHelper::parseCFMParams(&vType, tag, attrs, true)) {
931 vTypeObject->setVehicleTypeParameter(&vType);
932 return true;
933 } else if (myHardFail) {
934 throw ProcessError(TL("Invalid parsing embedded VType"));
935 } else {
936 writeError(TL("Invalid parsing embedded VType"));
937 }
938 }
939 return false;
940}
941
942
943bool
945 // check stop parameters
946 if (attrs.hasAttribute(SUMO_ATTR_ARRIVAL)) {
948 }
949 if (attrs.hasAttribute(SUMO_ATTR_DURATION)) {
951 }
952 if (attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
954 }
955 if (attrs.hasAttribute(SUMO_ATTR_STARTED)) {
957 }
958 if (attrs.hasAttribute(SUMO_ATTR_ENDED)) {
960 }
963 }
964 if (attrs.hasAttribute(SUMO_ATTR_ENDPOS)) {
966 }
967 if (attrs.hasAttribute(SUMO_ATTR_STARTPOS)) {
969 }
972 }
975 }
976 // legacy attribute
979 }
980 if (attrs.hasAttribute(SUMO_ATTR_PARKING)) {
982 }
983 if (attrs.hasAttribute(SUMO_ATTR_EXPECTED)) {
985 }
988 }
991 }
992 if (attrs.hasAttribute(SUMO_ATTR_TRIP_ID)) {
994 }
995 if (attrs.hasAttribute(SUMO_ATTR_SPLIT)) {
997 }
998 if (attrs.hasAttribute(SUMO_ATTR_JOIN)) {
1000 }
1001 if (attrs.hasAttribute(SUMO_ATTR_LINE)) {
1003 }
1004 if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
1006 }
1007 if (attrs.hasAttribute(SUMO_ATTR_ONDEMAND)) {
1009 }
1010 if (attrs.hasAttribute(SUMO_ATTR_JUMP)) {
1012 }
1013 // get parameters
1014 bool ok = true;
1015 // edge/lane
1016 stop.edge = attrs.getOpt<std::string>(SUMO_ATTR_EDGE, nullptr, ok, "");
1017 stop.lane = attrs.getOpt<std::string>(SUMO_ATTR_LANE, nullptr, ok, stop.busstop);
1018 // check errors
1019 if (!stop.edge.empty() && !stop.lane.empty()) {
1020 writeError(TL("A stop must be defined either with an edge or with an lane, not both"));
1021 return false;
1022 }
1023 // stopping places
1024 stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_BUS_STOP, nullptr, ok, "");
1025 if (stop.busstop.empty()) {
1026 stop.busstop = attrs.getOpt<std::string>(SUMO_ATTR_TRAIN_STOP, nullptr, ok, stop.busstop);
1027 }
1028 stop.chargingStation = attrs.getOpt<std::string>(SUMO_ATTR_CHARGING_STATION, nullptr, ok, "");
1029 stop.overheadWireSegment = attrs.getOpt<std::string>(SUMO_ATTR_OVERHEAD_WIRE_SEGMENT, nullptr, ok, "");
1030 stop.containerstop = attrs.getOpt<std::string>(SUMO_ATTR_CONTAINER_STOP, nullptr, ok, "");
1031 stop.parkingarea = attrs.getOpt<std::string>(SUMO_ATTR_PARKING_AREA, nullptr, ok, "");
1032 //check stopping places
1033 const int numStoppingPlaces = !stop.busstop.empty() + !stop.chargingStation.empty() + !stop.overheadWireSegment.empty() +
1034 !stop.containerstop.empty() + !stop.parkingarea.empty();
1035 if (numStoppingPlaces > 1) {
1036 writeError(TL("A stop must be defined only in a StoppingPlace"));
1037 return false;
1038 } else if ((numStoppingPlaces == 0) && stop.edge.empty() && stop.lane.empty()) {
1039 writeError(TL("A stop must be defined in an edge, a lane, or in a StoppingPlace"));
1040 return false;
1041 }
1042 // declare error suffix
1043 std::string errorSuffix;
1044 if (stop.busstop != "") {
1045 errorSuffix = " at '" + stop.busstop + "'" + errorSuffix;
1046 } else if (stop.chargingStation != "") {
1047 errorSuffix = " at '" + stop.chargingStation + "'" + errorSuffix;
1048 } else if (stop.overheadWireSegment != "") {
1049 errorSuffix = " at '" + stop.overheadWireSegment + "'" + errorSuffix;
1050 } else if (stop.containerstop != "") {
1051 errorSuffix = " at '" + stop.containerstop + "'" + errorSuffix;
1052 } else if (stop.parkingarea != "") {
1053 errorSuffix = " at '" + stop.parkingarea + "'" + errorSuffix;
1054 } else if (stop.edge != "") {
1055 errorSuffix = " at '" + stop.edge + "'" + errorSuffix;
1056 } else {
1057 errorSuffix = " on lane '" + stop.lane + "'" + errorSuffix;
1058 }
1059 // speed for counting as stopped
1060 stop.speed = attrs.getOpt<double>(SUMO_ATTR_SPEED, nullptr, ok, 0);
1061 if (stop.speed < 0) {
1062 writeError("Speed cannot be negative for stop" + errorSuffix);
1063 return false;
1064 }
1065 // get the standing duration
1066 bool expectTrigger = !attrs.hasAttribute(SUMO_ATTR_DURATION) && !attrs.hasAttribute(SUMO_ATTR_UNTIL) && !attrs.hasAttribute(SUMO_ATTR_SPEED);
1067 std::vector<std::string> triggers = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_TRIGGERED, nullptr, ok);
1068 // legacy
1069 if (attrs.getOpt<bool>(SUMO_ATTR_CONTAINER_TRIGGERED, nullptr, ok, false)) {
1070 triggers.push_back(toString(SUMO_TAG_CONTAINER));
1071 };
1072 SUMOVehicleParameter::parseStopTriggers(triggers, expectTrigger, stop);
1073 stop.startPos = attrs.getOpt<double>(SUMO_ATTR_STARTPOS, nullptr, ok, 0);
1074 stop.endPos = attrs.getOpt<double>(SUMO_ATTR_ENDPOS, nullptr, ok, 0);
1075 stop.friendlyPos = attrs.getOpt<bool>(SUMO_ATTR_FRIENDLY_POS, nullptr, ok, false);
1076 stop.arrival = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ARRIVAL, nullptr, ok, -1);
1077 stop.duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, nullptr, ok, -1);
1078 stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, nullptr, ok, -1);
1079 if (!expectTrigger && (!ok || (stop.duration < 0 && stop.until < 0 && stop.speed == 0))) {
1080 writeError("Invalid duration or end time is given for a stop" + errorSuffix);
1081 return false;
1082 }
1083 stop.extension = attrs.getOptSUMOTimeReporting(SUMO_ATTR_EXTENSION, nullptr, ok, -1);
1084 const bool defaultParking = (stop.triggered || stop.containerTriggered || stop.parkingarea != "");
1085 stop.parking = attrs.getOpt<ParkingType>(SUMO_ATTR_PARKING, nullptr, ok, defaultParking ? ParkingType::OFFROAD : ParkingType::ONROAD);
1086 if ((stop.parkingarea != "") && (stop.parking == ParkingType::ONROAD)) {
1087 WRITE_WARNING("Stop at parkingarea overrides attribute 'parking' for stop" + errorSuffix);
1089 }
1090 if (!ok) {
1091 writeError("Invalid bool for 'triggered', 'containerTriggered' or 'parking' for stop" + errorSuffix);
1092 return false;
1093 }
1094 // expected persons
1095 const std::vector<std::string>& expected = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EXPECTED, nullptr, ok);
1096 stop.awaitedPersons.insert(expected.begin(), expected.end());
1097 if (stop.awaitedPersons.size() > 0 && (stop.parametersSet & STOP_TRIGGER_SET) == 0) {
1098 stop.triggered = true;
1099 if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
1101 }
1102 }
1103 // permitted transportables
1104 const std::vector<std::string>& permitted = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_PERMITTED, nullptr, ok);
1105 stop.permitted.insert(permitted.begin(), permitted.end());
1106 // expected containers
1107 const std::vector<std::string>& expectedContainers = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EXPECTED_CONTAINERS, nullptr, ok);
1108 stop.awaitedContainers.insert(expectedContainers.begin(), expectedContainers.end());
1109 if (stop.awaitedContainers.size() > 0 && (stop.parametersSet & STOP_CONTAINER_TRIGGER_SET) == 0) {
1110 stop.containerTriggered = true;
1111 if ((stop.parametersSet & STOP_PARKING_SET) == 0) {
1113 }
1114 }
1115 // public transport trip id
1116 stop.tripId = attrs.getOpt<std::string>(SUMO_ATTR_TRIP_ID, nullptr, ok, "");
1117 stop.split = attrs.getOpt<std::string>(SUMO_ATTR_SPLIT, nullptr, ok, "");
1118 stop.join = attrs.getOpt<std::string>(SUMO_ATTR_JOIN, nullptr, ok, "");
1119 stop.line = attrs.getOpt<std::string>(SUMO_ATTR_LINE, nullptr, ok, "");
1120 // index
1121 const std::string idx = attrs.getOpt<std::string>(SUMO_ATTR_INDEX, nullptr, ok, "end");
1122 if (idx == "end") {
1123 stop.index = STOP_INDEX_END;
1124 } else if (idx == "fit") {
1125 stop.index = STOP_INDEX_FIT;
1126 } else {
1127 stop.index = attrs.get<int>(SUMO_ATTR_INDEX, nullptr, ok);
1128 if (!ok || stop.index < 0) {
1129 writeError("Invalid 'index' for stop" + errorSuffix);
1130 return false;
1131 }
1132 }
1133 stop.started = attrs.getOptSUMOTimeReporting(SUMO_ATTR_STARTED, nullptr, ok, -1);
1134 stop.ended = attrs.getOptSUMOTimeReporting(SUMO_ATTR_ENDED, nullptr, ok, -1);
1135 stop.posLat = attrs.getOpt<double>(SUMO_ATTR_POSITION_LAT, nullptr, ok, INVALID_DOUBLE);
1136 stop.actType = attrs.getOpt<std::string>(SUMO_ATTR_ACTTYPE, nullptr, ok, "");
1137 stop.onDemand = attrs.getOpt<bool>(SUMO_ATTR_ONDEMAND, nullptr, ok, false);
1138 stop.jump = attrs.getOptSUMOTimeReporting(SUMO_ATTR_JUMP, nullptr, ok, -1);
1139 return true;
1140}
1141
1142
1143bool
1145 // check conditions
1146 if (attrs.hasAttribute(SUMO_ATTR_ID)) {
1147 return false;
1149 return false;
1151 return false;
1153 return true;
1155 return true;
1156 } else {
1157 return false;
1158 }
1159}
1160
1161
1162void
1163RouteHandler::checkParent(const SumoXMLTag currentTag, const std::vector<SumoXMLTag>& parentTags, bool& ok) {
1164 // check that parent SUMOBaseObject's tag is the parentTag
1166 // set parent string
1167 std::string parentStrings;
1168 for (const auto& tag : parentTags) {
1169 if (tag == parentTags.back()) {
1170 parentStrings.append(toString(tag));
1171 } else {
1172 parentStrings.append(toString(tag) + ", ");
1173 }
1174 }
1175 if ((parent != nullptr) &&
1176 (parentTags.size() > 0) &&
1177 (std::find(parentTags.begin(), parentTags.end(), parent->getTag()) == parentTags.end())) {
1178 const std::string id = parent->hasStringAttribute(SUMO_ATTR_ID) ? ", id: '" + parent->getStringAttribute(SUMO_ATTR_ID) + "'" : "";
1179 writeError("'" + toString(currentTag) + "' must be defined within the definition of a '" + parentStrings + "' (found '" + toString(parent->getTag()) + "'" + id + ").");
1180 ok = false;
1181 }
1182}
1183
1184/****************************************************************************/
long long int SUMOTime
Definition GUI.h:36
#define WRITE_DEBUG(msg)
Definition MsgHandler.h:281
#define WRITE_WARNINGF(...)
Definition MsgHandler.h:271
#define WRITE_ERRORF(...)
Definition MsgHandler.h:280
#define WRITE_ERROR(msg)
Definition MsgHandler.h:279
#define WRITE_WARNING(msg)
Definition MsgHandler.h:270
#define TL(string)
Definition MsgHandler.h:287
#define TLF(string,...)
Definition MsgHandler.h:288
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition SUMOTime.cpp:46
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_JUMP_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 definition using from and to edges or a route
@ 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 destination 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_TO_TAZ
@ SUMO_ATTR_TRIP_ID
@ SUMO_ATTR_TO
@ SUMO_ATTR_FROM
@ SUMO_ATTR_END
weights: time range end
@ SUMO_ATTR_PERMITTED
@ SUMO_ATTR_FROM_TAZ
@ SUMO_ATTR_JOIN
@ SUMO_ATTR_JUMP
@ 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
invalid double
Definition StdDefs.h:64
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
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, const std::string &toTrainStopID, 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 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
virtual void buildFlowTAZs(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters, const std::string &fromTAZID, const std::string &toTAZID)=0
build flow (from-to TAZs)
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 buildFlowJunctions(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters, const std::string &fromJunctionID, const std::string &toJunctionID)=0
build flow (from-to junctions)
void parseVTypeDistribution(const SUMOSAXAttributes &attrs)
parse vType distribution
virtual void buildTripJunctions(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters, const std::string &fromJunctionID, const std::string &toJunctionID)=0
build trip (from-to junctions)
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)
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::string &toTrainStopID, const std::vector< std::string > &edgeIDs, const std::string &routeID, double arrivalPos)=0
build walk
void parseStop(const SUMOSAXAttributes &attrs)
parse stop
void parseContainer(const SUMOSAXAttributes &attrs)
parse container
virtual void buildRide(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const std::string &fromEdgeID, const std::string &toEdgeID, const std::string &toBusStopID, const std::string &toTrainStopID, double arrivalPos, const std::vector< std::string > &lines)=0
build ride
RouteHandler(const std::string &filename, const bool hardFail)
Constructor.
void parsePersonTrip(const SUMOSAXAttributes &attrs)
parse person trip
virtual void buildTrip(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters, const std::string &fromEdgeID, const std::string &toEdgeID)=0
build trip (from-to edges)
virtual void buildVType(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVTypeParameter &vTypeParameter)=0
build vType
void parseRoute(const SUMOSAXAttributes &attrs)
parse route
virtual void buildTripTAZs(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters, const std::string &fromTazID, const std::string &toTazID)=0
build trip (from-to TAZs)
void parseTrip(const SUMOSAXAttributes &attrs)
parse trip
SUMOTime myFlowEndDefault
The default value for flow ends.
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
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.
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
const bool myHardFail
enable or disable hardFail (stop parsing if parameter aren't correct)
void parseRouteDistribution(const SUMOSAXAttributes &attrs)
parse route distribution
void parseTranship(const SUMOSAXAttributes &attrs)
parse tranship
virtual void buildFlow(const CommonXMLStructure::SumoBaseObject *sumoBaseObject, const SUMOVehicleParameter &vehicleParameters, const std::string &fromEdgeID, const std::string &toEdgeID)=0
build flow (from-to edges)
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
SUMOTime jump
transfer time if there shall be a jump from this stop to the next route edge
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