MSRouteHandler Class Reference

#include <MSRouteHandler.h>

Inheritance diagram for MSRouteHandler:

---

Detailed Description

Parser and container for routes during their loading.

MSRouteHandler is the container for routes while they are build until their transfering to the MSNet::RouteDict The result of the operations are single MSNet::Route-instances

Definition at line 58 of file MSRouteHandler.h.

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.
	MSRouteHandler (const std::string &file, bool addVehiclesDirectly)
	standard 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	~MSRouteHandler () throw ()
	standard 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
std::string	buildErrorMessage (const SAXParseException &exception) throw ()
	Builds an error message.
void	closeFlow () throw (ProcessError)
	Ends the processing of a flow.
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	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
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	myAmUsingIncrementalDUA
	Information whether not all vehicle shall be emitted due to inc-dua.
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.
bool	myHaveWarned
	whether we have warned about routes defined as character strings
int	myIncrementalBase
	The base for inc-dua.
int	myIncrementalStage
	The current stage of inc-dua.
SUMOTime	myLastDepart
	the emission time of the vehicle read last
MSVehicle *	myLastReadVehicle
	the last vehicle read
unsigned int	myRunningVehicleNumber
	The current vehicle number (for inc-dua).
SUMOVehicleParameter *	myVehicleParameter
Private Member Functions
	MSRouteHandler (const MSRouteHandler &s)
MSRouteHandler &	operator= (const MSRouteHandler &s)

---

Constructor & Destructor Documentation

MSRouteHandler::MSRouteHandler	(	const std::string &	file,
		bool	addVehiclesDirectly
	)

standard constructor

Definition at line 62 of file MSRouteHandler.cpp.

References OptionsCont::getInt(), OptionsCont::getOptions(), myActiveRoute, myAmUsingIncrementalDUA, myIncrementalBase, and myIncrementalStage.

        : SUMOSAXHandler(file), myVehicleParameter(0),
        myLastDepart(0), myLastReadVehicle(0),
        myAddVehiclesDirectly(addVehiclesDirectly),
        myRunningVehicleNumber(0),
        myCurrentVTypeDistribution(0),
        myCurrentRouteDistribution(0),
        myHaveWarned(false), myCurrentVType(0) {
    myIncrementalBase = OptionsCont::getOptions().getInt("incremental-dua-base");
    myIncrementalStage = OptionsCont::getOptions().getInt("incremental-dua-step");
    myAmUsingIncrementalDUA = (myIncrementalStage>0);
    myActiveRoute.reserve(100);
}

MSRouteHandler::~MSRouteHandler

(

)

throw () [virtual]

standard destructor

Definition at line 78 of file MSRouteHandler.cpp.

References myVehicleParameter.

                                        {
    delete myVehicleParameter;
}

MSRouteHandler::MSRouteHandler

(

const MSRouteHandler &

s

)

[private]

invalid copy constructor

---

Member Function Documentation

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 MSRouteHandler::closeFlow

(

)

throw (ProcessError) [protected]

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, myActiveRouteID, myAddVehiclesDirectly, myVehicleParameter, SUMOVehicleParameter::repetitionNumber, SUMOVehicleParameter::repetitionOffset, SUMOVehicleParameter::repetitionsDone, SUMOVehicleParameter::routeid, string2time(), SUMOReal, and SUMOVehicleParameter::vtypeid.

Referenced by 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 MSRouteHandler::closePerson

(

)

throw (ProcessError) [protected]

Ends the processing of a person.

Definition at line 579 of file MSRouteHandler.cpp.

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

Referenced by 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]

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, myActiveRoute, myActiveRouteColor, myActiveRouteID, myActiveRouteProbability, myActiveRouteStops, myCurrentRouteDistribution, myVehicleParameter, and SUMOVehicleParameter::repetitionNumber.

Referenced by myEndElement(), and 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]

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(), myCurrentRouteDistribution, and myCurrentRouteDistributionID.

Referenced by 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 MSRouteHandler::closeVehicle

(

)

