MSBaseVehicle.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2010-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
/****************************************************************************/
// A base class for vehicle implementations
/****************************************************************************/
#ifndef MSBaseVehicle_h
#define MSBaseVehicle_h


// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>

#include <iostream>
#include <vector>
#include <set>
#include <utils/vehicle/SUMOVehicle.h>
#include <utils/common/StdDefs.h>
#include "MSRoute.h"
#include "MSMoveReminder.h"
#include "MSVehicleType.h"

// ===========================================================================
// class declarations
// ===========================================================================
class MSLane;
class MSDevice_Transportable;

// ===========================================================================
// class definitions
// ===========================================================================
class MSBaseVehicle : public SUMOVehicle {
public:
    // XXX: This definition was introduced to make the MSVehicle's previousSpeed
    //      available in the context of MSMoveReminder::notifyMove(). Another solution
    //      would be to modify notifyMove()'s interface to work with MSVehicle instead
    //      of SUMOVehicle (it is only called with MSVehicles!). Refs. #2579
    double getPreviousSpeed() const;

    friend class GUIBaseVehicle;

    MSBaseVehicle(SUMOVehicleParameter* pars, const MSRoute* route,
                  MSVehicleType* type, const double speedFactor);


    virtual ~MSBaseVehicle();


    const std::string& getID() const;

    const SUMOVehicleParameter& getParameter() const;

    void replaceParameter(const SUMOVehicleParameter* newParameter);

    bool hasDevice(const std::string& deviceName) const;

    void createDevice(const std::string& deviceName);

    std::string getDeviceParameter(const std::string& deviceName, const std::string& key) const;

    void setDeviceParameter(const std::string& deviceName, const std::string& key, const std::string& value);

    inline const MSRoute& getRoute() const {
        return *myRoute;
    }


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


    inline SUMOVehicleClass getVClass() const {
        return myType->getParameter().vehicleClass;
    }

    double getMaxSpeed() const;


    const MSEdge* succEdge(int nSuccs) const;

    const MSEdge* getEdge() const;


    virtual bool isOnRoad() const {
        return true;
    }

    virtual bool isRemoteControlled() const {
        return false;
    }

    virtual bool wasRemoteControlled(SUMOTime lookBack = DELTA_T) const {
        UNUSED_PARAMETER(lookBack);
        return false;
    }

    virtual bool isFrontOnLane(const MSLane*) const {
        return true;
    }

    virtual double getLateralPositionOnLane() const {
        return 0;
    }

    virtual const MSEdge* getRerouteOrigin() const {
        return *myCurrEdge;
    }


    const MSRouteIterator& getCurrentRouteEdge() const {
        return myCurrEdge;
    }


    void reroute(SUMOTime t, const std::string& info, SUMOAbstractRouter<MSEdge, SUMOVehicle>& router, const bool onInit = false, const bool withTaz = false);


    bool replaceRouteEdges(ConstMSEdgeVector& edges, const std::string& info, bool onInit = false, bool check = false, bool removeStops = true);


    virtual double getAcceleration() const;

    virtual double getSlope() const;

    void onDepart();

    inline SUMOTime getDeparture() const {
        return myDeparture;
    }

    SUMOTime getDepartDelay() const {
        return getDeparture() - getParameter().depart;
    }


    inline double getDepartPos() const {
        return myDepartPos;
    }

    virtual double getArrivalPos() const {
        return myArrivalPos;
    }

    virtual void setArrivalPos(double arrivalPos) {
        myArrivalPos = arrivalPos;
    }

    bool hasDeparted() const;

    virtual bool hasArrived() const;

    inline int getNumberReroutes() const {
        return myNumberReroutes;
    }

    double getImpatience() const;

    int getPersonNumber() const;

    std::vector<std::string> getPersonIDList() const;

    int getContainerNumber() const;


    inline const std::vector<MSDevice*>& getDevices() const {
        return myDevices;
    }

    virtual void addPerson(MSTransportable* person);


    virtual void addContainer(MSTransportable* container);

    void removeTransportable(MSTransportable* t);

    const std::vector<MSTransportable*>& getPersons() const;

    const std::vector<MSTransportable*>& getContainers() const;


    bool hasValidRoute(std::string& msg, const MSRoute* route = 0) const;

    void addReminder(MSMoveReminder* rem);

    void removeReminder(MSMoveReminder* rem);

    virtual void activateReminders(const MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);


    inline double getLength() const {
        return myType->getLength();
    }


    inline double getWidth() const {
        return myType->getWidth();
    }


    inline double getChosenSpeedFactor() const {
        return myChosenSpeedFactor;
    }

    inline void setChosenSpeedFactor(const double factor) {
        myChosenSpeedFactor = factor;
    }

    MSDevice* getDevice(const std::type_info& type) const;


    void replaceVehicleType(MSVehicleType* type);


    MSVehicleType& getSingularType();



    virtual void saveState(OutputDevice& out);


    void addStops(const bool ignoreStopErrors);

    virtual bool isSelected() const {
        return false;
    }

protected:
    void calculateArrivalParams();

    virtual const ConstMSEdgeVector getStopEdges() const = 0;

protected:
    const SUMOVehicleParameter* myParameter;

    const MSRoute* myRoute;

    MSVehicleType* myType;

    MSRouteIterator myCurrEdge;

    double myChosenSpeedFactor;



    //         The double value holds the relative position offset, i.e.,
    //         offset + vehicle-position - moveReminder-position = distance,
    //         i.e. the offset is counted up when the vehicle continues to a
    //         succeeding lane.
    typedef std::vector< std::pair<MSMoveReminder*, double> > MoveReminderCont;

    MoveReminderCont myMoveReminders;

    std::vector<MSDevice*> myDevices;

    MSDevice_Transportable* myPersonDevice;

    MSDevice_Transportable* myContainerDevice;

    SUMOTime myDeparture;

    double myDepartPos;

    double myArrivalPos;

    int myArrivalLane;

    int myNumberReroutes;

    /* @brief magic value for undeparted vehicles
     * @note: in previous versions this was -1
     */
    static const SUMOTime NOT_YET_DEPARTED;

    static std::vector<MSTransportable*> myEmptyTransportableVector;

private:
    MSBaseVehicle& operator=(const MSBaseVehicle& s);

#ifdef _DEBUG
public:
    static void initMoveReminderOutput(const OptionsCont& oc);

protected:
    void traceMoveReminder(const std::string& type, MSMoveReminder* rem, double pos, bool keep) const;

    const bool myTraceMoveReminders;
private:
    static std::set<std::string> myShallTraceMoveReminders;
#endif


};

#endif

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