NBLoadedTLDef Class Reference

#include <NBLoadedTLDef.h>

Inheritance diagram for NBLoadedTLDef:

---

Detailed Description

A loaded (complete) traffic light logic.

Definition at line 47 of file NBLoadedTLDef.h.

Public Types
typedef std::map< std::string, SignalGroup * >	SignalGroupCont
	Definition of the container for signal groups.
enum	TLColor {   TLCOLOR_RED, TLCOLOR_YELLOW, TLCOLOR_REDYELLOW, TLCOLOR_GREEN,   TLCOLOR_BLINK }
	An enumeration of possible tl-signal states. More...
Public Member Functions
void	addControlledInnerEdges (const std::vector< std::string > &edges) throw ()
	Adds the given ids into the list of edges not controlled by the tls.
void	addSignalGroup (const std::string &id) throw ()
	Adds a signal group.
void	addSignalGroupPhaseBegin (const std::string &groupid, SUMOTime time, TLColor color) throw ()
	Sets the information about the begin of a phase.
bool	addToSignalGroup (const std::string &groupid, const NBConnectionVector &connections) throw ()
	Adds a list of connections to a signal group.
bool	addToSignalGroup (const std::string &groupid, const NBConnection &connection) throw ()
	Adds a connection to a signal group.
NBTrafficLightLogic *	compute (const NBEdgeCont &ec, OptionsCont &oc) throw ()
	Computes the traffic light logic.
SignalGroup *	findGroup (NBEdge *from, NBEdge *to) const throw ()
	Returns the signal group which is responsible for the given connection.
bool	foes (const NBEdge *const from1, const NBEdge *const to1, const NBEdge *const from2, const NBEdge *const to2) const throw ()
	Returns the information whether the given flows cross.
bool	forbids (const NBEdge *const possProhibitorFrom, const NBEdge *const possProhibitorTo, const NBEdge *const possProhibitedFrom, const NBEdge *const possProhibitedTo, bool regardNonSignalisedLowerPriority) const throw ()
	Returns the information whether "prohibited" flow must let "prohibitor" flow pass.
const std::string &	getID () const throw ()
	Returns the id.
const EdgeVector &	getIncomingEdges () const throw ()
	Returns the list of incoming edges (must be build first).
bool	isLeftMover (const NBEdge *const from, const NBEdge *const to) const throw ()
	returns the information whether the given link is a left-mover
bool	mustBrake (const NBEdge *const possProhibitedFrom, const NBEdge *const possProhibitedTo, const NBEdge *const possProhibitorFrom, const NBEdge *const possProhibitorTo, bool regardNonSignalisedLowerPriority) const throw ()
	Returns the information whether the described flow must let any other flow pass.
bool	mustBrake (const NBConnection &possProhibited, const NBConnection &possProhibitor, bool regardNonSignalisedLowerPriority) const throw ()
	Returns the information whether the described flow must let the other flow pass.
bool	mustBrake (const NBEdge *const from, const NBEdge *const to) const throw ()
	Returns the information whether the described flow must let any other flow pass.
	NBLoadedTLDef (const std::string &id) throw ()
	Constructor.
	NBLoadedTLDef (const std::string &id, NBNode *junction) throw ()
	Constructor.
	NBLoadedTLDef (const std::string &id, const std::vector< NBNode * > &junctions) throw ()
	Constructor.
void	setCycleDuration (unsigned int cycleDur) throw ()
	Sets the duration of a cycle.
virtual void	setParticipantsInformation () throw ()
	Builds the list of participating nodes/edges/links.
void	setSignalYellowTimes (const std::string &groupid, SUMOTime tRedYellow, SUMOTime tYellow) throw ()
	Sets the times the light is yellow or red/yellow.
	~NBLoadedTLDef () throw ()
	Destructor.
Access to controlled nodes
void	addNode (NBNode *node) throw ()
	Adds a node to the traffic light logic.
const std::vector< NBNode * > &	getNodes () const throw ()
	Returns the list of controlled nodes.
void	removeNode (NBNode *node) throw ()
	Removes the given node from the list of controlled nodes.
Public methods from NBTrafficLightDefinition-interface
void	remapRemoved (NBEdge *removed, const EdgeVector &incoming, const EdgeVector &outgoing) throw ()
	Replaces occurences of the removed edge in incoming/outgoing edges of all definitions.
void	setTLControllingInformation (const NBEdgeCont &ec) const throw ()
	Informs edges about being controlled by a tls.
Protected Member Functions
void	collectEdges () throw ()
	Build the list of participating edges.
unsigned int	computeBrakingTime (SUMOReal minDecel) const throw ()
	Computes the time vehicles may need to brake.
std::pair< unsigned int, unsigned int >	getSizes () const throw ()
	Returns a pair of <number participating lanes, number participating links>.
Protected methods from NBTrafficLightDefinition-interface
void	collectLinks () throw (ProcessError)
	Collects the links participating in this traffic light Exceptions: ProcessError  If a link could not be found.
void	collectNodes () throw ()
	Collects the nodes participating in this traffic light.
bool	mustBrake (const NBEdgeCont &ec, const NBConnection &possProhibited, const std::string &state, unsigned int strmpos) const throw ()
	Returns the information whether a connection must brake, given a phase.
NBTrafficLightLogic *	myCompute (const NBEdgeCont &ec, unsigned int brakingTime) throw ()
	Computes the traffic light logic finally in dependence to the type.
void	replaceRemoved (NBEdge *removed, int removedLane, NBEdge *by, int byLane) throw ()
	Replaces a removed edge/lane.
Protected Attributes
std::vector< std::string >	myControlledInnerEdges
	List of inner edges that shall be controlled, though.
NBConnectionVector	myControlledLinks
	The list of controlled links.
std::vector< NBNode * >	myControlledNodes
	The container with participating nodes.
EdgeVector	myEdgesWithin
	The list of edges within the area controlled by the tls.
std::string	myID
	The name of the object.
EdgeVector	myIncomingEdges
	The list of incoming edges.
Private Member Functions
std::string	buildPhaseState (const NBEdgeCont &ec, unsigned int time) const throw ()
	Builds the phase for a given time.
Private Attributes
unsigned int	myCycleDuration
	The duration of a single cycle.
SignalGroupCont	mySignalGroups
	Controlled signal groups.
