GUIEdge Class Reference

#include <GUIEdge.h>

Inheritance diagram for GUIEdge:

---

Detailed Description

A road/street connecting two junctions (gui-version).

See also:

MSEdge

Definition at line 67 of file GUIEdge.h.

Static edge container
typedef std::map< std::string, MSEdge * >	DictType
	definition of the static dictionary type
static DictType	myDict
	Static dictionary to associate string-ids with objects.
static std::vector< MSEdge * >	myEdges
	Static list of edges.
Public Types
typedef std::map< const MSEdge *, std::vector< MSLane * > * >	AllowedLanesCont
	Suceeding edges (keys) and allowed lanes to reach these edges (values).
typedef std::map < SUMOVehicleClass, AllowedLanesCont >	ClassedAllowedLanesCont
	Map from vehicle types to lanes that may be used to reach one of the next edges.
enum	EdgeBasicFunction {   EDGEFUNCTION_UNKNOWN = -1, EDGEFUNCTION_NORMAL = 0, EDGEFUNCTION_CONNECTOR = 1, EDGEFUNCTION_INTERNAL = 2,   EDGEFUNCTION_DISTRICT = 3 }
	Defines possible edge types. More...
Public Member Functions
virtual bool	active () const throw ()
	Returns the information whether this object is still active.
virtual void	changeLanes (SUMOTime t) throw ()
	Performs lane changing on this edge.
void	closeBuilding ()
Boundary	getBoundary () const
	Returns the street's geometry.
SUMOReal	getCurrentTravelTime () const throw ()
	Computes and returns the current travel time for this edge.
MSLane &	getLane (size_t laneNo)
	returns the enumerated lane (!!! why not private with a friend?)
GUILaneWrapper &	getLaneGeometry (const MSLane *lane) const
GUILaneWrapper &	getLaneGeometry (size_t laneNo) const
	returns the enumerated lane's geometry (!!! why not private with a friend?)
	GUIEdge (const std::string &id, unsigned int numericalID, GUIGlObjectStorage &idStorage) throw ()
	Constructor.
void	initGeometry (GUIGlObjectStorage &idStorage) throw ()
	Builds lane wrappers for this edge's lanes.
void	initialize (MSLane *departLane, std::vector< MSLane * > *lanes, EdgeBasicFunction function) throw ()
	Initialize the edge.
bool	prohibits (const SUMOVehicle *const vehicle) const throw ()
	Returns whether the vehicle (class) is not allowed on the edge.
void	rebuildAllowedLanes () throw ()
	~GUIEdge () throw ()
	Destructor.
Access to succeeding/predecessing edges
void	addFollower (MSEdge *edge) throw ()
	Returns the list of edges which may be reached from this edge.
const MSEdge *const	getFollower (unsigned int n) const throw ()
	Returns the n-th of the following edges.
const std::vector< MSEdge * > &	getIncomingEdges () const throw ()
	Returns the list of edges from which this edge may be reached.
unsigned int	getNoFollowing () const throw ()
	Returns the number of edges that may be reached from this edge.
Access to the edge's lanes
const std::vector< MSLane * > *	allowedLanes (SUMOVehicleClass vclass=SVC_UNKNOWN) const throw ()
	Get the allowed lanes for the given vehicle class.
const std::vector< MSLane * > *	allowedLanes (const MSEdge &destination, SUMOVehicleClass vclass=SVC_UNKNOWN) const throw ()
	Get the allowed lanes to reach the destination-edge.
const std::vector< MSLane * > &	getLanes () const throw ()
	Returns this edge's lanes.
MSLane *const	leftLane (const MSLane *const lane) const throw ()
	Returns the lane left to the one given, 0 if the given lane is leftmost.
MSLane *const	rightLane (const MSLane *const lane) const throw ()
	Returns the lane right to the one given, 0 if the given lane is rightmost.
Access to vaporizing interface
SUMOTime	decVaporization (SUMOTime t) throw (ProcessError)
	Disables vaporization.
SUMOTime	incVaporization (SUMOTime t) throw (ProcessError)
	Enables vaporization.
bool	isVaporizing () const throw ()
	Returns whether vehicles on this edge shall be vaporized.
inherited from GUIGlObject
void	drawGL (const GUIVisualizationSettings &s) const throw ()
	Draws the object.
Boundary	getCenteringBoundary () const throw ()
	Returns the boundary to which the view shall be centered in order to show the object.
const std::string &	getMicrosimID () const throw ()
	Returns the id of the object as known to microsim.
virtual GUIParameterTableWindow *	getParameterWindow (GUIMainWindow &app, GUISUMOAbstractView &parent) throw ()
	Returns an own parameter window.
virtual GUIGLObjectPopupMenu *	getPopUpMenu (GUIMainWindow &app, GUISUMOAbstractView &parent) throw ()
	Returns an own popup-menu.
GUIGlObjectType	getType () const throw ()
	Returns the type of the object as coded in GUIGlObjectType.
Methods releated to vehicle emission
bool	emit (MSVehicle &v, SUMOTime time) const throw (ProcessError)
	Emits the given vehicle.
MSLane *	getDepartLane (const MSVehicle &v) const throw ()
	Finds a depart lane for the given vehicle.
MSLane *	getFreeLane (const SUMOVehicleClass vclass) const throw ()
	Finds the emptiest lane allowing the vehicle class.
SUMOTime	getLastFailedEmissionTime () const throw ()
	Returns the last time a vehicle could not be inserted.
void	setLastFailedEmissionTime (SUMOTime time) const throw ()
	Sets the last time a vehicle could not be inserted.
Atomar getter methods
const std::string &	getFullName () const throw ()
	Returns the full name appearing in the tool tip.
GLuint	getGlID () const throw ()
	Returns the numerical id of the object.
Access to other edge attributes
const std::string &	getID () const throw ()
	Returns the id of the edge.
unsigned int	getNumericalID () const throw ()
	Returns the numerical id of the edge.
EdgeBasicFunction	getPurpose () const throw ()
	Returns the edge type (EdgeBasicFunction).
Static Public Member Functions
static void	clear () throw ()
	Clears the dictionary.
static MSEdge *	dictionary (size_t index) throw ()
	Returns the MSEdge at the index.
static MSEdge *	dictionary (const std::string &id) throw ()
	Returns the MSEdge associated to the key id if exists, otherwise returns 0.
static bool	dictionary (const std::string &id, MSEdge *edge) throw ()
	Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary. Otherwise returns false.
static size_t	dictSize () throw ()
	Returns the number of edges.
static void	fill (std::vector< GUIEdge * > &netsWrappers)
static std::vector< GLuint >	getIDs ()
static std::pair< SUMOReal, SUMOReal >	getLaneOffsets (SUMOReal x1, SUMOReal y1, SUMOReal x2, SUMOReal y2, SUMOReal prev, SUMOReal wanted)
static void	insertIDs (std::vector< std::string > &into) throw ()
	Inserts IDs of all known edges into the given vector.
Static parser helper
static void	parseEdgesList (const std::vector< std::string > &desc, std::vector< const MSEdge * > &into, const std::string &rid) throw (ProcessError)
	Parses the given string vector assuming it edge ids.
static void	parseEdgesList (const std::string &desc, std::vector< const MSEdge * > &into, const std::string &rid) throw (ProcessError)
	Parses the given string assuming it contains a list of edge ids divided by spaces.
Protected Member Functions
const std::vector< MSLane * > *	allowedLanes (const MSEdge *destination, SUMOVehicleClass vclass=SVC_UNKNOWN) const throw ()
	Get the allowed lanes to reach the destination-edge.
helper methods for building popup-menus
void	buildCenterPopupEntry (GUIGLObjectPopupMenu *ret, bool addSeparator=true) throw ()
	Builds an entry which allows to center to the object.
void	buildNameCopyPopupEntry (GUIGLObjectPopupMenu *ret, bool addSeparator=true) throw ()
	Builds entries which allow to copy the name / typed name into the clipboard.
void	buildPopupHeader (GUIGLObjectPopupMenu *ret, GUIMainWindow &app, bool addSeparator=true) throw ()
	Builds the header.
void	buildPositionCopyEntry (GUIGLObjectPopupMenu *ret, bool addSeparator=true) throw ()
	Builds an entry which allows to copy the cursor position.
void	buildSelectionPopupEntry (GUIGLObjectPopupMenu *ret, bool addSeparator=true) throw ()
	Builds an entry which allows to (de)select the object.
void	buildShowManipulatorPopupEntry (GUIGLObjectPopupMenu *ret, bool addSeparator=true) throw ()
	Builds an entry which allows to open the manipulator window.
void	buildShowParamsPopupEntry (GUIGLObjectPopupMenu *ret, bool addSeparator=true) throw ()
	Builds an entry which allows to open the parameter window.
Protected Attributes
MSLane *	myDepartLane
	Lane from which vehicles will depart, usually the rightmost.
EdgeBasicFunction	myFunction
	the purpose of the edge
std::string	myID
	Unique ID.
MSLaneChanger *	myLaneChanger
	This member will do the lane-change.
std::vector< MSLane * > *	myLanes
	Container for the edge's lane; should be sorted: (right-hand-traffic) the more left the lane, the higher the container-index.
SUMOTime	myLastFailedEmissionTime
	The time of last emission failure.
unsigned int	myNumericalID
	This edge's numerical id.
std::vector< MSEdge * >	myPredeccesors
	The preceeding edges.
std::vector< MSEdge * >	mySuccessors
	The succeeding edges.
int	myVaporizationRequests
	Vaporizer counter.
Storages for allowed lanes (depending on vehicle classes)
AllowedLanesCont	myAllowed
	Associative container from destination-edge to allowed-lanes.
