RORDLoader_TripDefs Class Reference

#include <RORDLoader_TripDefs.h>

Inheritance diagram for RORDLoader_TripDefs:

ROTypedXMLRoutesLoader ROAbstractRouteDefLoader SUMOSAXHandler GenericSAXHandler RORDGenerator_ODAmounts

Detailed Description

A handler for route definitions which consists of the origin and the destination edge only. Additionally, read vehicles may have information about a certain position to leave from and a certain speed to leave with.

Definition at line 50 of file RORDLoader_TripDefs.h.


Public Member Functions

void characters (const XMLCh *const chars, const XERCES3_SIZE_t length)
 The inherited method called when characters occured.
void endDocument ()
 Called when the document has ended.
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
void registerParent (const SumoXMLTag tag, GenericSAXHandler *handler)
 Assigning a parent handler which is enabled when the specified tag is closed.
 RORDLoader_TripDefs (RONet &net, SUMOTime begin, SUMOTime end, bool emptyDestinationsAllowed, bool withTaz, const std::string &file="") throw (ProcessError)
 Constructor.
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.
 ~RORDLoader_TripDefs () throw ()
 Destructor.
inherited from ROAbstractRouteDefLoader
bool ended () const throw ()
 Returns the information whether no routes are available from this loader anymore.
bool readRoutesAtLeastUntil (SUMOTime time, bool skipping) throw (ProcessError)
 Adds routes from the file until the given time is reached.
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.
inherited from ROAbstractRouteDefLoader
SUMOTime getLastReadTimeStep () const throw ()
 Returns the time the current (last read) route starts at.

Protected Member Functions

std::string buildErrorMessage (const SAXParseException &exception) throw ()
 Builds an error message.
ROEdge * getEdge (const SUMOSAXAttributes &attrs, const std::string &purpose, SumoXMLAttr which, const std::string &id, bool emptyAllowed)
 Parses a named edge frm the attributes.
std::string getLane (const SUMOSAXAttributes &attrs)
 Parses and returns the name of the lane the vehicle starts at This value is optional.
SUMOTime getPeriod (const SUMOSAXAttributes &attrs, const std::string &id)
 Parses and returns the period the trip shall be repeated with.
int getRepetitionNumber (const SUMOSAXAttributes &attrs, const std::string &id)
 Parses and returns the number of cars that shall use the same parameter.
std::string getVehicleID (const SUMOSAXAttributes &attrs)
 Parses the vehicle id.
virtual void myCharacters (SumoXMLTag element, const std::string &chars) throw (ProcessError)
 Callback method for characters to implement by derived classes.
inherited from ROTypedXMLRoutesLoader
void beginNextRoute () throw ()
 Returns Initialises the reading of a further route.
bool nextRouteRead () throw ()
inherited from GenericSAXHandler
void myEndElement (SumoXMLTag element) throw (ProcessError)
 Called when a closing tag occurs.
void myStartElement (SumoXMLTag element, const SUMOSAXAttributes &attrs) throw (ProcessError)
 Called on the opening of a tag;.

Protected Attributes

SUMOTime myBegin
 The time for which the first route shall be loaded.
ROEdge * myBeginEdge
 The starting edge.
SUMOVTypeParameter * myCurrentVehicleType
 The currently parsed vehicle type.
SUMOTime myDepartureTime
const bool myEmptyDestinationsAllowed
 Information whether empty destinations are allowed This is a feature used for the handling of explicite routes within the jp-router where the destination is not necessary.
SUMOTime myEnd
 The time for which the first route shall be loaded.
bool myEnded
 Information whether the whole file has been parsed.
ROEdge * myEndEdge
 The end edge.
IDSupplier myIdSupplier
 generates numerical ids
RONet & myNet
 The network to add routes to.
bool myNextRouteRead
 The information whether the next route was read.
SUMOVehicleParameter * myParameter
SAX2XMLReader * myParser
 The parser used.
XMLPScanToken myToken
 Information about the current position within the file.
