ROEdge.h

Go to the documentation of this file.

/****************************************************************************/
// A basic edge for routing applications
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright (C) 2001-2011 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program 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 2 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef ROEdge_h
#define ROEdge_h


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

#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <utils/common/ValueTimeLine.h>
#include <utils/common/SUMOVehicleClass.h>
#include "RONode.h"


// ===========================================================================
// class declarations
// ===========================================================================
class ROLane;
class ROVehicle;


// ===========================================================================
// class definitions
// ===========================================================================
class ROEdge {
public:
    enum EdgeType {
        ET_NORMAL,
        ET_DISTRICT,
        ET_SOURCE,
        ET_SINK
    };


    ROEdge(const std::string& id, RONode* from, RONode* to, unsigned int index,
           bool useBoundariesOnOverride, bool interpolate=false) throw();


    virtual ~ROEdge() throw();




    virtual void addLane(ROLane* lane) throw();


    virtual void addFollower(ROEdge* s) throw();


    void setType(EdgeType type) throw();


    void buildTimeLines(const std::string& measure) throw();





    const std::string& getID() const throw() {
        return myID;
    }


    EdgeType getType() const throw() {
        return myType;
    }


    SUMOReal getLength() const throw() {
        return myLength;
    }

    unsigned int getNumericalID() const throw() {
        return myIndex;
    }


    SUMOReal getSpeed() const throw() {
        return mySpeed;
    }


    unsigned int getLaneNo() const throw() {
        return (unsigned int) myLanes.size();
    }


    RONode* getFromNode() const throw() {
        return myFromNode;
    }


    RONode* getToNode() const throw() {
        return myToNode;
    }


    bool isConnectedTo(const ROEdge* const e) const throw() {
        return std::find(myFollowingEdges.begin(), myFollowingEdges.end(), e)!=myFollowingEdges.end();
    }


    bool prohibits(const ROVehicle* const vehicle) const throw();


    bool allFollowersProhibit(const ROVehicle* const vehicle) const throw();





    void addEffort(SUMOReal value, SUMOReal timeBegin, SUMOReal timeEnd) throw();


    void addTravelTime(SUMOReal value, SUMOReal timeBegin, SUMOReal timeEnd) throw();


    unsigned int getNoFollowing() const throw();


    ROEdge* getFollower(unsigned int pos) const throw() {
        return myFollowingEdges[pos];
    }


    SUMOReal getEffort(const ROVehicle* const veh, SUMOReal time) const throw();


    SUMOReal getTravelTime(const ROVehicle* const veh, SUMOReal time) const throw();


    SUMOReal getCOEffort(const ROVehicle* const veh, SUMOReal time) const throw();
    SUMOReal getCO2Effort(const ROVehicle* const veh, SUMOReal time) const throw();
    SUMOReal getPMxEffort(const ROVehicle* const veh, SUMOReal time) const throw();
    SUMOReal getHCEffort(const ROVehicle* const veh, SUMOReal time) const throw();
    SUMOReal getNOxEffort(const ROVehicle* const veh, SUMOReal time) const throw();
    SUMOReal getFuelEffort(const ROVehicle* const veh, SUMOReal time) const throw();
    SUMOReal getNoiseEffort(const ROVehicle* const veh, SUMOReal time) const throw();

    static ROEdge* dictionary(size_t index) throw();


protected:
    bool getStoredEffort(SUMOReal time, SUMOReal& ret) const throw();



protected:
    std::string myID;

    SUMOReal mySpeed;

    unsigned int myIndex;

    SUMOReal myLength;


    mutable ValueTimeLine<SUMOReal> myTravelTimes;
    bool myUsingTTTimeLine;
    bool myUseBoundariesOnOverrideTT;
    static bool myHaveTTWarned;

    mutable ValueTimeLine<SUMOReal> myEfforts;
    bool myUsingETimeLine;
    bool myUseBoundariesOnOverrideE;
    static bool myHaveEWarned;

    bool myInterpolate;


    std::vector<ROEdge*> myFollowingEdges;

    EdgeType myType;

    std::vector<ROLane*> myLanes;

    SUMOVehicleClasses myAllowedClasses;

    SUMOVehicleClasses myNotAllowedClasses;

    RONode* myFromNode, *myToNode;

    static std::vector<ROEdge*> myEdges;

private:
    ROEdge(const ROEdge& src);

    ROEdge& operator=(const ROEdge& src);

};


#endif

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