NLHandler Class Reference

#include <NLHandler.h>

Inheritance diagram for NLHandler:

---

Detailed Description

Definition at line 67 of file NLHandler.h.

Public Types
typedef std::vector< MSLane * >	LaneVector
	Definition of a lane vector.
Public Member Functions
void	characters (const XMLCh *const chars, const XERCES3_SIZE_t length)
	The inherited method called when characters occured.
void	endElement (const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname)
	The inherited method called when a tag is being closed.
const std::string &	getFileName () const throw ()
	returns the current file name
SUMOTime	getLastDepart () const
	Returns the last loaded depart time.
	NLHandler (const std::string &file, MSNet &net, NLDetectorBuilder &detBuilder, NLTriggerBuilder &triggerBuilder, NLEdgeControlBuilder &edgeBuilder, NLJunctionControlBuilder &junctionBuilder, NLGeomShapeBuilder &shapeBuilder) throw ()
	Constructor.
void	registerParent (const SumoXMLTag tag, GenericSAXHandler *handler)
	Assigning a parent handler which is enabled when the specified tag is closed.
void	retrieveLastReadVehicle (MSEmitControl *into)
	Returns the last loaded vehicle.
void	setFileName (const std::string &name) throw ()
	Sets the current file name.
void	startElement (const XMLCh *const uri, const XMLCh *const localname, const XMLCh *const qname, const Attributes &attrs)
	The inherited method called when a new tag opens.
virtual	~NLHandler () throw ()
	Destructor.
SAX ErrorHandler callbacks
void	error (const SAXParseException &exception) throw (ProcessError)
	Handler for XML-errors.
void	fatalError (const SAXParseException &exception) throw (ProcessError)
	Handler for XML-errors.
void	warning (const SAXParseException &exception) throw ()
	Handler for XML-warnings.
Protected Member Functions
virtual void	addDetector (const SUMOSAXAttributes &attrs)
	adds a detector Determines the type of the detector first, and then calls the appropriate method
virtual void	addE1Detector (const SUMOSAXAttributes &attrs)
	Builds an e1-detector using the given specification.
virtual void	addE2Detector (const SUMOSAXAttributes &attrs)
	Builds an e2-detector using the given specification.
void	addE3Entry (const SUMOSAXAttributes &attrs)
	Adds an entry to the currently processed e3-detector.
void	addE3Exit (const SUMOSAXAttributes &attrs)
	Adds an exit to the currently processed e3-detector.
virtual void	addEdgeLaneMeanData (const SUMOSAXAttributes &attrs, const char *objecttype)
	Builds edge or lane base mean data collector using the given specification.
void	addParam (const SUMOSAXAttributes &attrs)
virtual void	addRouteProbeDetector (const SUMOSAXAttributes &attrs)
	Builds a routeprobe-detector using the given specification.
virtual void	addVTypeProbeDetector (const SUMOSAXAttributes &attrs)
	Builds a vtype-detector using the given specification.
void	beginE3Detector (const SUMOSAXAttributes &attrs)
	Starts building of an e3-detector using the given specification.
std::string	buildErrorMessage (const SAXParseException &exception) throw ()
	Builds an error message.
virtual void	closeEdge ()
	Closes the process of building an edge.
void	closeFlow () throw (ProcessError)
	Ends the processing of a flow.
virtual void	closeLane ()
	Closes the process of building a lane.
void	closePerson () throw (ProcessError)
	Ends the processing of a person.
void	closeRoute () throw (ProcessError)
void	closeRouteDistribution ()
void	closeVehicle () throw (ProcessError)
	Ends the processing of a vehicle.
void	closeVehicleTypeDistribution ()
void	endDetector ()
	Ends the detector building.
virtual void	endE3Detector ()
	Builds of an e3-detector using collected values.
void	openRoute (const SUMOSAXAttributes &attrs)
void	openRouteDistribution (const SUMOSAXAttributes &attrs)
void	openVehicleTypeDistribution (const SUMOSAXAttributes &attrs)
inherited from GenericSAXHandler
virtual void	myCharacters (SumoXMLTag element, const std::string &chars) throw (ProcessError)
	Called when characters occure.
virtual void	myEndElement (SumoXMLTag element) throw (ProcessError)
	Called when a closing tag occurs.
virtual void	myStartElement (SumoXMLTag element, const SUMOSAXAttributes &attrs) throw (ProcessError)
	Called on the opening of a tag;.
Protected Attributes
NLDiscreteEventBuilder	myActionBuilder
	A builder for object actions.
MSPerson::MSPersonPlan *	myActivePlan
	the plan of the current person
MSEdgeVector	myActiveRoute
	the current route
RGBColor	myActiveRouteColor
	The currently parsed route's color.
std::string	myActiveRouteID
	the id of the current route
SUMOReal	myActiveRouteProbability
	the id of the current route
std::vector < SUMOVehicleParameter::Stop >	myActiveRouteStops
	List of the stops on the parsed route.
bool	myAddVehiclesDirectly
bool	myAmInTLLogicMode
	internal information whether a tls-logic is currently read
bool	myAmUsingIncrementalDUA
	Information whether not all vehicle shall be emitted due to inc-dua.
Boundary	myConvBoundary
std::string	myCurrentDetectorType
	The type of the last detector.
bool	myCurrentIsBroken
bool	myCurrentIsInternalToSkip
	Information whether the currently parsed edge is internal and not wished, here.
RandomDistributor< const MSRoute * > *	myCurrentRouteDistribution
	The currently parsed distribution of routes (probability->route).
std::string	myCurrentRouteDistributionID
	The id of the currently parsed route distribution.
SUMOVTypeParameter *	myCurrentVType
	The currently parsed vehicle type.
RandomDistributor < MSVehicleType * > *	myCurrentVTypeDistribution
	The currently parsed distribution of vehicle types (probability->vehicle type).
std::string	myCurrentVTypeDistributionID
	The id of the currently parsed vehicle type distribution.
std::string	myCurrentWAUTID
	The id of the currently processed WAUT.
NLDetectorBuilder &	myDetectorBuilder
	The detector builder to use.
NLEdgeControlBuilder &	myEdgeControlBuilder
bool	myHaveWarned
	whether we have warned about routes defined as character strings
bool	myHaveWarnedAboutDeprecatedJunctionShape
	Whether deprecated definition of a junction shape in characters was already reported.
bool	myHaveWarnedAboutDeprecatedLaneShape
	Whether deprecated definition of a lane shape in characters was already reported.
bool	myHaveWarnedAboutDeprecatedLocation
	Whether deprecated definition of network boundaries/projection was already reported.
bool	myHaveWarnedAboutDeprecatedPhases
	Whether deprecated definition of phases was already reported.
bool	myHaveWarnedAboutDeprecatedPolyShape
	Whether deprecated definition of a polygon shape in characters was already reported.
bool	myHaveWarnedAboutDeprecatedVClass
	Whether deprecated usage of the "vclass" attribute was already reported.
int	myIncrementalBase
	The base for inc-dua.
int	myIncrementalStage
	The current stage of inc-dua.
NLJunctionControlBuilder &	myJunctionControlBuilder
SUMOTime	myLastDepart
	the emission time of the vehicle read last
MSVehicle *	myLastReadVehicle
	the last vehicle read
MSNet &	myNet
	The net to fill (preinitialised).
Position2D	myNetworkOffset
	The network offset.
Boundary	myOrigBoundary
	The network's boundaries.
unsigned int	myRunningVehicleNumber
	The current vehicle number (for inc-dua).
NLGeomShapeBuilder &	myShapeBuilder
NLSucceedingLaneBuilder	mySucceedingLaneBuilder
	storage for building succeeding lanes
NLTriggerBuilder &	myTriggerBuilder
	The trigger builder to use.
SUMOVehicleParameter *	myVehicleParameter
Information about a lane
std::vector< SUMOVehicleClass >	myAllowedClasses
	Vehicle classes allowed on the current lane.
std::string	myCurrentDistrictID
	The id of the current district.
std::string	myCurrentLaneID
	The id of the current lane.
SUMOReal	myCurrentLength
	The length of the current lane.
SUMOReal	myCurrentMaxSpeed
	The maximum speed allowed on the current lane.
std::vector< SUMOVehicleClass >	myDisallowedClasses
	Vehicle classes disallowed on the current lane.
bool	myLaneIsDepart
	The information whether the current lane is a depart lane.
Position2DVector	myShape
	The shape of the current lane.
Private Member Functions
void	addDistrict (const SUMOSAXAttributes &attrs) throw (ProcessError)
void	addDistrictEdge (const SUMOSAXAttributes &attrs, bool isSource)
void	addIncomingLanes (const std::string &chars)
	adds the incoming lanes
void	addIncomingPolyPosititon (const std::string &chars)
	adds the incoming Polygon's Positions
void	addJunctionShape (const std::string &chars)
	parses the shape of a junction
void	addLane (const SUMOSAXAttributes &attrs)
	adds a lane to the previously opened edge
void	addLaneShape (const std::string &chars)
	add the shape to the Lane
void	addLogicItem (const SUMOSAXAttributes &attrs)
	adds a logic item to the current logic
void	addPhase (const SUMOSAXAttributes &attrs)
	adds a phase to the traffic lights logic currently build
void	addPOI (const SUMOSAXAttributes &attrs)
	adds a polygon
void	addPoly (const SUMOSAXAttributes &attrs)
	adds a polygon
virtual void	addSource (const SUMOSAXAttributes &attrs)
	adds a source
void	addSuccLane (const SUMOSAXAttributes &attrs)
	adds a succeeding lane
void	addTrigger (const SUMOSAXAttributes &attrs)
	adds a trigger
void	addWAUTJunction (const SUMOSAXAttributes &attrs)
void	addWAUTSwitch (const SUMOSAXAttributes &attrs)
void	beginEdgeParsing (const SUMOSAXAttributes &attrs)
	begins the processing of an edge
virtual void	closeJunction ()
	ends the processing of a junction
void	closeSuccLane ()
	closes the processing of a lane
void	closeWAUT ()
void	initJunctionLogic (const SUMOSAXAttributes &attrs)
	begins the reading of a junction row logic
void	initTrafficLightLogic (const SUMOSAXAttributes &attrs)
	begins the reading of a traffic lights logic
	NLHandler (const NLHandler &s)
virtual void	openJunction (const SUMOSAXAttributes &attrs)
	opens a junction for processing
void	openSucc (const SUMOSAXAttributes &attrs)
	opens the container of succeeding lanes for processing
virtual void	openWAUT (const SUMOSAXAttributes &attrs)
NLHandler &	operator= (const NLHandler &s)
MSLink::LinkDirection	parseLinkDir (char dir)
	Parses the given character into an enumeration typed link direction.
MSLink::LinkState	parseLinkState (char state)
	Parses the given character into an enumeration typed link state.
void	setKey (const std::string &chars)
	sets the key of the current junction logic
void	setLaneNumber (const std::string &chars)
	sets the lane number of the current junction logic
void	setLocation (const SUMOSAXAttributes &attrs)
	Parses network location description.
void	setOffset (const std::string &chars)
	Sets the offset a tl-logic shall be fired the first time after.
void	setRequestSize (const std::string &chars)
	sets the request size of the current junction logic
void	setSubKey (const std::string &chars)
	sets the subkey of the current junction logic

---

Member Typedef Documentation

typedef std::vector<MSLane*> NLHandler::LaneVector

Definition of a lane vector.

Definition at line 70 of file NLHandler.h.

---

Constructor & Destructor Documentation

NLHandler::NLHandler	(	const std::string &	file,
		MSNet &	net,
		NLDetectorBuilder &	detBuilder,
		NLTriggerBuilder &	triggerBuilder,
		NLEdgeControlBuilder &	edgeBuilder,
		NLJunctionControlBuilder &	junctionBuilder,
		NLGeomShapeBuilder &	shapeBuilder
	)			throw ()

Constructor.

Parameters:

[in]	file	Name of the parsed file
[in,out]	net	The network to fill
[in]	detBuilder	The detector builder to use
[in]	triggerBuilder	The trigger builder to use
[in]	edgeBuilder	The builder of edges to use
[in]	junctionBuilder	The builder of junctions to use
[in]	shapeBuilder	The geometric shapes builder to use

Definition at line 64 of file NLHandler.cpp.

        : MSRouteHandler(file, true),
        myNet(net), myActionBuilder(net),
        myCurrentIsInternalToSkip(false),
        myDetectorBuilder(detBuilder), myTriggerBuilder(triggerBuilder),
        myEdgeControlBuilder(edgeBuilder), myJunctionControlBuilder(junctionBuilder),
        myShapeBuilder(shapeBuilder), mySucceedingLaneBuilder(junctionBuilder),
        myAmInTLLogicMode(false), myCurrentIsBroken(false),
        myHaveWarnedAboutDeprecatedVClass(false),
        myHaveWarnedAboutDeprecatedJunctionShape(false),
        myHaveWarnedAboutDeprecatedLaneShape(false),
        myHaveWarnedAboutDeprecatedPolyShape(false),
        myHaveWarnedAboutDeprecatedLocation(false),
        myHaveWarnedAboutDeprecatedPhases(false) {}

NLHandler::~NLHandler

(

)

throw () [virtual]

Destructor.

Definition at line 85 of file NLHandler.cpp.

{}

NLHandler::NLHandler

(

const NLHandler &

s

)

[private]

invalid copy constructor

---

Member Function Documentation

void NLHandler::addDetector

(

const SUMOSAXAttributes &

attrs

)

[protected, virtual]

adds a detector Determines the type of the detector first, and then calls the appropriate method

Definition at line 824 of file NLHandler.cpp.

References addE1Detector(), addE2Detector(), beginE3Detector(), SUMOSAXAttributes::getOptStringReporting(), myCurrentDetectorType, SUMOSAXAttributes::setIDFromAttributes(), and SUMO_ATTR_TYPE.

Referenced by myStartElement().

                                                     {
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("detector", id)) {
        return;
    }
    // try to get the type
    bool ok = true;
    std::string type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, 0, 0, ok, "induct_loop");
    // build in dependence to type
    // induct loops (E1-detectors)
    if (type=="induct_loop"||type=="E1"||type=="e1") {
        addE1Detector(attrs);
        myCurrentDetectorType = "e1";
        return;
    }
    // lane-based areal detectors (E2-detectors)
    if (type=="lane_based"||type=="E2"||type=="e2") {
        addE2Detector(attrs);
        myCurrentDetectorType = "e2";
        return;
    }
    // multi-origin/multi-destination detectors (E3-detectors)
    if (type=="multi_od"||type=="E3"||type=="e3") {
        beginE3Detector(attrs);
        myCurrentDetectorType = "e3";
        return;
    }
#ifdef _MESSAGES
    // new induct loop, for static messages
    if (type=="il_msg"||type=="E4"||type=="e4") {
        addMsgDetector(attrs);
        myCurrentDetectorType="e4";
    }
#endif
}

void NLHandler::addDistrict

(

const SUMOSAXAttributes &

attrs

)

throw (ProcessError) [private]

Parses a district and creates a pseudo edge for it

Called on the occurence of a "district" element, this method retrieves the id of the district and creates a district type edge with this id.

Parameters:

[in]

attrs

The attributes (of the "district"-element) to parse

Exceptions:

ProcessError

If an edge given in district is not known

Definition at line 1358 of file NLHandler.cpp.

References MSEdge::addFollower(), NLEdgeControlBuilder::buildEdge(), MSEdge::dictionary(), MSEdge::EDGEFUNCTION_DISTRICT, MsgHandler::getErrorInstance(), SUMOSAXAttributes::getString(), SUMOSAXAttributes::hasAttribute(), MsgHandler::inform(), MSEdge::initialize(), myCurrentDistrictID, myCurrentIsBroken, myEdgeControlBuilder, SUMOSAXAttributes::setIDFromAttributes(), and SUMO_ATTR_EDGES.

Referenced by myStartElement().

                                                                         {
    myCurrentIsBroken = false;
    // get the id, report an error if not given or empty...
    if (!attrs.setIDFromAttributes("district", myCurrentDistrictID)) {
        myCurrentIsBroken = true;
        return;
    }
    try {
        MSEdge* sink = myEdgeControlBuilder.buildEdge(myCurrentDistrictID);
        if (!MSEdge::dictionary(myCurrentDistrictID, sink)) {
            delete sink;
            throw InvalidArgument("Another edge with the id '" + myCurrentDistrictID + "' exists.");
        }
        sink->initialize(0, 0, MSEdge::EDGEFUNCTION_DISTRICT);
        MSEdge* source = myEdgeControlBuilder.buildEdge(myCurrentDistrictID + "-source");
        if (!MSEdge::dictionary(myCurrentDistrictID + "-source", source)) {
            delete source;
            throw InvalidArgument("Another edge with the id '" + myCurrentDistrictID + "-source' exists.");
        }
        source->initialize(0, 0, MSEdge::EDGEFUNCTION_DISTRICT);
        if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
            std::vector<std::string> desc = StringTokenizer(attrs.getString(SUMO_ATTR_EDGES)).getVector();
            for (std::vector<std::string>::const_iterator i=desc.begin(); i!=desc.end(); ++i) {
                MSEdge *edge = MSEdge::dictionary(*i);
                // check whether the edge exists
                if (edge==0) {
                    throw InvalidArgument("The edge '" + *i + "' within district '" + myCurrentDistrictID + "' is not known.");
                }
                source->addFollower(edge);
                edge->addFollower(sink);
            }
        }
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
        myCurrentIsBroken = true;
    }
}

void NLHandler::addDistrictEdge	(	const SUMOSAXAttributes &	attrs,
		bool	isSource
	)			[private]