const bool myWithTaz
 Information whether zones (districts) are used as origins / destinations.

Private Member Functions

RORDLoader_TripDefs & operator= (const RORDLoader_TripDefs &src)
 Invalidated assignment operator.
 RORDLoader_TripDefs (const RORDLoader_TripDefs &src)
 Invalidated copy constructor.

Constructor & Destructor Documentation

RORDLoader_TripDefs::RORDLoader_TripDefs ( RONet &  net,
SUMOTime  begin,
SUMOTime  end,
bool  emptyDestinationsAllowed,
bool  withTaz,
const std::string &  file = "" 
) throw (ProcessError)

Constructor.

Definition at line 51 of file RORDLoader_TripDefs.cpp.

00055         : ROTypedXMLRoutesLoader(net, begin, end, fileName),
00056         myEmptyDestinationsAllowed(emptyDestinationsAllowed),
00057         myWithTaz(withTaz),
00058         myDepartureTime(-1), myCurrentVehicleType(0),
00059         myParameter(0) {}

RORDLoader_TripDefs::~RORDLoader_TripDefs (  )  throw ()

Destructor.

Definition at line 62 of file RORDLoader_TripDefs.cpp.

00062 {}

RORDLoader_TripDefs::RORDLoader_TripDefs ( const RORDLoader_TripDefs &  src  )  [private]

Invalidated copy constructor.

Member Function Documentation

void RORDLoader_TripDefs::beginNextRoute (  )  throw () [protected, virtual]

Returns Initialises the reading of a further route.

Todo:
recheck/refactor
See also:
ROTypedXMLRoutesLoader::beginNextRoute

Implements ROTypedXMLRoutesLoader.

Definition at line 196 of file RORDLoader_TripDefs.cpp.

References myNextRouteRead.

00196                                             {
00197     myNextRouteRead = false;
00198 }

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().

00055                                                                             {
00056     std::ostringstream buf;
00057     char *pMsg = XMLString::transcode(exception.getMessage());
00058     buf << pMsg << std::endl;
00059     buf << " In file '" << getFileName() << "'" << std::endl;
00060     buf << " At line/column " << exception.getLineNumber()+1
00061     << '/' << exception.getColumnNumber() << "." << std::endl;
00062     XMLString::release(&pMsg);
00063     return buf.str();
00064 }

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.

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

void ROTypedXMLRoutesLoader::endDocument (  )  [inherited]

Called when the document has ended.

Todo:
Recheck usage of route loaders; it is not very fine to have one that use a parser and other that do not

Definition at line 81 of file ROTypedXMLRoutesLoader.cpp.

References ROTypedXMLRoutesLoader::myEnded.

00081                                     {
00082     myEnded = true;
00083 }

bool ROTypedXMLRoutesLoader::ended (  )  const throw () [inline, virtual, inherited]

Returns the information whether no routes are available from this loader anymore.

Returns:
Whether the whole input has been processed

Implements ROAbstractRouteDefLoader.

Definition at line 97 of file ROTypedXMLRoutesLoader.h.

References ROTypedXMLRoutesLoader::myEnded.

Referenced by ROTypedXMLRoutesLoader::readRoutesAtLeastUntil().

00097                                {
00098         return myEnded;
00099     }

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.

