MSTransportable.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2018 German Aerospace Center (DLR) and others.
// This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v20.html
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// The common superclass for modelling transportable objects like persons and containers
/****************************************************************************/
#ifndef MSTransportable_h
#define MSTransportable_h

// ===========================================================================
// included modules
// ===========================================================================
#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>


// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSLane;
class MSNet;
class MSStoppingPlace;
class MSVehicleType;
class OutputDevice;
class SUMOVehicleParameter;
class SUMOVehicle;

typedef std::vector<const MSEdge*> ConstMSEdgeVector;

// ===========================================================================
// class definitions
// ===========================================================================
class MSTransportable {
public:
    enum StageType {
        WAITING_FOR_DEPART = 0,
        WAITING = 1,
        MOVING_WITHOUT_VEHICLE = 2, // walking for persons, tranship for containers
        DRIVING = 3,
        ACCESS = 4
    };

    class Stage {
    public:
        Stage(const MSEdge* destination, MSStoppingPlace* toStop, const double arrivalPos, StageType type);

        virtual ~Stage();

        const MSEdge* getDestination() const;

        MSStoppingPlace* getDestinationStop() const {
            return myDestinationStop;
        }

        double getArrivalPos() const {
            return myArrivalPos;
        }

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

        virtual Position getPosition(SUMOTime now) const = 0;

        virtual double getAngle(SUMOTime now) const = 0;

        StageType getStageType() const {
            return myType;
        }

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

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

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

        virtual void abort(MSTransportable*) {};

        virtual void setSpeed(double) {};

        void setDeparted(SUMOTime now);

        virtual void setArrived(SUMOTime now);

        virtual bool isWaitingFor(const std::string& line) const;

        virtual bool isWaiting4Vehicle() const {
            return false;
        }

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

        virtual SUMOTime getWaitingTime(SUMOTime now) const;

        virtual double getSpeed() const;

        virtual ConstMSEdgeVector getEdges() const;

        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;

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

        virtual void routeOutput(OutputDevice& os) const = 0;

        virtual void beginEventOutput(const MSTransportable& transportable, SUMOTime t, OutputDevice& os) const = 0;

        virtual void endEventOutput(const MSTransportable& transportable, SUMOTime t, OutputDevice& os) const = 0;

    protected:
        const MSEdge* myDestination;

        MSStoppingPlace* myDestinationStop;

        double myArrivalPos;

        SUMOTime myDeparted;

        SUMOTime myArrived;

        StageType myType;

    private:
        Stage(const Stage&);

        Stage& operator=(const Stage&);

    };

    class Stage_Waiting : public Stage {
    public:
        Stage_Waiting(const MSEdge* destination, SUMOTime duration, SUMOTime until,
                      double pos, const std::string& actType, const bool initial);

        virtual ~Stage_Waiting();

        void abort(MSTransportable*);

        SUMOTime getUntil() const;

        Position getPosition(SUMOTime now) const;

        double getAngle(SUMOTime now) const;

        SUMOTime getWaitingTime(SUMOTime now) const;

        std::string getStageDescription() const {
            return "waiting (" + myActType + ")";
        }

        std::string getStageSummary() const;

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

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

        virtual void routeOutput(OutputDevice& os) const;

        virtual void beginEventOutput(const MSTransportable& p, SUMOTime t, OutputDevice& os) const;

        virtual void endEventOutput(const MSTransportable& p, SUMOTime t, OutputDevice& os) const;

    private:
        SUMOTime myWaitingDuration;

        SUMOTime myWaitingUntil;

        std::string myActType;

    private:
        Stage_Waiting(const Stage_Waiting&);

        Stage_Waiting& operator=(const Stage_Waiting&);

    };

    class Stage_Driving : public Stage {
    public:
        Stage_Driving(const MSEdge* destination, MSStoppingPlace* toStop,
                      const double arrivalPos, const std::vector<std::string>& lines,
                      const std::string& intendedVeh = "", SUMOTime intendedDepart = -1);

        virtual ~Stage_Driving();

        void abort(MSTransportable*);

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

        Position getPosition(SUMOTime now) const;

        double getAngle(SUMOTime now) const;

        bool isWaitingFor(const std::string& line) 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 setDestination(const MSEdge* newDestination, MSStoppingPlace* newDestStop);

        void setVehicle(SUMOVehicle* v);

        void setArrived(SUMOTime now);

