MSStage.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 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 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:
    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;
    }
 
    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;
    }
 
    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;
 
    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 SUMOTime getWaitingTime(SUMOTime now) const;
 
    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 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;
    }
 
protected:
    const MSEdge* myDestination;
 
    MSStoppingPlace* myDestinationStop;
 
    double myArrivalPos;
 
    double myArrivalPosLat;
 
    SUMOTime myDeparted;
 
    SUMOTime myArrived;
 
    MSStageType myType;
 
    const std::string myGroup;
 
    double myCosts;
 
    int myParametersSet;
 
    static const double ROADSIDE_OFFSET;
 
private:
    MSStage(const MSStage&);
 
    MSStage& operator=(const MSStage&) = delete;
 
};