00120                                                         {
00121     std::string name = TplConvert<XMLCh>::_2str(qname);
00122     SumoXMLTag element = convertTag(name);
00123     // collect characters
00124     if (myCharactersVector.size()!=0) {
00125         size_t len = 0;
00126         unsigned i;
00127         for (i=0; i<myCharactersVector.size(); ++i) {
00128             len += myCharactersVector[i].length();
00129         }
00130         char *buf = new char[len+1];
00131         size_t pos = 0;
00132         for (i=0; i<myCharactersVector.size(); ++i) {
00133             memcpy((unsigned char*) buf+pos, (unsigned char*) myCharactersVector[i].c_str(),
00134                    sizeof(char)*myCharactersVector[i].length());
00135             pos += myCharactersVector[i].length();
00136         }
00137         buf[pos] = 0;
00138 
00139         // call user handler
00140         try {
00141             myCharacters(element, buf);
00142         } catch (std::runtime_error &) {
00143             delete[] buf;
00144             throw;
00145         }
00146         delete[] buf;
00147     }
00148     if (element != SUMO_TAG_INCLUDE) {
00149         myEndElement(element);
00150         if (myParentHandler && myParentIndicator == element) {
00151             XMLSubSys::setHandler(*myParentHandler);
00152             myParentIndicator = SUMO_TAG_NOTHING;
00153             myParentHandler = 0;
00154         }
00155     }
00156 }

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().

00074                                                                             {
00075     throw ProcessError(buildErrorMessage(exception));
00076 }

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().

00080                                                                                  {
00081     throw ProcessError(buildErrorMessage(exception));
00082 }

ROEdge * RORDLoader_TripDefs::getEdge ( const SUMOSAXAttributes &  attrs,
const std::string &  purpose,
SumoXMLAttr  which,
const std::string &  id,
bool  emptyAllowed 
) [protected]

Parses a named edge frm the attributes.

Definition at line 116 of file RORDLoader_TripDefs.cpp.

References RONet::getEdge(), MsgHandler::getErrorInstance(), SUMOSAXAttributes::getStringReporting(), MsgHandler::inform(), ROAbstractRouteDefLoader::myNet, and SUMO_ATTR_FROM_TAZ.

Referenced by myStartElement(), and RORDGenerator_ODAmounts::parseFlowAmountDef().

00119                                                 {
00120     bool ok = true;
00121     std::string id = attrs.getStringReporting(which, 0, 0, ok, !emptyAllowed);
00122     if (which == SUMO_ATTR_FROM_TAZ) {
00123         id += "-source";
00124     }
00125     ROEdge *e = myNet.getEdge(id);
00126     if (e==0 && !emptyAllowed) {
00127         MsgHandler::getErrorInstance()->inform("The edge '" + id + "' is not known.\n Vehicle id='" + vid + "'.");
00128     }
00129     return e;
00130 }

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().

00078                                              {
00079     return myFileName;
00080 }

std::string RORDLoader_TripDefs::getLane ( const SUMOSAXAttributes &  attrs  )  [protected]

Parses and returns the name of the lane the vehicle starts at This value is optional.

Definition at line 158 of file RORDLoader_TripDefs.cpp.

References SUMOSAXAttributes::getOptStringReporting(), and SUMO_ATTR_LANE.

00158                                                            {
00159     bool ok = true;
00160     return attrs.getOptStringReporting(SUMO_ATTR_LANE, 0, 0, ok, "");
00161 }

SUMOTime RORDLoader_TripDefs::getLastReadTimeStep (  )  const throw () [inline, virtual]

Returns the time the current (last read) route starts at.

Returns:
The least time step that was read by this reader

Implements ROAbstractRouteDefLoader.

Definition at line 68 of file RORDLoader_TripDefs.h.

References myDepartureTime.

00068                                                  {
00069         return myDepartureTime;
00070     }

SUMOTime RORDLoader_TripDefs::getPeriod ( const SUMOSAXAttributes &  attrs,
const std::string &  id 
) [protected]

Parses and returns the period the trip shall be repeated with.

Definition at line 134 of file RORDLoader_TripDefs.cpp.

References SUMOSAXAttributes::getSUMOTimeReporting(), SUMOSAXAttributes::hasAttribute(), and SUMO_ATTR_PERIOD.

00135                                                     {
00136     if (!attrs.hasAttribute(SUMO_ATTR_PERIOD)) {
00137         return -1;
00138     }
00139     // get the repetition period
00140     bool ok = true;
00141     return attrs.getSUMOTimeReporting(SUMO_ATTR_PERIOD, "tripdef", id.c_str(), ok);
00142 }

