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