ClassedAllowedLanesCont	myClassedAllowed
	From vehicle class to lanes allowed to be used by it.
bool	myHaveClassConstraints
	Whether any class constraints exist for this edge.
Private Types
typedef std::vector < GUILaneWrapper * >	LaneWrapperVector
	Definition of the lane's positions vector.
Private Member Functions
	GUIEdge (const GUIEdge &s)
	invalidated copy constructor
GUIEdge &	operator= (const GUIEdge &s)
	invalidated assignment operator
Private Attributes
LaneWrapperVector	myLaneGeoms
	List of the edge's lanes geometrical information.
Friends
class	GUIGlObjectStorage
	Needed to set the id.
Data Structures
class	lane_wrapper_finder
	A class to find the matching lane wrapper. More...

---

Member Typedef Documentation

typedef std::map< const MSEdge*, std::vector<MSLane*>* > MSEdge::AllowedLanesCont [inherited]

Suceeding edges (keys) and allowed lanes to reach these edges (values).

Definition at line 86 of file MSEdge.h.

typedef std::map< SUMOVehicleClass, AllowedLanesCont > MSEdge::ClassedAllowedLanesCont [inherited]

Map from vehicle types to lanes that may be used to reach one of the next edges.

Definition at line 89 of file MSEdge.h.

typedef std::map< std::string, MSEdge* > MSEdge::DictType [protected, inherited]

definition of the static dictionary type

Definition at line 499 of file MSEdge.h.

typedef std::vector<GUILaneWrapper*> GUIEdge::LaneWrapperVector [private]

Definition of the lane's positions vector.

Definition at line 193 of file GUIEdge.h.

---

Member Enumeration Documentation

enum MSEdge::EdgeBasicFunction [inherited]

Defines possible edge types.

For different purposes, it is necessary to know whether the edge is a normal street or something special.

Enumerator:

EDGEFUNCTION_UNKNOWN	The purpose of the edge is not known.
EDGEFUNCTION_NORMAL	The edge is a normal street.
EDGEFUNCTION_CONNECTOR	The edge is a macroscopic connector (source/sink).
EDGEFUNCTION_INTERNAL	The edge is an internal edge.
EDGEFUNCTION_DISTRICT	The edge is a district edge.

Definition at line 71 of file MSEdge.h.

                           {
        EDGEFUNCTION_UNKNOWN = -1,
        EDGEFUNCTION_NORMAL = 0,
        EDGEFUNCTION_CONNECTOR = 1,
        EDGEFUNCTION_INTERNAL = 2,
        EDGEFUNCTION_DISTRICT = 3
    };

---

Constructor & Destructor Documentation

GUIEdge::GUIEdge	(	const std::string &	id,
		unsigned int	numericalID,
		GUIGlObjectStorage &	idStorage
	)			throw ()

Constructor.

Parameters:

[in]	id	The id of the edge
[in]	numericalID	The numerical id (index) of the edge
[in]	idStorage	The gl-objects storage to retrieve the gl-id for this edge from

See also:

MSEdge

Definition at line 65 of file GUIEdge.cpp.

        : MSEdge(id, numericalID),
        GUIGlObject(idStorage, "edge:" + id) {}

GUIEdge::~GUIEdge

(

)

throw ()

Destructor.

Definition at line 71 of file GUIEdge.cpp.

References myLaneGeoms.

                          {
    for (LaneWrapperVector::iterator i=myLaneGeoms.begin(); i!=myLaneGeoms.end(); ++i) {
        delete(*i);
    }
}

GUIEdge::GUIEdge

(

const GUIEdge &

s

)

[private]

invalidated copy constructor

---

Member Function Documentation

virtual bool GUIGlObject::active

(

)

const throw () [inline, virtual, inherited]

Returns the information whether this object is still active.

Returns:

Whether this object is active (always true in this case)

Reimplemented in GUIVehicle.

Definition at line 171 of file GUIGlObject.h.

Referenced by GLObjectValuePassConnector< std::pair< int, MSPhaseDefinition > >::updateEachTimestep().

                                        {
        return true;
    }

void MSEdge::addFollower

(

MSEdge *

edge

)

throw () [inline, inherited]

Returns the list of edges which may be reached from this edge.

Returns:

Edges reachable from this edge

Definition at line 213 of file MSEdge.h.

References MSEdge::mySuccessors.

Referenced by NLHandler::addDistrict(), and NLHandler::addDistrictEdge().

                                           {
        mySuccessors.push_back(edge);
    }

const std::vector< MSLane * > * MSEdge::allowedLanes	(	const MSEdge *	destination,
		SUMOVehicleClass	vclass = SVC_UNKNOWN
	)			const throw () [protected, inherited]

Get the allowed lanes to reach the destination-edge.

If there is no such edge, get 0. Then you are on the wrong edge.

Parameters:

[in]	destination	The edge to reach
[in]	vclass	The vehicle class for which this information shall be returned

Returns:

The lanes that may be used to reach the given edge, 0 if no such lanes exist

Definition at line 199 of file MSEdge.cpp.

References MSEdge::myAllowed, MSEdge::myClassedAllowed, MSEdge::myHaveClassConstraints, and SVC_UNKNOWN.

                                                                                     {
    if (myHaveClassConstraints&&vclass!=SVC_UNKNOWN) {
        ClassedAllowedLanesCont::const_iterator i = myClassedAllowed.find(vclass);
        if (i!=myClassedAllowed.end()) {
            const AllowedLanesCont &c = (*i).second;
            AllowedLanesCont::const_iterator j = (*i).second.find(destination);
            if (j==c.end()) {
                // Destination-edge not found.
                return 0;
            }
            return (*j).second;
        }
    }
    AllowedLanesCont::const_iterator it = myAllowed.find(destination);
    if (it!=myAllowed.end()) {
        return it->second;
    } else {
        // Destination-edge not found.
        return 0;
    }
}

const std::vector< MSLane * > * MSEdge::allowedLanes

(

SUMOVehicleClass

vclass = SVC_UNKNOWN

)

const throw () [inherited]

Get the allowed lanes for the given vehicle class.

If there is no such edge, get 0. Then you are on the wrong edge.

Parameters:

[in]

vclass

The vehicle class for which this information shall be returned

Returns:

The lanes that may be used by the given vclass

Definition at line 193 of file MSEdge.cpp.

References MSEdge::allowedLanes().

                                                          {
    return allowedLanes(0, vclass);
}

const std::vector< MSLane * > * MSEdge::allowedLanes	(	const MSEdge &	destination,
		SUMOVehicleClass	vclass = SVC_UNKNOWN
	)			const throw () [inherited]

Get the allowed lanes to reach the destination-edge.

If there is no such edge, get 0. Then you are on the wrong edge.

Parameters:

[in]	destination	The edge to reach
[in]	vclass	The vehicle class for which this information shall be returned

Returns:

The lanes that may be used to reach the given edge, 0 if no such lanes exist

Definition at line 187 of file MSEdge.cpp.

Referenced by MSEdge::allowedLanes(), MSEdge::getDepartLane(), MSEdge::getFreeLane(), MS_E2_ZS_CollectorOverLanes::getLanePredeccessorLanes(), and MSLane::succLinkSec().

                                                                                     {
    return allowedLanes(&destination, vclass);
}

void GUIGlObject::buildCenterPopupEntry	(	GUIGLObjectPopupMenu *	ret,
		bool	addSeparator = true
	)			throw () [protected, inherited]

Builds an entry which allows to center to the object.

Parameters:

	in,filled]	ret The popup menu to add the entry to
[in]	app	The application, needed for callbacks
[in]	addSeparator	Whether a separator shall be added, too

Definition at line 86 of file GUIGlObject.cpp.

References GUIIconSubSys::getIcon(), ICON_RECENTERVIEW, and MID_CENTER.

Referenced by GUIVehicle::getPopUpMenu(), GUITriggeredRerouter::getPopUpMenu(), GUITrafficLightLogicWrapper::getPopUpMenu(), GUIPolygon2D::getPopUpMenu(), GUIPointOfInterest::getPopUpMenu(), GUINet::getPopUpMenu(), GUILaneWrapper::getPopUpMenu(), GUILaneSpeedTrigger::getPopUpMenu(), GUIJunctionWrapper::getPopUpMenu(), GUIEmitter::getPopUpMenu(), getPopUpMenu(), GUIDetectorWrapper::getPopUpMenu(), and GUIBusStop::getPopUpMenu().

                                                              {
    new FXMenuCommand(ret, "Center", GUIIconSubSys::getIcon(ICON_RECENTERVIEW), ret, MID_CENTER);
    if (addSeparator) {
        new FXMenuSeparator(ret);
    }
}

void GUIGlObject::buildNameCopyPopupEntry	(	GUIGLObjectPopupMenu *	ret,
		bool	addSeparator = true
	)			throw () [protected, inherited]

Builds entries which allow to copy the name / typed name into the clipboard.

Parameters:

	in,filled]	ret The popup menu to add the entry to
[in]	app	The application, needed for callbacks
[in]	addSeparator	Whether a separator shall be added, too

Definition at line 96 of file GUIGlObject.cpp.

References MID_COPY_NAME, and MID_COPY_TYPED_NAME.

Referenced by GUIVehicle::getPopUpMenu(), GUITriggeredRerouter::getPopUpMenu(), GUITrafficLightLogicWrapper::getPopUpMenu(), GUIPolygon2D::getPopUpMenu(), GUIPointOfInterest::getPopUpMenu(), GUILaneWrapper::getPopUpMenu(), GUILaneSpeedTrigger::getPopUpMenu(), GUIJunctionWrapper::getPopUpMenu(), GUIEmitter::getPopUpMenu(), getPopUpMenu(), GUIDetectorWrapper::getPopUpMenu(), and GUIBusStop::getPopUpMenu().

                                                                {
    new FXMenuCommand(ret, "Copy name to clipboard", 0, ret, MID_COPY_NAME);
    new FXMenuCommand(ret, "Copy typed name to clipboard", 0, ret, MID_COPY_TYPED_NAME);
    if (addSeparator) {
        new FXMenuSeparator(ret);
    }
}