int RORDLoader_TripDefs::getRepetitionNumber ( const SUMOSAXAttributes &  attrs,
const std::string &  id 
) [protected]

Parses and returns the number of cars that shall use the same parameter.

Definition at line 146 of file RORDLoader_TripDefs.cpp.

References SUMOSAXAttributes::getIntReporting(), SUMOSAXAttributes::hasAttribute(), and SUMO_ATTR_REPNUMBER.

00147                              {
00148     if (!attrs.hasAttribute(SUMO_ATTR_REPNUMBER)) {
00149         return -1;
00150     }
00151     // get the repetition number
00152     bool ok = true;
00153     return attrs.getIntReporting(SUMO_ATTR_REPNUMBER, "tripdef", id.c_str(), ok);
00154 }

std::string RORDLoader_TripDefs::getVehicleID ( const SUMOSAXAttributes &  attrs  )  [protected]

Parses the vehicle id.

Definition at line 103 of file RORDLoader_TripDefs.cpp.

References IDSupplier::getNext(), myIdSupplier, and SUMOSAXAttributes::setIDFromAttributes().

Referenced by myStartElement(), and RORDGenerator_ODAmounts::parseFlowAmountDef().

00103                                                                 {
00104     // get the id, report an error if not given or empty...
00105     std::string id;
00106     attrs.setIDFromAttributes("tripdef", id, false);
00107     // get a valid vehicle id
00108     if (id=="") {
00109         id = myIdSupplier.getNext();
00110     }
00111     return id;
00112 }

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

Callback method for characters to implement by derived classes.

Called by "endElement" (see there).

Parameters:
[in] element The opened element, given as a SumoXMLTag
[in] chars The complete embedded character string ProcessError These method may throw a ProcessError if something fails

Reimplemented in ROJTRTurnDefLoader, MSRouteHandler, NIImporter_OpenDrive, NIImporter_SUMO, NLHandler, PCLoaderXML, PCNetProjectionLoader, and RORDLoader_SUMOBase.

Definition at line 189 of file GenericSAXHandler.cpp.

Referenced by GenericSAXHandler::endElement().

00189 {}

void RORDLoader_TripDefs::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 RORDGenerator_ODAmounts.

Definition at line 165 of file RORDLoader_TripDefs.cpp.

References RONet::addRouteDef(), RONet::addVehicle(), RONet::addVehicleType(), SUMOVehicleParserHelper::closeVTypeParsing(), SUMOVehicleParameter::color, MsgHandler::getErrorInstance(), RONet::getVehicleTypeSecure(), SUMOVehicleParameter::id, myBeginEdge, myCurrentVehicleType, ROAbstractRouteDefLoader::myEnd, myEndEdge, ROAbstractRouteDefLoader::myNet, myNextRouteRead, myParameter, SUMO_TAG_TRIPDEF, SUMO_TAG_VTYPE, VEHPARS_COLOR_SET, SUMOVehicleParameter::vtypeid, and SUMOVehicleParameter::wasSet().

Referenced by RORDGenerator_ODAmounts::myEndElement().

00165                                                                         {
00166     if (element==SUMO_TAG_TRIPDEF &&
00167             !MsgHandler::getErrorInstance()->wasInformed()) {
00168 
00169         if (myDepartureTime<myBegin||myDepartureTime>=myEnd) {
00170             return;
00171         }
00172         RGBColor *col = myParameter->wasSet(VEHPARS_COLOR_SET) ? new RGBColor(myParameter->color) : 0;
00173         RORouteDef *route = new RORouteDef_OrigDest(myParameter->id, col, myBeginEdge, myEndEdge);
00174         SUMOVTypeParameter *type = myNet.getVehicleTypeSecure(myParameter->vtypeid);
00175         // check whether any errors occured
00176         if (MsgHandler::getErrorInstance()->wasInformed()) {
00177             return;
00178         }
00179         myNet.addRouteDef(route);
00180         myNextRouteRead = true;
00181         // build the vehicle
00182         ROVehicle *veh = new ROVehicle(*myParameter, route, type);
00183         myNet.addVehicle(myParameter->id, veh);
00184         delete myParameter;
00185         myParameter = 0;
00186     }
00187     if (element==SUMO_TAG_VTYPE) {
00188         SUMOVehicleParserHelper::closeVTypeParsing(*myCurrentVehicleType);
00189         myNet.addVehicleType(myCurrentVehicleType);
00190         myCurrentVehicleType = 0;
00191     }
00192 }