throw (ProcessError) [protected]

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, myActiveRouteID, myAddVehiclesDirectly, myAmUsingIncrementalDUA, myIncrementalBase, myIncrementalStage, myLastDepart, myLastReadVehicle, myRunningVehicleNumber, myVehicleParameter, SUMOVehicleParameter::routeid, string2time(), and SUMOVehicleParameter::vtypeid.

Referenced by myEndElement(), and 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]

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(), myCurrentVTypeDistribution, and myCurrentVTypeDistributionID.

Referenced by 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 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 NLHandler::addE1Detector(), NLHandler::addE2Detector(), NLHandler::addEdgeLaneMeanData(), NLHandler::addRouteProbeDetector(), NLHandler::addSource(), NLHandler::addTrigger(), NLHandler::addVTypeProbeDetector(), NLHandler::beginE3Detector(), SUMOSAXHandler::buildErrorMessage(), MSRouteLoader::init(), PCNetProjectionLoader::loadIfSet(), NILoader::loadXMLType(), MSTriggeredXMLReader::myInit(), RODFDetectorHandler::myStartElement(), NLHandler::myStartElement(), NIImporter_OpenDrive::myStartElement(), MSLaneSpeedTrigger::myStartElement(), GUISettingsHandler::myStartElement(), RORDGenerator_ODAmounts::RORDGenerator_ODAmounts(), and GenericSAXHandler::startElement().

                                             {
    return myFileName;
}

SUMOTime MSRouteHandler::getLastDepart

(

)

const

Returns the last loaded depart time.

Definition at line 84 of file MSRouteHandler.cpp.

References myLastDepart.

Referenced by MSRouteLoader::loadUntil().

                                    {
    return myLastDepart;
}

void MSRouteHandler::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

Reimplemented from GenericSAXHandler.

Reimplemented in NLHandler.

Definition at line 334 of file MSRouteHandler.cpp.

References MsgHandler::getWarningInstance(), MsgHandler::inform(), myActiveRoute, myActiveRouteID, myHaveWarned, MSEdge::parseEdgesList(), and SUMO_TAG_ROUTE.

Referenced by NLHandler::myCharacters().

                                                                         {
    switch (element) {
    case SUMO_TAG_ROUTE: {
        size_t len = chars.length();
        size_t beg = 0;
        while (beg<len&&chars[beg]<=32) {
            beg++;
        }
        if (beg<len) {
            if (!myHaveWarned) {
                MsgHandler::getWarningInstance()->inform("Defining routes as a nested string is deprecated, use the edges attribute instead.");
                myHaveWarned = true;
            }
            MSEdge::parseEdgesList(chars, myActiveRoute, myActiveRouteID);
        }
        break;
    }
    default:
        break;
    }
}

void MSRouteHandler::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

Reimplemented from GenericSAXHandler.

Reimplemented in NLHandler.

Definition at line 361 of file MSRouteHandler.cpp.

References RandomDistributor< T >::add(), MSVehicleType::build(), closeFlow(), closePerson(), closeRoute(), closeRouteDistribution(), closeVehicle(), closeVehicleTypeDistribution(), SUMOVehicleParserHelper::closeVTypeParsing(), MSVehicleType::getDefaultProbability(), MSVehicleType::getID(), MSNet::getInstance(), myCurrentVType, myCurrentVTypeDistribution, myVehicleParameter, SUMOVehicleParameter::repetitionNumber, SUMO_TAG_FLOW, SUMO_TAG_PERSON, SUMO_TAG_ROUTE, SUMO_TAG_ROUTE_DISTRIBUTION, SUMO_TAG_VEHICLE, SUMO_TAG_VTYPE, and SUMO_TAG_VTYPE_DISTRIBUTION.