Parses a district edge and connects it to the district

Called on the occurence of a "dsource" or "dsink" element, this method retrieves the id of the approachable edge. If this edge is known and valid, the approaching edge is informed about it.

Parameters:

[in]	attrs	The attributes to parse
[in]	isSource	whether a "dsource or a "dsink" was given

Todo:

No exception?

Definition at line 1398 of file NLHandler.cpp.

References MSEdge::addFollower(), MSEdge::dictionary(), MsgHandler::getErrorInstance(), SUMOSAXAttributes::getStringReporting(), MsgHandler::inform(), myCurrentDistrictID, myCurrentIsBroken, and SUMO_ATTR_ID.

Referenced by myStartElement().

                                                                        {
    if (myCurrentIsBroken) {
        // earlier error
        return;
    }
    bool ok = true;
    std::string id = attrs.getStringReporting(SUMO_ATTR_ID, "district", myCurrentDistrictID.c_str(), ok);
    MSEdge *succ = MSEdge::dictionary(id);
    if (succ!=0) {
        // connect edge
        if (isSource) {
            MSEdge::dictionary(myCurrentDistrictID + "-source")->addFollower(succ);
        } else {
            succ->addFollower(MSEdge::dictionary(myCurrentDistrictID));
        }
    } else {
        MsgHandler::getErrorInstance()->inform("At district '" + myCurrentDistrictID + "': succeeding edge '" + id + "' does not exist.");
    }
}

void NLHandler::addE1Detector

(

const SUMOSAXAttributes &

attrs

)

[protected, virtual]

Builds an e1-detector using the given specification.

Parameters:

[in]

attrs

The attributes that define the detector

Definition at line 891 of file NLHandler.cpp.

References NLDetectorBuilder::buildInductLoop(), OutputDevice::getDevice(), MsgHandler::getErrorInstance(), GenericSAXHandler::getFileName(), SUMOSAXAttributes::getOptBoolReporting(), SUMOSAXAttributes::getOptStringReporting(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::getSUMORealReporting(), SUMOSAXAttributes::getSUMOTimeReporting(), MsgHandler::getWarningInstance(), MsgHandler::inform(), myDetectorBuilder, SUMOSAXAttributes::setIDFromAttributes(), SUMO_ATTR_FILE, SUMO_ATTR_FREQUENCY, SUMO_ATTR_FRIENDLY_POS, SUMO_ATTR_LANE, SUMO_ATTR_POSITION, SUMO_ATTR_STYLE, and SUMOReal.

Referenced by addDetector(), and myStartElement().

                                                       {
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("e1-detector", id)) {
        return;
    }
    // inform the user about deprecated values
    bool ok = true;
    if (attrs.getOptStringReporting(SUMO_ATTR_STYLE, "e1-detector", id.c_str(), ok, "<invalid>")!="<invalid>") {
        MsgHandler::getWarningInstance()->inform("While parsing E1-detector '" + id + "': 'style' is deprecated.");
    }
    SUMOTime frequency = attrs.getSUMOTimeReporting(SUMO_ATTR_FREQUENCY, "e1-detector", id.c_str(), ok);
    SUMOReal position = attrs.getSUMORealReporting(SUMO_ATTR_POSITION, "e1-detector", id.c_str(), ok);
    bool friendlyPos = attrs.getOptBoolReporting(SUMO_ATTR_FRIENDLY_POS, "e1-detector", id.c_str(), ok, false);
    std::string lane = attrs.getStringReporting(SUMO_ATTR_LANE, "e1-detector", id.c_str(), ok);
    std::string file = attrs.getStringReporting(SUMO_ATTR_FILE, "e1-detector", id.c_str(), ok);
    if (!ok) {
        return;
    }
    try {
        myDetectorBuilder.buildInductLoop(id, lane, position, frequency,
                                          OutputDevice::getDevice(file, getFileName()),
                                          friendlyPos);
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    } catch (IOError &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void NLHandler::addE2Detector

(

const SUMOSAXAttributes &

attrs

)

[protected, virtual]

Builds an e2-detector using the given specification.

Parameters:

[in]

attrs

The attributes that define the detector

Definition at line 974 of file NLHandler.cpp.

References NLDetectorBuilder::buildE2Detector(), OutputDevice::getDevice(), MsgHandler::getErrorInstance(), GenericSAXHandler::getFileName(), SUMOSAXAttributes::getOptBoolReporting(), SUMOSAXAttributes::getOptStringReporting(), SUMOSAXAttributes::getOptSUMORealReporting(), SUMOSAXAttributes::getOptSUMOTimeReporting(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::getSUMORealReporting(), SUMOSAXAttributes::getSUMOTimeReporting(), NLJunctionControlBuilder::getTLLogic(), MsgHandler::getWarningInstance(), MsgHandler::inform(), myDetectorBuilder, myJunctionControlBuilder, SUMOSAXAttributes::setIDFromAttributes(), SUMO_ATTR_CONT, SUMO_ATTR_FILE, SUMO_ATTR_FREQUENCY, SUMO_ATTR_FRIENDLY_POS, SUMO_ATTR_HALTING_SPEED_THRESHOLD, SUMO_ATTR_HALTING_TIME_THRESHOLD, SUMO_ATTR_JAM_DIST_THRESHOLD, SUMO_ATTR_LANE, SUMO_ATTR_LENGTH, SUMO_ATTR_MEASURES, SUMO_ATTR_POSITION, SUMO_ATTR_STYLE, SUMO_ATTR_TLID, SUMO_ATTR_TO, SUMOReal, and TIME2STEPS.

Referenced by addDetector(), and myStartElement().

                                                       {
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("e2-detector", id)) {
        return;
    }
    // check whether this is a detector connected to a tls an optionally to a link
    bool ok = true;
    std::string lsaid = attrs.getOptStringReporting(SUMO_ATTR_TLID, "e2-detector", id.c_str(), ok, "<invalid>");
    std::string toLane = attrs.getOptStringReporting(SUMO_ATTR_TO, "e2-detector", id.c_str(), ok, "<invalid>");
    // inform the user about deprecated values
    if (attrs.getOptStringReporting(SUMO_ATTR_MEASURES, "e2-detector", id.c_str(), ok, "<invalid>")!="<invalid>") {
        MsgHandler::getWarningInstance()->inform("While parsing E2-detector '" + id + "': 'measures' is deprecated.");
    }
    if (attrs.getOptStringReporting(SUMO_ATTR_STYLE, "e2-detector", id.c_str(), ok, "<invalid>")!="<invalid>") {
        MsgHandler::getWarningInstance()->inform("While parsing E2-detector '" + id + "': 'style' is deprecated.");
    }
    //
    try {
        const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, "e2-detector", id.c_str(), ok, TIME2STEPS(1));
        const SUMOReal haltingSpeedThreshold = attrs.getOptSUMORealReporting(SUMO_ATTR_HALTING_SPEED_THRESHOLD, "e2-detector", id.c_str(), ok, 5.0f/3.6f);
        const SUMOReal jamDistThreshold = attrs.getOptSUMORealReporting(SUMO_ATTR_JAM_DIST_THRESHOLD, "e2-detector", id.c_str(), ok, 10.0f);
        const SUMOReal position = attrs.getSUMORealReporting(SUMO_ATTR_POSITION, "e2-detector", id.c_str(), ok);
        const SUMOReal length = attrs.getSUMORealReporting(SUMO_ATTR_LENGTH, "e2-detector", id.c_str(), ok);
        const bool friendlyPos = attrs.getOptBoolReporting(SUMO_ATTR_FRIENDLY_POS, "e2-detector", id.c_str(), ok, false);
        const bool cont = attrs.getOptBoolReporting(SUMO_ATTR_CONT, "e2-detector", id.c_str(), ok, false);
        const std::string lane = attrs.getStringReporting(SUMO_ATTR_LANE, "e2-detector", id.c_str(), ok);
        const std::string file = attrs.getStringReporting(SUMO_ATTR_FILE, "e2-detector", id.c_str(), ok);
        if (!ok) {
            return;
        }
        if (lsaid!="<invalid>") {
            if (toLane=="<invalid>") {
                myDetectorBuilder.buildE2Detector(id, lane, position, length, cont,
                                                  myJunctionControlBuilder.getTLLogic(lsaid),
                                                  OutputDevice::getDevice(file, getFileName()),
                                                  (SUMOTime) haltingSpeedThreshold, haltingSpeedThreshold, jamDistThreshold,
                                                  friendlyPos);
            } else {
                myDetectorBuilder.buildE2Detector(id, lane, position, length, cont,
                                                  myJunctionControlBuilder.getTLLogic(lsaid), toLane,
                                                  OutputDevice::getDevice(file, getFileName()),
                                                  (SUMOTime) haltingSpeedThreshold, haltingSpeedThreshold, jamDistThreshold,
                                                  friendlyPos);
            }
        } else {
            bool ok = true;
            SUMOTime frequency = attrs.getSUMOTimeReporting(SUMO_ATTR_FREQUENCY, "e2-detector", id.c_str(), ok);
            if (!ok) {
                return;
            }
            myDetectorBuilder.buildE2Detector(id, lane, position, length, cont, frequency,
                                              OutputDevice::getDevice(file, getFileName()),
                                              (SUMOTime) haltingSpeedThreshold, haltingSpeedThreshold, jamDistThreshold,
                                              friendlyPos);
        }
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    } catch (IOError &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void NLHandler::addE3Entry

(

const SUMOSAXAttributes &

attrs

)

[protected]

Adds an entry to the currently processed e3-detector.

Parameters:

[in]

attrs

The attributes that define the entry

Definition at line 1073 of file NLHandler.cpp.

References NLDetectorBuilder::addE3Entry(), NLDetectorBuilder::getCurrentE3ID(), SUMOSAXAttributes::getOptBoolReporting(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::getSUMORealReporting(), myDetectorBuilder, SUMO_ATTR_FRIENDLY_POS, SUMO_ATTR_LANE, SUMO_ATTR_POSITION, and SUMOReal.

Referenced by myStartElement().

                                                    {
    bool ok = true;
    const SUMOReal position = attrs.getSUMORealReporting(SUMO_ATTR_POSITION, "e3-detector/entry", myDetectorBuilder.getCurrentE3ID().c_str(), ok);
    const bool friendlyPos = attrs.getOptBoolReporting(SUMO_ATTR_FRIENDLY_POS, "e3-detector/entry", myDetectorBuilder.getCurrentE3ID().c_str(), ok, false);
    const std::string lane = attrs.getStringReporting(SUMO_ATTR_LANE, "e3-detector/entry", myDetectorBuilder.getCurrentE3ID().c_str(), ok);
    if (!ok) {
        return;
    }
    myDetectorBuilder.addE3Entry(lane, position, friendlyPos);
}

void NLHandler::addE3Exit

(

const SUMOSAXAttributes &

attrs

)

[protected]

Adds an exit to the currently processed e3-detector.

Parameters:

[in]

attrs

The attributes that define the exit

Definition at line 1086 of file NLHandler.cpp.

References NLDetectorBuilder::addE3Exit(), NLDetectorBuilder::getCurrentE3ID(), SUMOSAXAttributes::getOptBoolReporting(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::getSUMORealReporting(), myDetectorBuilder, SUMO_ATTR_FRIENDLY_POS, SUMO_ATTR_LANE, SUMO_ATTR_POSITION, and SUMOReal.

Referenced by myStartElement().

                                                   {
    bool ok = true;
    const SUMOReal position = attrs.getSUMORealReporting(SUMO_ATTR_POSITION, "e3-detector/exit", myDetectorBuilder.getCurrentE3ID().c_str(), ok);
    const bool friendlyPos = attrs.getOptBoolReporting(SUMO_ATTR_FRIENDLY_POS, "e3-detector/exit", myDetectorBuilder.getCurrentE3ID().c_str(), ok, false);
    const std::string lane = attrs.getStringReporting(SUMO_ATTR_LANE, "e3-detector/exit", myDetectorBuilder.getCurrentE3ID().c_str(), ok);
    if (!ok) {
        return;
    }
    myDetectorBuilder.addE3Exit(lane, position, friendlyPos);
}

void NLHandler::addEdgeLaneMeanData	(	const SUMOSAXAttributes &	attrs,
		const char *	objecttype
	)			[protected, virtual]

Builds edge or lane base mean data collector using the given specification.

Parameters:

[in]

attrs

The attributes that define the detector

Definition at line 1099 of file NLHandler.cpp.

References NLDetectorBuilder::createEdgeLaneMeanData(), OutputDevice::getDevice(), MsgHandler::getErrorInstance(), GenericSAXHandler::getFileName(), SUMOSAXAttributes::getOptBoolReporting(), OptionsCont::getOptions(), SUMOSAXAttributes::getOptStringReporting(), SUMOSAXAttributes::getOptSUMORealReporting(), SUMOSAXAttributes::getOptSUMOTimeReporting(), SUMOSAXAttributes::getStringReporting(), MsgHandler::inform(), myDetectorBuilder, POSITION_EPS, SUMOSAXAttributes::setIDFromAttributes(), string2time(), SUMO_ATTR_BEGIN, SUMO_ATTR_END, SUMO_ATTR_EXCLUDE_EMPTY, SUMO_ATTR_FILE, SUMO_ATTR_FREQUENCY, SUMO_ATTR_HALTING_SPEED_THRESHOLD, SUMO_ATTR_MAX_TRAVELTIME, SUMO_ATTR_MIN_SAMPLES, SUMO_ATTR_TRACK_VEHICLES, SUMO_ATTR_TYPE, SUMO_ATTR_VTYPES, SUMO_ATTR_WITH_INTERNAL, and SUMOReal.

Referenced by myStartElement().

                                                                                     {
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes(objecttype, id)) {
        return;
    }
    bool ok = true;
    const SUMOReal maxTravelTime = attrs.getOptSUMORealReporting(SUMO_ATTR_MAX_TRAVELTIME, objecttype, id.c_str(), ok, 100000);
    const SUMOReal minSamples = attrs.getOptSUMORealReporting(SUMO_ATTR_MIN_SAMPLES, objecttype, id.c_str(), ok, 0);
    const SUMOReal haltingSpeedThreshold = attrs.getOptSUMORealReporting(SUMO_ATTR_HALTING_SPEED_THRESHOLD, objecttype, id.c_str(), ok, POSITION_EPS);
    const bool excludeEmpty = attrs.getOptBoolReporting(SUMO_ATTR_EXCLUDE_EMPTY, objecttype, id.c_str(), ok, false);
    const bool withInternal = attrs.getOptBoolReporting(SUMO_ATTR_WITH_INTERNAL, objecttype, id.c_str(), ok, false);
    const bool trackVehicles = attrs.getOptBoolReporting(SUMO_ATTR_TRACK_VEHICLES, objecttype, id.c_str(), ok, false);
    const std::string file = attrs.getStringReporting(SUMO_ATTR_FILE, objecttype, id.c_str(), ok);
    const std::string type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, objecttype, id.c_str(), ok, "performance");
    const std::string vtypes = attrs.getOptStringReporting(SUMO_ATTR_VTYPES, objecttype, id.c_str(), ok, "");
    const SUMOTime frequency = attrs.getOptSUMOTimeReporting(SUMO_ATTR_FREQUENCY, objecttype, id.c_str(), ok, -1);
    const SUMOTime begin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, objecttype, id.c_str(), ok, string2time(OptionsCont::getOptions().getString("begin")));
    const SUMOTime end = attrs.getOptSUMOTimeReporting(SUMO_ATTR_END, objecttype, id.c_str(), ok, string2time(OptionsCont::getOptions().getString("end")));
    if (!ok) {
        return;
    }
    try {
        myDetectorBuilder.createEdgeLaneMeanData(id, frequency, begin, end,
                type, objecttype=="meandata_lane", !excludeEmpty, withInternal, trackVehicles,
                maxTravelTime, minSamples, haltingSpeedThreshold, vtypes,
                OutputDevice::getDevice(file, getFileName()));
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    } catch (IOError &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void NLHandler::addIncomingLanes

(

const std::string &

chars

)

[private]

adds the incoming lanes

Definition at line 1422 of file NLHandler.cpp.

References NLJunctionControlBuilder::addIncomingLane(), MSLane::dictionary(), NLJunctionControlBuilder::getActiveID(), MsgHandler::getErrorInstance(), MSGlobals::gUsingInternalLanes, StringTokenizer::hasNext(), MsgHandler::inform(), myJunctionControlBuilder, and StringTokenizer::next().

Referenced by myCharacters(), and openJunction().

                                                  {
    // @deprecated: at some time, all junctions should have a shape attribute (moved from characters)
    StringTokenizer st(chars);
    while (st.hasNext()) {
        std::string set = st.next();
        MSLane *lane = MSLane::dictionary(set);
        if (!MSGlobals::gUsingInternalLanes&&set[0]==':') {
            continue;
        }
        if (lane==0) {
            MsgHandler::getErrorInstance()->inform("An unknown lane ('" + set + "') was tried to be set as incoming to junction '" + myJunctionControlBuilder.getActiveID() + "'.");
            return;
        }
        myJunctionControlBuilder.addIncomingLane(lane);
    }
}

void NLHandler::addIncomingPolyPosititon

(

const std::string &

chars

)

[private]

adds the incoming Polygon's Positions

void NLHandler::addJunctionShape

(

const std::string &

chars

)

[private]

parses the shape of a junction

Definition at line 1329 of file NLHandler.cpp.

References NLJunctionControlBuilder::addJunctionShape(), NLJunctionControlBuilder::getActiveID(), MsgHandler::getWarningInstance(), MsgHandler::inform(), myHaveWarnedAboutDeprecatedJunctionShape, myJunctionControlBuilder, and GeomConvHelper::parseShapeReporting().

Referenced by myCharacters().

                                                  {
    // @deprecated: at some time, all junctions should have a shape attribute (moved from characters)
    if (!myHaveWarnedAboutDeprecatedJunctionShape) {
        myHaveWarnedAboutDeprecatedJunctionShape = true;
        MsgHandler::getWarningInstance()->inform("Your network uses a deprecated junction shape description; please rebuild.");
    }
    bool ok = true;
    Position2DVector shape = GeomConvHelper::parseShapeReporting(chars, "junction", myJunctionControlBuilder.getActiveID().c_str(), ok, true);
    if (ok) {
        myJunctionControlBuilder.addJunctionShape(shape);
    }
}

void NLHandler::addLane

(

const SUMOSAXAttributes &

attrs

)

[private]

adds a lane to the previously opened edge

Definition at line 411 of file NLHandler.cpp.

References addLaneShape(), Position2DVector::clear(), SUMOSAXAttributes::getBoolReporting(), SUMOSAXAttributes::getOptStringReporting(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::getSUMORealReporting(), MsgHandler::getWarningInstance(), SUMOSAXAttributes::hasAttribute(), MsgHandler::inform(), myAllowedClasses, myCurrentIsBroken, myCurrentIsInternalToSkip, myCurrentLaneID, myCurrentLength, myCurrentMaxSpeed, myDisallowedClasses, myHaveWarnedAboutDeprecatedLaneShape, myHaveWarnedAboutDeprecatedVClass, myLaneIsDepart, myShape, parseVehicleClasses(), SUMOSAXAttributes::setIDFromAttributes(), SUMO_ATTR_ALLOW, SUMO_ATTR_DEPART, SUMO_ATTR_DISALLOW, SUMO_ATTR_LENGTH, SUMO_ATTR_MAXSPEED, SUMO_ATTR_SHAPE, and SUMO_ATTR_VCLASSES.

Referenced by myStartElement().

                                                 {
    myShape.clear();
    // omit internal edges if not wished and broken edges
    if (myCurrentIsInternalToSkip||myCurrentIsBroken) {
        return;
    }
    // get the id, report an error if not given or empty...
    if (!attrs.setIDFromAttributes("lane", myCurrentLaneID)) {
        myCurrentIsBroken = true;
        return;
    }
    bool ok = true;
    myLaneIsDepart = attrs.getBoolReporting(SUMO_ATTR_DEPART, "lane", myCurrentLaneID.c_str(), ok);
    myCurrentMaxSpeed = attrs.getSUMORealReporting(SUMO_ATTR_MAXSPEED, "lane", myCurrentLaneID.c_str(), ok);
    myCurrentLength = attrs.getSUMORealReporting(SUMO_ATTR_LENGTH, "lane", myCurrentLaneID.c_str(), ok);
    std::string allow = attrs.getOptStringReporting(SUMO_ATTR_ALLOW, "lane", myCurrentLaneID.c_str(), ok, "");
    std::string disallow = attrs.getOptStringReporting(SUMO_ATTR_DISALLOW, "lane", myCurrentLaneID.c_str(), ok, "");
    std::string vclasses = attrs.getOptStringReporting(SUMO_ATTR_VCLASSES, "lane", myCurrentLaneID.c_str(), ok, "");
    myAllowedClasses.clear();
    myDisallowedClasses.clear();
    parseVehicleClasses(vclasses, allow, disallow, myAllowedClasses, myDisallowedClasses, myHaveWarnedAboutDeprecatedVClass);
    myCurrentIsBroken |= !ok;
    if (!myCurrentIsBroken) {
        if (attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
            addLaneShape(attrs.getStringReporting(SUMO_ATTR_SHAPE, "lane", myCurrentLaneID.c_str(), ok));
        } else if (!myHaveWarnedAboutDeprecatedLaneShape) {
            myHaveWarnedAboutDeprecatedLaneShape = true;
            MsgHandler::getWarningInstance()->inform("Your network uses a deprecated lane shape description; please rebuild.");
        }
    }
}

void NLHandler::addLaneShape

(

const std::string &

chars

)

[private]

add the shape to the Lane

Definition at line 445 of file NLHandler.cpp.

References MsgHandler::getErrorInstance(), MsgHandler::inform(), myCurrentIsBroken, myCurrentIsInternalToSkip, myCurrentLaneID, myShape, and GeomConvHelper::parseShapeReporting().

Referenced by addLane(), and myCharacters().

                                              {
    // omit internal edges if not wished and broken edges
    if (myCurrentIsInternalToSkip||myCurrentIsBroken) {
        return;
    }
    bool ok = true;
    myShape = GeomConvHelper::parseShapeReporting(chars, "lane", myCurrentLaneID.c_str(), ok, false);
    if (!ok) {
        MsgHandler::getErrorInstance()->inform("Could not parse shape of lane '" + myCurrentLaneID + "'.\n Can not build according edge.");
        myCurrentIsBroken = true;
    }
}

void NLHandler::addLogicItem

(

const SUMOSAXAttributes &

attrs

)

[private]

adds a logic item to the current logic

Definition at line 688 of file NLHandler.cpp.

References NLJunctionControlBuilder::addLogicItem(), MsgHandler::getErrorInstance(), SUMOSAXAttributes::getIntReporting(), SUMOSAXAttributes::getOptBoolReporting(), SUMOSAXAttributes::getStringReporting(), MsgHandler::inform(), myJunctionControlBuilder, SUMO_ATTR_CONT, SUMO_ATTR_FOES, SUMO_ATTR_REQUEST, and SUMO_ATTR_RESPONSE.

Referenced by myStartElement().

                                                      {
    bool ok = true;
    int request = attrs.getIntReporting(SUMO_ATTR_REQUEST, "request", 0, ok);
    bool cont = false;
#ifdef HAVE_INTERNAL_LANES
    cont = attrs.getOptBoolReporting(SUMO_ATTR_CONT, 0, 0, ok, false);
#endif
    std::string response = attrs.getStringReporting(SUMO_ATTR_RESPONSE, 0, 0, ok);
    std::string foes = attrs.getStringReporting(SUMO_ATTR_FOES, 0, 0, ok);
    if (!ok) {
        return;
    }
    // store received information
    if (request>=0 && response.length()>0) {
        try {
            myJunctionControlBuilder.addLogicItem(request, response, foes, cont);
        } catch (InvalidArgument &e) {
            MsgHandler::getErrorInstance()->inform(e.what());
        }
    }
}

void NLHandler::addParam

(

const SUMOSAXAttributes &

attrs

)

[protected]

Definition at line 543 of file NLHandler.cpp.

References NLJunctionControlBuilder::addParam(), SUMOSAXAttributes::getStringReporting(), myAmInTLLogicMode, myJunctionControlBuilder, SUMO_ATTR_KEY, and SUMO_ATTR_VALUE.

Referenced by myStartElement().

                                                  {
    bool ok = true;
    std::string key = attrs.getStringReporting(SUMO_ATTR_KEY, 0, 0, ok);
    std::string val = attrs.getStringReporting(SUMO_ATTR_VALUE, 0, 0, ok);
    // set
    if (ok&&myAmInTLLogicMode) {
        assert(key!="");
        assert(val!="");
        myJunctionControlBuilder.addParam(key, val);
    }
}

void NLHandler::addPhase

(

const SUMOSAXAttributes &

attrs

)

[private]

adds a phase to the traffic lights logic currently build

Definition at line 757 of file NLHandler.cpp.

References NLJunctionControlBuilder::addPhase(), NLJunctionControlBuilder::getActiveKey(), NLJunctionControlBuilder::getActiveSubKey(), MsgHandler::getErrorInstance(), SUMOSAXAttributes::getOptSUMOTimeReporting(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::getSUMOTimeReporting(), MsgHandler::getWarningInstance(), SUMOSAXAttributes::hasAttribute(), MsgHandler::inform(), myHaveWarnedAboutDeprecatedPhases, myJunctionControlBuilder, MSPhaseDefinition::old2new(), SUMO_ATTR_BRAKE, SUMO_ATTR_DURATION, SUMO_ATTR_MAXDURATION, SUMO_ATTR_MINDURATION, SUMO_ATTR_PHASE, SUMO_ATTR_STATE, and SUMO_ATTR_YELLOW.

Referenced by myStartElement().

                                                  {
    // try to get the phase definition
    std::string state;
    std::string phase;
    std::string brakeMask;
    std::string yellowMask;
    bool ok = true;
    if (attrs.hasAttribute(SUMO_ATTR_STATE)) {
        // ok, doing it the new way
        state = attrs.getStringReporting(SUMO_ATTR_STATE, "phase", 0, ok);
    } else {
        phase = attrs.getStringReporting(SUMO_ATTR_PHASE, "phase", 0, ok);
        brakeMask = attrs.getStringReporting(SUMO_ATTR_BRAKE, "phase", 0, ok);
        yellowMask = attrs.getStringReporting(SUMO_ATTR_YELLOW, "phase", 0, ok);
        // check
        if (phase.length()!=brakeMask.length()||phase.length()!=yellowMask.length()) {
            MsgHandler::getErrorInstance()->inform("Definition of traffic light is broken - descriptions have different lengths.");
            return;
        }
        if (!myHaveWarnedAboutDeprecatedPhases) {
            myHaveWarnedAboutDeprecatedPhases = true;
            MsgHandler::getWarningInstance()->inform("Deprecated tls phase definition found; replace by one using states.");
        }
        // convert to new
        state = MSPhaseDefinition::old2new(phase, brakeMask, yellowMask);
    }
    if (!ok) {
        return;
    }
    // try to get the phase duration
    SUMOTime duration = attrs.getSUMOTimeReporting(SUMO_ATTR_DURATION, "phase", myJunctionControlBuilder.getActiveKey().c_str(), ok);
    if (duration==0) {
        MsgHandler::getErrorInstance()->inform("Duration of tls-logic '" + myJunctionControlBuilder.getActiveKey() + "/" + myJunctionControlBuilder.getActiveSubKey() + "' is zero.");
        return;
    }
    // if the traffic light is an actuated traffic light, try to get
    //  the minimum and maximum durations
    SUMOTime minDuration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_MINDURATION, "phase", myJunctionControlBuilder.getActiveKey().c_str(), ok, -1);
    SUMOTime maxDuration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_MAXDURATION, "phase", myJunctionControlBuilder.getActiveKey().c_str(), ok, -1);
    myJunctionControlBuilder.addPhase(duration, state, minDuration, maxDuration);
}

void NLHandler::addPOI

(

const SUMOSAXAttributes &

attrs

)

[private]

adds a polygon

Definition at line 630 of file NLHandler.cpp.

References NLGeomShapeBuilder::addPoint(), MsgHandler::getErrorInstance(), SUMOSAXAttributes::getOptIntReporting(), SUMOSAXAttributes::getOptStringReporting(), SUMOSAXAttributes::getOptSUMORealReporting(), MsgHandler::inform(), INVALID_POSITION, myShapeBuilder, RGBColor::parseColorReporting(), SUMOSAXAttributes::setIDFromAttributes(), SUMO_ATTR_COLOR, SUMO_ATTR_LANE, SUMO_ATTR_LAYER, SUMO_ATTR_POSITION, SUMO_ATTR_TYPE, SUMO_ATTR_X, SUMO_ATTR_Y, and SUMOReal.

Referenced by myStartElement().

                                                {
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("poi", id)) {
        return;
    }
    bool ok = true;
    SUMOReal x = attrs.getOptSUMORealReporting(SUMO_ATTR_X, "poi", id.c_str(), ok, INVALID_POSITION);
    SUMOReal y = attrs.getOptSUMORealReporting(SUMO_ATTR_Y, "poi", id.c_str(), ok, INVALID_POSITION);
    SUMOReal lanePos = attrs.getOptSUMORealReporting(SUMO_ATTR_POSITION, "poi", id.c_str(), ok, INVALID_POSITION);
    int layer = attrs.getOptIntReporting(SUMO_ATTR_LAYER, "poi", id.c_str(), ok, 1);
    std::string type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, "poi", id.c_str(), ok, "");
    std::string lane = attrs.getOptStringReporting(SUMO_ATTR_LANE, "poi", id.c_str(), ok, "");
    std::string colorStr = attrs.getOptStringReporting(SUMO_ATTR_COLOR, "poi", id.c_str(), ok, "1,0,0");
    RGBColor color = RGBColor::parseColorReporting(colorStr, "poi", id.c_str(), true, ok);
    if (!ok) {
        return;
    }
    try {
        myShapeBuilder.addPoint(id, layer, type, color, x, y, lane, lanePos);
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    } catch (OutOfBoundsException &) {
        MsgHandler::getErrorInstance()->inform("Color definition of POI '" + id + "' seems to be broken.");
    } catch (NumberFormatException &) {
        MsgHandler::getErrorInstance()->inform("One of POI's '" + id + "' SUMOSAXAttributes should be numeric but is not.");
    }
}

void NLHandler::addPoly

(

const SUMOSAXAttributes &

attrs

)

[private]

adds a polygon

Definition at line 661 of file NLHandler.cpp.

References SUMOSAXAttributes::getOptBoolReporting(), SUMOSAXAttributes::getOptIntReporting(), SUMOSAXAttributes::getOptStringReporting(), SUMOSAXAttributes::getStringReporting(), MsgHandler::getWarningInstance(), SUMOSAXAttributes::hasAttribute(), MsgHandler::inform(), myHaveWarnedAboutDeprecatedPolyShape, myShapeBuilder, RGBColor::parseColorReporting(), GeomConvHelper::parseShapeReporting(), NLGeomShapeBuilder::polygonBegin(), NLGeomShapeBuilder::polygonEnd(), SUMOSAXAttributes::setIDFromAttributes(), SUMO_ATTR_COLOR, SUMO_ATTR_FILL, SUMO_ATTR_LAYER, SUMO_ATTR_SHAPE, and SUMO_ATTR_TYPE.

Referenced by myStartElement().

                                                 {
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("poly", id)) {
        return;
    }
    bool ok = true;
    int layer = attrs.getOptIntReporting(SUMO_ATTR_LAYER, "poly", id.c_str(), ok, 1);
    bool fill = attrs.getOptBoolReporting(SUMO_ATTR_FILL, "poly", id.c_str(), ok, false);
    std::string type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, "poly", id.c_str(), ok, "");
    std::string colorStr = attrs.getStringReporting(SUMO_ATTR_COLOR, "poly", id.c_str(), ok);
    RGBColor color = RGBColor::parseColorReporting(colorStr, "poi", id.c_str(), true, ok);
    if (!ok) {
        return;
    }
    myShapeBuilder.polygonBegin(id, layer, type, color, fill);
    if (attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
        // @deprecated; at some time, this is mandatory (no character usage)
        myShapeBuilder.polygonEnd(GeomConvHelper::parseShapeReporting(attrs.getStringReporting(SUMO_ATTR_SHAPE, "poly", id.c_str(), ok), "poly", id.c_str(), ok, false));
    } else if (!myHaveWarnedAboutDeprecatedPolyShape) {
        myHaveWarnedAboutDeprecatedPolyShape = true;
        MsgHandler::getWarningInstance()->inform("You use a deprecated polygon shape description; use attribute 'shape' instead.");
    }
}