void GUIGlObject::buildPopupHeader	(	GUIGLObjectPopupMenu *	ret,
		GUIMainWindow &	app,
		bool	addSeparator = true
	)			throw () [protected, inherited]

Builds the header.

Parameters:

	in,filled]	ret The popup menu to add the entry to
[in]	app	The application, needed for callbacks
[in]	addSeparator	Whether a separator shall be added, too

Definition at line 75 of file GUIGlObject.cpp.

References GUIGlObject::getFullName().

Referenced by GUIVehicle::getPopUpMenu(), GUITriggeredRerouter::getPopUpMenu(), GUITrafficLightLogicWrapper::getPopUpMenu(), GUIPolygon2D::getPopUpMenu(), GUIPointOfInterest::getPopUpMenu(), GUINet::getPopUpMenu(), GUILaneWrapper::getPopUpMenu(), GUILaneSpeedTrigger::getPopUpMenu(), GUIJunctionWrapper::getPopUpMenu(), GUIEmitter::getPopUpMenu(), getPopUpMenu(), GUIDetectorWrapper::getPopUpMenu(), and GUIBusStop::getPopUpMenu().

                                                         {
    new MFXMenuHeader(ret, app.getBoldFont(), getFullName().c_str(), 0, 0, 0);
    if (addSeparator) {
        new FXMenuSeparator(ret);
    }
}

void GUIGlObject::buildPositionCopyEntry	(	GUIGLObjectPopupMenu *	ret,
		bool	addSeparator = true
	)			throw () [protected, inherited]

Builds an entry which allows to copy the cursor position.

Parameters:

	in,filled]	ret The popup menu to add the entry to
[in]	app	The application, needed for callbacks
[in]	addSeparator	Whether a separator shall be added, too

Definition at line 131 of file GUIGlObject.cpp.

References MID_COPY_CURSOR_POSITION.

Referenced by GUIVehicle::getPopUpMenu(), GUITriggeredRerouter::getPopUpMenu(), GUITrafficLightLogicWrapper::getPopUpMenu(), GUIPolygon2D::getPopUpMenu(), GUIPointOfInterest::getPopUpMenu(), GUINet::getPopUpMenu(), GUILaneWrapper::getPopUpMenu(), GUILaneSpeedTrigger::getPopUpMenu(), GUIJunctionWrapper::getPopUpMenu(), GUIEmitter::getPopUpMenu(), getPopUpMenu(), GUIDetectorWrapper::getPopUpMenu(), and GUIBusStop::getPopUpMenu().

                                                               {
    new FXMenuCommand(ret, "Copy cursor position to clipboard", 0, ret, MID_COPY_CURSOR_POSITION);
    if (addSeparator) {
        new FXMenuSeparator(ret);
    }
}

void GUIGlObject::buildSelectionPopupEntry	(	GUIGLObjectPopupMenu *	ret,
		bool	addSeparator = true
	)			throw () [protected, inherited]

Builds an entry which allows to (de)select the object.

Parameters:

	in,filled]	ret The popup menu to add the entry to
[in]	app	The application, needed for callbacks
[in]	addSeparator	Whether a separator shall be added, too

Definition at line 107 of file GUIGlObject.cpp.

References GUIGlObject::getGlID(), GUIIconSubSys::getIcon(), GUIGlObject::getType(), gSelected, ICON_FLAG_MINUS, ICON_FLAG_PLUS, GUISelectedStorage::isSelected(), MID_ADDSELECT, and MID_REMOVESELECT.

Referenced by GUIVehicle::getPopUpMenu(), GUITriggeredRerouter::getPopUpMenu(), GUITrafficLightLogicWrapper::getPopUpMenu(), GUIPolygon2D::getPopUpMenu(), GUIPointOfInterest::getPopUpMenu(), GUILaneWrapper::getPopUpMenu(), GUILaneSpeedTrigger::getPopUpMenu(), GUIJunctionWrapper::getPopUpMenu(), GUIEmitter::getPopUpMenu(), getPopUpMenu(), GUIDetectorWrapper::getPopUpMenu(), and GUIBusStop::getPopUpMenu().

                                                                 {
    if (gSelected.isSelected(getType(), getGlID())) {
        new FXMenuCommand(ret, "Remove From Selected", GUIIconSubSys::getIcon(ICON_FLAG_MINUS), ret, MID_REMOVESELECT);
    } else {
        new FXMenuCommand(ret, "Add To Selected", GUIIconSubSys::getIcon(ICON_FLAG_PLUS), ret, MID_ADDSELECT);
    }
    if (addSeparator) {
        new FXMenuSeparator(ret);
    }
}

void GUIGlObject::buildShowManipulatorPopupEntry	(	GUIGLObjectPopupMenu *	ret,
		bool	addSeparator = true
	)			throw () [protected, inherited]

Builds an entry which allows to open the manipulator window.

Parameters:

	in,filled]	ret The popup menu to add the entry to
[in]	app	The application, needed for callbacks
[in]	addSeparator	Whether a separator shall be added, too

Definition at line 141 of file GUIGlObject.cpp.

References GUIIconSubSys::getIcon(), ICON_MANIP, and MID_MANIP.

Referenced by GUITriggeredRerouter::getPopUpMenu(), GUILaneSpeedTrigger::getPopUpMenu(), and GUIEmitter::getPopUpMenu().

                                   {
    new FXMenuCommand(ret, "Open Manipulator...",
                      GUIIconSubSys::getIcon(ICON_MANIP), ret, MID_MANIP);
    if (addSeparator) {
        new FXMenuSeparator(ret);
    }
}

void GUIGlObject::buildShowParamsPopupEntry	(	GUIGLObjectPopupMenu *	ret,
		bool	addSeparator = true
	)			throw () [protected, inherited]

Builds an entry which allows to open the parameter window.

Parameters:

	in,filled]	ret The popup menu to add the entry to
[in]	app	The application, needed for callbacks
[in]	addSeparator	Whether a separator shall be added, too

Definition at line 121 of file GUIGlObject.cpp.

References GUIIconSubSys::getIcon(), ICON_APP_TABLE, and MID_SHOWPARS.

Referenced by GUIVehicle::getPopUpMenu(), GUINet::getPopUpMenu(), GUILaneWrapper::getPopUpMenu(), GUILaneSpeedTrigger::getPopUpMenu(), getPopUpMenu(), and GUIDetectorWrapper::getPopUpMenu().

                                                                  {
    new FXMenuCommand(ret, "Show Parameter", GUIIconSubSys::getIcon(ICON_APP_TABLE), ret, MID_SHOWPARS);
    if (addSeparator) {
        new FXMenuSeparator(ret);
    }
}

void MSEdge::changeLanes

(

SUMOTime

t

)

throw () [virtual, inherited]

Performs lane changing on this edge.

Definition at line 327 of file MSEdge.cpp.

References MSEdge::EDGEFUNCTION_INTERNAL, MSLaneChanger::laneChange(), MSEdge::myFunction, and MSEdge::myLaneChanger.

Referenced by MSEdgeControl::changeLanes().

                                      {
    if (myFunction==EDGEFUNCTION_INTERNAL) {
        return;
    }
    assert(myLaneChanger != 0);
    myLaneChanger->laneChange(t);
}

void MSEdge::clear

(

)

throw () [static, inherited]

Clears the dictionary.

Definition at line 442 of file MSEdge.cpp.

References MSEdge::myDict.

Referenced by MSNet::clearAll().

                      {
    for (DictType::iterator i=myDict.begin(); i!=myDict.end(); ++i) {
        delete(*i).second;
    }
    myDict.clear();
}

void MSEdge::closeBuilding

(

)

[inherited]

Todo:

Has to be called after all edges were built and all connections were set...; Still, is not very nice

Definition at line 94 of file MSEdge.cpp.

References MSLane::getEdge(), MSEdge::myAllowed, MSEdge::myLanes, MSEdge::myPredeccesors, MSEdge::mySuccessors, and MSEdge::rebuildAllowedLanes().

                      {
    myAllowed[0] = new std::vector<MSLane*>();
    for (std::vector<MSLane*>::iterator i=myLanes->begin(); i!=myLanes->end(); ++i) {
        myAllowed[0]->push_back(*i);
        const MSLinkCont &lc = (*i)->getLinkCont();
        for (MSLinkCont::const_iterator j=lc.begin(); j!=lc.end(); ++j) {
            MSLane *toL = (*j)->getLane();
            if (toL!=0) {
                MSEdge &to = toL->getEdge();
                //
                if (std::find(mySuccessors.begin(), mySuccessors.end(), &to)==mySuccessors.end()) {
                    mySuccessors.push_back(&to);
                }
                if (std::find(to.myPredeccesors.begin(), to.myPredeccesors.end(), this)==to.myPredeccesors.end()) {
                    to.myPredeccesors.push_back(this);
                }
                //
                if (myAllowed.find(&to)==myAllowed.end()) {
                    myAllowed[&to] = new std::vector<MSLane*>();
                }
                myAllowed[&to]->push_back(*i);
            }
        }
    }
    std::sort(mySuccessors.begin(), mySuccessors.end(), by_id_sorter());
    rebuildAllowedLanes();
}

SUMOTime MSEdge::decVaporization

(

SUMOTime

t

)

throw (ProcessError) [inherited]

Disables vaporization.