        virtual void beginEventOutput(const MSTransportable& p, SUMOTime t, OutputDevice& os) const;

        virtual void endEventOutput(const MSTransportable& p, SUMOTime t, OutputDevice& os) const;

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

        SUMOVehicle* myVehicle;
        std::string myVehicleID;
        std::string myVehicleLine;

        SUMOVehicleClass myVehicleVClass;
        double myVehicleDistance;

        double myWaitingPos;
        SUMOTime myWaitingSince;
        const MSEdge* myWaitingEdge;
        Position myStopWaitPos;

        std::string myIntendedVehicleID;
        SUMOTime myIntendedDepart;

    private:
        Stage_Driving(const Stage_Driving&);

        Stage_Driving& operator=(const Stage_Driving&);

    };

    typedef std::vector<MSTransportable::Stage*> MSTransportablePlan;

    MSTransportable(const SUMOVehicleParameter* pars, MSVehicleType* vtype, MSTransportablePlan* plan);

    virtual ~MSTransportable();

    /* @brief proceeds to the next step of the route,
     * @return Whether the transportables plan continues  */
    virtual bool proceed(MSNet* net, SUMOTime time) = 0;

    const std::string& getID() const;

    inline const SUMOVehicleParameter& getParameter() const {
        return *myParameter;
    }

    inline const MSVehicleType& getVehicleType() const {
        return *myVType;
    }

    SUMOTime getDesiredDepart() const;

    void setDeparted(SUMOTime now);

    const MSEdge* getDestination() const {
        return (*myStep)->getDestination();
    }

    const MSEdge* getNextDestination() const {
        return (*(myStep + 1))->getDestination();
    }

    const MSEdge* getEdge() const {
        return (*myStep)->getEdge();
    }

    const MSEdge* getFromEdge() const {
        return (*myStep)->getFromEdge();
    }

    virtual double getEdgePos() const;

    virtual Position getPosition() const;

    virtual double getAngle() const;

    virtual double getWaitingSeconds() const;

    virtual double getSpeed() const;

    virtual double getSpeedFactor() const {
        return 1;
    }

    StageType getCurrentStageType() const {
        return (*myStep)->getStageType();
    }

    StageType getStageType(int next) const {
        assert(myStep + next < myPlan->end());
        assert(myStep + next >= myPlan->begin());
        return (*(myStep + next))->getStageType();
    }

    std::string getStageSummary(int stageIndex) const;

    std::string getCurrentStageDescription() const {
        return (*myStep)->getStageDescription();
    }

    MSTransportable::Stage* getCurrentStage() const {
        return *myStep;
    }

    MSTransportable::Stage* getNextStage(int next) const {
        assert(myStep + next >= myPlan->begin());
        assert(myStep + next < myPlan->end());
        return *(myStep + next);
    }

    ConstMSEdgeVector getEdges(int next) const {
        assert(myStep + next < myPlan->end());
        assert(myStep + next >= myPlan->begin());
        return (*(myStep + next))->getEdges();
    }

    int getNumRemainingStages() const;

    int getNumStages() const;

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

    virtual void routeOutput(OutputDevice& os) const = 0;

    bool isWaitingFor(const std::string& line) const {
        return (*myStep)->isWaitingFor(line);
    }

    bool isWaiting4Vehicle() const {
        return (*myStep)->isWaiting4Vehicle();
    }

    SUMOVehicle* getVehicle() const {
        return (*myStep)->getVehicle();
    }

    void appendStage(Stage* stage, int next = -1);

    void removeStage(int next);

    void setSpeed(double speed);

    double getArrivalPos() const {
        return myPlan->back()->getArrivalPos();
    }

    const MSEdge* getArrivalEdge() const {
        return myPlan->back()->getEdges().back();
    }

    void replaceVehicleType(MSVehicleType* type);


    MSVehicleType& getSingularType();


    PositionVector getBoundingBox() const;

    bool hasArrived() const;

    void rerouteParkingArea(MSStoppingPlace* orig, MSStoppingPlace* replacement);

protected:
    static const double ROADSIDE_OFFSET;

    const SUMOVehicleParameter* myParameter;

    MSVehicleType* myVType;

    bool myWriteEvents;

    MSTransportablePlan* myPlan;

    MSTransportablePlan::iterator myStep;

private:
    MSTransportable(const MSTransportable&);

    MSTransportable& operator=(const MSTransportable&);

};


#endif

/****************************************************************************/