MSStage.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 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
/****************************************************************************/
// The common superclass for modelling transportable objects like persons and containers
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <set>
#include <cassert>
#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>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSLane;
class MSNet;
class MSStoppingPlace;
class MSVehicleType;
class OutputDevice;
class SUMOVehicleParameter;
class SUMOVehicle;
class MSStageTrip;
class MSTransportableDevice;
class MSTransportable;
class MSTransportableStateAdapter;
 
typedef std::vector<const MSEdge*> ConstMSEdgeVector;
 
// ===========================================================================
// class definitions
// ===========================================================================
enum class MSStageType {
    WAITING_FOR_DEPART = 0,
    WAITING = 1,
    WALKING = 2, // only for persons
    DRIVING = 3,
    ACCESS = 4,
    TRIP = 5,
    TRANSHIP = 6
};

class MSStage : public Parameterised {
public:
    static const double ARRIVALPOS_UNSPECIFIED;

    MSStage(const MSStageType type, const MSEdge* destination, MSStoppingPlace* toStop, const double arrivalPos,
            const double arrivalPosLat = 0.0, const std::string& group = "");

    virtual ~MSStage();

    virtual void init(MSTransportable* /*transportable*/) {};

    const MSEdge* getDestination() const;

    MSStoppingPlace* getDestinationStop() const {
        return myDestinationStop;
    }

    virtual MSStoppingPlace* getOriginStop() const {
        return nullptr;
    }
 
    virtual double getArrivalPos() const {
        return myArrivalPos;
    }
 
    bool unspecifiedArrivalPos() const;
 
 
    virtual double getArrivalPosLat() const {
        return myArrivalPosLat;
    }
 
    void setArrivalPos(double arrivalPos) {
        myArrivalPos = arrivalPos;
    }

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

    virtual int getDirection() const;

    virtual Position getPosition(SUMOTime now) const = 0;

    virtual double getAngle(SUMOTime now) const = 0;

    virtual const MSLane* getLane() const {
        return nullptr;
    }

    virtual SUMOTime getJumpDuration() const {
        return -1;
    }

    MSStageType getStageType() const {
        return myType;
    }

    const std::string& getGroup() const {
        return myGroup;
    }

    virtual std::string getStageDescription(const bool isPerson) const = 0;

    virtual std::string getStageSummary(const bool isPerson) const = 0;

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

    virtual void abort(MSTransportable*) {};

    virtual void setSpeed(double) {};

    SUMOTime getDeparted() const;

    SUMOTime getArrived() const;
 
    virtual SUMOTime getTimeLoss(const MSTransportable* transportable) const;
    virtual SUMOTime getDuration() const;
    virtual SUMOTime getTravelTime() const;
    virtual SUMOTime getWaitingTime() const;
    virtual SUMOTime getTotalWaitingTime() const;

    void setDeparted(SUMOTime now);

    virtual const std::string setArrived(MSNet* net, MSTransportable* transportable, SUMOTime now, const bool vehicleArrived);

    virtual bool isWaitingFor(const SUMOVehicle* vehicle) const;

    virtual bool isWaiting4Vehicle() const {
        return false;
    }

    virtual bool isWalk() const {
        return false;
    }

    virtual SUMOVehicle* getVehicle() const {
        return nullptr;
    }

    virtual double getSpeed() const;

    virtual ConstMSEdgeVector getEdges() const;

    virtual int getRoutePosition() const {
        return 0;
    }

    Position getEdgePosition(const MSEdge* e, double at, double offset) const;

    Position getLanePosition(const MSLane* lane, double at, double offset) const;

    double getEdgeAngle(const MSEdge* e, double at) const;
 
    void setDestination(const MSEdge* newDestination, MSStoppingPlace* newDestStop);
 
    virtual void setOrigin(const MSEdge* origin, MSStoppingPlace* originStop, double departPos) {
        UNUSED_PARAMETER(origin);
        UNUSED_PARAMETER(originStop);
        UNUSED_PARAMETER(departPos);
    }

    virtual double getDistance() const = 0;

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

    virtual void routeOutput(const bool isPerson, OutputDevice& os, const bool withRouteLength, const MSStage* const previous) const = 0;
 
    virtual MSStage* clone() const = 0;

    virtual void saveState(std::ostringstream& out) {
        UNUSED_PARAMETER(out);
    }

    virtual void loadState(MSTransportable* transportable, std::istringstream& state) {
        UNUSED_PARAMETER(transportable);
        UNUSED_PARAMETER(state);
    }
 
    bool wasSet(int what) const {
        return (myParametersSet & what) != 0;
    }
 
    void markSet(int what) {
        myParametersSet |= what;
    }

    double getCosts() const {
        return myCosts;
    }

    void setCosts(double costs) {
        myCosts = costs;
    }
 
    MSStageTrip* getTrip() const {
        return myTrip;
    }
 
    void setTrip(MSStageTrip* trip) {
        myTrip = trip;
    }
 
    virtual bool equals(const MSStage& s) const {
        return myDestination == s.myDestination &&
               myDestinationStop == s.myDestinationStop &&
               myArrivalPos == s.myArrivalPos &&
               myArrivalPosLat == s.myArrivalPosLat &&
               myType == s.myType &&
               myGroup == s.myGroup;
    }
 
protected:
    const MSEdge* myDestination;

    MSStoppingPlace* myDestinationStop;

    double myArrivalPos;

    double myArrivalPosLat;

    SUMOTime myDeparted;

    SUMOTime myArrived;

    MSStageType myType;

    const std::string myGroup;

    double myCosts;

    int myParametersSet;
 
    MSStageTrip* myTrip = nullptr;

    static const double ROADSIDE_OFFSET;
 
private:
    MSStage(const MSStage&);

    MSStage& operator=(const MSStage&) = delete;
 
};