The internal vaporization counter is decreased what disables the vaporization if it was only once enabled. Called from the event handler.

Parameters:

[in]

t

The current time (unused)

Returns:

Time to next call (always 0)

Exceptions:

ProcessError

not thrown by this method, just derived

Definition at line 231 of file MSEdge.cpp.

References MSEdge::myVaporizationRequests.

Referenced by NLTriggerBuilder::buildVaporizer().

                                                    {
    --myVaporizationRequests;
    return 0;
}

MSEdge * MSEdge::dictionary

(

size_t

index

)

throw () [static, inherited]

Returns the MSEdge at the index.

Definition at line 429 of file MSEdge.cpp.

References MSEdge::myEdges.

                                    {
    assert(myEdges.size()>id);
    return myEdges[id];
}

MSEdge * MSEdge::dictionary

(

const std::string &

id

)

throw () [static, inherited]

Returns the MSEdge associated to the key id if exists, otherwise returns 0.

Definition at line 418 of file MSEdge.cpp.

References MSEdge::myDict.

                                              {
    DictType::iterator it = myDict.find(id);
    if (it == myDict.end()) {
        // id not in myDict.
        return 0;
    }
    return it->second;
}

bool MSEdge::dictionary	(	const std::string &	id,
		MSEdge *	edge
	)			throw () [static, inherited]

Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary. Otherwise returns false.

Definition at line 402 of file MSEdge.cpp.

References MSEdge::myDict, and MSEdge::myEdges.

Referenced by NLHandler::addDistrict(), NLHandler::addDistrictEdge(), NLBuilder::EdgeFloatTimeLineRetriever_EdgeTravelTime::addEdgeWeight(), NLBuilder::EdgeFloatTimeLineRetriever_EdgeEffort::addEdgeWeight(), MSVehicleTransfer::addVeh(), NLEdgeControlBuilder::beginEdgeParsing(), NLDetectorBuilder::buildRouteProbe(), NLTriggerBuilder::buildVaporizer(), MSDevice_Routing::buildVehicleDevices(), MSVehicleTransfer::checkEmissions(), traci::TraCIServer::commandChangeRoute(), traci::TraCIServer::commandChangeTarget(), traci::TraCIServer::commandDistanceRequest(), traci::TraCIServer::commandStopNode(), traci::TraCIServer::convertCartesianToRoadMap(), traci::TraCIServer::convertRoadMapToCartesian(), GUINet::getEdgeBoundary(), traci::TraCIServer::handleRoadMapDomain(), traci::TraCIServer::handleVehicleDomain(), GUISelectionLoader::loadSelection(), MSTriggeredRerouter::myStartElement(), MSRouteHandler::myStartElement(), NLTriggerBuilder::parseAndBuildRerouter(), MSEdge::parseEdgesList(), TraCIServerAPI_Vehicle::processGet(), TraCIServerAPI_Edge::processGet(), TraCIServerAPI_Vehicle::processSet(), TraCIServerAPI_Edge::processSet(), and MSVehicle::reroute().

                                                           {
    DictType::iterator it = myDict.find(id);
    if (it == myDict.end()) {
        // id not in myDict.
        myDict[id] = ptr;
        while (myEdges.size()<ptr->getNumericalID()+1) {
            myEdges.push_back(0);
        }
        myEdges[ptr->getNumericalID()] = ptr;
        return true;
    }
    return false;
}

size_t MSEdge::dictSize

(

)

throw () [static, inherited]

Returns the number of edges.

Definition at line 436 of file MSEdge.cpp.

References MSEdge::myDict.

Referenced by traci::TraCIServer::commandChangeTarget(), traci::TraCIServer::commandDistanceRequest(), MSDevice_Routing::enterLaneAtEmit(), fill(), traci::TraCIServer::handleRoadMapDomain(), MSDevice_Routing::onTryEmit(), traci::TraCIServer::postProcessSimulationStep(), TraCIServerAPI_Vehicle::processSet(), MSTriggeredRerouter::reroute(), and MSDevice_Routing::wrappedRerouteCommandExecute().

                         {
    return myDict.size();
}

void GUIEdge::drawGL

(

const GUIVisualizationSettings &

s

)

const throw () [virtual]

Draws the object.

Parameters:

[in]

s

The settings for the current view (may influence drawing)

See also:

GUIGlObject::drawGL

Implements GUIGlObject.

Definition at line 209 of file GUIEdge.cpp.

References Position2D::add(), GLHelper::drawBoxLines(), MSEdge::EDGEFUNCTION_CONNECTOR, MSEdge::EDGEFUNCTION_INTERNAL, MSEdge::EDGEFUNCTION_NORMAL, getMicrosimID(), GUILaneWrapper::getShape(), Position2DVector::length(), Position2D::mul(), MSEdge::myFunction, myLaneGeoms, pfdkGetStringWidth(), pfDrawString(), pfSetPosition(), pfSetScale(), Position2DVector::positionAtLengthPosition(), Position2DVector::rotationDegreeAtLengthPosition(), SUMO_const_halfLaneAndOffset, SUMOReal, Position2D::x(), and Position2D::y().

                                                               {
    if (s.hideConnectors&&myFunction==MSEdge::EDGEFUNCTION_CONNECTOR) {
        return;
    }
    // draw the lanes
    for (LaneWrapperVector::const_iterator i=myLaneGeoms.begin(); i!=myLaneGeoms.end(); ++i) {
#ifdef HAVE_MESOSIM
        if (MSGlobals::gUseMesoSim) {
            s.edgeColorer.setGlColor(*this);
        }
#endif
        (*i)->drawGL(s);
    }
    // check whether lane boundaries shall be drawn
    if (s.scale>1.&&s.laneShowBorders&&myFunction!=MSEdge::EDGEFUNCTION_INTERNAL) {
        glTranslated(0, 0, .01);
        for (LaneWrapperVector::const_iterator i=myLaneGeoms.begin()+1; i!=myLaneGeoms.end(); ++i) {
            (*i)->drawBordersGL(s);
        }
        glTranslated(0, 0, -.01);
        // draw white boundings
        glTranslated(0, 0, .02);
        glColor3d(1,1,1);
        for (LaneWrapperVector::const_iterator i=myLaneGeoms.begin(); i!=myLaneGeoms.end(); ++i) {
            GLHelper::drawBoxLines((*i)->getShape(), (*i)->getShapeRotations(), (*i)->getShapeLengths(), SUMO_const_halfLaneAndOffset);
        }
        glTranslated(0, 0, -.02);
    }
#ifdef HAVE_MESOSIM
    if (MSGlobals::gUseMesoSim) {
        size_t idx = 0;
        for (LaneWrapperVector::const_iterator l=myLaneGeoms.begin(); l!=myLaneGeoms.end(); ++l,++idx) {
            const Position2DVector& shape = (*l)->getShape();
            const DoubleVector& shapeRotations = (*l)->getShapeRotations();
            const DoubleVector& shapeLengths = (*l)->getShapeLengths();
            const Position2D &laneBeg = shape[0];

            glColor3d(1,1,0);
            glPushMatrix();
            glTranslated(laneBeg.x(), laneBeg.y(), 0);
            glRotated(shapeRotations[0], 0, 0, 1);
            // go through the vehicles
            int shapePos = 0;
            SUMOReal positionOffset = 0;
            SUMOReal position = 0;
            for (MESegment *segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment!=0; segment = segment->getNextSegment()) {
                const std::vector<size_t> numCars = segment->getQueSizes();
                const SUMOReal length = segment->getLength();
                if (idx < numCars.size()) {
                    const SUMOReal avgCarSize = segment->getOccupancy() / segment->getCarNumber();
                    for (size_t i = 0; i < numCars[idx]; i++) {
                        SUMOReal vehiclePosition = position + length - i * avgCarSize;
                        SUMOReal xOff = 0.f;
                        while (vehiclePosition < position) {
                            vehiclePosition += length;
                            xOff += 0.5f;
                        }
                        while (shapePos<(int)shapeRotations.size()-1 && vehiclePosition>positionOffset+shapeLengths[shapePos]) {
                            glPopMatrix();
                            positionOffset += shapeLengths[shapePos];
                            shapePos++;
                            glPushMatrix();
                            glTranslated(shape[shapePos].x(), shape[shapePos].y(), 0);
                            glRotated(shapeRotations[shapePos], 0, 0, 1);
                        }
                        glPushMatrix();
                        glTranslated(xOff, -(vehiclePosition-positionOffset), 0);
                        glPushMatrix();
                        glScaled(1, avgCarSize, 1);
                        glBegin(GL_TRIANGLES);
                        glVertex2d(0, 0);
                        glVertex2d(0-1.25, 1);
                        glVertex2d(0+1.25, 1);
                        glEnd();
                        glPopMatrix();
                        glPopMatrix();
                    }
                }
                position += length;
            }
            glPopMatrix();
        }
    }
#endif
    // (optionally) draw the name
    if ((s.drawEdgeName && myFunction == EDGEFUNCTION_NORMAL) || (s.drawInternalEdgeName && myFunction != EDGEFUNCTION_NORMAL)) {
        float nameSize = s.edgeNameSize;
        if (myFunction == EDGEFUNCTION_NORMAL) {
            glColor3d(s.edgeNameColor.red(), s.edgeNameColor.green(), s.edgeNameColor.blue());
        } else {
            glColor3d(s.internalEdgeNameColor.red(), s.internalEdgeNameColor.green(), s.internalEdgeNameColor.blue());
            nameSize = s.internalEdgeNameSize;
        }
        GUILaneWrapper *lane1 = myLaneGeoms[0];
        GUILaneWrapper *lane2 = myLaneGeoms[myLaneGeoms.size()-1];
        glPushMatrix();
        glTranslated(0, 0, -.06);
        Position2D p = lane1->getShape().positionAtLengthPosition(lane1->getShape().length()/(SUMOReal) 2.);
        p.add(lane2->getShape().positionAtLengthPosition(lane2->getShape().length()/(SUMOReal) 2.));
        p.mul(.5);
        glTranslated(p.x(), p.y(), 0);
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        pfSetPosition(0, 0);
        pfSetScale(nameSize / s.scale);
        SUMOReal w = pfdkGetStringWidth(getMicrosimID().c_str());
        glRotated(180, 1, 0, 0);
        SUMOReal angle = lane1->getShape().rotationDegreeAtLengthPosition(lane1->getShape().length()/(SUMOReal) 2.);
        angle += 90;
        if (angle>90&&angle<270) {
            angle -= 180;
        }
        glRotated(angle, 0, 0, 1);
        glTranslated(-w/2., .2*nameSize / s.scale, 0);
        pfDrawString(getMicrosimID().c_str());
        glTranslated(0, 0, .06);
        glPopMatrix();
    }
}