Referenced by NLHandler::myEndElement().

                                                                   {
    switch (element) {
    case SUMO_TAG_ROUTE:
        closeRoute();
        break;
    case SUMO_TAG_PERSON:
        closePerson();
        delete myVehicleParameter;
        myVehicleParameter = 0;
        break;
    case SUMO_TAG_VEHICLE:
        if (myVehicleParameter->repetitionNumber>0) {
            myVehicleParameter->repetitionNumber++; // for backwards compatibility
            // it is a flow, thus no break here
        } else {
            closeVehicle();
            delete myVehicleParameter;
            myVehicleParameter = 0;
            break;
        }
    case SUMO_TAG_FLOW:
        closeFlow();
        break;
    case SUMO_TAG_VTYPE_DISTRIBUTION:
        closeVehicleTypeDistribution();
        break;
    case SUMO_TAG_ROUTE_DISTRIBUTION:
        closeRouteDistribution();
        break;
    case SUMO_TAG_VTYPE: {
        SUMOVehicleParserHelper::closeVTypeParsing(*myCurrentVType);
        MSVehicleType *vehType = MSVehicleType::build(*myCurrentVType);
        delete myCurrentVType;
        myCurrentVType = 0;
        if (!MSNet::getInstance()->getVehicleControl().addVType(vehType)) {
            std::string id = vehType->getID();
            delete vehType;
#ifdef HAVE_MESOSIM
            if (!MSGlobals::gStateLoaded) {
#endif
                throw ProcessError("Another vehicle type (or distribution) with the id '" + id + "' exists.");
#ifdef HAVE_MESOSIM
            }
#endif
        } else {
            if (myCurrentVTypeDistribution != 0) {
                myCurrentVTypeDistribution->add(vehType->getDefaultProbability(), vehType);
            }
        }
    }
    break;
    default:
        break;
    }
}

void MSRouteHandler::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

Reimplemented from GenericSAXHandler.

Reimplemented in NLHandler.

Definition at line 105 of file MSRouteHandler.cpp.

References SUMOVehicleParserHelper::beginVTypeParsing(), SUMOVehicleParameter::Stop::busstop, closeRoute(), closeVehicle(), SUMOVehicleParameter::depart, MSLane::dictionary(), MSEdge::dictionary(), SUMOVehicleParameter::Stop::duration, SUMOVehicleParameter::fromTaz, MSNet::getBusStop(), MSBusStop::getEndLanePosition(), MsgHandler::getErrorInstance(), MSEdge::getFollower(), MSLane::getID(), MSNet::getInstance(), MSBusStop::getLane(), MSEdge::getNoFollowing(), StringTokenizer::getVector(), SUMOVehicleParameter::id, MsgHandler::inform(), SUMOVehicleParameter::Stop::lane, myActivePlan, myActiveRoute, myActiveRouteID, myActiveRouteStops, myCurrentVType, myVehicleParameter, openRoute(), openRouteDistribution(), openVehicleTypeDistribution(), MSEdge::parseEdgesList(), SUMOVehicleParserHelper::parseFlowAttributes(), SUMOVehicleParserHelper::parseVehicleAttributes(), SUMOVehicleParserHelper::parseVTypeEmbedded(), SUMOVehicleParameter::Stop::pos, SUMOVehicleParameter::stops, SUMO_ATTR_BUS_STOP, SUMO_ATTR_DURATION, SUMO_ATTR_EDGES, SUMO_ATTR_FROM, SUMO_ATTR_LANE, SUMO_ATTR_LINES, SUMO_ATTR_POSITION, SUMO_ATTR_SPEED, SUMO_ATTR_TO, SUMO_ATTR_UNTIL, SUMO_TAG_FLOW, SUMO_TAG_PERSON, SUMO_TAG_RIDE, SUMO_TAG_ROUTE, SUMO_TAG_ROUTE_DISTRIBUTION, SUMO_TAG_STOP, SUMO_TAG_TRIPDEF, SUMO_TAG_VEHICLE, SUMO_TAG_VTYPE, SUMO_TAG_VTYPE_DISTRIBUTION, SUMO_TAG_WALK, SUMOReal, SUMOVehicleParameter::Stop::until, VEHPARS_TAZ_SET, SUMOVehicleParameter::wasSet(), and WRITE_ERROR.