void RORDLoader_TripDefs::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 RORDGenerator_ODAmounts.

Definition at line 66 of file RORDLoader_TripDefs.cpp.

References SUMOVehicleParserHelper::beginVTypeParsing(), getEdge(), MsgHandler::getErrorInstance(), getVehicleID(), SUMOVehicleParameter::id, MsgHandler::inform(), myBeginEdge, myCurrentVehicleType, myDepartureTime, myEmptyDestinationsAllowed, myEndEdge, myParameter, myWithTaz, SUMOVehicleParserHelper::parseVehicleAttributes(), SUMOVehicleParserHelper::parseVTypeEmbedded(), SUMO_ATTR_DEPART, SUMO_ATTR_FROM, SUMO_ATTR_FROM_TAZ, SUMO_ATTR_TO, SUMO_ATTR_TO_TAZ, SUMO_TAG_TRIPDEF, and SUMO_TAG_VTYPE.

Referenced by RORDGenerator_ODAmounts::myStartElement().

00067                                                                                         {
00068     // check whether a trip definition shall be parsed
00069     if (element==SUMO_TAG_TRIPDEF) {
00070         bool ok = true;
00071         // get the vehicle id, the edges, the speed and position and
00072         //  the departure time and other information
00073         std::string id = getVehicleID(attrs);
00074         myDepartureTime = attrs.getSUMOTimeReporting(SUMO_ATTR_DEPART, "tripdef", id.c_str(), ok);
00075         if (myWithTaz) {
00076             myBeginEdge = getEdge(attrs, "origin", SUMO_ATTR_FROM_TAZ, id, false);
00077             myEndEdge = getEdge(attrs, "destination", SUMO_ATTR_TO_TAZ, id, myEmptyDestinationsAllowed);
00078         } else {
00079             myBeginEdge = getEdge(attrs, "origin", SUMO_ATTR_FROM, id, false);
00080             myEndEdge = getEdge(attrs, "destination", SUMO_ATTR_TO, id, myEmptyDestinationsAllowed);
00081         }
00082         myParameter = SUMOVehicleParserHelper::parseVehicleAttributes(attrs, true);
00083         myParameter->id = id;
00084         // recheck attributes
00085         if (!ok) {
00086             return;
00087         }
00088         if (myDepartureTime<0) {
00089             MsgHandler::getErrorInstance()->inform("The departure time must be positive.");
00090             return;
00091         }
00092     }
00093     // check whether a vehicle type shall be parsed
00094     if (element==SUMO_TAG_VTYPE) {
00095         myCurrentVehicleType = SUMOVehicleParserHelper::beginVTypeParsing(attrs);
00096     } else if (myCurrentVehicleType!=0) {
00097         SUMOVehicleParserHelper::parseVTypeEmbedded(*myCurrentVehicleType, element, attrs);
00098     }
00099 }

bool RORDLoader_TripDefs::nextRouteRead (  )  throw () [inline, protected, virtual]

Returns the information whether a route was read

Returns:
Whether a further route was read
See also:
ROTypedXMLRoutesLoader::nextRouteRead

Implements ROTypedXMLRoutesLoader.

Definition at line 108 of file RORDLoader_TripDefs.h.

References myNextRouteRead.

00108                                  {
00109         return myNextRouteRead;
00110     }

RORDLoader_TripDefs& RORDLoader_TripDefs::operator= ( const RORDLoader_TripDefs &  src  )  [private]