bool MSEdge::emit	(	MSVehicle &	v,
		SUMOTime	time
	)			const throw (ProcessError) [inherited]

Emits the given vehicle.

The procedure for choosing the proper lane is determined, first. In dependance to this, the proper emission lane is chosen.

Emission itself is done by calling the chose lane's "emit" method.

Parameters:

[in]	v	The vehicle to emit
[in]	time	The current simulation time

Returns:

Whether the vehicle could be emitted

See also:

MSLane::emit

Definition at line 280 of file MSEdge.cpp.

References DEPART_POS_FREE, DEPART_POS_GIVEN, DEPART_POS_RANDOM, DEPART_POS_RANDOM_FREE, SUMOVehicleParameter::departPos, SUMOVehicleParameter::departPosProcedure, MSLane::emit(), MSEdge::getDepartLane(), MSEdge::getLanes(), MSEdge::isVaporizing(), RandHelper::rand(), and SUMOReal.

Referenced by MSEmitter::childCheckEmit(), MSCalibrator::childCheckEmit(), and MSEmitControl::tryEmit().

                                                                  {
    // when vaporizing, no vehicles are emitted...
    if (isVaporizing()) {
        return false;
    }
    const SUMOVehicleParameter &pars = v.getParameter();
#ifdef HAVE_MESOSIM
    if (MSGlobals::gUseMesoSim) {
        SUMOReal pos = 0.0;
        switch (pars.departPosProcedure) {
        case DEPART_POS_GIVEN:
            if (pars.departPos >= 0.) {
                pos = pars.departPos;
            } else {
                pos = pars.departPos + getLanes()[0]->getLength();
            }
            break;
        case DEPART_POS_RANDOM:
        case DEPART_POS_RANDOM_FREE:
            pos = RandHelper::rand(getLanes()[0]->getLength());
            break;
        default:
            break;
        }
        bool result = false;
        bool insertToNet = false;
        MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this, pos);
        if (pars.departPosProcedure == DEPART_POS_FREE) {
            while (segment != 0 && !result) {
                result = segment->initialise(&v, time, insertToNet);
                segment = segment->getNextSegment();
            }
        } else {
            result = segment->initialise(&v, time, insertToNet);
        }
        if (insertToNet) {
            MSGlobals::gMesoNet->addCar(&v);
        }
        return result;
    }
#endif
    MSLane* emitLane = getDepartLane(v);
    return emitLane != 0 && /*emitLane->getVehLenSum() + v.getLength() < emitLane->getLength() && */emitLane->emit(v);
}

void GUIEdge::fill

(

std::vector< GUIEdge * > &

netsWrappers

)

[static]

Definition at line 141 of file GUIEdge.cpp.

References MSEdge::dictSize(), MSEdge::EDGEFUNCTION_DISTRICT, MSEdge::myDict, and size.

Referenced by GUINet::initGUIStructures().

                                               {
    size_t size = MSEdge::dictSize();
    netsWrappers.reserve(size);
    for (DictType::iterator i=myDict.begin(); i!=myDict.end(); ++i) {
        if (i->second->getPurpose() != MSEdge::EDGEFUNCTION_DISTRICT) {
            netsWrappers.push_back(static_cast<GUIEdge*>((*i).second));
        }
    }
}

Boundary GUIEdge::getBoundary

(

)

const

Returns the street's geometry.

Definition at line 127 of file GUIEdge.cpp.

References Boundary::add(), Boundary::grow(), myLaneGeoms, and Position2DVector::size().

Referenced by getCenteringBoundary(), and GUINet::getEdgeBoundary().

                           {
    Boundary ret;
    for (LaneWrapperVector::const_iterator i=myLaneGeoms.begin(); i!=myLaneGeoms.end(); ++i) {
        const Position2DVector &g = (*i)->getShape();
        for (unsigned int j=0; j<g.size(); j++) {
            ret.add(g[j]);
        }
    }
    ret.grow(10);
    return ret;
}

Boundary GUIEdge::getCenteringBoundary

(

)

const throw () [virtual]

Returns the boundary to which the view shall be centered in order to show the object.

Returns:

The boundary the object is within

See also:

GUIGlObject::getCenteringBoundary

Implements GUIGlObject.

Definition at line 201 of file GUIEdge.cpp.

References getBoundary(), and Boundary::grow().

                                            {
    Boundary b = getBoundary();
    b.grow(20);
    return b;
}

SUMOReal MSEdge::getCurrentTravelTime

(

)

const throw () [inherited]

Computes and returns the current travel time for this edge.

The mean travel time of all lanes is summed and divided by the number of lanes. If the result is zero, 1000000. (a very large number) is returned, otherwise the edge's length divided by this speed.

Returns:

The current effort (travel time) to pass the edge

Definition at line 357 of file MSEdge.cpp.

References MSEdge::myLanes, and SUMOReal.

Referenced by TraCIServerAPI_Edge::processGet().

                                           {
    SUMOReal v = 0;
#ifdef HAVE_MESOSIM
    if (MSGlobals::gUseMesoSim) {
        MESegment *first = MSGlobals::gMesoNet->getSegmentForEdge(*this);
        unsigned segments = 0;
        do {
            v += first->getMeanSpeed();
            first = first->getNextSegment();
            segments++;
        } while (first!=0);
        v /= (SUMOReal) segments;
    } else {
#endif
        for (std::vector<MSLane*>::iterator i=myLanes->begin(); i!=myLanes->end(); ++i) {
            v += (*i)->getMeanSpeed();
        }
        v /= (SUMOReal) myLanes->size();
#ifdef HAVE_MESOSIM
    }
#endif
    if (v!=0) {
        return (*myLanes)[0]->getLength() / v;
    } else {
        return 1000000.;
    }
}

MSLane * MSEdge::getDepartLane

(

const MSVehicle &

v

)

const throw () [inherited]

Finds a depart lane for the given vehicle.

Depending on the depart lane procedure a depart lane is chosen. Repeated calls with the same vehicle may return different results if the procedure is "random" or "free". In case no appropriate lane was found, 0 is returned.

Parameters:

[in]

v

The vehicle to get the depart lane for

Returns:

a possible depart lane

See also:

MSLane::emit

Definition at line 255 of file MSEdge.cpp.

References MSEdge::allowedLanes(), MSLane::allowsVehicleClass(), DEPART_LANE_DEFAULT, DEPART_LANE_DEPARTLANE, DEPART_LANE_FREE, DEPART_LANE_GIVEN, DEPART_LANE_RANDOM, SUMOVehicleParameter::departLane, SUMOVehicleParameter::departLaneProcedure, MSEdge::getFreeLane(), RandHelper::getRandomFrom(), MSEdge::myDepartLane, and MSEdge::myLanes.

Referenced by MSEdge::emit().

                                                      {
    const SUMOVehicleParameter &pars = v.getParameter();
    switch (pars.departLaneProcedure) {
    case DEPART_LANE_GIVEN:
        if ((int) myLanes->size() <= pars.departLane || !(*myLanes)[pars.departLane]->allowsVehicleClass(v.getVehicleType().getVehicleClass())) {
            return 0;
        }
        return (*myLanes)[pars.departLane];
    case DEPART_LANE_RANDOM:
        return RandHelper::getRandomFrom(*allowedLanes(v.getVehicleType().getVehicleClass()));
    case DEPART_LANE_FREE:
        return getFreeLane(v.getVehicleType().getVehicleClass());
    case DEPART_LANE_DEPARTLANE:
    case DEPART_LANE_DEFAULT:
    default:
        break;
    }
    if (!myDepartLane->allowsVehicleClass(v.getVehicleType().getVehicleClass())) {
        return 0;
    }
    return myDepartLane;
}

const MSEdge* const MSEdge::getFollower

(

unsigned int

n

)

const throw () [inline, inherited]

Returns the n-th of the following edges.

Parameters:

[in]

n

The index within following edges of the edge to return

Returns:

The n-th of the following edges

Definition at line 237 of file MSEdge.h.

References MSEdge::mySuccessors.

Referenced by MSRouteHandler::myStartElement().

                                                                   {
        return mySuccessors[n];
    }

MSLane * MSEdge::getFreeLane

(

const SUMOVehicleClass

vclass

)

const throw () [inherited]

Finds the emptiest lane allowing the vehicle class.

The emptiest lane is the one with the fewest vehicles on. If there is more than one, the first according to its index in the lane container is chosen.

Parameters:

[in]

vclass

The vehicle class to look for

Returns:

the least occupied lane

See also:

MSLane::emit

Definition at line 238 of file MSEdge.cpp.

References MSEdge::allowedLanes(), and MSLane::getVehicleNumber().

