MSTransportable.h

Go to the documentation of this file.

/****************************************************************************/
// The common superclass for modelling transportable objects like persons and containers
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2001-2015 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef MSTransportable_h
#define MSTransportable_h

// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif


// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSLane;
class MSNet;
class MSVehicleType;
class OutputDevice;
class Position;
class SUMOVehicleParameter;


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

    class Stage {
    public:
        Stage(const MSEdge& destination, StageType type);

        virtual ~Stage();

        const MSEdge& getDestination() const;

        virtual const MSEdge* getEdge() const = 0;
        virtual const MSEdge* getFromEdge() const = 0;
        virtual SUMOReal getEdgePos(SUMOTime now) const = 0;

        virtual Position getPosition(SUMOTime now) const = 0;

        virtual SUMOReal getAngle(SUMOTime now) const = 0;

        StageType getStageType() const {
            return myType;
        }

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

        virtual void proceed(MSNet* net, MSTransportable* transportable, SUMOTime now, MSEdge* previousEdge, const SUMOReal at) = 0;

        void setDeparted(SUMOTime now);

        void setArrived(SUMOTime now);

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

        virtual bool isWaiting4Vehicle() const {
            return false;
        }

        virtual SUMOTime getWaitingTime(SUMOTime now) const = 0;

        virtual SUMOReal getSpeed() const = 0;

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

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

        SUMOReal getEdgeAngle(const MSEdge* e, SUMOReal at) const;

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

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

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

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

    protected:
        const MSEdge& myDestination;

        SUMOTime myDeparted;

        SUMOTime myArrived;

        StageType myType;

    private:
        Stage(const Stage&);

        Stage& operator=(const Stage&);

    };

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

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

    virtual ~MSTransportable();

    /* @brief proceeds to the next step of the route,
     * @return Whether the containers 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 SUMOReal getEdgePos() const;

    virtual Position getPosition() const;

    virtual SUMOReal getAngle() const;

    virtual SUMOReal getWaitingSeconds() const;

    virtual SUMOReal getSpeed() const;

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

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

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

    void tripInfoOutput(OutputDevice& os) const;

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

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

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

protected:
    const SUMOVehicleParameter* myParameter;

    const MSVehicleType* myVType;

    bool myWriteEvents;

    MSTransportablePlan* myPlan;

    MSTransportablePlan::iterator myStep;

private:
    MSTransportable(const MSTransportable&);

    MSTransportable& operator=(const MSTransportable&);

};


#endif

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