NIImporter_OpenStreetMap::EdgesHandler Class Reference

Inheritance diagram for NIImporter_OpenStreetMap::EdgesHandler:

SUMOSAXHandler GenericSAXHandler

Detailed Description

A class which extracts OSM-edges from a parsed OSM-file.

Definition at line 216 of file NIImporter_OpenStreetMap.h.


Public Member Functions

void characters (const XMLCh *const chars, const XERCES3_SIZE_t length)
 The inherited method called when characters occured.
 EdgesHandler (const std::map< int, NIOSMNode * > &osmNodes, std::map< std::string, Edge * > &toFill) throw ()
 Constructor.
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.
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.
 ~EdgesHandler () 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

std::string buildErrorMessage (const SAXParseException &exception) throw ()
 Builds an error message.
virtual void myCharacters (SumoXMLTag element, const std::string &chars) throw (ProcessError)
 Callback method for characters to implement by derived classes.
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;.

Private Member Functions

 EdgesHandler (const EdgesHandler &s)
 invalidated copy constructor
EdgesHandler & operator= (const EdgesHandler &s)
 invalidated assignment operator

Private Attributes

Edge * myCurrentEdge
 The currently built edge.
std::map< std::string, Edge * > & myEdgeMap
 A map of built edges.
const std::map< int, NIOSMNode * > & myOSMNodes
 The previously parsed nodes.
std::vector< SumoXMLTag > myParentElements
 The element stack.

Constructor & Destructor Documentation

NIImporter_OpenStreetMap::EdgesHandler::EdgesHandler ( const std::map< int, NIOSMNode * > &  osmNodes,
std::map< std::string, Edge * > &  toFill 
) throw ()

Constructor.

Parameters:
[in] osmNodes The previously parsed (osm-)nodes
[in] toFill The edges container to fill with read edges

Definition at line 563 of file NIImporter_OpenStreetMap.cpp.

00566         : SUMOSAXHandler("osm - file"),
00567         myOSMNodes(osmNodes), myEdgeMap(toFill) {
00568 }

NIImporter_OpenStreetMap::EdgesHandler::~EdgesHandler (  )  throw ()

Destructor.

Definition at line 571 of file NIImporter_OpenStreetMap.cpp.

00571                                                             {
00572 }

NIImporter_OpenStreetMap::EdgesHandler::EdgesHandler ( const EdgesHandler &  s  )  [private]

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

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 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 }

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 }

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 NIImporter_OpenStreetMap::EdgesHandler::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.

Definition at line 648 of file NIImporter_OpenStreetMap.cpp.

References NIImporter_OpenStreetMap::Edge::id, myCurrentEdge, NIImporter_OpenStreetMap::Edge::myCurrentIsRoad, myEdgeMap, myParentElements, and SUMO_TAG_WAY.

00648                                                                                          {
00649     myParentElements.pop_back();
00650     if (element==SUMO_TAG_WAY) {
00651         if (myCurrentEdge!=0 && myCurrentEdge->myCurrentIsRoad) {
00652             myEdgeMap[myCurrentEdge->id] = myCurrentEdge;
00653         } else {
00654             delete myCurrentEdge;
00655         }
00656         myCurrentEdge = 0;
00657     }
00658 }

void NIImporter_OpenStreetMap::EdgesHandler::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.

Definition at line 576 of file NIImporter_OpenStreetMap.cpp.

References TplConvert< E >::_2int(), TplConvert< E >::_2SUMOReal(), MsgHandler::getErrorInstance(), NIImporter_OpenStreetMap::Edge::id, MsgHandler::inform(), myCurrentEdge, NIImporter_OpenStreetMap::Edge::myCurrentIsRoad, NIImporter_OpenStreetMap::Edge::myCurrentNodes, NIImporter_OpenStreetMap::Edge::myHighWayType, NIImporter_OpenStreetMap::Edge::myIsOneWay, NIImporter_OpenStreetMap::Edge::myMaxSpeed, NIImporter_OpenStreetMap::Edge::myNoLanes, myOSMNodes, myParentElements, SUMO_ATTR_ID, SUMO_ATTR_K, SUMO_ATTR_REF, SUMO_ATTR_V, SUMO_TAG_ND, SUMO_TAG_TAG, SUMO_TAG_WAY, toString(), and WRITE_WARNING.