Referenced by MSVehicleTransfer::checkEmissions(), and MSEdge::getDepartLane().

                                                               {
    const std::vector<MSLane*>* lanes = allowedLanes(vclass);
    MSLane* res = 0;
    if (lanes != 0) {
        unsigned int noCars = INT_MAX;
        for (std::vector<MSLane*>::const_iterator i=lanes->begin(); i!=lanes->end(); ++i) {
            if ((*i)->getVehicleNumber()<noCars) {
                res = (*i);
                noCars = (*i)->getVehicleNumber();
            }
        }
    }
    return res;
}

const std::string& GUIGlObject::getFullName

(

)

const throw () [inline, inherited]

Returns the full name appearing in the tool tip.

Returns:

This object's typed id

Definition at line 95 of file GUIGlObject.h.

References GUIGlObject::myFullName.

Referenced by GUIGlObject::buildPopupHeader(), GUIGLObjectPopupMenu::onCmdCopyTypedName(), GUIParam_PopupMenuInterface::onCmdOpenTracker(), GUIGLObjectToolTip::onPaint(), GUITriggeredRerouter::openManipulator(), GUILaneSpeedTrigger::openManipulator(), GUIEmitter::openManipulator(), GUIDialog_GLChosenEditor::rebuildList(), GUISelectedStorage::save(), and GUISelectedStorage::SingleTypeSelections::save().

                                                 {
        return myFullName;
    }

GLuint GUIGlObject::getGlID

(

)

const throw () [inline, inherited]

Returns the numerical id of the object.

Returns:

This object's gl-id

Definition at line 103 of file GUIGlObject.h.

References GUIGlObject::myGlID.

Referenced by GUIGlObject::buildSelectionPopupEntry(), GUIViewTraffic::drawBestLanes(), GUIVehicle::drawGL(), GUITriggeredRerouter::drawGL(), GUIPolygon2D::drawGL(), GUIPointOfInterest::drawGL(), GUILaneWrapper::drawGL(), GUILaneSpeedTrigger::drawGL(), GUIJunctionWrapper::drawGL(), GUIInductLoop::MyWrapper::drawGL(), GUIEmitter::drawGL(), GUIE3Collector::MyWrapper::drawGL(), GUIBusStop::drawGL(), GUI_E2_ZS_Collector::MyWrapper::drawGL(), GUIViewTraffic::drawRoute(), FXIMPLEMENT(), GUILaneWrapper::Colorer::getColorValue(), GUISUMOAbstractView::getObjectUnderCursor(), GUIVehicle::getPopUpMenu(), GUIGLObjectPopupMenu::onCmdAddSelected(), GUIGLObjectPopupMenu::onCmdRemoveSelected(), GUIVehicle::GUIVehiclePopupMenu::onCmdStartTrack(), and ROWdrawAction_drawLinkRules().

                                   {
        return myGlID;
    }

const std::string& MSEdge::getID

(

)

const throw () [inline, inherited]

Returns the id of the edge.

Returns:

This edge's id

Definition at line 183 of file MSEdge.h.

References MSEdge::myID.

Referenced by MSVehicleTransfer::checkEmissions(), traci::TraCIServer::commandGetTLStatus(), getMicrosimID(), traci::TraCIServer::handleRoadMapDomain(), traci::TraCIServer::handleTrafficLightDomain(), traci::TraCIServer::handleVehicleDomain(), MSEdge::by_id_sorter::operator()(), traci::TraCIServer::postProcessSimulationStep(), TraCIServerAPI_Vehicle::processGet(), TraCIServerAPI_Lane::processGet(), and MSRouteProbe::writeXMLOutput().

                                           {
        return myID;
    }

std::vector< GLuint > GUIEdge::getIDs

(

)

[static]

Returns the list of all known junctions as their ids

Definition at line 116 of file GUIEdge.cpp.

References MSEdge::myDict, and size.

Referenced by FXIMPLEMENT().

                {
    std::vector<GLuint> ret;
    ret.reserve(MSEdge::myDict.size());
    for (MSEdge::DictType::iterator i=MSEdge::myDict.begin(); i!=MSEdge::myDict.end(); ++i) {
        ret.push_back(static_cast<GUIEdge*>((*i).second)->getGlID());
    }
    return ret;
}

const std::vector<MSEdge*>& MSEdge::getIncomingEdges

(

)

const throw () [inline, inherited]

Returns the list of edges from which this edge may be reached.

Returns:

Edges from which this edge may be reached

Definition at line 221 of file MSEdge.h.

References MSEdge::myPredeccesors.

                                                               {
        return myPredeccesors;
    }

MSLane & GUIEdge::getLane

(

size_t

laneNo

)

returns the enumerated lane (!!! why not private with a friend?)

Definition at line 93 of file GUIEdge.cpp.

References size.

                              {
    assert(laneNo<myLanes->size());
    return *((*myLanes)[laneNo]);
}

GUILaneWrapper & GUIEdge::getLaneGeometry

(

const MSLane *

lane

)

const

Definition at line 107 of file GUIEdge.cpp.

References myLaneGeoms.

                                                 {
    LaneWrapperVector::const_iterator i=
        find_if(myLaneGeoms.begin(), myLaneGeoms.end(), lane_wrapper_finder(*lane));
    assert(i!=myLaneGeoms.end());
    return *(*i);
}

GUILaneWrapper & GUIEdge::getLaneGeometry

(

size_t

laneNo

)

const

returns the enumerated lane's geometry (!!! why not private with a friend?)

Definition at line 100 of file GUIEdge.cpp.

References myLaneGeoms, and size.

Referenced by GUIViewTraffic::draw(), GUITriggeredRerouter::drawGL(), GUIEmitter::drawGL(), GUITriggeredRerouter::GUITriggeredRerouter(), GUINet::initDetectors(), and GUI_E2_ZS_CollectorOverLanes::MyWrapper::MyWrapper().

                                            {
    assert(laneNo<myLanes->size());
    return *(myLaneGeoms[laneNo]);
}

static std::pair<SUMOReal, SUMOReal> GUIEdge::getLaneOffsets	(	SUMOReal	x1,
		SUMOReal	y1,
		SUMOReal	x2,
		SUMOReal	y2,
		SUMOReal	prev,
		SUMOReal	wanted
	)			[static]

returns the position on the line given by the coordinates where "prev" is the length of the line and "wanted" the distance from the begin !!! should be within another class

const std::vector<MSLane*>& MSEdge::getLanes

(

)

const throw () [inline, inherited]

Returns this edge's lanes.

Returns:

This edge's lanes

Definition at line 148 of file MSEdge.h.

References MSEdge::myLanes.

Referenced by MSEdgeControl::changeLanes(), MSVehicleTransfer::checkEmissions(), traci::TraCIServer::commandChangeLane(), traci::TraCIServer::commandStopNode(), traci::TraCIServer::convertCartesianToRoadMap(), traci::TraCIServer::convertRoadMapToCartesian(), GUITriggeredRerouter::drawGL(), MSEdge::emit(), MS_E2_ZS_CollectorOverLanes::extendTo(), GUILaneWrapper::getEdgeLaneNumber(), MSDevice_Routing::getEffort(), MSNet::EdgeWeightsProxi::getTravelTime(), GUITriggeredRerouter::GUITriggeredRerouter(), traci::TraCIServer::handleRoadMapDomain(), GUINet::initGUIStructures(), MSVehicle::MSVehicle(), MSLCM_DK2004::patchSpeed(), TraCIServerAPI_Vehicle::processGet(), TraCIServerAPI_Edge::processGet(), TraCIServerAPI_Vehicle::processSet(), TraCIServerAPI_Edge::processSet(), MSVehicle::rebuildContinuationsFor(), and MSVehicle::replaceRoute().

                                                       {
        return *myLanes;
    }

SUMOTime MSEdge::getLastFailedEmissionTime

(

)

const throw () [inline, inherited]

Returns the last time a vehicle could not be inserted.

Returns:

The current value

Definition at line 341 of file MSEdge.h.

References MSEdge::myLastFailedEmissionTime.

Referenced by MSEmitControl::tryEmit().

                                                              {
        return myLastFailedEmissionTime;
    }

const std::string & GUIEdge::getMicrosimID

(

)

const throw () [virtual]

Returns the id of the object as known to microsim.

Returns:

The id of the edge

See also:

GUIGlObject::getMicrosimID

Implements GUIGlObject.

Definition at line 195 of file GUIEdge.cpp.

References MSEdge::getID().

Referenced by drawGL().

                                     {
    return getID();
}

unsigned int MSEdge::getNoFollowing

(

)

const throw () [inline, inherited]

Returns the number of edges that may be reached from this edge.

Returns:

The number of following edges

Definition at line 229 of file MSEdge.h.

References MSEdge::mySuccessors.

Referenced by MSRouteHandler::myStartElement().

                                                {
        return (unsigned int) mySuccessors.size();
    }

unsigned int MSEdge::getNumericalID

(

)

const throw () [inline, inherited]

Returns the numerical id of the edge.

Returns:

This edge's numerical id

Definition at line 200 of file MSEdge.h.

References MSEdge::myNumericalID.

Referenced by MSEdgeControl::changeLanes(), and traci::TraCIServer::handleRoadMapDomain().

                                                {
        return myNumericalID;
    }

GUIParameterTableWindow * GUIEdge::getParameterWindow	(	GUIMainWindow &	app,
		GUISUMOAbstractView &	parent
	)			throw () [virtual]

Returns an own parameter window.

Parameters:

[in]	app	The application needed to build the parameter window
[in]	parent	The parent window needed to build the parameter window

Returns:

The built parameter window

See also:

GUIGlObject::getParameterWindow

Implements GUIGlObject.

Definition at line 171 of file GUIEdge.cpp.