Data Structures
class	SignalGroup
	A single signal group, may control several connections. More...

---

Member Typedef Documentation

typedef std::map<std::string, SignalGroup*> NBLoadedTLDef::SignalGroupCont

Definition of the container for signal groups.

Definition at line 202 of file NBLoadedTLDef.h.

---

Member Enumeration Documentation

enum NBTrafficLightDefinition::TLColor [inherited]

An enumeration of possible tl-signal states.

Enumerator:

TLCOLOR_RED	Signal shows red.
TLCOLOR_YELLOW	Signal shows yellow.
TLCOLOR_REDYELLOW	Signal shows red/yellow (unused).
TLCOLOR_GREEN	Signal shows green.
TLCOLOR_BLINK	Signal is blinking yellow.

Definition at line 76 of file NBTrafficLightDefinition.h.

                 {
        TLCOLOR_RED,
        TLCOLOR_YELLOW,
        TLCOLOR_REDYELLOW,
        TLCOLOR_GREEN,
        TLCOLOR_BLINK
    };

---

Constructor & Destructor Documentation

NBLoadedTLDef::NBLoadedTLDef	(	const std::string &	id,
		const std::vector< NBNode * > &	junctions
	)			throw ()

Constructor.

Parameters:

[in]	id	The id of the tls
[in]	junctions	Junctions controlled by this tls

Definition at line 263 of file NBLoadedTLDef.cpp.

        : NBTrafficLightDefinition(id, junctions) {}

NBLoadedTLDef::NBLoadedTLDef	(	const std::string &	id,
		NBNode *	junction
	)			throw ()

Constructor.

Parameters:

[in]	id	The id of the tls
[in]	junction	The junction controlled by this tls

Definition at line 268 of file NBLoadedTLDef.cpp.

        : NBTrafficLightDefinition(id, junction) {}

NBLoadedTLDef::NBLoadedTLDef

(

const std::string &

id

)

throw ()

Constructor.

Parameters:

[in]

id

The id of the tls

Definition at line 272 of file NBLoadedTLDef.cpp.

        : NBTrafficLightDefinition(id) {}

NBLoadedTLDef::~NBLoadedTLDef

(

)

throw ()

Destructor.

Definition at line 276 of file NBLoadedTLDef.cpp.

References mySignalGroups.

                                      {
    for (SignalGroupCont::iterator i=mySignalGroups.begin(); i!=mySignalGroups.end(); ++i) {
        delete(*i).second;
    }
}

---

Member Function Documentation

void NBTrafficLightDefinition::addControlledInnerEdges

(

const std::vector< std::string > &

edges

)

throw () [inherited]

Adds the given ids into the list of edges not controlled by the tls.

Parameters:

[in]

edges

The list of edge ids to add the inner edges to

Definition at line 368 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myControlledInnerEdges.

Referenced by NIXMLNodesHandler::processTrafficLightDefinitions().

                                                                                           {
    copy(edges.begin(), edges.end(), back_inserter(myControlledInnerEdges));
}

void NBTrafficLightDefinition::addNode

(

NBNode *

node

)

throw () [inherited]

Adds a node to the traffic light logic.

Parameters:

[in]

node

A further node that shall be controlled by the tls

Definition at line 348 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myControlledNodes.

Referenced by addToSignalGroup(), and NIXMLNodesHandler::processTrafficLightDefinitions().

                                                      {
    if (std::find(myControlledNodes.begin(), myControlledNodes.end(), node)==myControlledNodes.end()) {
        myControlledNodes.push_back(node);
        std::sort(myControlledNodes.begin(), myControlledNodes.end(), NBNode::nodes_by_id_sorter());
        node->addTrafficLight(this);
    }
}

void NBLoadedTLDef::addSignalGroup

(

const std::string &

id

)

throw ()

Adds a signal group.

Parameters:

[in]

id

The id of the signal group

Definition at line 538 of file NBLoadedTLDef.cpp.

References mySignalGroups.

Referenced by NIVissimTL::NIVissimTLSignalGroup::addTo(), and NIVisumTL::build().

                                                         {
    assert(mySignalGroups.find(id)==mySignalGroups.end());
    mySignalGroups[id] = new SignalGroup(id);
}

void NBLoadedTLDef::addSignalGroupPhaseBegin	(	const std::string &	groupid,
		SUMOTime	time,
		TLColor	color
	)			throw ()

Sets the information about the begin of a phase.

Parameters:

[in]	groupid	The id of the signal group to add the phase to
[in]	time	The time the phase starts at
[in]	color	The color of the signal during this phase

Definition at line 545 of file NBLoadedTLDef.cpp.

References mySignalGroups.

Referenced by NIVissimTL::NIVissimTLSignalGroup::addTo(), and NIVisumTL::build().

                                                               {
    assert(mySignalGroups.find(groupid)!=mySignalGroups.end());
    mySignalGroups[groupid]->addPhaseBegin(time, color);
}

bool NBLoadedTLDef::addToSignalGroup	(	const std::string &	groupid,
		const NBConnectionVector &	connections
	)			throw ()

Adds a list of connections to a signal group.

Parameters:

[in]	groupid	The id of the signal group to add the connections to
[in]	connections	The connections to add

Definition at line 527 of file NBLoadedTLDef.cpp.

References addToSignalGroup().

                                                                               {
    bool ok = true;
    for (NBConnectionVector::const_iterator i=connections.begin(); i!=connections.end(); i++) {
        ok &= addToSignalGroup(groupid, *i);
    }
    return ok;
}

bool NBLoadedTLDef::addToSignalGroup	(	const std::string &	groupid,
		const NBConnection &	connection
	)			throw ()

Adds a connection to a signal group.

Parameters:

[in]	groupid	The id of the signal group to add the connection to
[in]	connection	The connection to add

Definition at line 506 of file NBLoadedTLDef.cpp.

References NBTrafficLightDefinition::addNode(), NBNode::addTrafficLight(), and mySignalGroups.

Referenced by NIVissimTL::NIVissimTLSignal::addTo(), addToSignalGroup(), and NIVisumTL::build().

                                                                        {
    if (mySignalGroups.find(groupid)==mySignalGroups.end()) {
        return false;
    }
    mySignalGroups[groupid]->addConnection(connection);
    NBNode *n1 = connection.getFrom()->getToNode();
    if (n1!=0) {
        addNode(n1);
        n1->addTrafficLight(this);
    }
    NBNode *n2 = connection.getTo()->getFromNode();
    if (n2!=0) {
        addNode(n2);
        n2->addTrafficLight(this);
    }
    return true;
}

