Eclipse SUMO - Simulation of Urban MObility
MSTransportable.h
Go to the documentation of this file.
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 /****************************************************************************/
15 // The common superclass for modelling transportable objects like persons and containers
16 /****************************************************************************/
17 #ifndef MSTransportable_h
18 #define MSTransportable_h
19 
20 // ===========================================================================
21 // included modules
22 // ===========================================================================
23 #include <config.h>
24 
25 #include <set>
26 #include <cassert>
27 #include <utils/common/SUMOTime.h>
29 #include <utils/geom/Position.h>
31 #include <utils/geom/Boundary.h>
34 
35 
36 // ===========================================================================
37 // class declarations
38 // ===========================================================================
39 class MSEdge;
40 class MSLane;
41 class MSNet;
42 class MSStoppingPlace;
43 class MSVehicleType;
44 class OutputDevice;
46 class SUMOVehicle;
48 
49 typedef std::vector<const MSEdge*> ConstMSEdgeVector;
50 
51 // ===========================================================================
52 // class definitions
53 // ===========================================================================
60 public:
61  enum StageType {
63  WAITING = 1,
64  MOVING_WITHOUT_VEHICLE = 2, // walking for persons, tranship for containers
65  DRIVING = 3,
66  ACCESS = 4,
67  TRIP = 5
68  };
69 
74  class Stage {
75  public:
77  Stage(const MSEdge* destination, MSStoppingPlace* toStop, const double arrivalPos, StageType type);
78 
80  virtual ~Stage();
81 
83  const MSEdge* getDestination() const;
84 
87  return myDestinationStop;
88  }
89 
91  virtual const MSStoppingPlace* getOriginStop() const {
92  return nullptr;
93  }
94 
95  double getArrivalPos() const {
96  return myArrivalPos;
97  }
98 
100  virtual const MSEdge* getEdge() const;
101  virtual const MSEdge* getFromEdge() const;
102  virtual double getEdgePos(SUMOTime now) const;
103 
105  virtual Position getPosition(SUMOTime now) const = 0;
106 
108  virtual double getAngle(SUMOTime now) const = 0;
109 
112  return myType;
113  }
114 
116  virtual std::string getStageDescription() const = 0;
117 
119  virtual std::string getStageSummary() const = 0;
120 
122  virtual void proceed(MSNet* net, MSTransportable* transportable, SUMOTime now, Stage* previous) = 0;
123 
125  virtual void abort(MSTransportable*) {};
126 
128  virtual void setSpeed(double) {};
129 
131  SUMOTime getDeparted() const;
132 
134  void setDeparted(SUMOTime now);
135 
137  virtual void setArrived(MSNet* net, MSTransportable* transportable, SUMOTime now);
138 
140  virtual bool isWaitingFor(const SUMOVehicle* vehicle) const;
141 
143  virtual bool isWaiting4Vehicle() const {
144  return false;
145  }
146 
148  virtual SUMOVehicle* getVehicle() const {
149  return nullptr;
150  }
151 
153  virtual SUMOTime getWaitingTime(SUMOTime now) const;
154 
156  virtual double getSpeed() const;
157 
159  virtual ConstMSEdgeVector getEdges() const;
160 
162  Position getEdgePosition(const MSEdge* e, double at, double offset) const;
163 
165  Position getLanePosition(const MSLane* lane, double at, double offset) const;
166 
168  double getEdgeAngle(const MSEdge* e, double at) const;
169 
170  void setDestination(const MSEdge* newDestination, MSStoppingPlace* newDestStop);
171 
173  virtual double getDistance() const = 0;
174 
179  virtual void tripInfoOutput(OutputDevice& os, const MSTransportable* const transportable) const = 0;
180 
186  virtual void routeOutput(OutputDevice& os, const bool withRouteLength) const = 0;
187 
192  virtual void beginEventOutput(const MSTransportable& transportable, SUMOTime t, OutputDevice& os) const = 0;
193 
198  virtual void endEventOutput(const MSTransportable& transportable, SUMOTime t, OutputDevice& os) const = 0;
199 
200  virtual Stage* clone() const = 0;
201 
202  protected:
205 
208 
210  double myArrivalPos;
211 
214 
217 
220 
221  private:
223  Stage(const Stage&);
224 
226  Stage& operator=(const Stage&);
227 
228  };
229 
233  class Stage_Trip : public Stage {
234  public:
236  Stage_Trip(const MSEdge* origin, MSStoppingPlace* fromStop,
237  const MSEdge* destination, MSStoppingPlace* toStop,
238  const SUMOTime duration, const SVCPermissions modeSet,
239  const std::string& vTypes, const double speed, const double walkFactor,
240  const double departPosLat, const bool hasArrivalPos, const double arrivalPos);
241 
243  virtual ~Stage_Trip();
244 
245  Stage* clone() const;
246 
247  const MSEdge* getEdge() const;
248 
250  return myOriginStop;
251  }
252 
253  double getEdgePos(SUMOTime now) const;
254 
255  Position getPosition(SUMOTime now) const;
256 
257  double getAngle(SUMOTime now) const;
258 
259  double getDistance() const {
260  // invalid
261  return -1;
262  }
263 
264  std::string getStageDescription() const {
265  return "trip";
266  }
267 
268  std::string getStageSummary() const;
269 
271  virtual void setArrived(MSNet* net, MSTransportable* transportable, SUMOTime now);
272 
274  void setOrigin(const MSEdge* origin) {
275  myOrigin = origin;
276  }
277 
279  virtual void proceed(MSNet* net, MSTransportable* transportable, SUMOTime now, Stage* previous);
280 
286  virtual void tripInfoOutput(OutputDevice& os, const MSTransportable* const transportable) const;
287 
293  virtual void routeOutput(OutputDevice& os, const bool withRouteLength) const;
294 
299  virtual void beginEventOutput(const MSTransportable& p, SUMOTime t, OutputDevice& os) const;
300 
305  virtual void endEventOutput(const MSTransportable& p, SUMOTime t, OutputDevice& os) const;
306 
307  private:
309  const MSEdge* myOrigin;
310 
313 
316 
319 
321  const std::string myVTypes;
322 
324  const double mySpeed;
325 
327  const double myWalkFactor;
328 
330  double myDepartPos;
331 
333  const double myDepartPosLat;
334 
336  const bool myHaveArrivalPos;
337 
338  private:
340  Stage_Trip(const Stage_Trip&);
341 
344 
345  };
346 
350  class Stage_Waiting : public Stage {
351  public:
353  Stage_Waiting(const MSEdge* destination, MSStoppingPlace* toStop, SUMOTime duration, SUMOTime until,
354  double pos, const std::string& actType, const bool initial);
355 
357  virtual ~Stage_Waiting();
358 
359  Stage* clone() const;
360 
362  void abort(MSTransportable*);
363 
364  SUMOTime getUntil() const;
365 
367  Position getPosition(SUMOTime now) const;
368 
369  double getAngle(SUMOTime now) const;
370 
372  double getDistance() const {
373  return 0;
374  }
375 
376  SUMOTime getWaitingTime(SUMOTime now) const;
377 
378  std::string getStageDescription() const {
379  return "waiting (" + myActType + ")";
380  }
381 
382  std::string getStageSummary() const;
383 
385  virtual void proceed(MSNet* net, MSTransportable* transportable, SUMOTime now, Stage* previous);
386 
392  virtual void tripInfoOutput(OutputDevice& os, const MSTransportable* const transportable) const;
393 
399  virtual void routeOutput(OutputDevice& os, const bool withRouteLength) const;
400 
405  virtual void beginEventOutput(const MSTransportable& p, SUMOTime t, OutputDevice& os) const;
406 
411  virtual void endEventOutput(const MSTransportable& p, SUMOTime t, OutputDevice& os) const;
412 
413  private:
416 
419 
421  std::string myActType;
422 
423  private:
426 
429 
430  };
431 
436  class Stage_Driving : public Stage {
437  public:
439  Stage_Driving(const MSEdge* destination, MSStoppingPlace* toStop,
440  const double arrivalPos, const std::vector<std::string>& lines,
441  const std::string& intendedVeh = "", SUMOTime intendedDepart = -1);
442 
444  virtual ~Stage_Driving();
445 
447  void abort(MSTransportable*);
448 
450  const MSEdge* getEdge() const;
451  const MSEdge* getFromEdge() const;
452  double getEdgePos(SUMOTime now) const;
453 
455  Position getPosition(SUMOTime now) const;
456 
457  double getAngle(SUMOTime now) const;
458 
460  double getDistance() const {
461  return myVehicleDistance;
462  }
463 
465  bool isWaitingFor(const SUMOVehicle* vehicle) const;
466 
468  bool isWaiting4Vehicle() const;
469 
471  std::string getWaitingDescription() const;
472 
474  return myVehicle;
475  }
476 
478  SUMOTime getWaitingTime(SUMOTime now) const;
479 
480  double getSpeed() const;
481 
482  ConstMSEdgeVector getEdges() const;
483 
484  void setVehicle(SUMOVehicle* v);
485 
487  void setArrived(MSNet* net, MSTransportable* transportable, SUMOTime now);
488 
493  virtual void beginEventOutput(const MSTransportable& p, SUMOTime t, OutputDevice& os) const;
494 
499  virtual void endEventOutput(const MSTransportable& p, SUMOTime t, OutputDevice& os) const;
500 
501  const std::set<std::string>& getLines() const {
502  return myLines;
503  }
504 
505  std::string getIntendedVehicleID() const {
506  return myIntendedVehicleID;
507  }
508 
510  return myIntendedDepart;
511  }
512 
513  protected:
515  const std::set<std::string> myLines;
516 
520  std::string myVehicleID;
521  std::string myVehicleLine;
522 
525 
526  double myWaitingPos;
531 
532  std::string myIntendedVehicleID;
534 
535  private:
538 
541 
542  };
543 
546  bool isVehicle() const {
547  return false;
548  }
549 
550  bool isStopped() const {
551  return getCurrentStageType() == WAITING;
552  }
553 
554  double getSlope() const;
555 
556  double getChosenSpeedFactor() const {
557  return 1.0;
558  }
559 
560  SUMOVehicleClass getVClass() const;
561 
562  double getMaxSpeed() const;
563 
564  SUMOTime getWaitingTime() const;
565 
566  double getPreviousSpeed() const {
567  return getSpeed();
568  }
569 
570  double getAcceleration() const {
571  return 0.0;
572  }
573 
574  double getPositionOnLane() const {
575  return getEdgePos();
576  }
577 
578  double getBackPositionOnLane(const MSLane* /*lane*/) const {
579  return getEdgePos();
580  }
581 
582  Position getPosition(const double /*offset*/) const {
583  return getPosition();
584  }
586 
588  typedef std::vector<MSTransportable::Stage*> MSTransportablePlan;
589 
591  MSTransportable(const SUMOVehicleParameter* pars, MSVehicleType* vtype, MSTransportablePlan* plan);
592 
594  virtual ~MSTransportable();
595 
596  /* @brief proceeds to the next step of the route,
597  * @return Whether the transportables plan continues */
598  virtual bool proceed(MSNet* net, SUMOTime time) = 0;
599 
601  const std::string& getID() const;
602 
603  inline const SUMOVehicleParameter& getParameter() const {
604  return *myParameter;
605  }
606 
607  inline const MSVehicleType& getVehicleType() const {
608  return *myVType;
609  }
610 
612  SUMOTime getDesiredDepart() const;
613 
615  void setDeparted(SUMOTime now);
616 
618  const MSEdge* getDestination() const {
619  return (*myStep)->getDestination();
620  }
621 
623  const MSEdge* getNextDestination() const {
624  return (*(myStep + 1))->getDestination();
625  }
626 
628  const MSEdge* getEdge() const {
629  return (*myStep)->getEdge();
630  }
631 
633  const MSEdge* getFromEdge() const {
634  return (*myStep)->getFromEdge();
635  }
636 
638  virtual double getEdgePos() const;
639 
641  virtual Position getPosition() const;
642 
644  virtual double getAngle() const;
645 
647  virtual double getWaitingSeconds() const;
648 
650  virtual double getSpeed() const;
651 
653  virtual double getSpeedFactor() const {
654  return 1;
655  }
656 
659  return (*myStep)->getStageType();
660  }
661 
663  StageType getStageType(int next) const {
664  assert(myStep + next < myPlan->end());
665  assert(myStep + next >= myPlan->begin());
666  return (*(myStep + next))->getStageType();
667  }
668 
670  std::string getStageSummary(int stageIndex) const;
671 
673  std::string getCurrentStageDescription() const {
674  return (*myStep)->getStageDescription();
675  }
676 
679  return *myStep;
680  }
681 
684  assert(myStep + next >= myPlan->begin());
685  assert(myStep + next < myPlan->end());
686  return *(myStep + next);
687  }
688 
690  ConstMSEdgeVector getEdges(int next) const {
691  assert(myStep + next < myPlan->end());
692  assert(myStep + next >= myPlan->begin());
693  return (*(myStep + next))->getEdges();
694  }
695 
697  int getNumRemainingStages() const;
698 
700  int getNumStages() const;
701 
707  virtual void tripInfoOutput(OutputDevice& os) const = 0;
708 
714  virtual void routeOutput(OutputDevice& os, const bool withRouteLength) const = 0;
715 
717  bool isWaitingFor(const SUMOVehicle* vehicle) const {
718  return (*myStep)->isWaitingFor(vehicle);
719  }
720 
722  bool isWaiting4Vehicle() const {
723  return (*myStep)->isWaiting4Vehicle();
724  }
725 
728  return (*myStep)->getVehicle();
729  }
730 
732  void appendStage(Stage* stage, int next = -1);
733 
735  void removeStage(int next);
736 
738  void setSpeed(double speed);
739 
741  double getArrivalPos() const {
742  return myPlan->back()->getArrivalPos();
743  }
744 
746  const MSEdge* getArrivalEdge() const {
747  return myPlan->back()->getEdges().back();
748  }
749 
758  void replaceVehicleType(MSVehicleType* type);
759 
760 
769 
770 
773 
775  bool hasArrived() const;
776 
778  bool hasDeparted() const;
779 
781  void rerouteParkingArea(MSStoppingPlace* orig, MSStoppingPlace* replacement);
782 
784  MSTransportableDevice* getDevice(const std::type_info& type) const;
785 
789  inline const std::vector<MSTransportableDevice*>& getDevices() const {
790  return myDevices;
791  }
792 
793 protected:
795  static const double ROADSIDE_OFFSET;
796 
799 
803 
806 
808  MSTransportablePlan* myPlan;
809 
811  MSTransportablePlan::iterator myStep;
812 
814  std::vector<MSTransportableDevice*> myDevices;
815 
816 private:
819 
822 
823 };
824 
825 
826 #endif
827 
828 /****************************************************************************/
double getAcceleration() const
Returns the vehicle&#39;s acceleration.
SUMOVehicle * getVehicle() const
The vehicle associated with this transportable.
Stage(const MSEdge *destination, MSStoppingPlace *toStop, const double arrivalPos, StageType type)
constructor
double getDistance() const
get travel distance in this stage
double getPositionOnLane() const
Get the vehicle&#39;s position along the lane.
long long int SUMOTime
Definition: SUMOTime.h:35
std::string myActType
The type of activity.
virtual const MSEdge * getFromEdge() const
double getArrivalPos() const
returns the final arrival pos
virtual void setArrived(MSNet *net, MSTransportable *transportable, SUMOTime now)
logs end of the step
virtual double getDistance() const =0
get travel distance in this stage
double getMaxSpeed() const
Returns the vehicle&#39;s maximum speed.
virtual void beginEventOutput(const MSTransportable &transportable, SUMOTime t, OutputDevice &os) const =0
Called for writing the events output (begin of an action)
virtual double getAngle(SUMOTime now) const =0
returns the angle of the transportable
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
const std::vector< MSTransportableDevice * > & getDevices() const
Returns this vehicle&#39;s devices.
const MSEdge * getEdge() const
Returns the current edge.
const SVCPermissions myModeSet
The allowed modes of transportation.
A lane area vehicles can halt at.
double getPreviousSpeed() const
Returns the vehicle&#39;s previous speed.
std::vector< const MSEdge * > ConstMSEdgeVector
bool hasArrived() const
return whether the person has reached the end of its plan
PositionVector getBoundingBox() const
return the bounding box of the person
const MSEdge * getDestination() const
returns the destination edge
const std::set< std::string > & getLines() const
virtual const MSEdge * getEdge() const
Returns the current edge.
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
virtual double getEdgePos(SUMOTime now) const
double getSlope() const
Returns the slope of the road at vehicle&#39;s position.
virtual void abort(MSTransportable *)
abort this stage (TraCI)
virtual Stage * clone() const =0
Stage & operator=(const Stage &)
Invalidated assignment operator.
virtual void setSpeed(double)
sets the walking speed (ignored in other stages)
double getDistance() const
get travel distance in this stage
bool isVehicle() const
Get the vehicle&#39;s ID.
const std::set< std::string > myLines
the lines to choose from
double getDistance() const
get travel distance in this stage
std::vector< const MSEdge * > ConstMSEdgeVector
Definition: MSEdge.h:73
SUMOTime myDuration
the time the trip should take (applies to only walking)
Position getLanePosition(const MSLane *lane, double at, double offset) const
get position on lane at length at with orthogonal offset
const MSEdge * myDestination
the next edge to reach by getting transported
double getChosenSpeedFactor() const
MSStoppingPlace * myDestinationStop
the stop to reach by getting transported (if any)
ConstMSEdgeVector getEdges(int next) const
Return the edges of the nth next stage.
const SUMOVehicleParameter & getParameter() const
MSTransportablePlan::iterator myStep
the iterator over the route
SUMOVehicleClass getVClass() const
Returns the vehicle&#39;s access class.
int getNumRemainingStages() const
Return the number of remaining stages (including the current)
The simulated network and simulation perfomer.
Definition: MSNet.h:92
The car-following model and parameter.
Definition: MSVehicleType.h:66
const SUMOVehicleParameter * myParameter
the plan of the transportable
void removeStage(int next)
removes the nth next stage
bool myWriteEvents
Whether events shall be written.
const MSEdge * getFromEdge() const
Returns the departure edge.
SUMOTime myWaitingSince
The time since which this person is waiting for a ride.
MSVehicleType & getSingularType()
Replaces the current vehicle type with a new one used by this vehicle only.
A road/street connecting two junctions.
Definition: MSEdge.h:76
double myDepartPos
The depart position.
const double myWalkFactor
The factor to apply to walking durations.
std::vector< MSTransportable::Stage * > MSTransportablePlan
the structure holding the plan of a transportable
virtual ConstMSEdgeVector getEdges() const
the edges of the current stage
MSTransportable::Stage * getCurrentStage() const
Return the current stage.
std::vector< MSTransportableDevice * > myDevices
The devices this transportable has.
virtual Position getPosition(SUMOTime now) const =0
returns the position of the transportable
MSTransportable::Stage * getNextStage(int next) const
Return the current stage.
virtual SUMOTime getWaitingTime(SUMOTime now) const
the time this transportable spent waiting
MSVehicleType * myVType
This transportable&#39;s type. (mainly used for drawing related information Note sure if it is really nec...
SUMOTime myArrived
the time at which this stage ended
SUMOTime myDeparted
the time at which this stage started
Representation of a vehicle.
Definition: SUMOVehicle.h:61
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:39
SUMOTime getDesiredDepart() const
Returns the desired departure time.
A list of positions.
virtual SUMOVehicle * getVehicle() const
Whether the transportable waits for a vehicle.
virtual void proceed(MSNet *net, MSTransportable *transportable, SUMOTime now, Stage *previous)=0
proceeds to this stage
bool hasDeparted() const
return whether the transportable has started it&#39;s plan
SUMOTime getDeparted() const
get departure time of stage
virtual ~MSTransportable()
destructor
Abstract in-person device.
bool isWaiting4Vehicle() const
Whether the transportable waits for a vehicle.
double getArrivalPos() const
std::string myVehicleID
cached vehicle data for output after the vehicle has been removed
const std::string & getID() const
returns the id of the transportable
const double mySpeed
The walking speed.
SUMOTime myWaitingUntil
the time until the person is waiting
SUMOVehicle * myVehicle
The taken vehicle.
std::string getIntendedVehicleID() const
virtual std::string getStageDescription() const =0
return (brief) string representation of the current stage
std::string getStageDescription() const
return (brief) string representation of the current stage
const MSEdge * getNextDestination() const
Returns the destination after the current destination.
virtual const MSStoppingPlace * getOriginStop() const
returns the origin stop (if any). only needed for Stage_Trip
Position getEdgePosition(const MSEdge *e, double at, double offset) const
get position on edge e at length at with orthogonal offset
virtual double getSpeed() const
the speed of the transportable
MSStoppingPlace * getDestinationStop() const
returns the destination stop (if any)
virtual double getSpeedFactor() const
the current speed factor of the transportable (where applicable)
void appendStage(Stage *stage, int next=-1)
Appends the given stage to the current plan.
std::string getCurrentStageDescription() const
Returns the current stage description as a string.
void rerouteParkingArea(MSStoppingPlace *orig, MSStoppingPlace *replacement)
adapt plan when the vehicle reroutes and now stops at replacement instead of orig ...
std::string getStageDescription() const
return (brief) string representation of the current stage
StageType myType
The type of this stage.
Structure representing possible vehicle parameter.
virtual void tripInfoOutput(OutputDevice &os, const MSTransportable *const transportable) const =0
Called on writing tripinfo output.
Representation of a vehicle or person.
MSTransportable(const SUMOVehicleParameter *pars, MSVehicleType *vtype, MSTransportablePlan *plan)
constructor
virtual void endEventOutput(const MSTransportable &transportable, SUMOTime t, OutputDevice &os) const =0
Called for writing the events output (end of an action)
void setOrigin(const MSEdge *origin)
change origin for parking area rerouting
MSTransportableDevice * getDevice(const std::type_info &type) const
Returns a device of the given type if it exists or 0.
SUMOVehicle * getVehicle() const
Whether the transportable waits for a vehicle.
StageType getStageType() const
static const double ROADSIDE_OFFSET
the offset for computing positions when standing at an edge
const MSEdge * myOrigin
the origin edge
StageType getStageType(int next) const
the stage type for the nth next stage
void replaceVehicleType(MSVehicleType *type)
Replaces the current vehicle type by the one given.
double getBackPositionOnLane(const MSLane *) const
Get the vehicle&#39;s back position along the given lane.
virtual void routeOutput(OutputDevice &os, const bool withRouteLength) const =0
Called on writing vehroute output.
virtual std::string getStageSummary() const =0
return string summary of the current stage
const std::string myVTypes
The possible vehicles to use.
double getEdgeAngle(const MSEdge *e, double at) const
get angle of the edge at a certain position
const MSEdge * getArrivalEdge() const
returns the final arrival edge
virtual bool isWaitingFor(const SUMOVehicle *vehicle) const
Whether the transportable waits for the given vehicle.
const MSVehicleType & getVehicleType() const
Returns the vehicle&#39;s type.
virtual double getWaitingSeconds() const
the time this transportable spent waiting in seconds
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:64
Position getPosition(const double) const
Return current position (x/y, cartesian)
void setDeparted(SUMOTime now)
logs end of the step
const double myDepartPosLat
The lateral depart position.
virtual bool isWaiting4Vehicle() const
Whether the transportable waits for a vehicle.
bool isStopped() const
Returns whether the vehicle is at a stop.
const MSEdge * getDestination() const
Returns the current destination.
MSTransportablePlan * myPlan
the plan of the transportable
virtual ~Stage()
destructor
const bool myHaveArrivalPos
whether an arrivalPos was in the input
const MSStoppingPlace * myOriginStop
the origin edge
Representation of a lane in the micro simulation.
Definition: MSLane.h:83
const MSStoppingPlace * getOriginStop() const
returns the origin stop (if any). only needed for Stage_Trip
SUMOTime myWaitingDuration
the time the person is waiting
int getNumStages() const
Return the total number stages in this persons plan.
double myArrivalPos
the position at which we want to arrive
bool isWaitingFor(const SUMOVehicle *vehicle) const
Whether the transportable waits for the given vehicle in the current step.
StageType getCurrentStageType() const
the current stage type of the transportable
void setDestination(const MSEdge *newDestination, MSStoppingPlace *newDestStop)