00577                                                             {
00578     myParentElements.push_back(element);
00579     // parse "way" elements
00580     if (element==SUMO_TAG_WAY) {
00581         bool ok = true;
00582         std::string id = attrs.getStringReporting(SUMO_ATTR_ID, "way", 0, ok);
00583         std::string action = attrs.hasAttribute("action") ? attrs.getStringSecure("action", "") : "";
00584         if (action=="delete") {
00585             myCurrentEdge = 0;
00586             return;
00587         }
00588         if (!ok) {
00589             myCurrentEdge = 0;
00590             return;
00591         }
00592         myCurrentEdge = new Edge();
00593         myCurrentEdge->id = id;
00594         myCurrentEdge->myNoLanes = -1;
00595         myCurrentEdge->myMaxSpeed = -1;
00596         myCurrentEdge->myCurrentIsRoad = false;
00597     }
00598     // parse "nd" (node) elements
00599     if (element==SUMO_TAG_ND) {
00600         bool ok = true;
00601         int ref = attrs.getIntReporting(SUMO_ATTR_REF, "nd", 0, ok);
00602         if (ok) {
00603             if (myOSMNodes.find(ref)==myOSMNodes.end()) {
00604                 MsgHandler::getErrorInstance()->inform("The referenced geometry information (ref='" + toString(ref) + "') is not known");
00605                 return;
00606             }
00607             myCurrentEdge->myCurrentNodes.push_back(ref);
00608         }
00609     }
00610     // parse values
00611     if (element==SUMO_TAG_TAG&&myParentElements.size()>2&&myParentElements[myParentElements.size()-2]==SUMO_TAG_WAY) {
00612         if (myCurrentEdge==0) {
00613             return;
00614         }
00615         bool ok = true;
00616         std::string key = attrs.getStringReporting(SUMO_ATTR_K, "way", toString(myCurrentEdge->id).c_str(), ok);
00617         std::string value = attrs.getStringReporting(SUMO_ATTR_V, "way", toString(myCurrentEdge->id).c_str(), ok);
00618         if (!ok) {
00619             return;
00620         }
00621         if (key=="highway"||key=="railway") {
00622             myCurrentEdge->myHighWayType = key + "." + value;
00623             myCurrentEdge->myCurrentIsRoad = true;
00624         } else if (key=="lanes") {
00625             try {
00626                 myCurrentEdge->myNoLanes = TplConvert<char>::_2int(value.c_str());
00627             } catch (NumberFormatException &) {
00628                 MsgHandler::getErrorInstance()->inform("Value of key '" + key + "' is not numeric ('" + value + "') in edge '" + myCurrentEdge->id + "'.");
00629             }
00630         } else if (key=="maxspeed") {
00631             try {
00632                 myCurrentEdge->myMaxSpeed = TplConvert<char>::_2SUMOReal(value.c_str());
00633             } catch (NumberFormatException &) {
00634                 WRITE_WARNING("Value of key '" + key + "' is not numeric ('" + value + "') in edge '" + myCurrentEdge->id + "'.");
00635             }
00636         } else if (key=="junction") {
00637             if ((value == "roundabout") && (myCurrentEdge->myIsOneWay == "")) {
00638                 myCurrentEdge->myIsOneWay = "yes";
00639             }
00640         } else if (key=="oneway") {
00641             myCurrentEdge->myIsOneWay = value;
00642         }
00643     }
00644 }

EdgesHandler& NIImporter_OpenStreetMap::EdgesHandler::operator= ( const EdgesHandler &  s  )  [private]

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

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

Edge* NIImporter_OpenStreetMap::EdgesHandler::myCurrentEdge [private]

The currently built edge.

Definition at line 263 of file NIImporter_OpenStreetMap.h.

Referenced by myEndElement(), and myStartElement().

std::map<std::string, Edge*>& NIImporter_OpenStreetMap::EdgesHandler::myEdgeMap [private]

A map of built edges.

Definition at line 260 of file NIImporter_OpenStreetMap.h.

Referenced by myEndElement().

const std::map<int, NIOSMNode*>& NIImporter_OpenStreetMap::EdgesHandler::myOSMNodes [private]

The previously parsed nodes.

Definition at line 257 of file NIImporter_OpenStreetMap.h.

Referenced by myStartElement().

std::vector<SumoXMLTag> NIImporter_OpenStreetMap::EdgesHandler::myParentElements [private]

The element stack.

Definition at line 266 of file NIImporter_OpenStreetMap.h.

Referenced by myEndElement(), and myStartElement().

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