std::string NBLoadedTLDef::buildPhaseState	(	const NBEdgeCont &	ec,
		unsigned int	time
	)			const throw () [private]

Builds the phase for a given time.

Parameters:

[in]	ec	The edge control to use
[in]	time	The time to build the phase for

Returns:

The phase of this tls for the given time

Definition at line 364 of file NBLoadedTLDef.cpp.

References NBConnection::check(), NBLoadedTLDef::SignalGroup::getConnection(), NBLoadedTLDef::SignalGroup::getLinkNo(), NBLoadedTLDef::SignalGroup::hasYellow(), NBLoadedTLDef::SignalGroup::mayDrive(), mustBrake(), and mySignalGroups.

Referenced by myCompute().

                                                                                    {
    unsigned int pos = 0;
    std::string state;
    // set the green and yellow information first;
    //  the information whether other have to break needs those masks
    //  completely filled
    for (SignalGroupCont::const_iterator i=mySignalGroups.begin(); i!=mySignalGroups.end(); i++) {
        SignalGroup *group = (*i).second;
        unsigned int linkNo = group->getLinkNo();
        bool mayDrive = group->mayDrive(time);
        bool hasYellow = group->hasYellow(time);
        char c = 'r';
        if (mayDrive) {
            c = 'g';
        }
        if (hasYellow) {
            c = 'y';
        }
        for (unsigned int j=0; j<linkNo; j++) {
            const NBConnection &conn = group->getConnection(j);
            NBConnection assConn(conn);
            // assert that the connection really exists
            if (assConn.check(ec)) {
                state = state + c;
                ++pos;
            }
        }
    }
    // set the braking mask
    pos = 0;
    for (SignalGroupCont::const_iterator i=mySignalGroups.begin(); i!=mySignalGroups.end(); i++) {
        SignalGroup *group = (*i).second;
        unsigned int linkNo = group->getLinkNo();
        for (unsigned int j=0; j<linkNo; j++) {
            const NBConnection &conn = group->getConnection(j);
            NBConnection assConn(conn);
            if (assConn.check(ec)) {
                if (!mustBrake(ec, assConn, state, pos)) {
                    if (state[pos]=='g') {
                        state[pos] = 'G';
                    }
                    if (state[pos]=='y') {
                        state[pos] = 'Y';
                    }
                }
                pos++;
            }
        }
    }
    return state;
}

void NBTrafficLightDefinition::collectEdges

(

)

throw () [protected, inherited]

Build the list of participating edges.

Definition at line 121 of file NBTrafficLightDefinition.cpp.

References NBEdge::getID(), NBTrafficLightDefinition::myControlledInnerEdges, NBTrafficLightDefinition::myControlledNodes, NBTrafficLightDefinition::myEdgesWithin, and NBTrafficLightDefinition::myIncomingEdges.

Referenced by NBTrafficLightDefinition::setParticipantsInformation(), and NBOwnTLDef::setParticipantsInformation().

                                               {
    EdgeVector myOutgoing;
    // collect the edges from the participating nodes
    for (std::vector<NBNode*>::iterator i=myControlledNodes.begin(); i!=myControlledNodes.end(); i++) {
        const EdgeVector &incoming = (*i)->getIncomingEdges();
        copy(incoming.begin(), incoming.end(), back_inserter(myIncomingEdges));
        const EdgeVector &outgoing = (*i)->getOutgoingEdges();
        copy(outgoing.begin(), outgoing.end(), back_inserter(myOutgoing));
    }
    // check which of the edges are completely within the junction
    //  remove these edges from the list of incoming edges
    //  add them to the list of edges lying within the node
    for (EdgeVector::iterator j=myIncomingEdges.begin(); j!=myIncomingEdges.end();) {
        NBEdge *edge = *j;
        // an edge lies within the logic if it is outgoing as well as incoming
        EdgeVector::iterator k = find(myOutgoing.begin(), myOutgoing.end(), edge);
        if (k!=myOutgoing.end()) {
            if (find(myControlledInnerEdges.begin(), myControlledInnerEdges.end(), edge->getID())==myControlledInnerEdges.end()) {
                myEdgesWithin.push_back(edge);
                (*j)->setIsInnerEdge();
                j = myIncomingEdges.erase(j);
                continue;
            }
        }
        ++j;
    }
}

void NBLoadedTLDef::collectLinks

(

)

throw (ProcessError) [protected, virtual]

Collects the links participating in this traffic light

Exceptions:

ProcessError

If a link could not be found.

See also:

NBTrafficLightDefinition::collectLinks

Reimplemented from NBTrafficLightDefinition.

Definition at line 476 of file NBLoadedTLDef.cpp.

References NBEdge::getConnectionsFromLane(), NBEdge::getNoLanes(), NBTrafficLightDefinition::myControlledLinks, NBTrafficLightDefinition::myIncomingEdges, NBEdge::Connection::toEdge, and NBEdge::Connection::toLane.

                                                {
    // build the list of links which are controled by the traffic light
    for (EdgeVector::iterator i=myIncomingEdges.begin(); i!=myIncomingEdges.end(); i++) {
        NBEdge *incoming = *i;
        unsigned int noLanes = incoming->getNoLanes();
        for (unsigned int j=0; j<noLanes; j++) {
            std::vector<NBEdge::Connection> elv = incoming->getConnectionsFromLane(j);
            for (std::vector<NBEdge::Connection>::iterator k=elv.begin(); k!=elv.end(); k++) {
                NBEdge::Connection el = *k;
                if (el.toEdge!=0) {
                    myControlledLinks.push_back(NBConnection(incoming, j, el.toEdge, el.toLane));
                }
            }
        }
    }
}

void NBLoadedTLDef::collectNodes

(

)

throw () [protected]

Collects the nodes participating in this traffic light.

See also:

NBTrafficLightDefinition::collectNodes

Definition at line 459 of file NBLoadedTLDef.cpp.