Invalidated assignment operator.

bool ROTypedXMLRoutesLoader::readRoutesAtLeastUntil ( SUMOTime  time,
bool  skipping 
) throw (ProcessError) [virtual, inherited]

Adds routes from the file until the given time is reached.

Parameters:
[in] time The time until which route definitions shall be loaded
[in] skipping Whether routes shall not be added
Returns:
Whether any errors occured
Exceptions:
ProcessError If a major error occured
See also:
ROAbstractRouteDefLoader::readRoutesAtLeastUntil

Implements ROAbstractRouteDefLoader.

Reimplemented in RORDGenerator_ODAmounts.

Definition at line 69 of file ROTypedXMLRoutesLoader.cpp.

References ROTypedXMLRoutesLoader::beginNextRoute(), ROTypedXMLRoutesLoader::ended(), ROAbstractRouteDefLoader::getLastReadTimeStep(), ROTypedXMLRoutesLoader::myParser, ROTypedXMLRoutesLoader::myToken, and ROTypedXMLRoutesLoader::nextRouteRead().

00069                                                                                                {
00070     while (getLastReadTimeStep()<time&&!ended()) {
00071         beginNextRoute();
00072         while (!nextRouteRead()&&!ended()) {
00073             myParser->parseNext(myToken);
00074         }
00075     }
00076     return true;
00077 }

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().

00160                                                                                   {
00161     myParentHandler = handler;
00162     myParentIndicator = tag;
00163     XMLSubSys::setHandler(*this);
00164 }

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().

00072                                                             {
00073     myFileName = name;
00074 }

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.

00100                                                          {
00101     std::string name = TplConvert<XMLCh>::_2str(qname);
00102     SumoXMLTag element = convertTag(name);
00103     myCharactersVector.clear();
00104     SUMOSAXAttributesImpl_Xerces na(attrs, myPredefinedTags, myPredefinedTagsMML);
00105     if (element == SUMO_TAG_INCLUDE) {
00106         std::string file = na.getString(SUMO_ATTR_HREF);
00107         if (!FileHelpers::isAbsolute(file)) {
00108             file = FileHelpers::getConfigurationRelative(getFileName(), file);
00109         }
00110         XMLSubSys::runParser(*this, file);
00111     } else {
00112         myStartElement(element, na);
00113     }
00114 }

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().

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

Field Documentation

SUMOTime ROAbstractRouteDefLoader::myBegin [protected, inherited]

The time for which the first route shall be loaded.

Definition at line 107 of file ROAbstractRouteDefLoader.h.

Referenced by RORDLoader_SUMOBase::closeVehicle(), RORDGenerator_ODAmounts::myEndFlowAmountDef(), RORDGenerator_ODAmounts::readRoutesAtLeastUntil(), and RORDGenerator_ODAmounts::RORDGenerator_ODAmounts().

ROEdge* RORDLoader_TripDefs::myBeginEdge [protected]

The starting edge.

Definition at line 145 of file RORDLoader_TripDefs.h.

Referenced by myEndElement(), RORDGenerator_ODAmounts::myEndFlowAmountDef(), myStartElement(), and RORDGenerator_ODAmounts::parseFlowAmountDef().

SUMOVTypeParameter* RORDLoader_TripDefs::myCurrentVehicleType [protected]

The currently parsed vehicle type.

Definition at line 162 of file RORDLoader_TripDefs.h.

Referenced by myEndElement(), and myStartElement().

SUMOTime RORDLoader_TripDefs::myDepartureTime [protected]

Definition at line 165 of file RORDLoader_TripDefs.h.

Referenced by RORDGenerator_ODAmounts::buildRoutes(), getLastReadTimeStep(), myStartElement(), RORDGenerator_ODAmounts::readRoutesAtLeastUntil(), and RORDGenerator_ODAmounts::RORDGenerator_ODAmounts().