Referenced by NLHandler::myStartElement().

                                                                                   {
    switch (element) {
    case SUMO_TAG_VEHICLE:
        delete myVehicleParameter;
        myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs);
        break;
    case SUMO_TAG_PERSON:
        delete myVehicleParameter;
        myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs);
        myActivePlan = new MSPerson::MSPersonPlan();
        break;
    case SUMO_TAG_RIDE: {
        const std::string pid = myVehicleParameter->id;
        bool ok = true;
        MSEdge *from = 0;
        if (attrs.hasAttribute(SUMO_ATTR_FROM)) {
            const std::string fromID = attrs.getStringReporting(SUMO_ATTR_FROM, "ride", pid.c_str(), ok);
            from = MSEdge::dictionary(fromID);
            if (from==0) {
                throw ProcessError("The from edge '" + fromID + "' within a ride of person '" + pid + "' is not known.");
            }
            if (myActivePlan->empty() || &myActivePlan->back()->getDestination() != from) {
                myActivePlan->push_back(new MSPerson::MSPersonStage_Waiting(*from, -1, myVehicleParameter->depart));
            }
        }
        const std::string toID = attrs.getStringReporting(SUMO_ATTR_TO, "ride", pid.c_str(), ok);
        MSEdge *to = MSEdge::dictionary(toID);
        if (to==0) {
            throw ProcessError("The to edge '" + toID + "' within a ride of person '" + pid + "' is not known.");
        }
        const std::string desc = attrs.getStringReporting(SUMO_ATTR_LINES, "ride", pid.c_str(), ok);
        StringTokenizer st(desc);
        myActivePlan->push_back(new MSPerson::MSPersonStage_Driving(*to, st.getVector()));
        break;
    }
    case SUMO_TAG_WALK: {
        myActiveRoute.clear();
        bool ok = true;
        MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_EDGES, "walk", myVehicleParameter->id.c_str(), ok), myActiveRoute, myActiveRouteID);
        if (myActiveRoute.empty()) {
            throw ProcessError("No edges to walk for person '" + myVehicleParameter->id + "'.");
        }
        if (myActivePlan->empty() || &myActivePlan->back()->getDestination() != myActiveRoute.front()) {
            myActivePlan->push_back(new MSPerson::MSPersonStage_Waiting(*myActiveRoute.front(), -1, myVehicleParameter->depart));
        }
        const SUMOTime duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, "walk", 0, ok, -1);
        const SUMOReal speed = attrs.getOptSUMORealReporting(SUMO_ATTR_SPEED, "walk", 0, ok, -1);
        myActivePlan->push_back(new MSPerson::MSPersonStage_Walking(myActiveRoute, duration, speed));
        myActiveRoute.clear();
        break;
    }
    case SUMO_TAG_FLOW:
        delete myVehicleParameter;
        myVehicleParameter = SUMOVehicleParserHelper::parseFlowAttributes(attrs);
        if (attrs.hasAttribute(SUMO_ATTR_FROM) && attrs.hasAttribute(SUMO_ATTR_TO)) {
            myActiveRouteID = "!" + myVehicleParameter->id;
            bool ok = true;
            MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_FROM, "flow", myVehicleParameter->id.c_str(), ok), myActiveRoute, myActiveRouteID);
            MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_TO, "flow", myVehicleParameter->id.c_str(), ok), myActiveRoute, myActiveRouteID);
            closeRoute();
        }
        break;
    case SUMO_TAG_VTYPE:
        myCurrentVType = SUMOVehicleParserHelper::beginVTypeParsing(attrs);
        break;
    case SUMO_TAG_VTYPE_DISTRIBUTION:
        openVehicleTypeDistribution(attrs);
        break;
    case SUMO_TAG_ROUTE:
        openRoute(attrs);
        break;
    case SUMO_TAG_ROUTE_DISTRIBUTION:
        openRouteDistribution(attrs);
        break;
    case SUMO_TAG_TRIPDEF: {
        bool ok = true;
        myVehicleParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs);
        myActiveRouteID = "!" + myVehicleParameter->id;
        if (attrs.hasAttribute(SUMO_ATTR_FROM) || !myVehicleParameter->wasSet(VEHPARS_TAZ_SET)) {
            MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_FROM, "tripdef", myVehicleParameter->id.c_str(), ok), myActiveRoute, myActiveRouteID);
            MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_TO, "tripdef", myVehicleParameter->id.c_str(), ok), myActiveRoute, myActiveRouteID);
        } else {
            const MSEdge* fromTaz = MSEdge::dictionary(myVehicleParameter->fromTaz+"-source");
            if (fromTaz == 0) {
                WRITE_ERROR("Source district '" + myVehicleParameter->fromTaz + "' not known for '" + myVehicleParameter->id + "'!");
            } else if (fromTaz->getNoFollowing() == 0) {
                WRITE_ERROR("Source district '" + myVehicleParameter->fromTaz + "' has no outgoing edges for '" + myVehicleParameter->id + "'!");
            } else {
                myActiveRoute.push_back(fromTaz->getFollower(0));
            }
        }
        closeRoute();
        closeVehicle();
    }
    break;
    default:
        break;
    }
    // parse embedded vtype information
    if (myCurrentVType!=0&&element!=SUMO_TAG_VTYPE) {
        SUMOVehicleParserHelper::parseVTypeEmbedded(*myCurrentVType, element, attrs);
        return;
    }

    if (element==SUMO_TAG_STOP) {
        bool ok = true;
        SUMOVehicleParameter::Stop stop;
        // try to parse the assigne bus stop
        stop.busstop = attrs.getOptStringReporting(SUMO_ATTR_BUS_STOP, "stop", 0, ok, "");
        if (stop.busstop!="") {
            // ok, we have obviously a bus stop
            MSBusStop *bs = MSNet::getInstance()->getBusStop(stop.busstop);
            if (bs!=0) {
                const MSLane &l = bs->getLane();
                stop.lane = l.getID();
                stop.pos = bs->getEndLanePosition();
            } else {
                MsgHandler::getErrorInstance()->inform("The bus stop '" + stop.busstop + "' is not known.");
                return;
            }
        } else {
            // no, the lane and the position should be given
            // get the lane
            stop.lane = attrs.getOptStringReporting(SUMO_ATTR_LANE, "stop", 0, ok, "");
            if (stop.lane!="") {
                if (MSLane::dictionary(stop.lane)==0) {
                    MsgHandler::getErrorInstance()->inform("The lane '" + stop.lane + "' for a stop is not known.");
                    return;
                }
            } else {
                MsgHandler::getErrorInstance()->inform("A stop must be placed on a bus stop or a lane.");
                return;
            }
            // get the position
            bool ok = true;
            stop.pos = attrs.getSUMORealReporting(SUMO_ATTR_POSITION, "stop", 0, ok);
            if (!ok) {
                return;
            }
        }

        // get the standing duration
        if (!attrs.hasAttribute(SUMO_ATTR_DURATION) && !attrs.hasAttribute(SUMO_ATTR_UNTIL)) {
            MsgHandler::getErrorInstance()->inform("The duration of a stop is not defined.");
            return;
        } else {
            bool ok = true;
            stop.duration = attrs.getOptSUMOTimeReporting(SUMO_ATTR_DURATION, "stop", 0, ok, -1);
            stop.until = attrs.getOptSUMOTimeReporting(SUMO_ATTR_UNTIL, "stop", 0, ok, -1);
            if (!ok) {
                return;
            }
            if (stop.duration<0&&stop.until<0) {
                MsgHandler::getErrorInstance()->inform("Neither the duration nor the end time is given for a stop.");
                return;
            }
        }
        if (myActiveRouteID != "") {
            myActiveRouteStops.push_back(stop);
        } else {
            myVehicleParameter->stops.push_back(stop);
        }
    }
}