References NBLoadedTLDef::SignalGroup::getConnection(), NBConnection::getFrom(), NBLoadedTLDef::SignalGroup::getLinkNo(), NBEdge::getToNode(), NBTrafficLightDefinition::myControlledNodes, and mySignalGroups.

                                    {
    SignalGroupCont::const_iterator m;
    for (m=mySignalGroups.begin(); m!=mySignalGroups.end(); m++) {
        SignalGroup *group = (*m).second;
        unsigned int linkNo = group->getLinkNo();
        for (unsigned int j=0; j<linkNo; j++) {
            const NBConnection &conn = group->getConnection(j);
            NBEdge *edge = conn.getFrom();
            NBNode *node = edge->getToNode();
            myControlledNodes.push_back(node);
        }
    }
    std::sort(myControlledNodes.begin(), myControlledNodes.end(), NBNode::nodes_by_id_sorter());
}

NBTrafficLightLogic * NBTrafficLightDefinition::compute	(	const NBEdgeCont &	ec,
		OptionsCont &	oc
	)			throw () [inherited]

Computes the traffic light logic.

Does some initialisation at first, then calls myCompute to finally build the tl-logic

Parameters:

[in]	ec	The edge container in order to retrieve edge information
[in]	oc	The options container holding options needed during the building

Returns:

The built logic (may be 0)

Definition at line 88 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::computeBrakingTime(), Named::getID(), NBTrafficLightDefinition::myCompute(), NBTrafficLightDefinition::myIncomingEdges, and WRITE_WARNING.

Referenced by NBTrafficLightLogicCont::computeLogics().

                                                                               {
    // it is not really a traffic light if no incoming edge exists
    if (myIncomingEdges.size()==0) {
        WRITE_WARNING("The traffic light '" + getID() + "' has no incoming edges; it will not be build.");
        return 0;
    }
    // compute the time needed to brake
    unsigned int brakingTime = computeBrakingTime(oc.getFloat("min-decel"));
    // perform the computation depending on whether the traffic light
    //  definition was loaded or shall be computed new completely
    if (oc.isSet("traffic-light-yellow")) {
        brakingTime = oc.getInt("traffic-light-yellow");
    }
    return myCompute(ec, brakingTime);
}

unsigned int NBTrafficLightDefinition::computeBrakingTime

(

SUMOReal

minDecel

)

const throw () [protected, inherited]

Computes the time vehicles may need to brake.

This time depends on the maximum speed allowed on incoming junctions. It is computed as max_speed_allowed / minimum_vehicle_decleration

Definition at line 106 of file NBTrafficLightDefinition.cpp.

References NBContHelper::maxSpeed(), NBTrafficLightDefinition::myIncomingEdges, and SUMOReal.

Referenced by NBTrafficLightDefinition::compute().

                                                                            {
    SUMOReal vmax = NBContHelper::maxSpeed(myIncomingEdges);
    return (unsigned int)(vmax / minDecel);
}

NBLoadedTLDef::SignalGroup * NBLoadedTLDef::findGroup	(	NBEdge *	from,
		NBEdge *	to
	)			const throw ()

Returns the signal group which is responsible for the given connection.

Parameters:

[in]	from	The connection's start edge
[in]	to	The connection's end edge

Returns:

The signal group which controls the given connection

Definition at line 495 of file NBLoadedTLDef.cpp.

References mySignalGroups.

                                                               {
    for (SignalGroupCont::const_iterator i=mySignalGroups.begin(); i!=mySignalGroups.end(); i++) {
        if ((*i).second->containsConnection(from, to)) {
            return (*i).second;
        }
    }
    return 0;
}

bool NBTrafficLightDefinition::foes	(	const NBEdge *const	from1,
		const NBEdge *const	to1,
		const NBEdge *const	from2,
		const NBEdge *const	to2
	)			const throw () [inherited]

Returns the information whether the given flows cross.

Parameters:

[in]	from1	The starting edge of the first stream
[in]	to1	The ending edge of the first stream
[in]	from2	The starting edge of the second stream
[in]	to2	The ending edge of the second stream

Returns:

Whether both stream are foes (cross)

Definition at line 325 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myControlledNodes.

Referenced by NBOwnTLDef::computeUnblockedWeightedStreamNumber().

                                                                                                   {
    if (to1==0||to2==0) {
        return false;
    }
    // retrieve both nodes (it is possible that a connection
    std::vector<NBNode*>::const_iterator incoming =
        find_if(myControlledNodes.begin(), myControlledNodes.end(),
                NBContHelper::node_with_incoming_finder(from1));
    std::vector<NBNode*>::const_iterator outgoing =
        find_if(myControlledNodes.begin(), myControlledNodes.end(),
                NBContHelper::node_with_outgoing_finder(to1));
    assert(incoming!=myControlledNodes.end());
    NBNode *incnode = *incoming;
    NBNode *outnode = *outgoing;
    if (incnode!=outnode) {
        return false;
    }
    return incnode->foes(from1, to1, from2, to2);
}

bool NBTrafficLightDefinition::forbids	(	const NBEdge *const	possProhibitorFrom,
		const NBEdge *const	possProhibitorTo,
		const NBEdge *const	possProhibitedFrom,
		const NBEdge *const	possProhibitedTo,
		bool	regardNonSignalisedLowerPriority
	)			const throw () [inherited]

Returns the information whether "prohibited" flow must let "prohibitor" flow pass.

Parameters:

[in]	possProhibitedFrom	The maybe prohibited connection's begin
[in]	possProhibitedTo	The maybe prohibited connection's end
[in]	possProhibitorFrom	The maybe prohibiting connection's begin
[in]	possProhibitorTo	The maybe prohibiting connection's end
[in]	regardNonSignalisedLowerPriority	Whether the right of way rules without traffic lights shall be regarded

Returns:

Whether the second flow prohibits the first one

See also:

forbids

Definition at line 248 of file NBTrafficLightDefinition.cpp.

References NBNode::foes(), NBNode::forbids(), and NBTrafficLightDefinition::myControlledNodes.