References GUIParameterTableWindow::closeBuilding(), GUIParameterTableWindow::mkItem(), and MSEdge::myLanes.

                                                           {
    GUIParameterTableWindow *ret = 0;
#ifdef HAVE_MESOSIM
    ret = new GUIParameterTableWindow(app, *this, 5);
    // add items
    ret->mkItem("length [m]", false, (*myLanes)[0]->getLength());
    ret->mkItem("allowed speed [m/s]", false, getAllowedSpeed());
    ret->mkItem("occupancy [%]", true,
                new FunctionBinding<GUIEdge, SUMOReal>(this, &GUIEdge::getOccupancy));
    ret->mkItem("mean vehicle speed [m/s]", true,
                new FunctionBinding<GUIEdge, SUMOReal>(this, &GUIEdge::getMeanSpeed));
    ret->mkItem("flow [veh/h/lane]", true,
                new FunctionBinding<GUIEdge, SUMOReal>(this, &GUIEdge::getFlow));
    ret->mkItem("#vehicles", true,
                new CastingFunctionBinding<GUIEdge, SUMOReal, unsigned int>(this, &GUIEdge::getVehicleNo));
    // close building
    ret->closeBuilding();
#endif
    return ret;
}

GUIGLObjectPopupMenu * GUIEdge::getPopUpMenu	(	GUIMainWindow &	app,
		GUISUMOAbstractView &	parent
	)			throw () [virtual]

Returns an own popup-menu.

Parameters:

[in]	app	The application needed to build the popup-menu
[in]	parent	The parent window needed to build the popup-menu

Returns:

The built popup-menu

See also:

GUIGlObject::getPopUpMenu

Implements GUIGlObject.

Definition at line 154 of file GUIEdge.cpp.

References GUIGlObject::buildCenterPopupEntry(), GUIGlObject::buildNameCopyPopupEntry(), GUIGlObject::buildPopupHeader(), GUIGlObject::buildPositionCopyEntry(), GUIGlObject::buildSelectionPopupEntry(), and GUIGlObject::buildShowParamsPopupEntry().

                                                                             {
    GUIGLObjectPopupMenu *ret = new GUIGLObjectPopupMenu(app, parent, *this);
    buildPopupHeader(ret, app);
    buildCenterPopupEntry(ret);
    buildNameCopyPopupEntry(ret);
    buildSelectionPopupEntry(ret);
#ifdef HAVE_MESOSIM
    if (MSGlobals::gUseMesoSim) {
        buildShowParamsPopupEntry(ret);
    }
#endif
    buildPositionCopyEntry(ret, false);
    return ret;
}

EdgeBasicFunction MSEdge::getPurpose

(

)

const throw () [inline, inherited]

Returns the edge type (EdgeBasicFunction).

Returns:

This edge's EdgeBasicFunction

See also:

EdgeBasicFunction

Definition at line 192 of file MSEdge.h.

References MSEdge::myFunction.

Referenced by MSLane::appropriate(), MSVehicle::checkRewindLinkLanes(), MSVehicle::enterLaneAtMove(), MSVehicle::getBestLanesContinuation(), GUILaneWrapper::getPurpose(), traci::TraCIServer::postProcessSimulationStep(), and MSVehicle::vsafeCriticalCont().

                                                 {
        return myFunction;
    }

GUIGlObjectType GUIEdge::getType

(

)

const throw () [inline, virtual]

Returns the type of the object as coded in GUIGlObjectType.

Returns:

GLO_EDGE (is an edge)

See also:

GUIGlObject::getType

GUIGlObjectType

Implements GUIGlObject.

Definition at line 155 of file GUIEdge.h.

References GLO_EDGE.

                                            {
        return GLO_EDGE;
    }

SUMOTime MSEdge::incVaporization

(

SUMOTime

t

)

throw (ProcessError) [inherited]

Enables vaporization.

The internal vaporization counter is increased enabling the vaporization. Called from the event handler.

Parameters:

[in]

t

The current time (unused)

Returns:

Time to next call (always 0)

Exceptions:

ProcessError

not thrown by this method, just derived

Definition at line 224 of file MSEdge.cpp.

References MSEdge::myVaporizationRequests.

Referenced by NLTriggerBuilder::buildVaporizer().

                                                    {
    ++myVaporizationRequests;
    return 0;
}

void GUIEdge::initGeometry

(

GUIGlObjectStorage &

idStorage

)

throw ()

Builds lane wrappers for this edge's lanes.

Parameters:

[in]

idStorage

The gl-objects storage to retrieve the gl-id for this edge's lanes from

Definition at line 79 of file GUIEdge.cpp.

References myLaneGeoms, and MSEdge::myLanes.

                                                           {
    // don't do this twice
    if (myLaneGeoms.size()>0) {
        return;
    }
    // build the lane wrapper
    myLaneGeoms.reserve(myLanes->size());
    for (std::vector<MSLane*>::const_iterator i=myLanes->begin(); i<myLanes->end(); ++i) {
        myLaneGeoms.push_back((*i)->buildLaneWrapper(idStorage));
    }
}

void MSEdge::initialize	(	MSLane *	departLane,
		std::vector< MSLane * > *	lanes,
		EdgeBasicFunction	function
	)			throw () [inherited]

Initialize the edge.

Parameters:

[in]	allowed	Information which edges may be reached from which lanes
[in]	departLane	The default departure lane (may be 0)
[in]	lanes	List of this edge's lanes
[in]	function	A basic type of the edge

Definition at line 81 of file MSEdge.cpp.

References MSEdge::EDGEFUNCTION_DISTRICT, MSEdge::EDGEFUNCTION_INTERNAL, MSEdge::myDepartLane, MSEdge::myFunction, MSEdge::myLaneChanger, and MSEdge::myLanes.

Referenced by NLHandler::addDistrict(), and NLEdgeControlBuilder::closeEdge().

                                                                                  {
    assert(function == EDGEFUNCTION_DISTRICT || lanes!=0);
    myDepartLane = departLane;
    myLanes = lanes;
    myFunction = function;
    if (myLanes && myLanes->size() > 1 && function!=EDGEFUNCTION_INTERNAL) {
        myLaneChanger = new MSLaneChanger(myLanes);
    }
}

void MSEdge::insertIDs

(

std::vector< std::string > &

into

)

throw () [static, inherited]

Inserts IDs of all known edges into the given vector.

Definition at line 451 of file MSEdge.cpp.

References MSEdge::myDict.

Referenced by TraCIServerAPI_Edge::processGet().

                                                    {
    for (DictType::iterator i=myDict.begin(); i!=myDict.end(); ++i) {
        into.push_back((*i).first);
    }
}

bool MSEdge::isVaporizing

(

)

const throw () [inline, inherited]

Returns whether vehicles on this edge shall be vaporized.

Returns:

Whether no vehicle shall be on this edge

Definition at line 250 of file MSEdge.h.

References MSEdge::myVaporizationRequests.

Referenced by MSEmitter::childCheckEmit(), MSCalibrator::childCheckEmit(), MSEdge::emit(), and MSEmitControl::tryEmit().

                                      {
        return myVaporizationRequests>0;
    }

MSLane *const MSEdge::leftLane

(

const MSLane *const

lane

)

const throw () [inherited]

Returns the lane left to the one given, 0 if the given lane is leftmost.

Parameters:

[in]

lane

The lane right to the one to be returned

Returns:

The lane left to the given, 0 if no such lane exists

Todo:

This method searches for the given in the container; probably, this could be done faster

Definition at line 167 of file MSEdge.cpp.

References MSEdge::myLanes.

Referenced by traci::TraCIServer::commandStopNode(), and MSLane::getLeftLane().

                                                        {
    std::vector<MSLane*>::iterator laneIt = find(myLanes->begin(), myLanes->end(), lane);
    if (laneIt==myLanes->end()||laneIt==myLanes->end()-1) {
        return 0;
    }
    return *(laneIt+1);
}

GUIEdge& GUIEdge::operator=

(

const GUIEdge &

s

)

[private]

invalidated assignment operator

void MSEdge::parseEdgesList	(	const std::vector< std::string > &	desc,
		std::vector< const MSEdge * > &	into,
		const std::string &	rid
	)			throw (ProcessError) [static, inherited]

Parses the given string vector assuming it edge ids.

Parameters:

[in]	desc	The string vector containing edge ids
[out]	into	The vector to fill
[in]	rid	The id of the route these description belongs to; used for error message generation

Exceptions:

ProcessError

If one of the strings contained is not a known edge id

Definition at line 467 of file MSEdge.cpp.

References MSEdge::dictionary().

                                                                 {
    for (std::vector<std::string>::const_iterator i=desc.begin(); i!=desc.end(); ++i) {
        const MSEdge *edge = MSEdge::dictionary(*i);
        // check whether the edge exists
        if (edge==0) {
            throw ProcessError("The edge '" + *i + "' within route '" + rid + "' is not known."
                               + "\n The route can not be build.");
        }
        into.push_back(edge);
    }
}

void MSEdge::parseEdgesList	(	const std::string &	desc,
		std::vector< const MSEdge * > &	into,
		const std::string &	rid
	)			throw (ProcessError) [static, inherited]

Parses the given string assuming it contains a list of edge ids divided by spaces.

Splits the string at spaces, uses polymorph method to generate edge vector.

Parameters:

[in]	desc	The string containing space-separated edge ids
[out]	into	The vector to fill
[in]	rid	The id of the route these description belongs to; used for error message generation

Exceptions:

ProcessError

If one of the strings contained is not a known edge id

Definition at line 459 of file MSEdge.cpp.

References StringTokenizer::getVector().

