MSStageDriving.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2026 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// A stage performing the travelling by a transport system (cars, public transport)
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <set>
#include <cassert>
#include <utils/common/Command.h>
#include <utils/common/SUMOTime.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/geom/Position.h>
#include <utils/geom/PositionVector.h>
#include <utils/geom/Boundary.h>
#include <utils/router/SUMOAbstractRouter.h>
#include <utils/vehicle/SUMOTrafficObject.h>
#include "MSStage.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSLane;
class MSNet;
class MSStop;
class MSStoppingPlace;
class MSVehicleType;
class OutputDevice;
class SUMOVehicleParameter;
class SUMOVehicle;
class MSTransportableDevice;
class MSTransportable;
 
typedef std::vector<const MSEdge*> ConstMSEdgeVector;
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSStageDriving : public MSStage {
public:
    MSStageDriving(const MSEdge* origin, const MSEdge* destination, MSStoppingPlace* toStop,
                   const double arrivalPos, const double arrivalPosLat, const std::vector<std::string>& lines,
                   const std::string& group = "",
                   const std::string& intendedVeh = "", SUMOTime intendedDepart = -1);

    virtual ~MSStageDriving();
 
    MSStage* clone() const;

    double getArrivalPos() const;

    void abort(MSTransportable* t);

    void init(MSTransportable* transportable);

    const MSEdge* getEdge() const;
    const MSEdge* getFromEdge() const;
    double getEdgePos(SUMOTime now) const;

    int getDirection() const;
 
    const MSLane* getLane() const;
 
    MSStoppingPlace* getOriginStop() const {
        return myOriginStop;
    }

    Position getPosition(SUMOTime now) const;
 
    double getAngle(SUMOTime now) const;

    double getDistance() const;

    std::string getStageDescription(const bool isPerson) const;

    std::string getStageSummary(const bool isPerson) const;

    void proceed(MSNet* net, MSTransportable* transportable, SUMOTime now, MSStage* previous);

    void tripInfoOutput(OutputDevice& os, const MSTransportable* const transportable) const;

    void routeOutput(const bool isPerson, OutputDevice& os, const bool withRouteLength, const MSStage* const previous, const bool withTiming, const bool saveState = false) const;

    bool isWaitingFor(const SUMOVehicle* vehicle) const;

    bool isWaiting4Vehicle() const;

    std::string getWaitingDescription() const;
 
    SUMOVehicle* getVehicle() const {
        return myVehicle;
    }

    SUMOTime getWaitingTime(SUMOTime now) const;
 
    double getSpeed() const;
 
    ConstMSEdgeVector getEdges() const;
 
    void setVehicle(SUMOVehicle* v);
    void setVehicleID(const std::string vehID) {
        myVehicleID = vehID;
    }

    const std::string setArrived(MSNet* net, MSTransportable* transportable, SUMOTime now, const bool vehicleArrived);
 
    const std::set<std::string>& getLines() const {
        return myLines;
    }
 
    std::string getIntendedVehicleID() const {
        return myIntendedVehicleID;
    }
 
    SUMOTime getIntendedDepart() const {
        return myIntendedDepart;
    }
 
    std::string getVehicleType() const {
        return myVehicleType;
    }

    void setOrigin(const MSEdge* origin, MSStoppingPlace* originStop, double departPos) {
        myOrigin = origin;
        myOriginStop = originStop;
        myWaitingPos = departPos;
    }

    void setWaitingSince(SUMOTime t) {
        myWaitingSince = t;
    }

    void setVehicleDistance(double dist) {
        myVehicleDistance = dist;
    }

    bool canLeaveVehicle(const MSTransportable* t, const SUMOVehicle& veh, const MSStop& stop);
 
    SUMOTime getTimeLoss(const MSTransportable* transportable) const;
    SUMOTime getDuration() const;
    SUMOTime getTravelTime() const;
    SUMOTime getWaitingTime() const;

    void saveState(std::ostringstream& out, MSTransportable* transportable);

    void loadState(MSTransportable* transportable, std::istringstream& state);
 
    bool equals(const MSStage& s) const {
        if (!MSStage::equals(s)) {
            return false;
        }
        // this is safe because MSStage already checked that the type fits
        const MSStageDriving& sd = static_cast<const MSStageDriving&>(s);
        return myOrigin == sd.myOrigin &&
               myLines == sd.myLines &&
               myIntendedVehicleID == sd.myIntendedVehicleID;
    }
 
protected:
    const MSEdge* myOrigin;

    const std::set<std::string> myLines;

    SUMOVehicle* myVehicle;
    std::string myVehicleID;
    std::string myVehicleLine;
    std::string myVehicleType;
 
    SUMOVehicleClass myVehicleVClass;
    double myVehicleDistance;
    SUMOTime myTimeLoss;
 
    double myWaitingPos;
    SUMOTime myWaitingSince;
    const MSEdge* myWaitingEdge;
    Position myStopWaitPos;
    MSStoppingPlace* myOriginStop;
 
    std::string myIntendedVehicleID;
    SUMOTime myIntendedDepart;
    double myReservationWaitingPos = INVALID_DOUBLE;
 
private:
    void registerWaiting(MSTransportable* transportable, SUMOTime now);
 
private:
    MSStageDriving(const MSStageDriving&);

    MSStageDriving& operator=(const MSStageDriving&) = delete;
 
private:
    class BookReservation : public Command {
    public:
        BookReservation(MSTransportable* transportable, SUMOTime earliestPickupTime, MSStageDriving* stage) :
            myTransportable(transportable), myEarliestPickupTime(earliestPickupTime), myStage(stage), myWaitingPos(stage->myWaitingPos) {}
        SUMOTime execute(SUMOTime currentTime);
 
    public:
        MSTransportable* myTransportable;
        SUMOTime myEarliestPickupTime;
        MSStageDriving* myStage;
        double myWaitingPos;
    };
};