Referenced by NBTrafficLightDefinition::mustBrake(), and NBOwnTLDef::myCompute().

                                                                                       {
    if (possProhibitorFrom==0||possProhibitorTo==0||possProhibitedFrom==0||possProhibitedTo==0) {
        return false;
    }
    // retrieve both nodes
    std::vector<NBNode*>::const_iterator incoming =
        find_if(myControlledNodes.begin(), myControlledNodes.end(), NBContHelper::node_with_incoming_finder(possProhibitorFrom));
    std::vector<NBNode*>::const_iterator outgoing =
        find_if(myControlledNodes.begin(), myControlledNodes.end(), NBContHelper::node_with_outgoing_finder(possProhibitedTo));
    assert(incoming!=myControlledNodes.end());
    NBNode *incnode = *incoming;
    NBNode *outnode = *outgoing;
    EdgeVector::const_iterator i;
    if (incnode!=outnode) {
        // the links are located at different nodes
        const EdgeVector &ev1 = possProhibitedTo->getConnectedEdges();
        // go through the following edge,
        //  check whether one of these connections is prohibited
        for (i=ev1.begin(); i!=ev1.end(); ++i) {
            std::vector<NBNode*>::const_iterator outgoing2 =
                find_if(myControlledNodes.begin(), myControlledNodes.end(), NBContHelper::node_with_outgoing_finder(*i));
            if (outgoing2==myControlledNodes.end()) {
                continue;
            }
            NBNode *outnode2 = *outgoing2;
            if (incnode!=outnode2) {
                continue;
            }
            bool ret1 = incnode->foes(possProhibitorTo, *i,
                                      possProhibitedFrom, possProhibitedTo);
            bool ret2 = incnode->forbids(possProhibitorFrom, possProhibitorTo,
                                         possProhibitedTo, *i,
                                         regardNonSignalisedLowerPriority);
            bool ret = ret1||ret2;
            if (ret) {
                return true;
            }
        }

        const EdgeVector &ev2 = possProhibitorTo->getConnectedEdges();
        // go through the following edge,
        //  check whether one of these connections is prohibited
        for (i=ev2.begin(); i!=ev2.end(); ++i) {
            std::vector<NBNode*>::const_iterator incoming2 =
                find_if(myControlledNodes.begin(), myControlledNodes.end(), NBContHelper::node_with_incoming_finder(possProhibitorTo));
            if (incoming2==myControlledNodes.end()) {
                continue;
            }
            NBNode *incnode2 = *incoming2;
            if (incnode2!=outnode) {
                continue;
            }
            bool ret1 = incnode2->foes(possProhibitorTo, *i,
                                       possProhibitedFrom, possProhibitedTo);
            bool ret2 = incnode2->forbids(possProhibitorTo, *i,
                                          possProhibitedFrom, possProhibitedTo,
                                          regardNonSignalisedLowerPriority);
            bool ret = ret1||ret2;
            if (ret) {
                return true;
            }
        }
        return false;
    }
    // both links are located at the same node
    //  check using this node's information
    return incnode->forbids(possProhibitorFrom, possProhibitorTo,
                            possProhibitedFrom, possProhibitedTo,
                            regardNonSignalisedLowerPriority);
}

const std::string& Named::getID

(

)

const throw () [inline, inherited]

Returns the id.

Returns:

The stored id

Definition at line 59 of file Named.h.

References Named::myID.

Referenced by RORouteDef_Alternatives::addAlternative(), MSRouteProbe::addRoute(), MSEmitter::MSEmitter_FileTriggeredChild::buildAndScheduleFlowVehicle(), MSCalibrator::MSCalibrator_FileTriggeredChild::buildAndScheduleFlowVehicle(), RORouteDef_Complete::buildCurrentRoute(), ODDistrictHandler::closeDistrict(), NBTrafficLightDefinition::collectLinks(), NBTrafficLightDefinition::compute(), GUIPointOfInterest::drawGL(), MSInductLoop::enterDetectorByMove(), MSVTypeProbe::execute(), MSNet::getBusStopID(), GUITriggeredRerouter::getMicrosimID(), GUIPointOfInterest::getMicrosimID(), GUILaneSpeedTrigger::getMicrosimID(), GUIInductLoop::MyWrapper::getMicrosimID(), GUIEmitter::getMicrosimID(), GUIBusStop::getMicrosimID(), GUI_E2_ZS_Collector::MyWrapper::getMicrosimID(), traci::TraCIServer::handlePoiDomain(), RORDLoader_SUMOBase::myCharacters(), NBOwnTLDef::myCompute(), myCompute(), MSTriggeredRerouter::myStartElement(), MSLaneSpeedTrigger::myStartElement(), MSEmitter::MSEmitter_FileTriggeredChild::myStartElement(), MSCalibrator::MSCalibrator_FileTriggeredChild::myStartElement(), NBLoadedTLDef::SignalGroup::patchTYellow(), TraCIServerAPI_Vehicle::processGet(), MSVehicle::replaceRoute(), MSVehicle::saveState(), NBOwnTLDef::setTLControllingInformation(), setTLControllingInformation(), RORDLoader_SUMOBase::startRoute(), GUIEmitter::GUIEmitterChild_UserTriggeredChild::wrappedExecute(), NBTrafficLightLogic::writeXML(), MSRouteProbe::writeXMLOutput(), MSInductLoop::writeXMLOutput(), MSE2Collector::writeXMLOutput(), and MSVehicle::~MSVehicle().

                                           {
        return myID;
    }

const EdgeVector & NBTrafficLightDefinition::getIncomingEdges

(

)

const throw () [inherited]

Returns the list of incoming edges (must be build first).

Returns:

The edges which are incoming into the tls

Definition at line 374 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myIncomingEdges.

Referenced by NBOwnTLDef::myCompute().

                                                         {
    return myIncomingEdges;
}

const std::vector<NBNode*>& NBTrafficLightDefinition::getNodes

(

)

const throw () [inline, inherited]

Returns the list of controlled nodes.

Returns:

Controlled nodes

Definition at line 147 of file NBTrafficLightDefinition.h.

References NBTrafficLightDefinition::myControlledNodes.

                                                       {
        return myControlledNodes;
    }

std::pair< unsigned int, unsigned int > NBTrafficLightDefinition::getSizes

(

)

const throw () [protected, inherited]

Returns a pair of <number participating lanes, number participating links>.

Returns:

The numbers of lanes and links controlled by this tls

Definition at line 180 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myIncomingEdges.

                                                 {
    unsigned int noLanes = 0;
    unsigned int noLinks = 0;
    for (EdgeVector::const_iterator i=myIncomingEdges.begin(); i!=myIncomingEdges.end(); i++) {
        unsigned int noLanesEdge = (*i)->getNoLanes();
        for (unsigned int j=0; j<noLanesEdge; j++) {
            assert((*i)->getConnectionsFromLane(j).size()!=0);
            noLinks += (unsigned int)(*i)->getConnectionsFromLane(j).size();
        }
        noLanes += noLanesEdge;
    }
    return std::pair<unsigned int, unsigned int>(noLanes, noLinks);
}