void MSRouteHandler::openRoute

(

const SUMOSAXAttributes &

attrs

)

[protected]

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, myActiveRoute, myActiveRouteColor, myActiveRouteID, myActiveRouteProbability, myVehicleParameter, RGBColor::parseColorReporting(), MSEdge::parseEdgesList(), SUMO_ATTR_COLOR, SUMO_ATTR_EDGES, SUMO_ATTR_ID, and SUMO_ATTR_PROB.

Referenced by 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]

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(), myCurrentRouteDistribution, myCurrentRouteDistributionID, StringTokenizer::next(), SUMOSAXAttributes::setIDFromAttributes(), and SUMO_ATTR_ROUTES.

Referenced by 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 MSRouteHandler::openVehicleTypeDistribution

(

const SUMOSAXAttributes &

attrs

)

[protected]

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(), myCurrentVTypeDistribution, myCurrentVTypeDistributionID, StringTokenizer::next(), SUMOSAXAttributes::setIDFromAttributes(), and SUMO_ATTR_VTYPES.

Referenced by 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);
            }
        }
    }
}

MSRouteHandler& MSRouteHandler::operator=

(

const MSRouteHandler &

s

)

[private]

invalid assignment operator

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

)

Returns the last loaded vehicle.

Definition at line 90 of file MSRouteHandler.cpp.

