NLSucceedingLaneBuilder Class Reference

#include <NLSucceedingLaneBuilder.h>

---

Detailed Description

Temporary storage for a lanes succeeding lanes while parsing them.

Todo:

Consider moving this functionality to another class

Definition at line 51 of file NLSucceedingLaneBuilder.h.

Public Member Functions
void	addSuccLane (bool yield, const std::string &laneId, MSLink::LinkDirection dir, MSLink::LinkState state, bool internalEnd, const std::string &tlid="", unsigned int linkNo=0) throw (InvalidArgument)
	Adds a succeeding lane.
void	closeSuccLane () throw (InvalidArgument)
	Ends the computation of a container holding the succeeding lanes of a lane.
const std::string &	getCurrentLaneName () const throw ()
	Returns the name of the lane the succeeding lanes are added to.
	NLSucceedingLaneBuilder (NLJunctionControlBuilder &jb) throw ()
	Constructor.
void	openSuccLane (const std::string &laneId) throw ()
	Begins the computation of a container holding the succeeding lanes of a lane.
	~NLSucceedingLaneBuilder () throw ()
	Destructor.
Private Member Functions
	NLSucceedingLaneBuilder (const NLSucceedingLaneBuilder &s)
	invalid copy constructor
NLSucceedingLaneBuilder &	operator= (const NLSucceedingLaneBuilder &s)
	invalid assignment operator
Private Attributes
std::string	myCurrentLane
	ID of the lane the succeeding lanes are added to.
NLJunctionControlBuilder &	myJunctionControlBuilder
	The junction control builder to obtain referenced tls from.
MSLinkCont *	mySuccLanes
	The list of connections.

---

Constructor & Destructor Documentation

NLSucceedingLaneBuilder::NLSucceedingLaneBuilder

(

NLJunctionControlBuilder &

jb

)

throw ()

Constructor.

Parameters:

[in]

jb

The junction control builder to obtain referenced tls from

Definition at line 54 of file NLSucceedingLaneBuilder.cpp.

        : myJunctionControlBuilder(jb) {
    mySuccLanes = new MSLinkCont();
    mySuccLanes->reserve(10);
}

NLSucceedingLaneBuilder::~NLSucceedingLaneBuilder

(

)

throw ()

Destructor.

Definition at line 61 of file NLSucceedingLaneBuilder.cpp.

References mySuccLanes.

                                                          {
    delete mySuccLanes;
}

NLSucceedingLaneBuilder::NLSucceedingLaneBuilder

(

const NLSucceedingLaneBuilder &

s

)

[private]

invalid copy constructor

---

Member Function Documentation

void NLSucceedingLaneBuilder::addSuccLane	(	bool	yield,
		const std::string &	laneId,
		MSLink::LinkDirection	dir,
		MSLink::LinkState	state,
		bool	internalEnd,
		const std::string &	tlid = "",
		unsigned int	linkNo = 0
	)			throw (InvalidArgument)

Adds a succeeding lane.

If either the current, or the succeeding lane is not known, an InvalidArgument is thrown (with the proper message). Also if a tls-logic is referenced, but not known to the junction control builder, an InvalidArgument is thrown.

Parameters:

[in]	yield	Whether the vehicles on the link have to wait
[in]	laneId	ID of the lane to add a connection to (from the last opened lane)
[in]	viaID	The junction-internal lane to use to reach the destination lane
[in]	pass	Theoretically: the maximum filling rate at the internal link; unused currently
[in]	dir	The abstract direction of the link
[in]	state	The abstract state of the link
[in]	internalEnd	Whether the link is followed by an internal end lane
[in]	tlid	(optional) ID of the tls that controls the link
[in]	linkNo	(optional) index of the link within the controlling tls

Todo:

Recheck usage of "pass"

Exceptions:

InvalidArgument

If one of the referenced structures was not found or is invalid

See also:

MSLink::LinkDirection

MSLink::LinkState

MSLink

Definition at line 73 of file NLSucceedingLaneBuilder.cpp.

References MSLane::addIncomingLane(), MSTLLogicControl::TLSLogicVariants::addLink(), MSLane::dictionary(), MSLane::getLength(), MSLane::getShape(), NLJunctionControlBuilder::getTLLogic(), MSGlobals::gUsingInternalLanes, MSLink::LINKDIR_NODIR, MSLink::LINKSTATE_DEADEND, myCurrentLane, myJunctionControlBuilder, mySuccLanes, and SUMOReal.