bool NBTrafficLightDefinition::isLeftMover	(	const NBEdge *const	from,
		const NBEdge *const	to
	)			const throw () [inherited]

returns the information whether the given link is a left-mover

Parameters:

[in]	from	The connection's start edge
[in]	to	The connection's end edge

Returns:

Whether the connection is a left-mover

Definition at line 196 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myControlledNodes.

Referenced by NBOwnTLDef::myCompute().

                                                                                                     {
    // the destination edge may be unused
    if (to==0) {
        return false;
    }
    // get the node which is holding this connection
    std::vector<NBNode*>::const_iterator i =
        find_if(myControlledNodes.begin(), myControlledNodes.end(),
                NBContHelper::node_with_incoming_finder(from));
    assert(i!=myControlledNodes.end());
    NBNode *node = *i;
    return node->isLeftMover(from, to);
}

bool NBTrafficLightDefinition::mustBrake	(	const NBEdge *const	possProhibitedFrom,
		const NBEdge *const	possProhibitedTo,
		const NBEdge *const	possProhibitorFrom,
		const NBEdge *const	possProhibitorTo,
		bool	regardNonSignalisedLowerPriority
	)			const throw () [inherited]

Returns the information whether the described flow must let any other flow pass.

Parameters:

[in]	possProhibitedFrom	The maybe prohibited connection's begin
[in]	possProhibitedTo	The maybe prohibited connection's end
[in]	possProhibitorFrom	The maybe prohibiting connection's begin
[in]	possProhibitorTo	The maybe prohibiting connection's end
[in]	regardNonSignalisedLowerPriority	Whether the right of way rules without traffic lights shall be regarded

Returns:

Whether the second flow prohibits the first one

See also:

forbids

Definition at line 226 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::forbids().

                                                                                         {
    return forbids(possProhibitorFrom, possProhibitorTo,
                   possProhibitedFrom, possProhibitedTo,
                   regardNonSignalisedLowerPriority);
}

bool NBTrafficLightDefinition::mustBrake	(	const NBConnection &	possProhibited,
		const NBConnection &	possProhibitor,
		bool	regardNonSignalisedLowerPriority
	)			const throw () [inherited]

Returns the information whether the described flow must let the other flow pass.

Parameters:

[in]	possProhibited	The maybe prohibited connection
[in]	possProhibitor	The maybe prohibiting connection
[in]	regardNonSignalisedLowerPriority	Whether the right of way rules without traffic lights shall be regarded

Returns:

Whether the second flow prohibits the first one

See also:

forbids

Definition at line 238 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::forbids().

                                                                                         {
    return forbids(possProhibitor.getFrom(), possProhibitor.getTo(),
                   possProhibited.getFrom(), possProhibited.getTo(),
                   regardNonSignalisedLowerPriority);
}

bool NBTrafficLightDefinition::mustBrake	(	const NBEdge *const	from,
		const NBEdge *const	to
	)			const throw () [inherited]

Returns the information whether the described flow must let any other flow pass.

If the from/to connection passes only one junction (from is incoming into same node as to outgoes from) the node is asked whether the flow must brake- Otherwise true is returned (recheck!) "from" must be an incoming edge into one of the participating nodes!

Parameters:

[in]	from	The connection's start edge
[in]	to	The connection's end edge

Returns:

Whether the described connection must brake (has higher priorised foes)

Definition at line 212 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myControlledNodes.

Referenced by mustBrake().

                                                                                                    {
    std::vector<NBNode*>::const_iterator i =
        find_if(myControlledNodes.begin(), myControlledNodes.end(),
                NBContHelper::node_with_incoming_finder(from));
    assert(i!=myControlledNodes.end());
    NBNode *node = *i;
    if (!node->hasOutgoing(to)) {
        return true; // !!!
    }
    return node->mustBrake(from, to, -1);
}

bool NBLoadedTLDef::mustBrake	(	const NBEdgeCont &	ec,
		const NBConnection &	possProhibited,
		const std::string &	state,
		unsigned int	strmpos
	)			const throw () [protected]

Returns the information whether a connection must brake, given a phase.

Parameters:

[in]	ec	The edge control to retrieve edges from
[in]	possProhibited	The connection to investigate
[in]	state	The state
[in]	strmpos	The index of this connection within the masks

Returns:

Whether the given connection must brake

Definition at line 418 of file NBLoadedTLDef.cpp.

References NBConnection::check(), NBLoadedTLDef::SignalGroup::getConnection(), NBConnection::getFrom(), NBLoadedTLDef::SignalGroup::getLinkNo(), NBTrafficLightDefinition::mustBrake(), and mySignalGroups.

Referenced by buildPhaseState().

                                                             {
    // check whether the stream has red
    if (state[strmpos]!='g'&&state[strmpos]!='G') {
        return true;
    }

    // check whether another stream which has green is a higher
    //  priorised foe to the given
    unsigned int pos = 0;
    for (SignalGroupCont::const_iterator i=mySignalGroups.begin(); i!=mySignalGroups.end(); i++) {
        SignalGroup *group = (*i).second;
        // get otherlinks that have green
        unsigned int linkNo = group->getLinkNo();
        for (unsigned int j=0; j<linkNo; j++) {
            // get the current connection (possible foe)
            const NBConnection &other = group->getConnection(j);
            NBConnection possProhibitor(other);
            // if the connction ist still valid ...
            if (possProhibitor.check(ec)) {
                // ... do nothing if it starts at the same edge
                if (possProhibited.getFrom()==possProhibitor.getFrom()) {
                    pos++;
                    continue;
                }
                if (state[pos]=='g'||state[pos]=='G') {
                    if (NBTrafficLightDefinition::mustBrake(possProhibited, possProhibitor, true)) {
                        return true;
                    }
                }
                pos++;
            }
        }
    }
    return false;
}

NBTrafficLightLogic * NBLoadedTLDef::myCompute	(	const NBEdgeCont &	ec,
		unsigned int	brakingTime
	)			throw () [protected, virtual]

Computes the traffic light logic finally in dependence to the type.

Parameters:

