1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
10 /// @file    SUMOVehicleParameter.cpp
11 /// @author  Daniel Krajzewicz
12 /// @author  Jakob Erdmann
13 /// @author  Michael Behrisch
14 /// @date    Tue, 31.03.2009
15 /// @version $Id$
16 ///
17 // Structure representing possible vehicle parameter
18 /****************************************************************************/
19 
20 
21 // ===========================================================================
22 // included modules
23 // ===========================================================================
24 #include <config.h>
25 
26 #include "SUMOVehicleParameter.h"
27 #include <utils/common/ToString.h>
28 #include <utils/common/StringUtils.h>
29 #include <utils/common/MsgHandler.h>
30 #include <utils/iodevices/OutputDevice.h>
31 #include <utils/options/OptionsCont.h>
32 
33 
34 // ===========================================================================
35 // member method definitions
36 // ===========================================================================
SUMOVehicleParameter()37 SUMOVehicleParameter::SUMOVehicleParameter()
38     : vtypeid(DEFAULT_VTYPE_ID), color(RGBColor::DEFAULT_COLOR),
39       depart(-1), departProcedure(DEPART_GIVEN),
40       departLane(0), departLaneProcedure(DEPART_LANE_DEFAULT),
41       departPos(0), departPosProcedure(DEPART_POS_DEFAULT),
42       departPosLat(0), departPosLatProcedure(DEPART_POSLAT_DEFAULT),
43       departSpeed(-1), departSpeedProcedure(DEPART_SPEED_DEFAULT),
44       arrivalLane(0), arrivalLaneProcedure(ARRIVAL_LANE_DEFAULT),
45       arrivalPos(0), arrivalPosProcedure(ARRIVAL_POS_DEFAULT),
46       arrivalPosLat(0), arrivalPosLatProcedure(ARRIVAL_POSLAT_DEFAULT),
47       arrivalSpeed(-1), arrivalSpeedProcedure(ARRIVAL_SPEED_DEFAULT),
48       repetitionNumber(-1), repetitionsDone(-1), repetitionOffset(-1), repetitionProbability(-1), repetitionEnd(-1),
49       line(), fromTaz(), toTaz(), personNumber(0), containerNumber(0), parametersSet(0) {
50 }
51 
~SUMOVehicleParameter()52 SUMOVehicleParameter::~SUMOVehicleParameter() {
53 }
54 
55 bool
defaultOptionOverrides(const OptionsCont & oc,const std::string & optionName) const56 SUMOVehicleParameter::defaultOptionOverrides(const OptionsCont& oc, const std::string& optionName) const {
57     return oc.exists(optionName) && oc.isSet(optionName) && oc.getBool("defaults-override");
58 }
59 
60 
61 void
write(OutputDevice & dev,const OptionsCont & oc,const SumoXMLTag tag,const std::string & typeID) const62 SUMOVehicleParameter::write(OutputDevice& dev, const OptionsCont& oc, const SumoXMLTag tag, const std::string& typeID) const {
63     dev.openTag(tag).writeAttr(SUMO_ATTR_ID, id);
64     if (typeID == "") {
65         if (wasSet(VEHPARS_VTYPE_SET)) {
66             dev.writeAttr(SUMO_ATTR_TYPE, vtypeid);
67         }
68     } else {
69         dev.writeAttr(SUMO_ATTR_TYPE, typeID);
70     }
71     // write depart depending of tag
72     if (tag == SUMO_TAG_FLOW) {
73         dev.writeAttr(SUMO_ATTR_BEGIN, getDepart());
74     } else {
75         dev.writeAttr(SUMO_ATTR_DEPART, getDepart());
76     }
77     // optional parameter
78     //  departlane
79     if (wasSet(VEHPARS_DEPARTLANE_SET) && !defaultOptionOverrides(oc, "departlane")) {
80         dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTLANE, getDepartLane());
81     } else if (oc.exists("departlane") && oc.isSet("departlane")) {
82         dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTLANE, oc.getString("departlane"));
83     }
84     //  departpos
85     if (wasSet(VEHPARS_DEPARTPOS_SET) && !defaultOptionOverrides(oc, "departpos")) {
86         dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTPOS, getDepartPos());
87     } else if (oc.exists("departpos") && oc.isSet("departpos")) {
88         dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTPOS, oc.getString("departpos"));
89     }
90     //  departPosLat
91     if (wasSet(VEHPARS_DEPARTPOSLAT_SET)) {
92         dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTPOS_LAT, getDepartPosLat());
93     }
94 
95     //  departspeed
96     if (wasSet(VEHPARS_DEPARTSPEED_SET) && !defaultOptionOverrides(oc, "departspeed")) {
97         dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTSPEED, getDepartSpeed());
98     } else if (oc.exists("departspeed") && oc.isSet("departspeed")) {
99         dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTSPEED, oc.getString("departspeed"));
100     }
101     //  arrivallane
102     if (wasSet(VEHPARS_ARRIVALLANE_SET) && !defaultOptionOverrides(oc, "arrivallane")) {
103         dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALLANE, getArrivalLane());
104     } else if (oc.exists("arrivallane") && oc.isSet("arrivallane")) {
105         dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALLANE, oc.getString("arrivallane"));
106     }
107     //  arrivalpos
108     if (wasSet(VEHPARS_ARRIVALPOS_SET) && !defaultOptionOverrides(oc, "arrivalpos")) {
109         dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALPOS, getArrivalPos());
110     } else if (oc.exists("arrivalpos") && oc.isSet("arrivalpos")) {
111         dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALPOS, oc.getString("arrivalpos"));
112     }
113     //  arrivalPosLat
114     if (wasSet(VEHPARS_ARRIVALPOSLAT_SET)) {
115         dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALPOS_LAT, getArrivalPosLat());
116     }
117     //  arrivalspeed
118     if (wasSet(VEHPARS_ARRIVALSPEED_SET) && !defaultOptionOverrides(oc, "arrivalspeed")) {
119         dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALSPEED, getArrivalSpeed());
120     } else if (oc.exists("arrivalspeed") && oc.isSet("arrivalspeed")) {
121         dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALSPEED, oc.getString("arrivalspeed"));
122     }
123     // color
124     if (wasSet(VEHPARS_COLOR_SET)) {
125         dev.writeAttr(SUMO_ATTR_COLOR, color);
126     }
127     // line
128     if (wasSet(VEHPARS_LINE_SET)) {
129         dev.writeAttr(SUMO_ATTR_LINE, line);
130     }
131     // from TAZ
132     if (wasSet(VEHPARS_FROM_TAZ_SET)) {
133         dev.writeAttr(SUMO_ATTR_FROM_TAZ, fromTaz);
134     }
135     // to TAZ
136     if (wasSet(VEHPARS_TO_TAZ_SET)) {
137         dev.writeAttr(SUMO_ATTR_TO_TAZ, toTaz);
138     }
139     // person number
140     if (wasSet(VEHPARS_PERSON_NUMBER_SET)) {
141         dev.writeAttr(SUMO_ATTR_PERSON_NUMBER, personNumber);
142     }
143     // container number
144     if (wasSet(VEHPARS_CONTAINER_NUMBER_SET)) {
145         dev.writeAttr(SUMO_ATTR_CONTAINER_NUMBER, containerNumber);
146     }
147 }
148 
149 
150 void
write(OutputDevice & dev) const151 SUMOVehicleParameter::Stop::write(OutputDevice& dev) const {
152     dev.openTag(SUMO_TAG_STOP);
153     if (busstop != "") {
154         dev.writeAttr(SUMO_ATTR_BUS_STOP, busstop);
155     }
156     if (containerstop != "") {
157         dev.writeAttr(SUMO_ATTR_CONTAINER_STOP, containerstop);
158     }
159     if (parkingarea != "") {
160         dev.writeAttr(SUMO_ATTR_PARKING_AREA, parkingarea);
161     }
162     if (busstop == "" && containerstop == "" && parkingarea == "") {
163         dev.writeAttr(SUMO_ATTR_LANE, lane);
164         if ((parametersSet & STOP_START_SET) != 0) {
165             dev.writeAttr(SUMO_ATTR_STARTPOS, startPos);
166         }
167         if ((parametersSet & STOP_END_SET) != 0) {
168             dev.writeAttr(SUMO_ATTR_ENDPOS, endPos);
169         }
170     }
171     if (duration >= 0) {
172         dev.writeAttr(SUMO_ATTR_DURATION, time2string(duration));
173     }
174     if (until >= 0) {
175         dev.writeAttr(SUMO_ATTR_UNTIL, time2string(until));
176     }
177     if ((parametersSet & STOP_TRIGGER_SET) != 0) {
178         dev.writeAttr(SUMO_ATTR_TRIGGERED, triggered);
179     }
180     if ((parametersSet & STOP_CONTAINER_TRIGGER_SET) != 0) {
181         dev.writeAttr(SUMO_ATTR_CONTAINER_TRIGGERED, containerTriggered);
182     }
183     if ((parametersSet & STOP_PARKING_SET) != 0) {
184         dev.writeAttr(SUMO_ATTR_PARKING, parking);
185     }
186     if ((parametersSet & STOP_EXPECTED_SET) != 0) {
187         dev.writeAttr(SUMO_ATTR_EXPECTED, awaitedPersons);
188     }
189     if ((parametersSet & STOP_EXPECTED_CONTAINERS_SET) != 0) {
190         dev.writeAttr(SUMO_ATTR_EXPECTED_CONTAINERS, awaitedContainers);
191     }
192     if ((parametersSet & STOP_TRIP_ID_SET) != 0) {
193         dev.writeAttr(SUMO_ATTR_TRIP_ID, tripId);
194     }
195     dev.closeTag();
196 }
197 
198 
199 bool
parseDepart(const std::string & val,const std::string & element,const std::string & id,SUMOTime & depart,DepartDefinition & dd,std::string & error)200 SUMOVehicleParameter::parseDepart(const std::string& val, const std::string& element, const std::string& id,
201                                   SUMOTime& depart, DepartDefinition& dd, std::string& error) {
202     if (val == "triggered") {
203         dd = DEPART_TRIGGERED;
204     } else if (val == "containerTriggered") {
205         dd = DEPART_CONTAINER_TRIGGERED;
206     } else if (val == "now") {
207         // only used via TraCI. depart must be set by the calling code
208         dd = DEPART_NOW;
209     } else {
210         try {
211             depart = string2time(val);
212             dd = DEPART_GIVEN;
213             if (depart < 0) {
214                 error = "Negative departure time in the definition of '" + id + "'.";
215                 return false;
216             }
217         } catch (...) {
218             error = "Invalid departure time for " + element + " '" + id + "';\n must be one of (\"triggered\", \"containerTriggered\", \"now\", or a float >= 0)";
219             return false;
220         }
221     }
222     return true;
223 }
224 
225 
226 bool
parseDepartLane(const std::string & val,const std::string & element,const std::string & id,int & lane,DepartLaneDefinition & dld,std::string & error)227 SUMOVehicleParameter::parseDepartLane(const std::string& val, const std::string& element, const std::string& id,
228                                       int& lane, DepartLaneDefinition& dld, std::string& error) {
229     bool ok = true;
230     if (val == "random") {
231         dld = DEPART_LANE_RANDOM;
232     } else if (val == "free") {
233         dld = DEPART_LANE_FREE;
234     } else if (val == "allowed") {
235         dld = DEPART_LANE_ALLOWED_FREE;
236     } else if (val == "best") {
237         dld = DEPART_LANE_BEST_FREE;
238     } else if (val == "first") {
239         dld = DEPART_LANE_FIRST_ALLOWED;
240     } else {
241         try {
242             lane = StringUtils::toInt(val);
243             dld = DEPART_LANE_GIVEN;
244             if (lane < 0) {
245                 ok = false;
246             }
247         } catch (...) {
248             ok = false;
249         }
250     }
251     if (!ok) {
252         error = "Invalid departLane definition for " + element + " '" + id + "';\n must be one of (\"random\", \"free\", \"allowed\", \"best\", \"first\", or an int>=0)";
253     }
254     return ok;
255 }
256 
257 
258 bool
parseDepartPos(const std::string & val,const std::string & element,const std::string & id,double & pos,DepartPosDefinition & dpd,std::string & error)259 SUMOVehicleParameter::parseDepartPos(const std::string& val, const std::string& element, const std::string& id,
260                                      double& pos, DepartPosDefinition& dpd, std::string& error) {
261     bool ok = true;
262     if (val == "random") {
263         dpd = DEPART_POS_RANDOM;
264     } else if (val == "random_free") {
265         dpd = DEPART_POS_RANDOM_FREE;
266     } else if (val == "free") {
267         dpd = DEPART_POS_FREE;
268     } else if (val == "base") {
269         dpd = DEPART_POS_BASE;
270     } else if (val == "last") {
271         dpd = DEPART_POS_LAST;
272     } else {
273         try {
274             pos = StringUtils::toDouble(val);
275             dpd = DEPART_POS_GIVEN;
276         } catch (...) {
277             ok = false;
278         }
279     }
280     if (!ok) {
281         error = "Invalid departPos definition for " + element + " '" + id + "';\n must be one of (\"random\", \"random_free\", \"free\", \"base\", \"last\" or a float)";
282     }
283     return ok;
284 }
285 
286 
287 bool
parseDepartPosLat(const std::string & val,const std::string & element,const std::string & id,double & pos,DepartPosLatDefinition & dpd,std::string & error)288 SUMOVehicleParameter::parseDepartPosLat(const std::string& val, const std::string& element, const std::string& id,
289                                         double& pos, DepartPosLatDefinition& dpd, std::string& error) {
290     bool ok = true;
291     if (val == "random") {
292         dpd = DEPART_POSLAT_RANDOM;
293     } else if (val == "random_free") {
294         dpd = DEPART_POSLAT_RANDOM_FREE;
295     } else if (val == "free") {
296         dpd = DEPART_POSLAT_FREE;
297     } else if (val == "right") {
298         dpd = DEPART_POSLAT_RIGHT;
299     } else if (val == "center") {
300         dpd = DEPART_POSLAT_CENTER;
301     } else if (val == "left") {
302         dpd = DEPART_POSLAT_LEFT;
303     } else {
304         try {
305             pos = StringUtils::toDouble(val);
306             dpd = DEPART_POSLAT_GIVEN;
307         } catch (...) {
308             ok = false;
309         }
310     }
311     if (!ok) {
312         error = "Invalid departPosLat definition for " + element + " '" + id + "';\n must be one of (\"random\", \"random_free\", \"free\", \"right\", \"center\", \"left\", or a float)";
313     }
314     return ok;
315 }
316 
317 
318 bool
parseDepartSpeed(const std::string & val,const std::string & element,const std::string & id,double & speed,DepartSpeedDefinition & dsd,std::string & error)319 SUMOVehicleParameter::parseDepartSpeed(const std::string& val, const std::string& element, const std::string& id,
320                                        double& speed, DepartSpeedDefinition& dsd, std::string& error) {
321     bool ok = true;
322     if (val == "random") {
323         dsd = DEPART_SPEED_RANDOM;
324     } else if (val == "max") {
325         dsd = DEPART_SPEED_MAX;
326     } else {
327         try {
328             speed = StringUtils::toDouble(val);
329             dsd = DEPART_SPEED_GIVEN;
330             if (speed < 0) {
331                 ok = false;
332             }
333         } catch (...) {
334             ok = false;
335         }
336     }
337     if (!ok) {
338         error = "Invalid departSpeed definition for " + element + " '" + id + "';\n must be one of (\"random\", \"max\", or a float>=0)";
339     }
340     return ok;
341 }
342 
343 
344 bool
parseArrivalLane(const std::string & val,const std::string & element,const std::string & id,int & lane,ArrivalLaneDefinition & ald,std::string & error)345 SUMOVehicleParameter::parseArrivalLane(const std::string& val, const std::string& element, const std::string& id,
346                                        int& lane, ArrivalLaneDefinition& ald, std::string& error) {
347     bool ok = true;
348     if (val == "current") {
349         ald = ARRIVAL_LANE_CURRENT;
350     } else {
351         try {
352             lane = StringUtils::toInt(val);
353             ald = ARRIVAL_LANE_GIVEN;
354             if (lane < 0) {
355                 ok = false;
356             }
357         } catch (...) {
358             ok = false;
359         }
360     }
361     if (!ok) {
362         error = "Invalid arrivalLane definition for " + element + " '" + id + "';\n must be one of (\"current\", or an int>=0)";
363     }
364     return ok;
365 }
366 
367 
368 bool
parseArrivalPos(const std::string & val,const std::string & element,const std::string & id,double & pos,ArrivalPosDefinition & apd,std::string & error)369 SUMOVehicleParameter::parseArrivalPos(const std::string& val, const std::string& element, const std::string& id,
370                                       double& pos, ArrivalPosDefinition& apd, std::string& error) {
371     bool ok = true;
372     if (val == "random") {
373         apd = ARRIVAL_POS_RANDOM;
374     } else if (val == "center") {
375         apd = ARRIVAL_POS_CENTER;
376     } else if (val == "max") {
377         apd = ARRIVAL_POS_MAX;
378     } else {
379         try {
380             pos = StringUtils::toDouble(val);
381             apd = ARRIVAL_POS_GIVEN;
382         } catch (...) {
383             ok = false;
384         }
385     }
386     if (!ok) {
387         error = "Invalid arrivalPos definition for " + element + " '" + id + "';\n must be one of (\"random\", \"max\", or a float)";
388     }
389     return ok;
390 }
391 
392 
393 bool
parseArrivalPosLat(const std::string & val,const std::string & element,const std::string & id,double & pos,ArrivalPosLatDefinition & apd,std::string & error)394 SUMOVehicleParameter::parseArrivalPosLat(const std::string& val, const std::string& element, const std::string& id,
395         double& pos, ArrivalPosLatDefinition& apd, std::string& error) {
396     bool ok = true;
397     if (val == "right") {
398         apd = ARRIVAL_POSLAT_RIGHT;
399     } else if (val == "center") {
400         apd = ARRIVAL_POSLAT_CENTER;
401     } else if (val == "left") {
402         apd = ARRIVAL_POSLAT_LEFT;
403     } else {
404         try {
405             pos = StringUtils::toDouble(val);
406             apd = ARRIVAL_POSLAT_GIVEN;
407         } catch (...) {
408             ok = false;
409         }
410     }
411     if (!ok) {
412         error = "Invalid arrivalPosLat definition for " + element + " '" + id + "';\n must be one of (\"right\", \"center\", \"left\", or a float)";
413     }
414     return ok;
415 }
416 
417 
418 bool
parseArrivalSpeed(const std::string & val,const std::string & element,const std::string & id,double & speed,ArrivalSpeedDefinition & asd,std::string & error)419 SUMOVehicleParameter::parseArrivalSpeed(const std::string& val, const std::string& element, const std::string& id,
420                                         double& speed, ArrivalSpeedDefinition& asd, std::string& error) {
421     bool ok = true;
422     if (val == "current") {
423         asd = ARRIVAL_SPEED_CURRENT;
424     } else {
425         try {
426             speed = StringUtils::toDouble(val);
427             if (speed < 0) {
428                 ok = false;
429             }
430             asd = ARRIVAL_SPEED_GIVEN;
431         } catch (...) {
432             ok = false;
433         }
434     }
435     if (!ok) {
436         error = "Invalid arrivalSpeed definition for " + element + " '" + id + "';\n must be one of (\"current\", or a float>=0)";
437     }
438     return ok;
439 }
440 
441 
442 double
interpretEdgePos(double pos,double maximumValue,SumoXMLAttr attr,const std::string & id)443 SUMOVehicleParameter::interpretEdgePos(double pos, double maximumValue, SumoXMLAttr attr, const std::string& id) {
444     if (pos < 0) {
445         pos = maximumValue + pos;
446     }
447     if (pos > maximumValue) {
448         WRITE_WARNING("Invalid " + toString(attr) + " " + toString(pos) + " given for " + id + ". Using edge end instead.");
449         pos = maximumValue;
450     }
451     return pos;
452 }
453 
454 
455 std::string
getDepart() const456 SUMOVehicleParameter::getDepart() const {
457     if (departProcedure == DEPART_TRIGGERED) {
458         return "triggered";
459     } else if (departProcedure == DEPART_CONTAINER_TRIGGERED) {
460         return "containerTriggered";
461     } else {
462         return time2string(depart);
463     }
464 }
465 
466 
467 std::string
getDepartLane() const468 SUMOVehicleParameter::getDepartLane() const {
469     std::string val;
470     switch (departLaneProcedure) {
471         case DEPART_LANE_GIVEN:
472             val = toString(departLane);
473             break;
474         case DEPART_LANE_RANDOM:
475             val = "random";
476             break;
477         case DEPART_LANE_FREE:
478             val = "free";
479             break;
480         case DEPART_LANE_ALLOWED_FREE:
481             val = "allowed";
482             break;
483         case DEPART_LANE_BEST_FREE:
484             val = "best";
485             break;
486         case DEPART_LANE_FIRST_ALLOWED:
487             val = "first";
488             break;
489         case DEPART_LANE_DEFAULT:
490         default:
491             break;
492     }
493     return val;
494 }
495 
496 
497 std::string
getDepartPos() const498 SUMOVehicleParameter::getDepartPos() const {
499     std::string val;
500     switch (departPosProcedure) {
501         case DEPART_POS_GIVEN:
502             val = toString(departPos);
503             break;
504         case DEPART_POS_RANDOM:
505             val = "random";
506             break;
507         case DEPART_POS_RANDOM_FREE:
508             val = "random_free";
509             break;
510         case DEPART_POS_FREE:
511             val = "free";
512             break;
513         case DEPART_POS_LAST:
514             val = "last";
515             break;
516         case DEPART_POS_BASE:
517             val = "base";
518             break;
519         case DEPART_POS_DEFAULT:
520         default:
521             break;
522     }
523     return val;
524 }
525 
526 
527 std::string
getDepartPosLat() const528 SUMOVehicleParameter::getDepartPosLat() const {
529     std::string val;
530     switch (departPosLatProcedure) {
531         case DEPART_POSLAT_GIVEN:
532             val = toString(departPos);
533             break;
534         case DEPART_POSLAT_RANDOM:
535             val = "random";
536             break;
537         case DEPART_POSLAT_RANDOM_FREE:
538             val = "random_free";
539             break;
540         case DEPART_POSLAT_FREE:
541             val = "free";
542             break;
543         case DEPART_POSLAT_RIGHT:
544             val = "right";
545             break;
546         case DEPART_POSLAT_CENTER:
547             val = "center";
548             break;
549         case DEPART_POSLAT_LEFT:
550             val = "left";
551             break;
552         case DEPART_POSLAT_DEFAULT:
553         default:
554             break;
555     }
556     return val;
557 }
558 
559 
560 std::string
getDepartSpeed() const561 SUMOVehicleParameter::getDepartSpeed() const {
562     std::string val;
563     switch (departSpeedProcedure) {
564         case DEPART_SPEED_GIVEN:
565             val = toString(departSpeed);
566             break;
567         case DEPART_SPEED_RANDOM:
568             val = "random";
569             break;
570         case DEPART_SPEED_MAX:
571             val = "max";
572             break;
573         case DEPART_SPEED_DEFAULT:
574         default:
575             break;
576     }
577     return val;
578 }
579 
580 
581 std::string
getArrivalLane() const582 SUMOVehicleParameter::getArrivalLane() const {
583     std::string val;
584     switch (arrivalLaneProcedure) {
585         case ARRIVAL_LANE_GIVEN:
586             val = toString(arrivalLane);
587             break;
588         case ARRIVAL_LANE_CURRENT:
589             val = "current";
590             break;
591         case ARRIVAL_LANE_DEFAULT:
592         default:
593             break;
594     }
595     return val;
596 }
597 
598 
599 std::string
getArrivalPos() const600 SUMOVehicleParameter::getArrivalPos() const {
601     std::string val;
602     switch (arrivalPosProcedure) {
603         case ARRIVAL_POS_GIVEN:
604             val = toString(arrivalPos);
605             break;
606         case ARRIVAL_POS_RANDOM:
607             val = "random";
608             break;
609         case ARRIVAL_POS_CENTER:
610             val = "center";
611             break;
612         case ARRIVAL_POS_MAX:
613             val = "max";
614             break;
615         case ARRIVAL_POS_DEFAULT:
616         default:
617             break;
618     }
619     return val;
620 }
621 
622 
623 std::string
getArrivalPosLat() const624 SUMOVehicleParameter::getArrivalPosLat() const {
625     std::string val;
626     switch (arrivalPosLatProcedure) {
627         case ARRIVAL_POSLAT_GIVEN:
628             val = toString(arrivalPos);
629             break;
630         case ARRIVAL_POSLAT_RIGHT:
631             val = "right";
632             break;
633         case ARRIVAL_POSLAT_CENTER:
634             val = "center";
635             break;
636         case ARRIVAL_POSLAT_LEFT:
637             val = "left";
638             break;
639         case ARRIVAL_POSLAT_DEFAULT:
640         default:
641             break;
642     }
643     return val;
644 }
645 
646 
647 std::string
getArrivalSpeed() const648 SUMOVehicleParameter::getArrivalSpeed() const {
649     std::string val;
650     switch (arrivalSpeedProcedure) {
651         case ARRIVAL_SPEED_GIVEN:
652             val = toString(arrivalSpeed);
653             break;
654         case ARRIVAL_SPEED_CURRENT:
655             val = "current";
656             break;
657         case ARRIVAL_SPEED_DEFAULT:
658         default:
659             break;
660     }
661     return val;
662 }
663 
664 /****************************************************************************/
665