Referenced by MSRouteHandler::myCharacters(), MSRouteHandler::myStartElement(), MSRouteHandler::openRoute(), and TraCIServerAPI_Vehicle::processSet().

                                                                 {
    StringTokenizer st(desc);
    parseEdgesList(st.getVector(), into, rid);
}

bool MSEdge::prohibits

(

const SUMOVehicle *const

vehicle

)

const throw () [inherited]

Returns whether the vehicle (class) is not allowed on the edge.

Definition at line 387 of file MSEdge.cpp.

References MSEdge::EDGEFUNCTION_DISTRICT, MSEdge::myFunction, MSEdge::myHaveClassConstraints, and MSEdge::myLanes.

                                                                 {
    if (myFunction == EDGEFUNCTION_DISTRICT || !myHaveClassConstraints) {
        return false;
    }
    SUMOVehicleClass vclass = vehicle->getVehicleType().getVehicleClass();
    for (std::vector<MSLane*>::iterator i=myLanes->begin(); i!=myLanes->end(); ++i) {
        if ((*i)->allowsVehicleClass(vclass)) {
            return false;
        }
    }
    return true;
}

void MSEdge::rebuildAllowedLanes

(

)

throw () [inherited]

Definition at line 124 of file MSEdge.cpp.

References MSEdge::myAllowed, MSEdge::myClassedAllowed, MSEdge::myHaveClassConstraints, and MSEdge::myLanes.

Referenced by MSEdge::closeBuilding(), TraCIServerAPI_Lane::processSet(), and TraCIServerAPI_Edge::processSet().

                                    {
    // build the classed allowed lanes
    myHaveClassConstraints = false;
    // build list of vehicle classes that are constrained
    // ... all others will be not regarded (allowed) ...
    std::set<SUMOVehicleClass> vclasses;
    for (std::vector<MSLane*>::const_iterator i2=myLanes->begin(); i2!=myLanes->end(); ++i2) {
        const std::vector<SUMOVehicleClass> &allowed = (*i2)->getAllowedClasses();
        for (std::vector<SUMOVehicleClass>::const_iterator j=allowed.begin(); j!=allowed.end(); j++) {
            vclasses.insert(*j);
        }
        const std::vector<SUMOVehicleClass> &disallowed = (*i2)->getNotAllowedClasses();
        for (std::vector<SUMOVehicleClass>::const_iterator j=disallowed.begin(); j!=disallowed.end(); j++) {
            vclasses.insert(*j);
        }
    }
    // go through these classes
    for (std::set<SUMOVehicleClass>::const_iterator j=vclasses.begin(); j!=vclasses.end(); ++j) {
        // go through connected edges
        for (AllowedLanesCont::iterator i1=myAllowed.begin(); i1!=myAllowed.end(); ++i1) {
            delete myClassedAllowed[*j][(*i1).first];
            myClassedAllowed[*j][(*i1).first] = new std::vector<MSLane*>();
            // go through lanes approaching current edge
            for (std::vector<MSLane*>::iterator i2=(*i1).second->begin(); i2!=(*i1).second->end(); ++i2) {
                // allows the current vehicle class?
                if ((*i2)->allowsVehicleClass(*j)) {
                    // -> may be used
                    myClassedAllowed[*j][(*i1).first]->push_back(*i2);
                }
            }
            // assert that 0 is returned if no connection is allowed for a class
            if (myClassedAllowed[*j][(*i1).first]->size()==0) {
                delete myClassedAllowed[*j][(*i1).first];
                myClassedAllowed[*j][(*i1).first] = 0;
            }
        }
        myHaveClassConstraints = true;
    }
}

MSLane *const MSEdge::rightLane

(

const MSLane *const

lane

)

const throw () [inherited]

Returns the lane right to the one given, 0 if the given lane is rightmost.

Parameters:

[in]

lane

The lane left to the one to be returned

Returns:

The lane right to the given, 0 if no such lane exists

Todo:

This method searches for the given in the container; probably, this could be done faster

Definition at line 177 of file MSEdge.cpp.

References MSEdge::myLanes.

Referenced by traci::TraCIServer::commandStopNode(), and MSLane::getRightLane().

                                                         {
    std::vector<MSLane*>::iterator laneIt = find(myLanes->begin(), myLanes->end(), lane);
    if (laneIt==myLanes->end()||laneIt==myLanes->begin()) {
        return 0;
    }
    return *(laneIt-1);
}

void MSEdge::setLastFailedEmissionTime

(

SUMOTime

time

)

const throw () [inline, inherited]

Sets the last time a vehicle could not be inserted.

Parameters:

[in]

time

the new value

Definition at line 349 of file MSEdge.h.

References MSEdge::myLastFailedEmissionTime.

Referenced by MSEmitControl::tryEmit().

                                                                       {
        myLastFailedEmissionTime = time;
    }

---

Friends And Related Function Documentation

friend class GUIGlObjectStorage [friend, inherited]

Needed to set the id.

Reimplemented in GUI_E2_ZS_CollectorOverLanes::MyWrapper.

Definition at line 111 of file GUIGlObject.h.

---

Field Documentation

AllowedLanesCont MSEdge::myAllowed [protected, inherited]

Associative container from destination-edge to allowed-lanes.

Definition at line 484 of file MSEdge.h.

Referenced by MSEdge::allowedLanes(), MSEdge::closeBuilding(), MSEdge::rebuildAllowedLanes(), and MSEdge::~MSEdge().

ClassedAllowedLanesCont MSEdge::myClassedAllowed [protected, inherited]

From vehicle class to lanes allowed to be used by it.

Definition at line 487 of file MSEdge.h.

Referenced by MSEdge::allowedLanes(), MSEdge::rebuildAllowedLanes(), and MSEdge::~MSEdge().

MSLane* MSEdge::myDepartLane [protected, inherited]

Lane from which vehicles will depart, usually the rightmost.

Definition at line 458 of file MSEdge.h.

Referenced by MSEdge::getDepartLane(), and MSEdge::initialize().

MSEdge::DictType MSEdge::myDict [static, protected, inherited]

Static dictionary to associate string-ids with objects.

Deprecated:

Move to MSEdgeControl, make non-static

Definition at line 504 of file MSEdge.h.

Referenced by MSEdge::clear(), MSEdge::dictionary(), MSEdge::dictSize(), fill(), getIDs(), and MSEdge::insertIDs().

std::vector< MSEdge * > MSEdge::myEdges [static, protected, inherited]

Static list of edges.

Deprecated:

Move to MSEdgeControl, make non-static

Definition at line 509 of file MSEdge.h.

Referenced by MSEdge::dictionary().

EdgeBasicFunction MSEdge::myFunction [protected, inherited]

the purpose of the edge

Definition at line 464 of file MSEdge.h.

Referenced by MSEdge::changeLanes(), drawGL(), MSEdge::getPurpose(), MSEdge::initialize(), and MSEdge::prohibits().

bool MSEdge::myHaveClassConstraints [protected, inherited]

Whether any class constraints exist for this edge.

Definition at line 490 of file MSEdge.h.

Referenced by MSEdge::allowedLanes(), MSEdge::prohibits(), and MSEdge::rebuildAllowedLanes().

std::string MSEdge::myID [protected, inherited]

Unique ID.

Definition at line 449 of file MSEdge.h.

Referenced by MSEdge::getID().

MSLaneChanger* MSEdge::myLaneChanger [protected, inherited]

This member will do the lane-change.

Definition at line 461 of file MSEdge.h.

Referenced by MSEdge::changeLanes(), MSEdge::initialize(), and MSEdge::~MSEdge().

LaneWrapperVector GUIEdge::myLaneGeoms [private]

List of the edge's lanes geometrical information.

Definition at line 196 of file GUIEdge.h.

Referenced by drawGL(), getBoundary(), getLaneGeometry(), initGeometry(), and ~GUIEdge().

std::vector<MSLane*>* MSEdge::myLanes [protected, inherited]

Container for the edge's lane; should be sorted: (right-hand-traffic) the more left the lane, the higher the container-index.

Definition at line 455 of file MSEdge.h.

Referenced by MSEdge::closeBuilding(), MSEdge::getCurrentTravelTime(), MSEdge::getDepartLane(), MSEdge::getLanes(), getParameterWindow(), initGeometry(), MSEdge::initialize(), MSEdge::leftLane(), MSEdge::prohibits(), MSEdge::rebuildAllowedLanes(), MSEdge::rightLane(), and MSEdge::~MSEdge().

SUMOTime MSEdge::myLastFailedEmissionTime [mutable, protected, inherited]

The time of last emission failure.

Definition at line 470 of file MSEdge.h.

Referenced by MSEdge::getLastFailedEmissionTime(), and MSEdge::setLastFailedEmissionTime().

unsigned int MSEdge::myNumericalID [protected, inherited]

This edge's numerical id.

Definition at line 452 of file MSEdge.h.

Referenced by MSEdge::getNumericalID().

std::vector<MSEdge*> MSEdge::myPredeccesors [protected, inherited]

The preceeding edges.

Definition at line 476 of file MSEdge.h.

Referenced by MSEdge::closeBuilding(), and MSEdge::getIncomingEdges().

std::vector<MSEdge*> MSEdge::mySuccessors [protected, inherited]

The succeeding edges.

Definition at line 473 of file MSEdge.h.

Referenced by MSEdge::addFollower(), MSEdge::closeBuilding(), MSEdge::getFollower(), and MSEdge::getNoFollowing().

int MSEdge::myVaporizationRequests [protected, inherited]

Vaporizer counter.

Definition at line 467 of file MSEdge.h.

Referenced by MSEdge::decVaporization(), MSEdge::incVaporization(), and MSEdge::isVaporizing().

---

The documentation for this class was generated from the following files:

• GUIEdge.h
• GUIEdge.cpp