[in]	ec	The edge container
[in]	brakingTime	Duration a vehicle needs for braking in front of the tls

Returns:

The computed logic

See also:

NBTrafficLightDefinition::myCompute

Implements NBTrafficLightDefinition.

Definition at line 284 of file NBLoadedTLDef.cpp.

References NBTrafficLightLogic::addStep(), buildPhaseState(), MsgHandler::clear(), NBTrafficLightLogic::closeBuilding(), Named::getID(), OptionsCont::getOptions(), NBLoadedTLDef::SignalGroup::getTimes(), MsgHandler::getWarningInstance(), myCycleDuration, mySignalGroups, NBLoadedTLDef::SignalGroup::patchTYellow(), NBLoadedTLDef::SignalGroup::sortPhases(), and WRITE_WARNING.

                                                                               {
    MsgHandler::getWarningInstance()->clear(); // !!!
    NBLoadedTLDef::SignalGroupCont::const_iterator i;
    // compute the switching times
    std::set<SUMOReal> tmpSwitchTimes;
    for (i=mySignalGroups.begin(); i!=mySignalGroups.end(); i++) {
        NBLoadedTLDef::SignalGroup *group = (*i).second;
        // needed later
        group->sortPhases();
        // patch the yellow time for this group
        if (OptionsCont::getOptions().getBool("patch-small-tyellow")) {
            group->patchTYellow(brakingTime);
        }
        // copy the now valid times into the container
        //  both the given red and green phases are added and also the
        //  yellow times
        DoubleVector gtimes = group->getTimes(myCycleDuration);
        for (DoubleVector::const_iterator k=gtimes.begin(); k!=gtimes.end(); k++) {
            tmpSwitchTimes.insert(*k);
        }
    }
    std::vector<SUMOReal> switchTimes;
    copy(tmpSwitchTimes.begin(), tmpSwitchTimes.end(), back_inserter(switchTimes));
    sort(switchTimes.begin(), switchTimes.end());

    // count the signals
    unsigned int noSignals = 0;
    for (i=mySignalGroups.begin(); i!=mySignalGroups.end(); i++) {
        noSignals += (*i).second->getLinkNo();
    }
    // build the phases
    NBTrafficLightLogic *logic = new NBTrafficLightLogic(getID(), "0", noSignals);
    for (std::vector<SUMOReal>::iterator l=switchTimes.begin(); l!=switchTimes.end(); l++) {
        // compute the duration of the current phase
        unsigned int duration;
        if (l!=switchTimes.end()-1) {
            // get from the difference to the next switching time
            duration = (unsigned int)((*(l+1)) - (*l));
        } else {
            // get from the differenc to the first switching time
            duration = (unsigned int)(myCycleDuration - (*l) + *(switchTimes.begin())) ;
        }
        // no information about yellow times will be generated
        assert((*l)>=0);
        logic->addStep(duration, buildPhaseState(ec, (unsigned int)(*l)));
    }
    // check whether any warnings were printed
    if (MsgHandler::getWarningInstance()->wasInformed()) {
        WRITE_WARNING("During computation of traffic light '" + getID() + "'.");
    }
    logic->closeBuilding();
    return logic;
}

void NBLoadedTLDef::remapRemoved	(	NBEdge *	removed,
		const EdgeVector &	incoming,
		const EdgeVector &	outgoing
	)			throw () [virtual]

Replaces occurences of the removed edge in incoming/outgoing edges of all definitions.

Parameters:

[in]	removed	The removed edge
[in]	incoming	The edges to use instead if an incoming edge was removed
[in]	outgoing	The edges to use instead if an outgoing edge was removed

See also:

NBTrafficLightDefinition::remapRemoved

Implements NBTrafficLightDefinition.

Definition at line 566 of file NBLoadedTLDef.cpp.

References NBLoadedTLDef::SignalGroup::containsIncoming(), NBLoadedTLDef::SignalGroup::containsOutgoing(), mySignalGroups, NBLoadedTLDef::SignalGroup::remapIncoming(), and NBLoadedTLDef::SignalGroup::remapOutgoing().

                                                                {
    for (SignalGroupCont::const_iterator i=mySignalGroups.begin(); i!=mySignalGroups.end(); i++) {
        SignalGroup *group = (*i).second;
        if (group->containsIncoming(removed)) {
            group->remapIncoming(removed, incoming);
        }
        if (group->containsOutgoing(removed)) {
            group->remapOutgoing(removed, outgoing);
        }
    }
}

void NBTrafficLightDefinition::removeNode

(

NBNode *

node

)

throw () [inherited]

Removes the given node from the list of controlled nodes.

Parameters:

[in]

node

The node that shall not be controlled by the tls any more

Definition at line 358 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::myControlledNodes.

                                                         {
    std::vector<NBNode*>::iterator i = std::find(myControlledNodes.begin(), myControlledNodes.end(), node);
    if (i!=myControlledNodes.end()) {
        myControlledNodes.erase(i);
    }
    // !!! remove in node?
}

void NBLoadedTLDef::replaceRemoved	(	NBEdge *	removed,
		int	removedLane,
		NBEdge *	by,
		int	byLane
	)			throw () [protected, virtual]

Replaces a removed edge/lane.

Parameters:

[in]	removed	The edge to replace
[in]	removedLane	The lane of this edge to replace
[in]	by	The edge to insert instead
[in]	byLane	This edge's lane to insert instead

See also:

NBTrafficLightDefinition::replaceRemoved

Implements NBTrafficLightDefinition.

Definition at line 582 of file NBLoadedTLDef.cpp.

References NBLoadedTLDef::SignalGroup::containsIncoming(), NBLoadedTLDef::SignalGroup::containsOutgoing(), mySignalGroups, and NBLoadedTLDef::SignalGroup::remap().

                                                              {
    for (SignalGroupCont::const_iterator i=mySignalGroups.begin(); i!=mySignalGroups.end(); i++) {
        SignalGroup *group = (*i).second;
        if (group->containsIncoming(removed)||group->containsOutgoing(removed)) {
            group->remap(removed, removedLane, by, byLane);
        }
    }
}

void NBLoadedTLDef::setCycleDuration

(

unsigned int

cycleDur

)

throw ()

Sets the duration of a cycle.

Parameters:

[in]

cycleDur

The duration of the cycle