const bool RORDLoader_TripDefs::myEmptyDestinationsAllowed [protected]

Information whether empty destinations are allowed This is a feature used for the handling of explicite routes within the jp-router where the destination is not necessary.

Definition at line 153 of file RORDLoader_TripDefs.h.

Referenced by myStartElement(), and RORDGenerator_ODAmounts::parseFlowAmountDef().

SUMOTime ROAbstractRouteDefLoader::myEnd [protected, inherited]

The time for which the first route shall be loaded.

Definition at line 110 of file ROAbstractRouteDefLoader.h.

Referenced by RORDGenerator_ODAmounts::buildForTimeStep(), RORDLoader_SUMOBase::closeVehicle(), and myEndElement().

bool ROTypedXMLRoutesLoader::myEnded [protected, inherited]

Information whether the whole file has been parsed.

Definition at line 139 of file ROTypedXMLRoutesLoader.h.

Referenced by RORDGenerator_ODAmounts::buildForTimeStep(), ROTypedXMLRoutesLoader::endDocument(), and ROTypedXMLRoutesLoader::ended().

ROEdge* RORDLoader_TripDefs::myEndEdge [protected]

The end edge.

Definition at line 148 of file RORDLoader_TripDefs.h.

Referenced by myEndElement(), RORDGenerator_ODAmounts::myEndFlowAmountDef(), myStartElement(), and RORDGenerator_ODAmounts::parseFlowAmountDef().

IDSupplier RORDLoader_TripDefs::myIdSupplier [protected]

generates numerical ids

Definition at line 142 of file RORDLoader_TripDefs.h.

Referenced by getVehicleID().

RONet& ROAbstractRouteDefLoader::myNet [protected, inherited]

The network to add routes to.

Definition at line 104 of file ROAbstractRouteDefLoader.h.

Referenced by RORDGenerator_ODAmounts::buildForTimeStep(), RORDLoader_SUMOBase::closeVehicle(), getEdge(), RORDLoader_SUMOBase::myCharacters(), myEndElement(), RORDLoader_SUMOBase::myEndElement(), and RORDGenerator_ODAmounts::myEndFlowAmountDef().

bool RORDLoader_TripDefs::myNextRouteRead [protected]

The information whether the next route was read.

Definition at line 159 of file RORDLoader_TripDefs.h.

Referenced by beginNextRoute(), myEndElement(), RORDGenerator_ODAmounts::myEndFlowAmountDef(), and nextRouteRead().

SUMOVehicleParameter* RORDLoader_TripDefs::myParameter [protected]

Definition at line 164 of file RORDLoader_TripDefs.h.

Referenced by myEndElement(), RORDGenerator_ODAmounts::myEndFlowAmountDef(), myStartElement(), and RORDGenerator_ODAmounts::parseFlowAmountDef().

SAX2XMLReader* ROTypedXMLRoutesLoader::myParser [protected, inherited]

The parser used.

Definition at line 133 of file ROTypedXMLRoutesLoader.h.

Referenced by ROTypedXMLRoutesLoader::readRoutesAtLeastUntil(), RORDGenerator_ODAmounts::RORDGenerator_ODAmounts(), and ROTypedXMLRoutesLoader::~ROTypedXMLRoutesLoader().

XMLPScanToken ROTypedXMLRoutesLoader::myToken [protected, inherited]

Information about the current position within the file.

Definition at line 136 of file ROTypedXMLRoutesLoader.h.

Referenced by ROTypedXMLRoutesLoader::readRoutesAtLeastUntil(), and RORDGenerator_ODAmounts::RORDGenerator_ODAmounts().

const bool RORDLoader_TripDefs::myWithTaz [protected]

Information whether zones (districts) are used as origins / destinations.

Definition at line 156 of file RORDLoader_TripDefs.h.

Referenced by myStartElement().

The documentation for this class was generated from the following files:
Generated on Wed May 5 00:07:00 2010 for Sumo - Simulation of Urban MObility by  doxygen 1.5.6