void NLHandler::addRouteProbeDetector

(

const SUMOSAXAttributes &

attrs

)

[protected, virtual]

Builds a routeprobe-detector using the given specification.

Parameters:

[in]

attrs

The attributes that define the detector

Definition at line 947 of file NLHandler.cpp.

References NLDetectorBuilder::buildRouteProbe(), OutputDevice::getDevice(), MsgHandler::getErrorInstance(), GenericSAXHandler::getFileName(), SUMOSAXAttributes::getOptSUMOTimeReporting(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::getSUMOTimeReporting(), MsgHandler::inform(), myDetectorBuilder, SUMOSAXAttributes::setIDFromAttributes(), SUMO_ATTR_BEGIN, SUMO_ATTR_EDGE, SUMO_ATTR_FILE, and SUMO_ATTR_FREQUENCY.

Referenced by myStartElement().

                                                               {
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("routeprobe", id)) {
        return;
    }
    bool ok = true;
    SUMOTime frequency = attrs.getSUMOTimeReporting(SUMO_ATTR_FREQUENCY, "routeprobe", id.c_str(), ok);
    SUMOTime begin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, "routeprobe", id.c_str(), ok, -1);
    std::string edge = attrs.getStringReporting(SUMO_ATTR_EDGE, "routeprobe", id.c_str(), ok);
    std::string file = attrs.getStringReporting(SUMO_ATTR_FILE, "routeprobe", id.c_str(), ok);
    if (!ok) {
        return;
    }
    try {
        myDetectorBuilder.buildRouteProbe(id, edge, frequency, begin,
                                          OutputDevice::getDevice(file, getFileName()));
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    } catch (IOError &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void NLHandler::addSource

(

const SUMOSAXAttributes &

attrs

)

[private, virtual]

adds a source

Definition at line 1136 of file NLHandler.cpp.

References NLTriggerBuilder::buildTrigger(), MsgHandler::getErrorInstance(), GenericSAXHandler::getFileName(), MsgHandler::inform(), myNet, myTriggerBuilder, and SUMOSAXAttributes::setIDFromAttributes().

Referenced by myStartElement().

                                                   {
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("source", id)) {
        return;
    }
    try {
        myTriggerBuilder.buildTrigger(myNet, attrs, getFileName());
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void NLHandler::addSuccLane

(

const SUMOSAXAttributes &

attrs

)

[private]

adds a succeeding lane

Definition at line 1180 of file NLHandler.cpp.

References NLSucceedingLaneBuilder::addSuccLane(), endif, SUMOSAXAttributes::getBoolReporting(), MsgHandler::getErrorInstance(), SUMOSAXAttributes::getIntReporting(), SUMOSAXAttributes::getOptBoolReporting(), SUMOSAXAttributes::getOptStringReporting(), SUMOSAXAttributes::getOptSUMORealReporting(), SUMOSAXAttributes::getStringReporting(), HAVE_INTERNAL_LANES, MsgHandler::inform(), myCurrentIsInternalToSkip, mySucceedingLaneBuilder, parseLinkDir(), parseLinkState(), SUMO_ATTR_DIR, SUMO_ATTR_LANE, SUMO_ATTR_PASS, SUMO_ATTR_STATE, SUMO_ATTR_TLID, SUMO_ATTR_TLLINKNO, SUMO_ATTR_VIA, SUMO_ATTR_YIELD, and SUMOReal.

Referenced by myStartElement().

                                                     {
    // do not process internal lanes if not wished
    if (myCurrentIsInternalToSkip) {
        return;
    }
    try {
        bool ok = true;
        SUMOReal pass = attrs.getOptSUMORealReporting(SUMO_ATTR_PASS, 0, 0, ok, -1);
        bool yield = attrs.getBoolReporting(SUMO_ATTR_YIELD, 0, 0, ok);
        bool internalEnd = attrs.getOptBoolReporting(SUMO_ATTR_YIELD, 0, 0, ok, false);
        std::string lane = attrs.getStringReporting(SUMO_ATTR_LANE, 0, 0, ok);
        std::string dir = attrs.getStringReporting(SUMO_ATTR_DIR, 0, 0, ok);
        std::string state = attrs.getStringReporting(SUMO_ATTR_STATE, 0, 0, ok);
        std::string tlID = attrs.getOptStringReporting(SUMO_ATTR_TLID, 0, 0, ok, "");
#ifdef HAVE_INTERNAL_LANES
        std::string via = attrs.getOptStringReporting(SUMO_ATTR_VIA, 0, 0, ok, "");
#endif
        if (!ok) {
            return;
        }
        if (tlID!="") {
            int linkNumber = attrs.getIntReporting(SUMO_ATTR_TLLINKNO, 0, 0, ok);
            if (!ok) {
                return;
            }
            mySucceedingLaneBuilder.addSuccLane(yield, lane,
#ifdef HAVE_INTERNAL_LANES
                                                via, pass,
#endif
                                                parseLinkDir(dir[0]), parseLinkState(state[0]), internalEnd, tlID, linkNumber);
        } else {
            mySucceedingLaneBuilder.addSuccLane(yield, lane,
#ifdef HAVE_INTERNAL_LANES
                                                via, pass,
#endif
                                                parseLinkDir(dir[0]), parseLinkState(state[0]), internalEnd);
        }
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void NLHandler::addTrigger

(

const SUMOSAXAttributes &

attrs

)

[private]

adds a trigger

Definition at line 1151 of file NLHandler.cpp.

References NLTriggerBuilder::buildTrigger(), MsgHandler::getErrorInstance(), GenericSAXHandler::getFileName(), MsgHandler::inform(), myNet, myTriggerBuilder, and SUMOSAXAttributes::setIDFromAttributes().

Referenced by myStartElement().

                                                    {
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("trigger", id)) {
        return;
    }
    try {
        myTriggerBuilder.buildTrigger(myNet, attrs, getFileName());
        return;
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void NLHandler::addVTypeProbeDetector

(

const SUMOSAXAttributes &

attrs

)

[protected, virtual]

Builds a vtype-detector using the given specification.

Parameters:

[in]

attrs

The attributes that define the detector

Definition at line 923 of file NLHandler.cpp.

References NLDetectorBuilder::buildVTypeProbe(), OutputDevice::getDevice(), MsgHandler::getErrorInstance(), GenericSAXHandler::getFileName(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::getStringSecure(), SUMOSAXAttributes::getSUMOTimeReporting(), MsgHandler::inform(), myDetectorBuilder, SUMOSAXAttributes::setIDFromAttributes(), SUMO_ATTR_FILE, SUMO_ATTR_FREQUENCY, and SUMO_ATTR_TYPE.

Referenced by myStartElement().

                                                               {
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("vtypeprobe", id)) {
        return;
    }
    bool ok = true;
    SUMOTime frequency = attrs.getSUMOTimeReporting(SUMO_ATTR_FREQUENCY, "vtypeprobe", id.c_str(), ok);
    std::string type = attrs.getStringSecure(SUMO_ATTR_TYPE, "");
    std::string file = attrs.getStringReporting(SUMO_ATTR_FILE, "vtypeprobe", id.c_str(), ok);
    if (!ok) {
        return;
    }
    try {
        myDetectorBuilder.buildVTypeProbe(id, type, frequency, OutputDevice::getDevice(file, getFileName()));
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    } catch (IOError &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void NLHandler::addWAUTJunction

(

const SUMOSAXAttributes &

attrs

)

[private]

Definition at line 604 of file NLHandler.cpp.

References MSTLLogicControl::addWAUTJunction(), MsgHandler::getErrorInstance(), SUMOSAXAttributes::getOptBoolReporting(), SUMOSAXAttributes::getOptStringReporting(), SUMOSAXAttributes::getStringReporting(), NLJunctionControlBuilder::getTLLogicControlToUse(), MsgHandler::inform(), myCurrentIsBroken, myJunctionControlBuilder, SUMO_ATTR_JUNCTION_ID, SUMO_ATTR_PROCEDURE, SUMO_ATTR_SYNCHRON, and SUMO_ATTR_WAUT_ID.

Referenced by myStartElement().

                                                         {
    bool ok = true;
    std::string wautID = attrs.getStringReporting(SUMO_ATTR_WAUT_ID, "wautJunction", 0, ok);
    std::string junctionID = attrs.getStringReporting(SUMO_ATTR_JUNCTION_ID, "wautJunction", 0, ok);
    std::string procedure = attrs.getOptStringReporting(SUMO_ATTR_PROCEDURE, "wautJunction", 0, ok, "");
    bool synchron = attrs.getOptBoolReporting(SUMO_ATTR_SYNCHRON, "wautJunction", 0, ok, false);
    if (!ok) {
        myCurrentIsBroken = true;
    }
    try {
        if (!myCurrentIsBroken) {
            myJunctionControlBuilder.getTLLogicControlToUse().addWAUTJunction(wautID, junctionID, procedure, synchron);
        }
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
        myCurrentIsBroken = true;
    }
}

void NLHandler::addWAUTSwitch

(

const SUMOSAXAttributes &

attrs

)

[private]

Definition at line 585 of file NLHandler.cpp.

References MSTLLogicControl::addWAUTSwitch(), MsgHandler::getErrorInstance(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::getSUMOTimeReporting(), NLJunctionControlBuilder::getTLLogicControlToUse(), MsgHandler::inform(), myCurrentIsBroken, myCurrentWAUTID, myJunctionControlBuilder, SUMO_ATTR_TIME, and SUMO_ATTR_TO.

Referenced by myStartElement().

                                                       {
    bool ok = true;
    SUMOTime t = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME, "wautSwitch", myCurrentWAUTID.c_str(), ok);
    std::string to = attrs.getStringReporting(SUMO_ATTR_TO, "wautSwitch", myCurrentWAUTID.c_str(), ok);
    if (!ok) {
        myCurrentIsBroken = true;
    }
    if (!myCurrentIsBroken) {
        try {
            myJunctionControlBuilder.getTLLogicControlToUse().addWAUTSwitch(myCurrentWAUTID, t, to);
        } catch (InvalidArgument &e) {
            MsgHandler::getErrorInstance()->inform(e.what());
            myCurrentIsBroken = true;
        }
    }
}

void NLHandler::beginE3Detector

(

const SUMOSAXAttributes &

attrs

)

[protected]

Starts building of an e3-detector using the given specification.

Parameters:

[in]

attrs

The attributes that define the detector

Definition at line 1039 of file NLHandler.cpp.

References NLDetectorBuilder::beginE3Detector(), OutputDevice::getDevice(), MsgHandler::getErrorInstance(), GenericSAXHandler::getFileName(), SUMOSAXAttributes::getOptStringReporting(), SUMOSAXAttributes::getOptSUMORealReporting(), SUMOSAXAttributes::getOptSUMOTimeReporting(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::getSUMOTimeReporting(), MsgHandler::getWarningInstance(), MsgHandler::inform(), myDetectorBuilder, SUMOSAXAttributes::setIDFromAttributes(), SUMO_ATTR_FILE, SUMO_ATTR_FREQUENCY, SUMO_ATTR_HALTING_SPEED_THRESHOLD, SUMO_ATTR_HALTING_TIME_THRESHOLD, SUMO_ATTR_MEASURES, SUMO_ATTR_STYLE, SUMOReal, and TIME2STEPS.

Referenced by addDetector(), and myStartElement().

                                                         {
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("e3-detector", id)) {
        return;
    }
    bool ok = true;
    // inform the user about deprecated values
    if (attrs.getOptStringReporting(SUMO_ATTR_MEASURES, "e3-detector", id.c_str(), ok, "<invalid>")!="<invalid>") {
        MsgHandler::getWarningInstance()->inform("While parsing E3-detector '" + id + "': 'measures' is deprecated.");
    }
    if (attrs.getOptStringReporting(SUMO_ATTR_STYLE, "e3-detector", id.c_str(), ok, "<invalid>")!="<invalid>") {
        MsgHandler::getWarningInstance()->inform("While parsing E3-detector '" + id + "': 'style' is deprecated.");
    }
    const SUMOTime frequency = attrs.getSUMOTimeReporting(SUMO_ATTR_FREQUENCY, "e3-detector", id.c_str(), ok);
    const SUMOTime haltingTimeThreshold = attrs.getOptSUMOTimeReporting(SUMO_ATTR_HALTING_TIME_THRESHOLD, "e3-detector", id.c_str(), ok, TIME2STEPS(1));
    const SUMOReal haltingSpeedThreshold = attrs.getOptSUMORealReporting(SUMO_ATTR_HALTING_SPEED_THRESHOLD, "e3-detector", id.c_str(), ok, 5.0f/3.6f);
    const std::string file = attrs.getStringReporting(SUMO_ATTR_FILE, "e3-detector", id.c_str(), ok);
    if (!ok) {
        return;
    }
    try {
        myDetectorBuilder.beginE3Detector(id,
                                          OutputDevice::getDevice(file, getFileName()),
                                          frequency, haltingSpeedThreshold, haltingTimeThreshold);
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    } catch (IOError &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void NLHandler::beginEdgeParsing

(

const SUMOSAXAttributes &

attrs

)

[private]

begins the processing of an edge

Definition at line 350 of file NLHandler.cpp.

References NLEdgeControlBuilder::beginEdgeParsing(), MSEdge::EDGEFUNCTION_CONNECTOR, MSEdge::EDGEFUNCTION_INTERNAL, MSEdge::EDGEFUNCTION_NORMAL, MSEdge::EDGEFUNCTION_UNKNOWN, MsgHandler::getErrorInstance(), SUMOSAXAttributes::getStringReporting(), MSGlobals::gUsingInternalLanes, MsgHandler::inform(), myCurrentIsBroken, myCurrentIsInternalToSkip, myEdgeControlBuilder, SUMOSAXAttributes::setIDFromAttributes(), and SUMO_ATTR_FUNCTION.

Referenced by myStartElement().

                                                          {
    myCurrentIsBroken = false;
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("edge", id)) {
        myCurrentIsBroken = true;
        return;
    }
    // omit internal edges if not wished
    if (!MSGlobals::gUsingInternalLanes&&id[0]==':') {
        myCurrentIsInternalToSkip = true;
        return;
    }
    myCurrentIsInternalToSkip = false;
    // get the function
    bool ok = true;
    std::string func = attrs.getStringReporting(SUMO_ATTR_FUNCTION, "edge", id.c_str(), ok);
    if (!ok) {
        myCurrentIsBroken = true;
        return;
    }
    // parse the function
    MSEdge::EdgeBasicFunction funcEnum = MSEdge::EDGEFUNCTION_UNKNOWN;
    if (func=="normal") {
        funcEnum = MSEdge::EDGEFUNCTION_NORMAL;
    } else if (func=="connector"||func=="sink"||func=="source") {
        funcEnum = MSEdge::EDGEFUNCTION_CONNECTOR;
    } else if (func=="internal") {
        funcEnum = MSEdge::EDGEFUNCTION_INTERNAL;
    }
    if (funcEnum<0) {
        MsgHandler::getErrorInstance()->inform("Edge '" + id + "' has an invalid type ('" + func + "').");
        myCurrentIsBroken = true;
        return;
    }
    //
    try {
        myEdgeControlBuilder.beginEdgeParsing(id, funcEnum);
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
        myCurrentIsBroken = true;
    }
}

std::string SUMOSAXHandler::buildErrorMessage

(

const SAXParseException &

exception

)

throw () [protected, inherited]

Builds an error message.

The error message includes the file name and the line/column information as supported by the given SAXParseException

Parameters:

[in]

exception

The name of the currently processed file

Returns:

A string describing the given exception

Definition at line 55 of file SUMOSAXHandler.cpp.

References GenericSAXHandler::getFileName().

Referenced by SUMOSAXHandler::error(), SUMOSAXHandler::fatalError(), and SUMOSAXHandler::warning().

                                                                            {
    std::ostringstream buf;
    char *pMsg = XMLString::transcode(exception.getMessage());
    buf << pMsg << std::endl;
    buf << " In file '" << getFileName() << "'" << std::endl;
    buf << " At line/column " << exception.getLineNumber()+1
    << '/' << exception.getColumnNumber() << "." << std::endl;
    XMLString::release(&pMsg);
    return buf.str();
}

void GenericSAXHandler::characters	(	const XMLCh *const	chars,
		const XERCES3_SIZE_t	length
	)			[inherited]

The inherited method called when characters occured.

The retrieved characters are converted into a string and appended into a private buffer. They are reported as soon as the element ends.

Todo:

recheck/describe what happens with characters when a new element is opened

Todo:

describe characters processing in the class' head

Definition at line 168 of file GenericSAXHandler.cpp.

References GenericSAXHandler::myCharactersVector.

                                                           {
    myCharactersVector.push_back(TplConvert<XMLCh>::_2str(chars, length));
}

void NLHandler::closeEdge

(

)

[protected, virtual]

Closes the process of building an edge.

Definition at line 396 of file NLHandler.cpp.

References NLEdgeControlBuilder::closeEdge(), MsgHandler::getErrorInstance(), MsgHandler::inform(), myCurrentIsBroken, myCurrentIsInternalToSkip, and myEdgeControlBuilder.

Referenced by myEndElement().

                     {
    // omit internal edges if not wished and broken edges
    if (myCurrentIsInternalToSkip||myCurrentIsBroken) {
        return;
    }
    try {
        MSEdge& edge = *myEdgeControlBuilder.closeEdge();
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void MSRouteHandler::closeFlow

(

)

throw (ProcessError) [protected, inherited]

Ends the processing of a flow.

Definition at line 590 of file MSRouteHandler.cpp.

References MSEmitControl::add(), SUMOVehicleParameter::depart, MSRoute::dictionary(), MSNet::getEmitControl(), MSNet::getInstance(), OptionsCont::getOptions(), SUMOVehicleParameter::id, MSRouteHandler::myActiveRouteID, MSRouteHandler::myAddVehiclesDirectly, MSRouteHandler::myVehicleParameter, SUMOVehicleParameter::repetitionNumber, SUMOVehicleParameter::repetitionOffset, SUMOVehicleParameter::repetitionsDone, SUMOVehicleParameter::routeid, string2time(), SUMOReal, and SUMOVehicleParameter::vtypeid.

Referenced by MSRouteHandler::myEndElement().

                                              {
    // let's check whether vehicles had to be emitted before the simulation starts
    myVehicleParameter->repetitionsDone = 0;
    SUMOReal offsetToBegin = string2time(OptionsCont::getOptions().getString("begin")) - myVehicleParameter->depart;
    while (myVehicleParameter->repetitionsDone * myVehicleParameter->repetitionOffset < offsetToBegin) {
        myVehicleParameter->repetitionsDone++;
        if (myVehicleParameter->repetitionsDone == myVehicleParameter->repetitionNumber) {
            return;
        }
    }
    if (MSNet::getInstance()->getVehicleControl().getVType(myVehicleParameter->vtypeid)==0) {
        throw ProcessError("The vehicle type '" + myVehicleParameter->vtypeid + "' for vehicle '" + myVehicleParameter->id + "' is not known.");
    }
    if (MSRoute::dictionary("!" + myVehicleParameter->id)==0) {
        // if not, try via the (hopefully) given route-id
        if (MSRoute::dictionary(myVehicleParameter->routeid) == 0) {
            if (myVehicleParameter->routeid!="") {
                throw ProcessError("The route '" + myVehicleParameter->routeid + "' for vehicle '" + myVehicleParameter->id + "' is not known.");
            } else {
                throw ProcessError("Vehicle '" + myVehicleParameter->id + "' has no route.");
            }
        }
    } else {
        myVehicleParameter->routeid = "!" + myVehicleParameter->id;
    }
    myActiveRouteID = "";

    // check whether the vehicle shall be added directly to the network or
    //  shall stay in the internal buffer
    if (myAddVehiclesDirectly) {
        MSNet::getInstance()->getEmitControl().add(myVehicleParameter);
        myVehicleParameter = 0;
    }
}

void NLHandler::closeJunction

(

)

[private, virtual]

ends the processing of a junction

Definition at line 530 of file NLHandler.cpp.

References NLJunctionControlBuilder::closeJunction(), MsgHandler::getErrorInstance(), MsgHandler::inform(), myCurrentIsBroken, and myJunctionControlBuilder.

Referenced by myEndElement().

                         {
    if (myCurrentIsBroken) {
        return;
    }
    try {
        myJunctionControlBuilder.closeJunction();
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void NLHandler::closeLane

(

)

[protected, virtual]

Closes the process of building a lane.

Definition at line 460 of file NLHandler.cpp.

References NLEdgeControlBuilder::addLane(), MSLane::dictionary(), MsgHandler::getErrorInstance(), MsgHandler::inform(), myAllowedClasses, myCurrentIsBroken, myCurrentIsInternalToSkip, myCurrentLaneID, myCurrentLength, myCurrentMaxSpeed, myDisallowedClasses, myEdgeControlBuilder, myLaneIsDepart, myShape, and Position2DVector::size().

Referenced by myEndElement().

                     {
    // omit internal edges if not wished and broken edges
    if (myCurrentIsInternalToSkip||myCurrentIsBroken) {
        return;
    }
    // check shape
    if (myShape.size()<2) {
        MsgHandler::getErrorInstance()->inform("Shape of lane '" + myCurrentLaneID + "' is broken.\n Can not build according edge.");
        myCurrentIsBroken = true;
        return;
    }
    // build
    try {
        MSLane *lane =
            myEdgeControlBuilder.addLane(myCurrentLaneID, myCurrentMaxSpeed, myCurrentLength, myLaneIsDepart, myShape, myAllowedClasses, myDisallowedClasses);
        // insert the lane into the lane-dictionary, checking
        if (!MSLane::dictionary(myCurrentLaneID, lane)) {
            delete lane;
            MsgHandler::getErrorInstance()->inform("Another lane with the id '" + myCurrentLaneID + "' exists.");
            myCurrentIsBroken = true;
        }
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void MSRouteHandler::closePerson

(

)

throw (ProcessError) [protected, inherited]

Ends the processing of a person.

Definition at line 579 of file MSRouteHandler.cpp.

References SUMOVehicleParameter::depart, MSNet::getInstance(), MSNet::getPersonControl(), SUMOVehicleParameter::id, MSRouteHandler::myActivePlan, MSRouteHandler::myVehicleParameter, and MSPersonControl::setArrival().

Referenced by MSRouteHandler::myEndElement().

                                                {
    MSPerson *person = new MSPerson(myVehicleParameter, myActivePlan);
    if (MSNet::getInstance()->getPersonControl().add(myVehicleParameter->id, person)) {
        MSNet::getInstance()->getPersonControl().setArrival(myVehicleParameter->depart, person);
    }
    myVehicleParameter = 0;
    myActivePlan = 0;
}

void MSRouteHandler::closeRoute

(

)

throw (ProcessError) [protected, inherited]

closes (ends) the building of a route. Afterwards no edges may be added to it; this method may throw exceptions when a) the route is empty or b) another route with the same id already exists

Definition at line 419 of file MSRouteHandler.cpp.

References RandomDistributor< T >::add(), MSRoute::dictionary(), MSNet::getInstance(), SUMOVehicleParameter::id, MSRouteHandler::myActiveRoute, MSRouteHandler::myActiveRouteColor, MSRouteHandler::myActiveRouteID, MSRouteHandler::myActiveRouteProbability, MSRouteHandler::myActiveRouteStops, MSRouteHandler::myCurrentRouteDistribution, MSRouteHandler::myVehicleParameter, and SUMOVehicleParameter::repetitionNumber.

Referenced by MSRouteHandler::myEndElement(), and MSRouteHandler::myStartElement().

                                               {
    if (myActiveRoute.size()==0) {
        if (myVehicleParameter!=0) {
            throw ProcessError("Vehicle's '" + myVehicleParameter->id + "' route has no edges.");
        } else {
            throw ProcessError("Route '" + myActiveRouteID + "' has no edges.");
        }
    }
    MSRoute *route = new MSRoute(myActiveRouteID, myActiveRoute,
                                 myVehicleParameter==0||myVehicleParameter->repetitionNumber>=1,
                                 myActiveRouteColor, myActiveRouteStops);
    myActiveRoute.clear();
    if (!MSRoute::dictionary(myActiveRouteID, route)) {
        delete route;
#ifdef HAVE_MESOSIM
        if (!MSGlobals::gStateLoaded) {
#endif
            if (myVehicleParameter!=0) {
                if (MSNet::getInstance()->getVehicleControl().getVehicle(myVehicleParameter->id)==0) {
                    throw ProcessError("Another route for vehicle '" + myVehicleParameter->id + "' exists.");
                } else {
                    throw ProcessError("A vehicle with id '" + myVehicleParameter->id + "' already exists.");
                }
            } else {
                throw ProcessError("Another route (or distribution) with the id '" + myActiveRouteID + "' exists.");
            }
#ifdef HAVE_MESOSIM
        }
#endif
    } else {
        if (myCurrentRouteDistribution != 0) {
            myCurrentRouteDistribution->add(myActiveRouteProbability, route);
        }
    }
    myActiveRouteID = "";
    myActiveRouteStops.clear();
}

void MSRouteHandler::closeRouteDistribution

(

)

[protected, inherited]

closes (ends) the building of a distribution

Definition at line 479 of file MSRouteHandler.cpp.

References MSRoute::dictionary(), MsgHandler::getErrorInstance(), RandomDistributor< T >::getOverallProb(), MsgHandler::inform(), MSRouteHandler::myCurrentRouteDistribution, and MSRouteHandler::myCurrentRouteDistributionID.

Referenced by MSRouteHandler::myEndElement().

                                       {
    if (myCurrentRouteDistribution != 0) {
        if (myCurrentRouteDistribution->getOverallProb() == 0) {
            delete myCurrentRouteDistribution;
            MsgHandler::getErrorInstance()->inform("Route distribution '" + myCurrentRouteDistributionID + "' is empty.");
        } else if (!MSRoute::dictionary(myCurrentRouteDistributionID, myCurrentRouteDistribution)) {
            delete myCurrentRouteDistribution;
            MsgHandler::getErrorInstance()->inform("Another route (or distribution) with the id '" + myCurrentRouteDistributionID + "' exists.");
        }
        myCurrentRouteDistribution = 0;
    }
}

void NLHandler::closeSuccLane

(

)

[private]

closes the processing of a lane

Definition at line 1470 of file NLHandler.cpp.

References NLSucceedingLaneBuilder::closeSuccLane(), MsgHandler::getErrorInstance(), MsgHandler::inform(), myCurrentIsInternalToSkip, and mySucceedingLaneBuilder.

Referenced by myEndElement().

                         {
    // do not process internal lanes if not wished
    if (myCurrentIsInternalToSkip) {
        return;
    }
    try {
        mySucceedingLaneBuilder.closeSuccLane();
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void MSRouteHandler::closeVehicle

(

)

throw (ProcessError) [protected, inherited]

Ends the processing of a vehicle.

Definition at line 494 of file MSRouteHandler.cpp.

References MSEmitControl::add(), MSVehicleControl::addVehicle(), MSVehicleControl::addWaiting(), MSRoute::begin(), MSVehicleControl::buildVehicle(), SUMOVehicleParameter::depart, DEPART_GIVEN, DEPART_TRIGGERED, SUMOVehicleParameter::departProcedure, MSRoute::dictionary(), MSNet::getEmitControl(), MSNet::getInstance(), OptionsCont::getOptions(), MSVehicle::getParameter(), MSNet::getVehicleControl(), MSVehicleControl::getVType(), SUMOVehicleParameter::id, MSRouteHandler::myActiveRouteID, MSRouteHandler::myAddVehiclesDirectly, MSRouteHandler::myAmUsingIncrementalDUA, MSRouteHandler::myIncrementalBase, MSRouteHandler::myIncrementalStage, MSRouteHandler::myLastDepart, MSRouteHandler::myLastReadVehicle, MSRouteHandler::myRunningVehicleNumber, MSRouteHandler::myVehicleParameter, SUMOVehicleParameter::routeid, string2time(), and SUMOVehicleParameter::vtypeid.

Referenced by MSRouteHandler::myEndElement(), and MSRouteHandler::myStartElement().

                                                 {
    if (myVehicleParameter->departProcedure == DEPART_GIVEN) {
        myLastDepart = myVehicleParameter->depart;
        // let's check whether this vehicle had to be emitted before the simulation starts
        if (myVehicleParameter->depart<string2time(OptionsCont::getOptions().getString("begin"))) {
            return;
        }
    }
    // get the vehicle's type
    MSVehicleType *vtype = 0;
    if (myVehicleParameter->vtypeid!="") {
        vtype = MSNet::getInstance()->getVehicleControl().getVType(myVehicleParameter->vtypeid);
        if (vtype==0) {
            throw ProcessError("The vehicle type '" + myVehicleParameter->vtypeid + "' for vehicle '" + myVehicleParameter->id + "' is not known.");
        }
    } else {
        // there should be one (at least the default one)
        vtype = MSNet::getInstance()->getVehicleControl().getVType();
    }
    // get the vehicle's route
    //  maybe it was explicitely assigned to the vehicle
    const MSRoute *route = MSRoute::dictionary("!" + myVehicleParameter->id);
    if (route==0) {
        // if not, try via the (hopefully) given route-id
        route = MSRoute::dictionary(myVehicleParameter->routeid);
    }
    if (route==0) {
        // nothing found? -> error
        if (myVehicleParameter->routeid!="") {
            throw ProcessError("The route '" + myVehicleParameter->routeid + "' for vehicle '" + myVehicleParameter->id + "' is not known.");
        } else {
            throw ProcessError("Vehicle '" + myVehicleParameter->id + "' has no route.");
        }
    }
    myActiveRouteID = "";

    // try to build the vehicle
    MSVehicle *vehicle = 0;
    if (MSNet::getInstance()->getVehicleControl().getVehicle(myVehicleParameter->id)==0) {
        // ok there was no other vehicle with the same id, yet
        // maybe we do not want this vehicle to be emitted due to using incremental dua
        bool add = true;
        if (myAmUsingIncrementalDUA) {
            if ((int)(myRunningVehicleNumber%myIncrementalBase)>=(int) myIncrementalStage) {
                add = false;
            }
            myRunningVehicleNumber++;
        }
        if (add) {
            vehicle = MSNet::getInstance()->getVehicleControl().buildVehicle(myVehicleParameter, route, vtype);
            // add the vehicle to the vehicle control
            MSNet::getInstance()->getVehicleControl().addVehicle(myVehicleParameter->id, vehicle);
            if (myVehicleParameter->departProcedure == DEPART_TRIGGERED) {
                MSNet::getInstance()->getVehicleControl().addWaiting(*route->begin(), vehicle);
            }
            myVehicleParameter = 0;
        }
    } else {
        // strange: another vehicle with the same id already exists
#ifdef HAVE_MESOSIM
        if (!MSGlobals::gStateLoaded) {
#endif
            // and was not loaded while loading a simulation state
            // -> error
            throw ProcessError("Another vehicle with the id '" + myVehicleParameter->id + "' exists.");
#ifdef HAVE_MESOSIM
        } else {
            // ok, it seems to be loaded previously while loading a simulation state
            vehicle = 0;
        }
#endif
    }
    // check whether the vehicle shall be added directly to the network or
    //  shall stay in the internal buffer
    if (myAddVehiclesDirectly&&vehicle!=0) {
        if (vehicle->getParameter().departProcedure == DEPART_GIVEN) {
            MSNet::getInstance()->getEmitControl().add(vehicle);
        }
    } else {
        myLastReadVehicle = vehicle;
    }
}

void MSRouteHandler::closeVehicleTypeDistribution

(

)

[protected, inherited]

closes (ends) the building of a distribution

Definition at line 293 of file MSRouteHandler.cpp.

References MsgHandler::getErrorInstance(), MSNet::getInstance(), RandomDistributor< T >::getOverallProb(), MsgHandler::inform(), MSRouteHandler::myCurrentVTypeDistribution, and MSRouteHandler::myCurrentVTypeDistributionID.

Referenced by MSRouteHandler::myEndElement().

                                             {
    if (myCurrentVTypeDistribution != 0) {
        if (myCurrentVTypeDistribution->getOverallProb() == 0) {
            delete myCurrentVTypeDistribution;
            MsgHandler::getErrorInstance()->inform("Vehicle type distribution '" + myCurrentVTypeDistributionID + "' is empty.");
        } else if (!MSNet::getInstance()->getVehicleControl().addVTypeDistribution(myCurrentVTypeDistributionID, myCurrentVTypeDistribution)) {
            delete myCurrentVTypeDistribution;
            MsgHandler::getErrorInstance()->inform("Another vehicle type (or distribution) with the id '" + myCurrentVTypeDistributionID + "' exists.");
        }
        myCurrentVTypeDistribution = 0;
    }
}

void NLHandler::closeWAUT

(

)

[private]

Definition at line 1503 of file NLHandler.cpp.

References MSTLLogicControl::closeWAUT(), MsgHandler::getErrorInstance(), NLJunctionControlBuilder::getTLLogicControlToUse(), MsgHandler::inform(), myCurrentIsBroken, myCurrentWAUTID, and myJunctionControlBuilder.

Referenced by myEndElement().

                     {
    if (!myCurrentIsBroken) {
        try {
            myJunctionControlBuilder.getTLLogicControlToUse().closeWAUT(myCurrentWAUTID);
        } catch (InvalidArgument &e) {
            MsgHandler::getErrorInstance()->inform(e.what());
            myCurrentIsBroken = true;
        }
    }
    myCurrentWAUTID = "";
}

void NLHandler::endDetector

(

)

[protected]

Ends the detector building.

Todo:

Remove this

Definition at line 1484 of file NLHandler.cpp.

References endE3Detector(), and myCurrentDetectorType.

Referenced by myEndElement().

                       {
    if (myCurrentDetectorType=="e3") {
        endE3Detector();
    }
    myCurrentDetectorType = "";
}

void NLHandler::endE3Detector

(

)

[protected, virtual]

Builds of an e3-detector using collected values.

Definition at line 1493 of file NLHandler.cpp.

References NLDetectorBuilder::endE3Detector(), MsgHandler::getErrorInstance(), MsgHandler::inform(), and myDetectorBuilder.

Referenced by endDetector(), and myEndElement().

                         {
    try {
        myDetectorBuilder.endE3Detector();
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
}

void GenericSAXHandler::endElement	(	const XMLCh *const	uri,
		const XMLCh *const	localname,
		const XMLCh *const	qname
	)			[inherited]

The inherited method called when a tag is being closed.

This method calls the user-implemented methods myCharacters with the previously collected and converted characters.

Then, myEndElement is called, supplying it the qname converted to its enum- and string-representations.

Todo:

recheck/describe encoding of the string-representation

Todo:

do not generate and report the string-representation

Definition at line 118 of file GenericSAXHandler.cpp.

References TplConvert< E >::_2str(), GenericSAXHandler::convertTag(), GenericSAXHandler::myCharacters(), GenericSAXHandler::myCharactersVector, GenericSAXHandler::myEndElement(), GenericSAXHandler::myParentHandler, GenericSAXHandler::myParentIndicator, XMLSubSys::setHandler(), SUMO_TAG_INCLUDE, and SUMO_TAG_NOTHING.

                                                        {
    std::string name = TplConvert<XMLCh>::_2str(qname);
    SumoXMLTag element = convertTag(name);
    // collect characters
    if (myCharactersVector.size()!=0) {
        size_t len = 0;
        unsigned i;
        for (i=0; i<myCharactersVector.size(); ++i) {
            len += myCharactersVector[i].length();
        }
        char *buf = new char[len+1];
        size_t pos = 0;
        for (i=0; i<myCharactersVector.size(); ++i) {
            memcpy((unsigned char*) buf+pos, (unsigned char*) myCharactersVector[i].c_str(),
                   sizeof(char)*myCharactersVector[i].length());
            pos += myCharactersVector[i].length();
        }
        buf[pos] = 0;

        // call user handler
        try {
            myCharacters(element, buf);
        } catch (std::runtime_error &) {
            delete[] buf;
            throw;
        }
        delete[] buf;
    }
    if (element != SUMO_TAG_INCLUDE) {
        myEndElement(element);
        if (myParentHandler && myParentIndicator == element) {
            XMLSubSys::setHandler(*myParentHandler);
            myParentIndicator = SUMO_TAG_NOTHING;
            myParentHandler = 0;
        }
    }
}

void SUMOSAXHandler::error

(

const SAXParseException &

exception

)

throw (ProcessError) [inherited]

Handler for XML-errors.

The message is built using buildErrorMessage and thrown within a ProcessError.

Parameters:

[in]

exception

The occured exception to process

Exceptions:

ProcessError

On any call

Definition at line 74 of file SUMOSAXHandler.cpp.

References SUMOSAXHandler::buildErrorMessage().

                                                                            {
    throw ProcessError(buildErrorMessage(exception));
}

void SUMOSAXHandler::fatalError

(

const SAXParseException &

exception

)

throw (ProcessError) [inherited]

Handler for XML-errors.

The message is built using buildErrorMessage and thrown within a ProcessError.

Exceptions:

ProcessError

On any call

Parameters:

[in]

exception

The occured exception to process

Definition at line 80 of file SUMOSAXHandler.cpp.

References SUMOSAXHandler::buildErrorMessage().

                                                                                 {
    throw ProcessError(buildErrorMessage(exception));
}

const std::string & GenericSAXHandler::getFileName

(

)

const throw () [inherited]

returns the current file name

Returns:

The name of the currently processed file

Definition at line 78 of file GenericSAXHandler.cpp.

References GenericSAXHandler::myFileName.

Referenced by addE1Detector(), addE2Detector(), addEdgeLaneMeanData(), addRouteProbeDetector(), addSource(), addTrigger(), addVTypeProbeDetector(), beginE3Detector(), SUMOSAXHandler::buildErrorMessage(), MSRouteLoader::init(), PCNetProjectionLoader::loadIfSet(), NILoader::loadXMLType(), MSTriggeredXMLReader::myInit(), RODFDetectorHandler::myStartElement(), myStartElement(), NIImporter_OpenDrive::myStartElement(), MSLaneSpeedTrigger::myStartElement(), GUISettingsHandler::myStartElement(), RORDGenerator_ODAmounts::RORDGenerator_ODAmounts(), and GenericSAXHandler::startElement().

                                             {
    return myFileName;
}

SUMOTime MSRouteHandler::getLastDepart

(

)

const [inherited]

Returns the last loaded depart time.

Definition at line 84 of file MSRouteHandler.cpp.

References MSRouteHandler::myLastDepart.

Referenced by MSRouteLoader::loadUntil().

                                    {
    return myLastDepart;
}

void NLHandler::initJunctionLogic

(

const SUMOSAXAttributes &

attrs

)

[private]

begins the reading of a junction row logic

Definition at line 712 of file NLHandler.cpp.

References SUMOSAXAttributes::getIntReporting(), SUMOSAXAttributes::hasAttribute(), NLJunctionControlBuilder::initJunctionLogic(), myJunctionControlBuilder, SUMOSAXAttributes::setIDFromAttributes(), SUMO_ATTR_ID, SUMO_ATTR_LANENUMBER, and SUMO_ATTR_REQUESTSIZE.

Referenced by myStartElement().

                                                           {
    if (!attrs.hasAttribute(SUMO_ATTR_ID)) {
        // @deprecated: assuming a net could still use characters for the id
        myJunctionControlBuilder.initJunctionLogic("", -1, -1);
        return;
    }
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("row-logic", id)) {
        return;
    }
    bool ok = true;
    int requestSize = attrs.getIntReporting(SUMO_ATTR_REQUESTSIZE, "row-logic", id.c_str(), ok);
    int laneNumber = attrs.getIntReporting(SUMO_ATTR_LANENUMBER, "row-logic", id.c_str(), ok);
    if (ok) {
        myJunctionControlBuilder.initJunctionLogic(id, requestSize, laneNumber);
    }
}

void NLHandler::initTrafficLightLogic

(

const SUMOSAXAttributes &

attrs

)

[private]

begins the reading of a traffic lights logic

Definition at line 733 of file NLHandler.cpp.

References SUMOSAXAttributes::getOptStringReporting(), SUMOSAXAttributes::getOptSUMORealReporting(), SUMOSAXAttributes::getOptSUMOTimeReporting(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::hasAttribute(), NLJunctionControlBuilder::initIncomingLanes(), NLJunctionControlBuilder::initTrafficLightLogic(), myAmInTLLogicMode, myJunctionControlBuilder, SUMO_ATTR_DET_OFFSET, SUMO_ATTR_ID, SUMO_ATTR_OFFSET, SUMO_ATTR_PROGRAMID, SUMO_ATTR_TYPE, and SUMOReal.

Referenced by myStartElement().

                                                               {
    SUMOReal detectorOffset = -1;
    myJunctionControlBuilder.initIncomingLanes(); // @deprecated (is this still used?)
    bool ok = true;
    std::string type = attrs.getStringReporting(SUMO_ATTR_TYPE, "tl-logic", 0, ok);
    detectorOffset = attrs.getOptSUMORealReporting(SUMO_ATTR_DET_OFFSET, "tl-logic", 0, ok, -1);
    //
    if (!attrs.hasAttribute(SUMO_ATTR_ID)) {
        // @deprecated: assuming a net could still use characters for the id
        myJunctionControlBuilder.initTrafficLightLogic("", "", type, 0, detectorOffset);
        return;
    }
    std::string id = attrs.getStringReporting(SUMO_ATTR_ID, "tl-logic", 0, ok);
    int offset = attrs.getOptSUMOTimeReporting(SUMO_ATTR_OFFSET, "tl-logic", id.c_str(), ok, 0);
    if (!ok) {
        return;
    }
    std::string programID = attrs.getOptStringReporting(SUMO_ATTR_PROGRAMID, "tl-logic", id.c_str(), ok, "<unknown>");
    myJunctionControlBuilder.initTrafficLightLogic(id, programID, type, offset, detectorOffset);
    myAmInTLLogicMode = true;
}

void NLHandler::myCharacters	(	SumoXMLTag	element,
		const std::string &	chars
	)			throw (ProcessError) [protected, virtual]

Called when characters occure.

Parameters:

[in]	element	ID of the last opened element
[in]	chars	The read characters (complete)

Exceptions:

ProcessError

If something fails

See also:

GenericSAXHandler::myCharacters

Todo:

Refactor/describe

Reimplemented from MSRouteHandler.

Definition at line 228 of file NLHandler.cpp.

References addIncomingLanes(), addJunctionShape(), addLaneShape(), NLJunctionControlBuilder::getActiveKey(), MsgHandler::getWarningInstance(), MsgHandler::inform(), GeoConvHelper::init(), MSRouteHandler::myCharacters(), myConvBoundary, myHaveWarnedAboutDeprecatedLocation, myJunctionControlBuilder, myNetworkOffset, myOrigBoundary, myShapeBuilder, GeomConvHelper::parseBoundaryReporting(), GeomConvHelper::parseShapeReporting(), NLGeomShapeBuilder::polygonEnd(), setKey(), setLaneNumber(), setOffset(), setRequestSize(), setSubKey(), SUMO_TAG_CONV_BOUNDARY, SUMO_TAG_INCOMING_LANES, SUMO_TAG_INTERNAL_LANES, SUMO_TAG_KEY, SUMO_TAG_LANE, SUMO_TAG_LANENUMBER, SUMO_TAG_NET_OFFSET, SUMO_TAG_OFFSET, SUMO_TAG_ORIG_BOUNDARY, SUMO_TAG_ORIG_PROJ, SUMO_TAG_POLY, SUMO_TAG_REQUESTSIZE, SUMO_TAG_SHAPE, and SUMO_TAG_SUBKEY.

                                                                    {
    bool ok = true;
    switch (element) {
    case SUMO_TAG_POLY:
        if (chars.length()!=0) {
            myShapeBuilder.polygonEnd(GeomConvHelper::parseShapeReporting(chars, "polygon", 0, ok, false)); // !!! no error handling!
        }
        break;
    case SUMO_TAG_INCOMING_LANES:
        addIncomingLanes(chars);
        break;
#ifdef HAVE_INTERNAL_LANES
    case SUMO_TAG_INTERNAL_LANES:
        addInternalLanes(chars);
        break;
#endif
    case SUMO_TAG_LANE:
        if (chars.length()!=0) {
            addLaneShape(chars);
        }
        break;
    case SUMO_TAG_REQUESTSIZE:
        if (myJunctionControlBuilder.getActiveKey().length()!=0) {
            setRequestSize(chars);
        }
        break;
    case SUMO_TAG_LANENUMBER:
        if (myJunctionControlBuilder.getActiveKey().length()!=0) {
            setLaneNumber(chars);
        }
        break;
    case SUMO_TAG_KEY:
        setKey(chars);
        break;
    case SUMO_TAG_SUBKEY:
        setSubKey(chars);
        break;
    case SUMO_TAG_OFFSET:
        setOffset(chars);
        break;
    case SUMO_TAG_NET_OFFSET: {
        if (!myHaveWarnedAboutDeprecatedLocation) {
            myHaveWarnedAboutDeprecatedLocation = true;
            MsgHandler::getWarningInstance()->inform("Your network uses a deprecated network offset/projection definition.");
        }
        Position2DVector s = GeomConvHelper::parseShapeReporting(chars, "net", 0, ok, false);
        if (ok) {
            myNetworkOffset = s[0];
        }
    }
    break;
    case SUMO_TAG_CONV_BOUNDARY:
        myConvBoundary = GeomConvHelper::parseBoundaryReporting(chars, "net", 0, ok);
        break;
    case SUMO_TAG_ORIG_BOUNDARY:
        myOrigBoundary = GeomConvHelper::parseBoundaryReporting(chars, "net", 0, ok);
        break;
    case SUMO_TAG_ORIG_PROJ:
        GeoConvHelper::init(chars, myNetworkOffset, myOrigBoundary, myConvBoundary);
        break;
    case SUMO_TAG_SHAPE:
        if (chars.length()!=0) {
            addJunctionShape(chars);
        }
        break;
    default:
        break;
    }
    MSRouteHandler::myCharacters(element, chars);
}

void NLHandler::myEndElement

(

SumoXMLTag

element

)

throw (ProcessError) [protected, virtual]

Called when a closing tag occurs.

Parameters:

[in]

element

ID of the currently opened element

Exceptions:

ProcessError

If something fails

See also:

GenericSAXHandler::myEndElement

Todo:

Refactor/describe

Reimplemented from MSRouteHandler.

Definition at line 302 of file NLHandler.cpp.

References closeEdge(), closeJunction(), NLJunctionControlBuilder::closeJunctionLogic(), closeLane(), closeSuccLane(), NLJunctionControlBuilder::closeTrafficLightLogic(), closeWAUT(), endDetector(), endE3Detector(), MsgHandler::getErrorInstance(), MsgHandler::inform(), myAmInTLLogicMode, MSRouteHandler::myEndElement(), myJunctionControlBuilder, SUMO_TAG_DETECTOR, SUMO_TAG_E3DETECTOR, SUMO_TAG_EDGE, SUMO_TAG_JUNCTION, SUMO_TAG_LANE, SUMO_TAG_ROWLOGIC, SUMO_TAG_SUCC, SUMO_TAG_TLLOGIC, and SUMO_TAG_WAUT.

                                                              {
    switch (element) {
    case SUMO_TAG_EDGE:
        closeEdge();
        break;
    case SUMO_TAG_LANE:
        closeLane();
        break;
    case SUMO_TAG_JUNCTION:
        closeJunction();
        break;
    case SUMO_TAG_SUCC:
        closeSuccLane();
        break;
    case SUMO_TAG_ROWLOGIC:
        try {
            myJunctionControlBuilder.closeJunctionLogic();
        } catch (InvalidArgument &e) {
            MsgHandler::getErrorInstance()->inform(e.what());
        }
        break;
    case SUMO_TAG_TLLOGIC:
        try {
            myJunctionControlBuilder.closeTrafficLightLogic();
        } catch (InvalidArgument &e) {
            MsgHandler::getErrorInstance()->inform(e.what());
        }
        myAmInTLLogicMode = false;
        break;
    case SUMO_TAG_WAUT:
        closeWAUT();
        break;
    case SUMO_TAG_E3DETECTOR:
        endE3Detector();
        break;
    case SUMO_TAG_DETECTOR:
        endDetector();
        break;
    default:
        break;
    }
    MSRouteHandler::myEndElement(element);
}

void NLHandler::myStartElement	(	SumoXMLTag	element,
		const SUMOSAXAttributes &	attrs
	)			throw (ProcessError) [protected, virtual]

Called on the opening of a tag;.

Parameters:

[in]	element	ID of the currently opened element
[in]	attrs	Attributes within the currently opened element

Exceptions:

ProcessError

If something fails

See also:

GenericSAXHandler::myStartElement

Todo:

Refactor/describe

Deprecated:

begins

Deprecated:

ends

Reimplemented from MSRouteHandler.

Definition at line 89 of file NLHandler.cpp.

References NLDiscreteEventBuilder::addAction(), addDetector(), addDistrict(), addDistrictEdge(), addE1Detector(), addE2Detector(), addE3Entry(), addE3Exit(), addEdgeLaneMeanData(), addLane(), addLogicItem(), addParam(), addPhase(), addPOI(), addPoly(), addRouteProbeDetector(), addSource(), addSuccLane(), addTrigger(), addVTypeProbeDetector(), addWAUTJunction(), addWAUTSwitch(), beginE3Detector(), beginEdgeParsing(), NLTriggerBuilder::buildVaporizer(), MsgHandler::getErrorInstance(), GenericSAXHandler::getFileName(), MsgHandler::inform(), initJunctionLogic(), initTrafficLightLogic(), myActionBuilder, myNet, MSRouteHandler::myStartElement(), myTriggerBuilder, openJunction(), openSucc(), openWAUT(), NLTriggerBuilder::parseAndBuildBusStop(), NLTriggerBuilder::parseAndBuildCalibrator(), NLTriggerBuilder::parseAndBuildLaneEmitTrigger(), NLTriggerBuilder::parseAndBuildLaneSpeedTrigger(), NLTriggerBuilder::parseAndBuildRerouter(), setLocation(), SUMO_TAG_BUS_STOP, SUMO_TAG_CALIBRATOR, SUMO_TAG_DET_ENTRY, SUMO_TAG_DET_EXIT, SUMO_TAG_DETECTOR, SUMO_TAG_DISTRICT, SUMO_TAG_DSINK, SUMO_TAG_DSOURCE, SUMO_TAG_E1DETECTOR, SUMO_TAG_E2DETECTOR, SUMO_TAG_E3DETECTOR, SUMO_TAG_EDGE, SUMO_TAG_EMITTER, SUMO_TAG_JUNCTION, SUMO_TAG_LANE, SUMO_TAG_LOCATION, SUMO_TAG_LOGICITEM, SUMO_TAG_MEANDATA_EDGE, SUMO_TAG_MEANDATA_LANE, SUMO_TAG_PARAM, SUMO_TAG_PHASE, SUMO_TAG_POI, SUMO_TAG_POLY, SUMO_TAG_REROUTER, SUMO_TAG_ROUTEPROBE, SUMO_TAG_ROWLOGIC, SUMO_TAG_SOURCE, SUMO_TAG_SUCC, SUMO_TAG_SUCCLANE, SUMO_TAG_TIMEDEVENT, SUMO_TAG_TLLOGIC, SUMO_TAG_TRIGGER, SUMO_TAG_VAPORIZER, SUMO_TAG_VSS, SUMO_TAG_VTYPEPROBE, SUMO_TAG_WAUT, SUMO_TAG_WAUT_JUNCTION, and SUMO_TAG_WAUT_SWITCH.

                                                                              {
    try {
        switch (element) {
        case SUMO_TAG_EDGE:
            beginEdgeParsing(attrs);
            break;
        case SUMO_TAG_LANE:
            addLane(attrs);
            break;
        case SUMO_TAG_POLY:
            addPoly(attrs);
            break;
        case SUMO_TAG_POI:
            addPOI(attrs);
            break;
        case SUMO_TAG_JUNCTION:
            openJunction(attrs);
            break;
        case SUMO_TAG_PHASE:
            addPhase(attrs);
            break;
        case SUMO_TAG_SUCC:
            openSucc(attrs);
            break;
        case SUMO_TAG_SUCCLANE:
            addSuccLane(attrs);
            break;
        case SUMO_TAG_ROWLOGIC:
            initJunctionLogic(attrs);
            break;
        case SUMO_TAG_TLLOGIC:
            initTrafficLightLogic(attrs);
            break;
        case SUMO_TAG_LOGICITEM:
            addLogicItem(attrs);
            break;
        case SUMO_TAG_WAUT:
            openWAUT(attrs);
            break;
        case SUMO_TAG_WAUT_SWITCH:
            addWAUTSwitch(attrs);
            break;
        case SUMO_TAG_WAUT_JUNCTION:
            addWAUTJunction(attrs);
            break;
        case SUMO_TAG_DETECTOR:
            addDetector(attrs);
            break;
#ifdef _MESSAGES
        case SUMO_TAG_MSG_EMITTER:
            addMsgEmitter(attrs);
            break;
        case SUMO_TAG_MSG:
            addMsgDetector(attrs);
            break;
#endif
        case SUMO_TAG_E1DETECTOR:
            addE1Detector(attrs);
            break;
        case SUMO_TAG_E2DETECTOR:
            addE2Detector(attrs);
            break;
        case SUMO_TAG_E3DETECTOR:
            beginE3Detector(attrs);
            break;
        case SUMO_TAG_DET_ENTRY:
            addE3Entry(attrs);
            break;
        case SUMO_TAG_DET_EXIT:
            addE3Exit(attrs);
            break;
        case SUMO_TAG_VSS:
            myTriggerBuilder.parseAndBuildLaneSpeedTrigger(myNet, attrs, getFileName());
            break;
        case SUMO_TAG_EMITTER:
            myTriggerBuilder.parseAndBuildLaneEmitTrigger(myNet, attrs, getFileName());
            break;
        case SUMO_TAG_CALIBRATOR:
            myTriggerBuilder.parseAndBuildCalibrator(myNet, attrs, getFileName());
            break;
        case SUMO_TAG_REROUTER:
            myTriggerBuilder.parseAndBuildRerouter(myNet, attrs, getFileName());
            break;
        case SUMO_TAG_BUS_STOP:
            myTriggerBuilder.parseAndBuildBusStop(myNet, attrs);
            break;
        case SUMO_TAG_VTYPEPROBE:
            addVTypeProbeDetector(attrs);
            break;
        case SUMO_TAG_ROUTEPROBE:
            addRouteProbeDetector(attrs);
            break;
        case SUMO_TAG_MEANDATA_EDGE:
            addEdgeLaneMeanData(attrs, "meandata_edge");
            break;
        case SUMO_TAG_MEANDATA_LANE:
            addEdgeLaneMeanData(attrs, "meandata_lane");
            break;
        case SUMO_TAG_SOURCE:
            addSource(attrs);
            break;
        case SUMO_TAG_TRIGGER:
            addTrigger(attrs);
            break;
        case SUMO_TAG_TIMEDEVENT:
            myActionBuilder.addAction(attrs, getFileName());
            break;
        case SUMO_TAG_VAPORIZER:
            myTriggerBuilder.buildVaporizer(attrs);
            break;
        case SUMO_TAG_LOCATION:
            setLocation(attrs);
            break;
        case SUMO_TAG_DISTRICT:
            addDistrict(attrs);
            break;
        case SUMO_TAG_DSOURCE:
            addDistrictEdge(attrs, true);
            break;
        case SUMO_TAG_DSINK:
            addDistrictEdge(attrs, false);
            break;
        default:
            break;
        }
    } catch (InvalidArgument &e) {
        MsgHandler::getErrorInstance()->inform(e.what());
    }
    MSRouteHandler::myStartElement(element, attrs);
    if (element==SUMO_TAG_PARAM) {
        addParam(attrs);
    }
}

void NLHandler::openJunction

(

const SUMOSAXAttributes &

attrs

)

[private, virtual]

opens a junction for processing

Definition at line 489 of file NLHandler.cpp.

References addIncomingLanes(), MsgHandler::getErrorInstance(), SUMOSAXAttributes::getOptStringReporting(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::getStringSecure(), SUMOSAXAttributes::getSUMORealReporting(), SUMOSAXAttributes::hasAttribute(), MsgHandler::inform(), myCurrentIsBroken, myJunctionControlBuilder, NLJunctionControlBuilder::openJunction(), GeomConvHelper::parseShapeReporting(), SUMOSAXAttributes::setIDFromAttributes(), SUMO_ATTR_INCLANES, SUMO_ATTR_INTLANES, SUMO_ATTR_KEY, SUMO_ATTR_SHAPE, SUMO_ATTR_TYPE, SUMO_ATTR_X, SUMO_ATTR_Y, and SUMOReal.

Referenced by myStartElement().

                                                      {
    myCurrentIsBroken = false;
    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("junction", id)) {
        myCurrentIsBroken = true;
        return;
    }
    bool ok = true;
    Position2DVector shape;
    if (attrs.hasAttribute(SUMO_ATTR_SHAPE)) {
        // @deprecated: at some time, all junctions should have a shape attribute (moved from characters)
        shape = GeomConvHelper::parseShapeReporting(attrs.getStringSecure(SUMO_ATTR_SHAPE, ""), "junction", id.c_str(), ok, true);
    }
    SUMOReal x = attrs.getSUMORealReporting(SUMO_ATTR_X, "junction", id.c_str(), ok);
    SUMOReal y = attrs.getSUMORealReporting(SUMO_ATTR_Y, "junction", id.c_str(), ok);
    std::string type = attrs.getStringReporting(SUMO_ATTR_TYPE, "junction", id.c_str(), ok);
    std::string key = attrs.getOptStringReporting(SUMO_ATTR_KEY, "junction", id.c_str(), ok, "");
    if (!ok) {
        myCurrentIsBroken = true;
    } else {
        try {
            myJunctionControlBuilder.openJunction(id, key, type, x, y, shape);
        } catch (InvalidArgument &e) {
            MsgHandler::getErrorInstance()->inform(e.what() + std::string("\n Can not build according junction."));
            myCurrentIsBroken = true;
        }
        //
        if (!myCurrentIsBroken&&attrs.hasAttribute(SUMO_ATTR_INCLANES)) {
            addIncomingLanes(attrs.getStringSecure(SUMO_ATTR_INCLANES, ""));
        }
#ifdef HAVE_INTERNAL_LANES
        if (!myCurrentIsBroken&&attrs.hasAttribute(SUMO_ATTR_INTLANES)) {
            addInternalLanes(attrs.getStringSecure(SUMO_ATTR_INTLANES, ""));
        }
#endif
    }
}

void MSRouteHandler::openRoute

(

const SUMOSAXAttributes &

attrs

)

[protected, inherited]

opens a route for reading

Definition at line 308 of file MSRouteHandler.cpp.

References DEFAULT_VEH_PROB, RGBColor::getDefaultColor(), SUMOSAXAttributes::getOptSUMORealReporting(), SUMOSAXAttributes::getString(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::hasAttribute(), SUMOVehicleParameter::id, MSRouteHandler::myActiveRoute, MSRouteHandler::myActiveRouteColor, MSRouteHandler::myActiveRouteID, MSRouteHandler::myActiveRouteProbability, MSRouteHandler::myVehicleParameter, RGBColor::parseColorReporting(), MSEdge::parseEdgesList(), SUMO_ATTR_COLOR, SUMO_ATTR_EDGES, SUMO_ATTR_ID, and SUMO_ATTR_PROB.

Referenced by MSRouteHandler::myStartElement().

                                                        {
    // check whether the id is really necessary
    if (myVehicleParameter!=0) {
        // ok, a vehicle is wrapping the route,
        //  we may use this vehicle's id as default
        myActiveRouteID = "!" + myVehicleParameter->id; // !!! document this
    } else {
        bool ok = true;
        myActiveRouteID = attrs.getStringReporting(SUMO_ATTR_ID, "route", 0, ok, false);
        if (!ok) {
            return;
        }
    }
    bool ok = true;
    if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
        MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_EDGES, "route", myActiveRouteID.c_str(), ok), myActiveRoute, myActiveRouteID);
    }
    myActiveRouteProbability = attrs.getOptSUMORealReporting(SUMO_ATTR_PROB, "route", myActiveRouteID.c_str(), ok, DEFAULT_VEH_PROB);
    myActiveRouteColor = attrs.hasAttribute(SUMO_ATTR_COLOR) ? RGBColor::parseColorReporting(attrs.getString(SUMO_ATTR_COLOR), "route", myActiveRouteID.c_str(), true, ok) : RGBColor::getDefaultColor();
}

void MSRouteHandler::openRouteDistribution

(

const SUMOSAXAttributes &

attrs

)

[protected, inherited]

opens a route distribution for reading

Definition at line 459 of file MSRouteHandler.cpp.

References RandomDistributor< T >::add(), MSRoute::dictionary(), SUMOSAXAttributes::getStringReporting(), SUMOSAXAttributes::hasAttribute(), StringTokenizer::hasNext(), MSRouteHandler::myCurrentRouteDistribution, MSRouteHandler::myCurrentRouteDistributionID, StringTokenizer::next(), SUMOSAXAttributes::setIDFromAttributes(), and SUMO_ATTR_ROUTES.

Referenced by MSRouteHandler::myStartElement().

                                                                    {
    if (attrs.setIDFromAttributes("routeDistribution", myCurrentRouteDistributionID)) {
        myCurrentRouteDistribution = new RandomDistributor<const MSRoute*>();
        if (attrs.hasAttribute(SUMO_ATTR_ROUTES)) {
            bool ok = true;
            StringTokenizer st(attrs.getStringReporting(SUMO_ATTR_ROUTES, "routeDistribution", myCurrentRouteDistributionID.c_str(), ok));
            while (st.hasNext()) {
                std::string routeID = st.next();
                const MSRoute *route = MSRoute::dictionary(routeID);
                if (route==0) {
                    throw ProcessError("Unknown route '" + routeID + "' in distribution '" + myCurrentRouteDistributionID + "'.");
                }
                myCurrentRouteDistribution->add(1., route, false);
            }
        }
    }
}

void NLHandler::openSucc

(

const SUMOSAXAttributes &

attrs

)

[private]

opens the container of succeeding lanes for processing

Definition at line 1167 of file NLHandler.cpp.

References SUMOSAXAttributes::getStringReporting(), MSGlobals::gUsingInternalLanes, myCurrentIsInternalToSkip, mySucceedingLaneBuilder, NLSucceedingLaneBuilder::openSuccLane(), and SUMO_ATTR_LANE.

Referenced by myStartElement().

                                                  {
    bool ok = true;
    std::string id = attrs.getStringReporting(SUMO_ATTR_LANE, "succ", 0, ok);
    if (!MSGlobals::gUsingInternalLanes&&id[0]==':') {
        myCurrentIsInternalToSkip = true;
        return;
    }
    myCurrentIsInternalToSkip = false;
    mySucceedingLaneBuilder.openSuccLane(id);
}

void MSRouteHandler::openVehicleTypeDistribution

(

const SUMOSAXAttributes &

attrs

)

[protected, inherited]

opens a type distribution for reading

Definition at line 273 of file MSRouteHandler.cpp.

References RandomDistributor< T >::add(), MSVehicleType::getDefaultProbability(), MSNet::getInstance(), SUMOSAXAttributes::getStringReporting(), MSNet::getVehicleControl(), MSVehicleControl::getVType(), SUMOSAXAttributes::hasAttribute(), StringTokenizer::hasNext(), MSRouteHandler::myCurrentVTypeDistribution, MSRouteHandler::myCurrentVTypeDistributionID, StringTokenizer::next(), SUMOSAXAttributes::setIDFromAttributes(), and SUMO_ATTR_VTYPES.

Referenced by MSRouteHandler::myStartElement().

                                                                          {
    if (attrs.setIDFromAttributes("vtypeDistribution", myCurrentVTypeDistributionID)) {
        myCurrentVTypeDistribution = new RandomDistributor<MSVehicleType*>();
        if (attrs.hasAttribute(SUMO_ATTR_VTYPES)) {
            bool ok = true;
            StringTokenizer st(attrs.getStringReporting(SUMO_ATTR_VTYPES, "vtypeDistribution", myCurrentVTypeDistributionID.c_str(), ok));
            while (st.hasNext()) {
                std::string vtypeID = st.next();
                MSVehicleType *type = MSNet::getInstance()->getVehicleControl().getVType(vtypeID);
                if (type==0) {
                    throw ProcessError("Unknown vtype '" + vtypeID + "' in distribution '" + myCurrentVTypeDistributionID + "'.");
                }
                myCurrentVTypeDistribution->add(type->getDefaultProbability(), type);
            }
        }
    }
}

void NLHandler::openWAUT

(

const SUMOSAXAttributes &

attrs

)

[private, virtual]

Definition at line 557 of file NLHandler.cpp.

References MSTLLogicControl::addWAUT(), MsgHandler::getErrorInstance(), SUMOSAXAttributes::getOptSUMOTimeReporting(), SUMOSAXAttributes::getStringReporting(), NLJunctionControlBuilder::getTLLogicControlToUse(), MsgHandler::inform(), myCurrentIsBroken, myCurrentWAUTID, myJunctionControlBuilder, SUMOSAXAttributes::setIDFromAttributes(), SUMO_ATTR_REF_TIME, and SUMO_ATTR_START_PROG.

Referenced by myStartElement().

                                                  {
    myCurrentIsBroken = false;

    // get the id, report an error if not given or empty...
    std::string id;
    if (!attrs.setIDFromAttributes("waut", id)) {
        myCurrentIsBroken = true;
        return;
    }
    bool ok = true;
    SUMOTime t = attrs.getOptSUMOTimeReporting(SUMO_ATTR_REF_TIME, "waut", id.c_str(), ok, 0);
    std::string pro = attrs.getStringReporting(SUMO_ATTR_START_PROG, "waut", id.c_str(), ok);
    if (!ok) {
        myCurrentIsBroken = true;
    }
    if (!myCurrentIsBroken) {
        myCurrentWAUTID = id;
        try {
            myJunctionControlBuilder.getTLLogicControlToUse().addWAUT(t, id, pro);
        } catch (InvalidArgument &e) {
            MsgHandler::getErrorInstance()->inform(e.what());
            myCurrentIsBroken = true;
        }
    }
}

NLHandler& NLHandler::operator=

(

const NLHandler &

s

)

[private]

invalid assignment operator

MSLink::LinkDirection NLHandler::parseLinkDir

(

char

dir

)

[private]

Parses the given character into an enumeration typed link direction.

Definition at line 1225 of file NLHandler.cpp.

References MSLink::LINKDIR_LEFT, MSLink::LINKDIR_PARTLEFT, MSLink::LINKDIR_PARTRIGHT, MSLink::LINKDIR_RIGHT, MSLink::LINKDIR_STRAIGHT, MSLink::LINKDIR_TURN, and toString().

Referenced by addSuccLane().

                                {
    switch (dir) {
    case 's':
        return MSLink::LINKDIR_STRAIGHT;
    case 'l':
        return MSLink::LINKDIR_LEFT;
    case 'r':
        return MSLink::LINKDIR_RIGHT;
    case 't':
        return MSLink::LINKDIR_TURN;
    case 'L':
        return MSLink::LINKDIR_PARTLEFT;
    case 'R':
        return MSLink::LINKDIR_PARTRIGHT;
    default:
        throw InvalidArgument("Unrecognised link direction '" + toString(dir) + "'.");
    }
}

MSLink::LinkState NLHandler::parseLinkState

(

char

state

)

[private]

Parses the given character into an enumeration typed link state.

Definition at line 1246 of file NLHandler.cpp.

References MSLink::LINKSTATE_EQUAL, MSLink::LINKSTATE_MAJOR, MSLink::LINKSTATE_MINOR, MSLink::LINKSTATE_TL_OFF_BLINKING, MSLink::LINKSTATE_TL_OFF_NOSIGNAL, and toString().

Referenced by addSuccLane().

                                    {
    switch (state) {
    case 't':
    case 'o':
        return MSLink::LINKSTATE_TL_OFF_BLINKING;
    case 'O':
        return MSLink::LINKSTATE_TL_OFF_NOSIGNAL;
    case 'M':
        return MSLink::LINKSTATE_MAJOR;
    case 'm':
        return MSLink::LINKSTATE_MINOR;
    case '=':
        return MSLink::LINKSTATE_EQUAL;
    default:
        throw InvalidArgument("Unrecognised link state '" + toString(state) + "'.");
    }
}

void GenericSAXHandler::registerParent	(	const SumoXMLTag	tag,
		GenericSAXHandler *	handler
	)			[inherited]

Assigning a parent handler which is enabled when the specified tag is closed.

Definition at line 160 of file GenericSAXHandler.cpp.

References GenericSAXHandler::myParentHandler, GenericSAXHandler::myParentIndicator, and XMLSubSys::setHandler().

Referenced by NLTriggerBuilder::parseAndBuildLaneSpeedTrigger().

                                                                                  {
    myParentHandler = handler;
    myParentIndicator = tag;
    XMLSubSys::setHandler(*this);
}

void MSRouteHandler::retrieveLastReadVehicle

(

MSEmitControl *

into

)

[inherited]

Returns the last loaded vehicle.

Definition at line 90 of file MSRouteHandler.cpp.

References MSEmitControl::add(), DEPART_GIVEN, SUMOVehicleParameter::departProcedure, MSVehicle::getParameter(), MSRouteHandler::myLastReadVehicle, MSRouteHandler::myVehicleParameter, and SUMOVehicleParameter::repetitionsDone.

Referenced by MSRouteLoader::loadUntil().

                                                           {
    if (myLastReadVehicle != 0) {
        if (myLastReadVehicle->getParameter().departProcedure == DEPART_GIVEN) {
            into->add(myLastReadVehicle);
        }
        myLastReadVehicle = 0;
    }
    if (myVehicleParameter != 0 && myVehicleParameter->repetitionsDone>=0) {
        into->add(myVehicleParameter);
        myVehicleParameter = 0;
    }
}

void GenericSAXHandler::setFileName

(

const std::string &

name

)

throw () [inherited]

Sets the current file name.

Parameters:

[in]

name

The name of the currently processed file

Todo:

Hmmm - this is as unsafe as having a direct access to the variable; recheck

Definition at line 72 of file GenericSAXHandler.cpp.

References GenericSAXHandler::myFileName.

Referenced by PCNetProjectionLoader::loadIfSet(), ROLoader::loadNet(), NIImporter_OpenStreetMap::loadNetwork(), NILoader::loadXMLType(), and traci::TraCIServer::TraCIServer().

                                                            {
    myFileName = name;
}

void NLHandler::setKey

(

const std::string &

chars

)

[private]

sets the key of the current junction logic

Definition at line 1294 of file NLHandler.cpp.

References MsgHandler::getErrorInstance(), MsgHandler::inform(), myJunctionControlBuilder, and NLJunctionControlBuilder::setKey().

Referenced by myCharacters().

                                        {
    // @deprecated: assuming a net could still use characters for the id
    if (chars.length()==0) {
        MsgHandler::getErrorInstance()->inform("No key given for the current junction logic.");
        return;
    }
    myJunctionControlBuilder.setKey(chars);
}

void NLHandler::setLaneNumber

(

const std::string &

chars

)

[private]

sets the lane number of the current junction logic

Definition at line 1281 of file NLHandler.cpp.

References MsgHandler::getErrorInstance(), MsgHandler::inform(), myJunctionControlBuilder, and NLJunctionControlBuilder::setLaneNumber().

Referenced by myCharacters().

                                               {
    // @deprecated: assuming a net could still use characters for the lane number
    try {
        myJunctionControlBuilder.setLaneNumber(TplConvert<char>::_2int(chars.c_str()));
    } catch (EmptyData &) {
        MsgHandler::getErrorInstance()->inform("Missing lane number.");
    } catch (NumberFormatException &) {
        MsgHandler::getErrorInstance()->inform("One of an edge's SUMOSAXAttributes must be numeric but is not.");
    }
}

void NLHandler::setLocation

(

const SUMOSAXAttributes &

attrs

)

[private]

Parses network location description.

Definition at line 1344 of file NLHandler.cpp.

References SUMOSAXAttributes::getStringReporting(), GeoConvHelper::init(), GeomConvHelper::parseBoundaryReporting(), GeomConvHelper::parseShapeReporting(), SUMO_ATTR_CONV_BOUNDARY, SUMO_ATTR_NET_OFFSET, SUMO_ATTR_ORIG_BOUNDARY, and SUMO_ATTR_ORIG_PROJ.

Referenced by myStartElement().

                                                     {
    bool ok = true;
    Position2DVector s = GeomConvHelper::parseShapeReporting(attrs.getStringReporting(SUMO_ATTR_NET_OFFSET, "net", 0, ok), "net", 0, ok, false);
    Boundary convBoundary = GeomConvHelper::parseBoundaryReporting(attrs.getStringReporting(SUMO_ATTR_CONV_BOUNDARY, "net", 0, ok), "net", 0, ok);
    Boundary origBoundary = GeomConvHelper::parseBoundaryReporting(attrs.getStringReporting(SUMO_ATTR_ORIG_BOUNDARY, "net", 0, ok), "net", 0, ok);
    std::string proj = attrs.getStringReporting(SUMO_ATTR_ORIG_PROJ, "net", 0, ok);
    if (ok) {
        Position2D networkOffset = s[0];
        GeoConvHelper::init(proj, networkOffset, origBoundary, convBoundary);
    }
}

void NLHandler::setOffset

(

const std::string &

chars

)

[private]

Sets the offset a tl-logic shall be fired the first time after.

Definition at line 1316 of file NLHandler.cpp.

References MsgHandler::getErrorInstance(), MsgHandler::inform(), myJunctionControlBuilder, NLJunctionControlBuilder::setOffset(), and string2time().

Referenced by myCharacters().

                                           {
    // @deprecated: assuming a net could still use characters for the offset
    try {
        myJunctionControlBuilder.setOffset(string2time(chars));
    } catch (NumberFormatException &) {
        MsgHandler::getErrorInstance()->inform("The offset for a junction is not numeric.");
    } catch (EmptyData &) {
        MsgHandler::getErrorInstance()->inform("The offset for a junction is not empty.");
    } // !!! can chars have length 0?
}

void NLHandler::setRequestSize

(

const std::string &

chars

)

[private]

sets the request size of the current junction logic

Definition at line 1268 of file NLHandler.cpp.

References MsgHandler::getErrorInstance(), MsgHandler::inform(), myJunctionControlBuilder, and NLJunctionControlBuilder::setRequestSize().

Referenced by myCharacters().

                                                {
    // @deprecated: assuming a net could still use characters for the request size
    try {
        myJunctionControlBuilder.setRequestSize(TplConvert<char>::_2int(chars.c_str()));
    } catch (EmptyData &) {
        MsgHandler::getErrorInstance()->inform("Missing request size.");
    } catch (NumberFormatException &) {
        MsgHandler::getErrorInstance()->inform("One of an edge's SUMOSAXAttributes must be numeric but is not.");
    }
}

void NLHandler::setSubKey

(

const std::string &

chars

)

[private]

sets the subkey of the current junction logic

Definition at line 1305 of file NLHandler.cpp.

References MsgHandler::getErrorInstance(), MsgHandler::inform(), myJunctionControlBuilder, and NLJunctionControlBuilder::setSubKey().

Referenced by myCharacters().

                                           {
    // @deprecated: assuming a net could still use characters for the sub id
    if (chars.length()==0) {
        MsgHandler::getErrorInstance()->inform("No subkey given for the current junction logic.");
        return;
    }
    myJunctionControlBuilder.setSubKey(chars);
}

void GenericSAXHandler::startElement	(	const XMLCh *const	uri,
		const XMLCh *const	localname,
		const XMLCh *const	qname,
		const Attributes &	attrs
	)			[inherited]

The inherited method called when a new tag opens.

The method parses the supplied XMLCh*-qname using the internal name/enum-map to obtain the enum representation of the attribute name.

Then, "myStartElement" is called supplying the enumeration value, the string-representation of the name and the attributes.

Todo:

recheck/describe encoding of the string-representation

Todo:

do not generate and report the string-representation

Definition at line 97 of file GenericSAXHandler.cpp.

References TplConvert< E >::_2str(), GenericSAXHandler::convertTag(), FileHelpers::getConfigurationRelative(), GenericSAXHandler::getFileName(), SUMOSAXAttributesImpl_Xerces::getString(), FileHelpers::isAbsolute(), GenericSAXHandler::myCharactersVector, GenericSAXHandler::myPredefinedTags, GenericSAXHandler::myPredefinedTagsMML, GenericSAXHandler::myStartElement(), XMLSubSys::runParser(), SUMO_ATTR_HREF, and SUMO_TAG_INCLUDE.

                                                         {
    std::string name = TplConvert<XMLCh>::_2str(qname);
    SumoXMLTag element = convertTag(name);
    myCharactersVector.clear();
    SUMOSAXAttributesImpl_Xerces na(attrs, myPredefinedTags, myPredefinedTagsMML);
    if (element == SUMO_TAG_INCLUDE) {
        std::string file = na.getString(SUMO_ATTR_HREF);
        if (!FileHelpers::isAbsolute(file)) {
            file = FileHelpers::getConfigurationRelative(getFileName(), file);
        }
        XMLSubSys::runParser(*this, file);
    } else {
        myStartElement(element, na);
    }
}

void SUMOSAXHandler::warning

(

const SAXParseException &

exception

)

throw () [inherited]

Handler for XML-warnings.

The message is built using buildErrorMessage and reported to the warning-instance of the MsgHandler.

Parameters:

[in]

exception

The occured exception to process

Definition at line 68 of file SUMOSAXHandler.cpp.

References SUMOSAXHandler::buildErrorMessage(), MsgHandler::getWarningInstance(), and MsgHandler::inform().

                                                                  {
    MsgHandler::getWarningInstance()->inform(buildErrorMessage(exception));
}

---

Field Documentation

NLDiscreteEventBuilder NLHandler::myActionBuilder [protected]

A builder for object actions.

Definition at line 341 of file NLHandler.h.

Referenced by myStartElement().

MSPerson::MSPersonPlan* MSRouteHandler::myActivePlan [protected, inherited]

the plan of the current person

Definition at line 166 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closePerson(), and MSRouteHandler::myStartElement().

MSEdgeVector MSRouteHandler::myActiveRoute [protected, inherited]

the current route

Definition at line 151 of file MSRouteHandler.h.

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

RGBColor MSRouteHandler::myActiveRouteColor [protected, inherited]

The currently parsed route's color.

Definition at line 160 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeRoute(), and MSRouteHandler::openRoute().

std::string MSRouteHandler::myActiveRouteID [protected, inherited]

the id of the current route

Definition at line 154 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeFlow(), MSRouteHandler::closeRoute(), MSRouteHandler::closeVehicle(), MSRouteHandler::myCharacters(), MSRouteHandler::myStartElement(), and MSRouteHandler::openRoute().

SUMOReal MSRouteHandler::myActiveRouteProbability [protected, inherited]

the id of the current route

Definition at line 157 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeRoute(), and MSRouteHandler::openRoute().

std::vector<SUMOVehicleParameter::Stop> MSRouteHandler::myActiveRouteStops [protected, inherited]

List of the stops on the parsed route.

Definition at line 163 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeRoute(), and MSRouteHandler::myStartElement().

bool MSRouteHandler::myAddVehiclesDirectly [protected, inherited]

information whether vehicles shall be directly added to the network or kept within the buffer

Definition at line 170 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeFlow(), and MSRouteHandler::closeVehicle().

std::vector<SUMOVehicleClass> NLHandler::myAllowedClasses [protected]

Vehicle classes allowed on the current lane.

Definition at line 386 of file NLHandler.h.

Referenced by addLane(), and closeLane().

bool NLHandler::myAmInTLLogicMode [protected]

internal information whether a tls-logic is currently read

Definition at line 396 of file NLHandler.h.

Referenced by addParam(), initTrafficLightLogic(), and myEndElement().

bool MSRouteHandler::myAmUsingIncrementalDUA [protected, inherited]

Information whether not all vehicle shall be emitted due to inc-dua.

Definition at line 185 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeVehicle(), and MSRouteHandler::MSRouteHandler().

Boundary NLHandler::myConvBoundary [protected]

Definition at line 405 of file NLHandler.h.

Referenced by myCharacters().

std::string NLHandler::myCurrentDetectorType [protected]

The type of the last detector.

Definition at line 350 of file NLHandler.h.

Referenced by addDetector(), and endDetector().

std::string NLHandler::myCurrentDistrictID [protected]

The id of the current district.

Definition at line 374 of file NLHandler.h.

Referenced by addDistrict(), and addDistrictEdge().

bool NLHandler::myCurrentIsBroken [protected]

Definition at line 407 of file NLHandler.h.

Referenced by addDistrict(), addDistrictEdge(), addLane(), addLaneShape(), addWAUTJunction(), addWAUTSwitch(), beginEdgeParsing(), closeEdge(), closeJunction(), closeLane(), closeWAUT(), openJunction(), and openWAUT().

bool NLHandler::myCurrentIsInternalToSkip [protected]

Information whether the currently parsed edge is internal and not wished, here.

Definition at line 344 of file NLHandler.h.

Referenced by addLane(), addLaneShape(), addSuccLane(), beginEdgeParsing(), closeEdge(), closeLane(), closeSuccLane(), and openSucc().

std::string NLHandler::myCurrentLaneID [protected]

The id of the current lane.

Definition at line 371 of file NLHandler.h.

Referenced by addLane(), addLaneShape(), and closeLane().

SUMOReal NLHandler::myCurrentLength [protected]

The length of the current lane.

Definition at line 383 of file NLHandler.h.

Referenced by addLane(), and closeLane().

SUMOReal NLHandler::myCurrentMaxSpeed [protected]

The maximum speed allowed on the current lane.

Definition at line 380 of file NLHandler.h.

Referenced by addLane(), and closeLane().

RandomDistributor<const MSRoute*>* MSRouteHandler::myCurrentRouteDistribution [protected, inherited]

The currently parsed distribution of routes (probability->route).

Definition at line 179 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeRoute(), MSRouteHandler::closeRouteDistribution(), and MSRouteHandler::openRouteDistribution().

std::string MSRouteHandler::myCurrentRouteDistributionID [protected, inherited]

The id of the currently parsed route distribution.

Definition at line 182 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeRouteDistribution(), and MSRouteHandler::openRouteDistribution().

SUMOVTypeParameter* MSRouteHandler::myCurrentVType [protected, inherited]

The currently parsed vehicle type.

Definition at line 200 of file MSRouteHandler.h.

Referenced by MSRouteHandler::myEndElement(), and MSRouteHandler::myStartElement().

RandomDistributor<MSVehicleType*>* MSRouteHandler::myCurrentVTypeDistribution [protected, inherited]

The currently parsed distribution of vehicle types (probability->vehicle type).

Definition at line 173 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeVehicleTypeDistribution(), MSRouteHandler::myEndElement(), and MSRouteHandler::openVehicleTypeDistribution().

std::string MSRouteHandler::myCurrentVTypeDistributionID [protected, inherited]

The id of the currently parsed vehicle type distribution.

Definition at line 176 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeVehicleTypeDistribution(), and MSRouteHandler::openVehicleTypeDistribution().

std::string NLHandler::myCurrentWAUTID [protected]

The id of the currently processed WAUT.

Definition at line 399 of file NLHandler.h.

Referenced by addWAUTSwitch(), closeWAUT(), and openWAUT().

NLDetectorBuilder& NLHandler::myDetectorBuilder [protected]

The detector builder to use.

Definition at line 347 of file NLHandler.h.

Referenced by addE1Detector(), addE2Detector(), addE3Entry(), addE3Exit(), addEdgeLaneMeanData(), addRouteProbeDetector(), addVTypeProbeDetector(), beginE3Detector(), and endE3Detector().

std::vector<SUMOVehicleClass> NLHandler::myDisallowedClasses [protected]

Vehicle classes disallowed on the current lane.

Definition at line 389 of file NLHandler.h.

Referenced by addLane(), and closeLane().

NLEdgeControlBuilder& NLHandler::myEdgeControlBuilder [protected]

storage for edges during building

Definition at line 356 of file NLHandler.h.

Referenced by addDistrict(), beginEdgeParsing(), closeEdge(), and closeLane().

bool MSRouteHandler::myHaveWarned [protected, inherited]

whether we have warned about routes defined as character strings

Definition at line 197 of file MSRouteHandler.h.

Referenced by MSRouteHandler::myCharacters().

bool NLHandler::myHaveWarnedAboutDeprecatedJunctionShape [protected]

Whether deprecated definition of a junction shape in characters was already reported.

Definition at line 413 of file NLHandler.h.

Referenced by addJunctionShape().

bool NLHandler::myHaveWarnedAboutDeprecatedLaneShape [protected]

Whether deprecated definition of a lane shape in characters was already reported.

Definition at line 416 of file NLHandler.h.

Referenced by addLane().

bool NLHandler::myHaveWarnedAboutDeprecatedLocation [protected]

Whether deprecated definition of network boundaries/projection was already reported.

Definition at line 422 of file NLHandler.h.

Referenced by myCharacters().

bool NLHandler::myHaveWarnedAboutDeprecatedPhases [protected]

Whether deprecated definition of phases was already reported.

Definition at line 425 of file NLHandler.h.

Referenced by addPhase().

bool NLHandler::myHaveWarnedAboutDeprecatedPolyShape [protected]

Whether deprecated definition of a polygon shape in characters was already reported.

Definition at line 419 of file NLHandler.h.

Referenced by addPoly().

bool NLHandler::myHaveWarnedAboutDeprecatedVClass [protected]

Whether deprecated usage of the "vclass" attribute was already reported.

Definition at line 410 of file NLHandler.h.

Referenced by addLane().

int MSRouteHandler::myIncrementalBase [protected, inherited]

The base for inc-dua.

Definition at line 191 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeVehicle(), and MSRouteHandler::MSRouteHandler().

int MSRouteHandler::myIncrementalStage [protected, inherited]

The current stage of inc-dua.

Definition at line 194 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeVehicle(), and MSRouteHandler::MSRouteHandler().

NLJunctionControlBuilder& NLHandler::myJunctionControlBuilder [protected]

storage for junctions during building

Definition at line 359 of file NLHandler.h.

Referenced by addE2Detector(), addIncomingLanes(), addJunctionShape(), addLogicItem(), addParam(), addPhase(), addWAUTJunction(), addWAUTSwitch(), closeJunction(), closeWAUT(), initJunctionLogic(), initTrafficLightLogic(), myCharacters(), myEndElement(), openJunction(), openWAUT(), setKey(), setLaneNumber(), setOffset(), setRequestSize(), and setSubKey().

bool NLHandler::myLaneIsDepart [protected]

The information whether the current lane is a depart lane.

Definition at line 377 of file NLHandler.h.

Referenced by addLane(), and closeLane().

SUMOTime MSRouteHandler::myLastDepart [protected, inherited]

the emission time of the vehicle read last

Definition at line 144 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeVehicle(), and MSRouteHandler::getLastDepart().

MSVehicle* MSRouteHandler::myLastReadVehicle [protected, inherited]

the last vehicle read

Definition at line 147 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeVehicle(), and MSRouteHandler::retrieveLastReadVehicle().

MSNet& NLHandler::myNet [protected]

The net to fill (preinitialised).

Definition at line 206 of file NLHandler.h.

Referenced by addSource(), addTrigger(), and myStartElement().

Position2D NLHandler::myNetworkOffset [protected]

The network offset.

Definition at line 402 of file NLHandler.h.

Referenced by myCharacters().

Boundary NLHandler::myOrigBoundary [protected]

The network's boundaries.

Definition at line 405 of file NLHandler.h.

Referenced by myCharacters().

unsigned int MSRouteHandler::myRunningVehicleNumber [protected, inherited]

The current vehicle number (for inc-dua).

Definition at line 188 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeVehicle().

Position2DVector NLHandler::myShape [protected]

The shape of the current lane.

Definition at line 392 of file NLHandler.h.

Referenced by addLane(), addLaneShape(), and closeLane().

NLGeomShapeBuilder& NLHandler::myShapeBuilder [protected]

Definition at line 361 of file NLHandler.h.

Referenced by addPOI(), addPoly(), and myCharacters().

NLSucceedingLaneBuilder NLHandler::mySucceedingLaneBuilder [protected]

storage for building succeeding lanes

Definition at line 364 of file NLHandler.h.

Referenced by addSuccLane(), closeSuccLane(), and openSucc().

NLTriggerBuilder& NLHandler::myTriggerBuilder [protected]

The trigger builder to use.

Definition at line 353 of file NLHandler.h.

Referenced by addSource(), addTrigger(), and myStartElement().

SUMOVehicleParameter* MSRouteHandler::myVehicleParameter [protected, inherited]

Definition at line 141 of file MSRouteHandler.h.

Referenced by MSRouteHandler::closeFlow(), MSRouteHandler::closePerson(), MSRouteHandler::closeRoute(), MSRouteHandler::closeVehicle(), MSRouteHandler::myEndElement(), MSRouteHandler::myStartElement(), MSRouteHandler::openRoute(), MSRouteHandler::retrieveLastReadVehicle(), and MSRouteHandler::~MSRouteHandler().

---

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

• NLHandler.h
• NLHandler.cpp