Definition at line 560 of file NBLoadedTLDef.cpp.

References myCycleDuration.

Referenced by NIVisumTL::build().

                                                             {
    myCycleDuration = cycleDur;
}

void NBTrafficLightDefinition::setParticipantsInformation

(

)

throw () [virtual, inherited]

Builds the list of participating nodes/edges/links.

Reimplemented in NBOwnTLDef.

Definition at line 113 of file NBTrafficLightDefinition.cpp.

References NBTrafficLightDefinition::collectEdges(), and NBTrafficLightDefinition::collectLinks().

                                                             {
    // collect the information about participating edges and links
    collectEdges();
    collectLinks();
}

void NBLoadedTLDef::setSignalYellowTimes	(	const std::string &	groupid,
		SUMOTime	tRedYellow,
		SUMOTime	tYellow
	)			throw ()

Sets the times the light is yellow or red/yellow.

Parameters:

[in]	groupid	The id of the signal group to add the phase to
[in]	tRedYellow	The duration of redyellow
[in]	tYellow	The duration of yellow

Definition at line 552 of file NBLoadedTLDef.cpp.

References mySignalGroups.

Referenced by NIVissimTL::NIVissimTLSignalGroup::addTo(), and NIVisumTL::build().

                                                                                       {
    assert(mySignalGroups.find(groupid)!=mySignalGroups.end());
    mySignalGroups[groupid]->setYellowTimes(myTRedYellow, myTYellow);
}

void NBLoadedTLDef::setTLControllingInformation

(

const NBEdgeCont &

ec

)

const throw () [virtual]

Informs edges about being controlled by a tls.

Parameters:

[in]

ec

The container of edges

See also:

NBTrafficLightDefinition::setTLControllingInformation

Implements NBTrafficLightDefinition.

Definition at line 340 of file NBLoadedTLDef.cpp.

References NBLoadedTLDef::SignalGroup::getConnection(), NBConnection::getFrom(), NBConnection::getFromLane(), Named::getID(), NBLoadedTLDef::SignalGroup::getLinkNo(), NBEdge::getNoLanes(), NBConnection::getTo(), NBConnection::getToLane(), mySignalGroups, NBEdge::setControllingTLInformation(), and WRITE_WARNING.

                                                                             {
    // assign the links to the connections
    unsigned int pos = 0;
    for (SignalGroupCont::const_iterator m=mySignalGroups.begin(); m!=mySignalGroups.end(); m++) {
        SignalGroup *group = (*m).second;
        unsigned int linkNo = group->getLinkNo();
        for (unsigned int j=0; j<linkNo; j++) {
            const NBConnection &conn = group->getConnection(j);
            assert(conn.getFromLane()<0||(int) conn.getFrom()->getNoLanes()>conn.getFromLane());
            NBConnection tst(conn);
            if (tst.check(ec)) {
                NBEdge *edge = conn.getFrom();
                if (edge->setControllingTLInformation(conn.getFromLane(), conn.getTo(), conn.getToLane(), getID(), pos)) {
                    pos++;
                }
            } else {
                WRITE_WARNING("Could not set signal on connection (signal: " + getID() + ", group: " + group->getID()+ ")");
            }
        }
    }
}

---

Field Documentation

std::vector<std::string> NBTrafficLightDefinition::myControlledInnerEdges [protected, inherited]

List of inner edges that shall be controlled, though.

Definition at line 315 of file NBTrafficLightDefinition.h.

Referenced by NBTrafficLightDefinition::addControlledInnerEdges(), and NBTrafficLightDefinition::collectEdges().

NBConnectionVector NBTrafficLightDefinition::myControlledLinks [protected, inherited]

The list of controlled links.

Definition at line 312 of file NBTrafficLightDefinition.h.

Referenced by NBTrafficLightDefinition::collectLinks(), NBOwnTLDef::collectLinks(), collectLinks(), and NBOwnTLDef::setTLControllingInformation().

std::vector<NBNode*> NBTrafficLightDefinition::myControlledNodes [protected, inherited]

The container with participating nodes.

Definition at line 303 of file NBTrafficLightDefinition.h.

Referenced by NBTrafficLightDefinition::addNode(), NBTrafficLightDefinition::collectEdges(), collectNodes(), NBTrafficLightDefinition::foes(), NBTrafficLightDefinition::forbids(), NBTrafficLightDefinition::getNodes(), NBTrafficLightDefinition::isLeftMover(), NBTrafficLightDefinition::mustBrake(), and NBTrafficLightDefinition::removeNode().

unsigned int NBLoadedTLDef::myCycleDuration [private]

The duration of a single cycle.

Definition at line 370 of file NBLoadedTLDef.h.

Referenced by myCompute(), and setCycleDuration().

EdgeVector NBTrafficLightDefinition::myEdgesWithin [protected, inherited]

The list of edges within the area controlled by the tls.

Definition at line 309 of file NBTrafficLightDefinition.h.

Referenced by NBTrafficLightDefinition::collectEdges().

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

The name of the object.

Definition at line 66 of file Named.h.

Referenced by RORouteDef_OrigDest::buildCurrentRoute(), RORouteDef_Complete::buildCurrentRoute(), RORouteDef_Alternatives::buildCurrentRoute(), and Named::getID().

EdgeVector NBTrafficLightDefinition::myIncomingEdges [protected, inherited]

The list of incoming edges.

Definition at line 306 of file NBTrafficLightDefinition.h.

Referenced by NBTrafficLightDefinition::collectEdges(), NBTrafficLightDefinition::collectLinks(), NBOwnTLDef::collectLinks(), collectLinks(), NBTrafficLightDefinition::compute(), NBTrafficLightDefinition::computeBrakingTime(), NBTrafficLightDefinition::getIncomingEdges(), and NBTrafficLightDefinition::getSizes().

SignalGroupCont NBLoadedTLDef::mySignalGroups [private]

Controlled signal groups.

Definition at line 367 of file NBLoadedTLDef.h.

Referenced by addSignalGroup(), addSignalGroupPhaseBegin(), addToSignalGroup(), buildPhaseState(), collectNodes(), findGroup(), mustBrake(), myCompute(), remapRemoved(), replaceRemoved(), setSignalYellowTimes(), setTLControllingInformation(), and ~NBLoadedTLDef().

---

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

• NBLoadedTLDef.h
• NBLoadedTLDef.cpp