References MSEmitControl::add(), DEPART_GIVEN, SUMOVehicleParameter::departProcedure, MSVehicle::getParameter(), myLastReadVehicle, 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 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

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

the plan of the current person

Definition at line 166 of file MSRouteHandler.h.

Referenced by closePerson(), and myStartElement().

MSEdgeVector MSRouteHandler::myActiveRoute [protected]

the current route

Definition at line 151 of file MSRouteHandler.h.

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

RGBColor MSRouteHandler::myActiveRouteColor [protected]

The currently parsed route's color.

Definition at line 160 of file MSRouteHandler.h.

Referenced by closeRoute(), and openRoute().

std::string MSRouteHandler::myActiveRouteID [protected]

the id of the current route

Definition at line 154 of file MSRouteHandler.h.

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

SUMOReal MSRouteHandler::myActiveRouteProbability [protected]

the id of the current route

Definition at line 157 of file MSRouteHandler.h.

Referenced by closeRoute(), and openRoute().

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

List of the stops on the parsed route.

Definition at line 163 of file MSRouteHandler.h.

Referenced by closeRoute(), and myStartElement().

bool MSRouteHandler::myAddVehiclesDirectly [protected]

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 closeFlow(), and closeVehicle().

bool MSRouteHandler::myAmUsingIncrementalDUA [protected]

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

Definition at line 185 of file MSRouteHandler.h.

Referenced by closeVehicle(), and MSRouteHandler().

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

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

Definition at line 179 of file MSRouteHandler.h.

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

std::string MSRouteHandler::myCurrentRouteDistributionID [protected]

The id of the currently parsed route distribution.

Definition at line 182 of file MSRouteHandler.h.

Referenced by closeRouteDistribution(), and openRouteDistribution().

SUMOVTypeParameter* MSRouteHandler::myCurrentVType [protected]

The currently parsed vehicle type.

Definition at line 200 of file MSRouteHandler.h.

Referenced by myEndElement(), and myStartElement().

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

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

Definition at line 173 of file MSRouteHandler.h.

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

std::string MSRouteHandler::myCurrentVTypeDistributionID [protected]

The id of the currently parsed vehicle type distribution.

Definition at line 176 of file MSRouteHandler.h.

Referenced by closeVehicleTypeDistribution(), and openVehicleTypeDistribution().

bool MSRouteHandler::myHaveWarned [protected]

whether we have warned about routes defined as character strings

Definition at line 197 of file MSRouteHandler.h.

Referenced by myCharacters().

int MSRouteHandler::myIncrementalBase [protected]

The base for inc-dua.

Definition at line 191 of file MSRouteHandler.h.

Referenced by closeVehicle(), and MSRouteHandler().

int MSRouteHandler::myIncrementalStage [protected]

The current stage of inc-dua.

Definition at line 194 of file MSRouteHandler.h.

Referenced by closeVehicle(), and MSRouteHandler().

SUMOTime MSRouteHandler::myLastDepart [protected]

the emission time of the vehicle read last

Definition at line 144 of file MSRouteHandler.h.

Referenced by closeVehicle(), and getLastDepart().

MSVehicle* MSRouteHandler::myLastReadVehicle [protected]

the last vehicle read

Definition at line 147 of file MSRouteHandler.h.

Referenced by closeVehicle(), and retrieveLastReadVehicle().

unsigned int MSRouteHandler::myRunningVehicleNumber [protected]

The current vehicle number (for inc-dua).

Definition at line 188 of file MSRouteHandler.h.

Referenced by closeVehicle().

SUMOVehicleParameter* MSRouteHandler::myVehicleParameter [protected]

Definition at line 141 of file MSRouteHandler.h.

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

---

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

• MSRouteHandler.h
• MSRouteHandler.cpp