Referenced by NLHandler::addSuccLane().

                                                                                                        {
    // check whether the link is a dead link
    if (laneId=="SUMO_NO_DESTINATION") {
        // build the dead link and add it to the container
#ifdef HAVE_INTERNAL_LANES
        MSLink *link = new MSLink(0, 0, yield, MSLink::LINKDIR_NODIR, MSLink::LINKSTATE_DEADEND, false, 0.);
#else
        MSLink *link = new MSLink(0, yield, MSLink::LINKDIR_NODIR, MSLink::LINKSTATE_DEADEND, 0.);
#endif
        mySuccLanes->push_back(link);
        if (tlid!="") {
            MSTLLogicControl::TLSLogicVariants &logics = myJunctionControlBuilder.getTLLogic(tlid);
            MSLane *current = MSLane::dictionary(myCurrentLane);
            if (current==0) {
                throw InvalidArgument("An unknown lane ('" + myCurrentLane + "') should be assigned to a tl-logic.");
            }
            logics.addLink(link, current, linkNo);
        }
        return;
    }

    // get the lane the link belongs to
    MSLane *lane = MSLane::dictionary(laneId);
    if (lane==0) {
        throw InvalidArgument("An unknown lane ('" + laneId + "') should be set as a follower for lane '" + myCurrentLane + "'.");
    }
#ifdef HAVE_INTERNAL_LANES
    MSLane *via = 0;
    if (viaID!="" && MSGlobals::gUsingInternalLanes) {
        via = MSLane::dictionary(viaID);
        if (via==0) {
            throw InvalidArgument("An unknown lane ('" + viaID + "') should be set as a via-lane for lane '" + myCurrentLane + "'.");
        }
    }
    if (pass>=0) {
        static_cast<MSInternalLane*>(lane)->setPassPosition(pass);
    }
#endif
    MSLane *orig = MSLane::dictionary(myCurrentLane);
    if (orig==0) {
        return;
    }


    // build the link
    SUMOReal length = orig!=0&&lane!=0
                      ? orig->getShape()[-1].distanceTo(lane->getShape()[0])
                      : 0;
#ifdef HAVE_INTERNAL_LANES
    if (via!=0) {
        length = via->getLength();
    }
    MSLink *link = new MSLink(lane, via, yield, dir, state, internalEnd, length);
#else
    MSLink *link = new MSLink(lane, yield, dir, state, length);
#endif

    if (MSLane::dictionary(myCurrentLane)!=0) {
#ifdef HAVE_INTERNAL_LANES
        if (via!=0) {
            // from a normal in to a normal out via
            //  --> via incomes in out
            lane->addIncomingLane(via, link);
            //  --> in incomes in via
            via->addIncomingLane(MSLane::dictionary(myCurrentLane), link);
        } else {
            if (myCurrentLane[0]!=':') {
                // internal not wished; other case already set
                lane->addIncomingLane(MSLane::dictionary(myCurrentLane), link);
            }
        }
#else
        lane->addIncomingLane(MSLane::dictionary(myCurrentLane), link);
#endif
    }
    // if a traffic light is responsible for it, inform the traffic light
    // check whether this link is controlled by a traffic light
    if (tlid!="") {
        MSTLLogicControl::TLSLogicVariants &logics = myJunctionControlBuilder.getTLLogic(tlid);
        MSLane *current = MSLane::dictionary(myCurrentLane);
        if (current==0) {
            throw InvalidArgument("An unknown lane ('" + myCurrentLane + "') should be assigned to a tl-logic.");
        }
        logics.addLink(link, current, linkNo);
    }
    // add the link to the container
    mySuccLanes->push_back(link);
}

void NLSucceedingLaneBuilder::closeSuccLane

(

)

throw (InvalidArgument)

Ends the computation of a container holding the succeeding lanes of a lane.

The current lane is determined and the parsed connections are added to it. If the lane is not known, an InvalidArgument is thrown.

Exceptions:

InvalidArgument

If the current lane is not known

Definition at line 172 of file NLSucceedingLaneBuilder.cpp.

References MSLane::dictionary(), MSLane::initialize(), myCurrentLane, and mySuccLanes.

Referenced by NLHandler::closeSuccLane().

                                                              {
    MSLane *current = MSLane::dictionary(myCurrentLane);
    if (current==0) {
        throw InvalidArgument("Trying to close connections of an unknown lane ('" + myCurrentLane + "').");
    }
    MSLinkCont *cont = new MSLinkCont();
    cont->reserve(mySuccLanes->size());
    copy(mySuccLanes->begin(), mySuccLanes->end(), back_inserter(*cont));
    current->initialize(cont);
    mySuccLanes->clear();
}

const std::string & NLSucceedingLaneBuilder::getCurrentLaneName

(

)

const throw ()

Returns the name of the lane the succeeding lanes are added to.

Returns:

The ID of the currently opened lane

Definition at line 186 of file NLSucceedingLaneBuilder.cpp.

References myCurrentLane.

                                                          {
    return myCurrentLane;
}

void NLSucceedingLaneBuilder::openSuccLane

(

const std::string &

laneId

)

throw ()

Begins the computation of a container holding the succeeding lanes of a lane.

Parameters:

[in]

laneId

The id of the lane from which connections will be built

Todo:

Why is the ID kept, not already the lane itself?

Definition at line 67 of file NLSucceedingLaneBuilder.cpp.

References myCurrentLane.

Referenced by NLHandler::openSucc().

                                                                     {
    myCurrentLane = laneId;
}

NLSucceedingLaneBuilder& NLSucceedingLaneBuilder::operator=

(

const NLSucceedingLaneBuilder &

s

)

[private]

invalid assignment operator

---

Field Documentation

std::string NLSucceedingLaneBuilder::myCurrentLane [private]

ID of the lane the succeeding lanes are added to.

Todo:

Why is not the lane itself saved?

Definition at line 121 of file NLSucceedingLaneBuilder.h.

Referenced by addSuccLane(), closeSuccLane(), getCurrentLaneName(), and openSuccLane().

NLJunctionControlBuilder& NLSucceedingLaneBuilder::myJunctionControlBuilder [private]

The junction control builder to obtain referenced tls from.

Definition at line 128 of file NLSucceedingLaneBuilder.h.

Referenced by addSuccLane().

MSLinkCont* NLSucceedingLaneBuilder::mySuccLanes [private]

The list of connections.

Todo:

Is it really necessary to have this as a pointer - the link container is rebuilt anyway

Definition at line 125 of file NLSucceedingLaneBuilder.h.

Referenced by addSuccLane(), closeSuccLane(), and ~NLSucceedingLaneBuilder().

---

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

• NLSucceedingLaneBuilder.h
• NLSucceedingLaneBuilder.cpp