MSBaseVehicle.h

Go to the documentation of this file.

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


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

#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 definitions
// ===========================================================================
class MSBaseVehicle : public SUMOVehicle {
public:
    MSBaseVehicle(SUMOVehicleParameter* pars, const MSRoute* route,
                  const MSVehicleType* type, const SUMOReal speedFactor);


    virtual ~MSBaseVehicle();


    const std::string& getID() const;

    const SUMOVehicleParameter& getParameter() const;


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


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


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

    SUMOReal getMaxSpeed() const;


    const MSEdge* succEdge(unsigned int nSuccs) const;

    const MSEdge* getEdge() const;


    virtual bool isOnRoad() const {
        return true;
    }


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


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


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


    bool replaceRouteEdges(ConstMSEdgeVector& edges, bool onInit = false);


    virtual SUMOReal getAcceleration() const;

    virtual SUMOReal getSlope() const;

    void onDepart();

    inline SUMOTime getDeparture() const {
        return myDeparture;
    }

    virtual SUMOReal getArrivalPos() const {
        return myArrivalPos;
    }

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

    bool hasDeparted() const;

    virtual bool hasArrived() const;

    inline unsigned int getNumberReroutes() const {
        return myNumberReroutes;
    }

    SUMOReal getImpatience() const;


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

    virtual void addPerson(MSTransportable* person);


    virtual void addContainer(MSTransportable* container);

    bool hasValidRoute(std::string& msg) const;

    void addReminder(MSMoveReminder* rem);

    void removeReminder(MSMoveReminder* rem);

    virtual void activateReminders(const MSMoveReminder::Notification reason);

    inline SUMOReal getChosenSpeedFactor() const {
        return myChosenSpeedFactor;
    }

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

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




    virtual void saveState(OutputDevice& out);


    void addStops(const bool ignoreStopErrors);


protected:
    void calculateArrivalPos();

    virtual const ConstMSEdgeVector getStopEdges() const = 0;

protected:
    const SUMOVehicleParameter* myParameter;

    const MSRoute* myRoute;

    const MSVehicleType* myType;

    MSRouteIterator myCurrEdge;

    SUMOReal myChosenSpeedFactor;



    typedef std::vector< std::pair<MSMoveReminder*, SUMOReal> > MoveReminderCont;

    MoveReminderCont myMoveReminders;

    std::vector<MSDevice*> myDevices;

    SUMOTime myDeparture;

    SUMOReal myArrivalPos;

    unsigned int myNumberReroutes;

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

    MSBaseVehicle& operator=(const MSBaseVehicle& s);


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

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

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


};

#endif

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