NIXMLConnectionsHandler Class Reference

#include <NIXMLConnectionsHandler.h>

Inheritance diagram for NIXMLConnectionsHandler:

SUMOSAXHandler GenericSAXHandler

Detailed Description

Importer for edge connections stored in XML.

This importer parses connections, and prohibitions, and is able to reset connections between edges.

Definition at line 53 of file NIXMLConnectionsHandler.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
 NIXMLConnectionsHandler (NBEdgeCont &ec) throw ()
 Constructor.
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.
 ~NIXMLConnectionsHandler () 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.
virtual void myEndElement (SumoXMLTag element) throw (ProcessError)
 Callback method for a closing tag to implement by derived classes.
inherited from GenericSAXHandler
void myStartElement (SumoXMLTag element, const SUMOSAXAttributes &attrs) throw (ProcessError)
 Called on the opening of a tag;.

Private Member Functions

 NIXMLConnectionsHandler (const NIXMLConnectionsHandler &s)
 invalidated copy constructor
NIXMLConnectionsHandler & operator= (const NIXMLConnectionsHandler &s)
 invalidated assignment operator
NBConnection parseConnection (const std::string &defRole, const std::string &def) throw ()
 Returns the connection described by def.
void parseLaneBound (const SUMOSAXAttributes &attrs, NBEdge *from, NBEdge *to) throw ()
 Parses a connection when it describes a lane-2-lane relationship.

Private Attributes

NBEdgeCont & myEdgeCont
 The edge container to fill.
bool myHaveReportedAboutFunctionDeprecation
 Whether an information about an occured, deprecated attributes has bee printed.

Constructor & Destructor Documentation

NIXMLConnectionsHandler::NIXMLConnectionsHandler ( NBEdgeCont &  ec  )  throw ()

Constructor.

Parameters:
[in] ec The edge container which includes the edges to change connections of

Definition at line 57 of file NIXMLConnectionsHandler.cpp.

00058         : SUMOSAXHandler("xml-connection-description"), myEdgeCont(ec),
00059         myHaveReportedAboutFunctionDeprecation(false) {}

NIXMLConnectionsHandler::~NIXMLConnectionsHandler (  )  throw ()

Destructor.

Definition at line 62 of file NIXMLConnectionsHandler.cpp.

00062 {}

NIXMLConnectionsHandler::NIXMLConnectionsHandler ( const NIXMLConnectionsHandler &  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 GenericSAXHandler::myEndElement ( SumoXMLTag  element  )  throw (ProcessError) [protected, virtual, inherited]

Callback method for a closing tag to implement by derived classes.

Called by "endElement" (see there).

Parameters:
[in] element The closed element, given as a SumoXMLTag ProcessError These method may throw a ProcessError if something fails

Reimplemented in MSRouteHandler, MSLaneSpeedTrigger, MSTriggeredRerouter, NIImporter_OpenDrive, NIImporter_OpenStreetMap::NodesHandler, NIImporter_OpenStreetMap::EdgesHandler, NIImporter_SUMO, NIXMLEdgesHandler, NLHandler, ODDistrictHandler, PCLoaderOSM::NodesHandler, PCLoaderOSM::EdgesHandler, RORDGenerator_ODAmounts, RORDLoader_SUMOBase, RORDLoader_TripDefs, traci::TraCIHandler, and SAXWeightsHandler.

Definition at line 193 of file GenericSAXHandler.cpp.

Referenced by GenericSAXHandler::endElement().

00193 {}

void NIXMLConnectionsHandler::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 66 of file NIXMLConnectionsHandler.cpp.

References NBEdge::addEdge2EdgeConnection(), NBNode::addSortedLinkFoes(), MsgHandler::getErrorInstance(), NBConnection::getFrom(), NBEdge::getToNode(), MsgHandler::getWarningInstance(), MsgHandler::inform(), myEdgeCont, myHaveReportedAboutFunctionDeprecation, parseConnection(), parseLaneBound(), NBEdge::removeFromConnections(), NBEdgeCont::retrieve(), SUMO_ATTR_FROM, SUMO_ATTR_LANE, SUMO_ATTR_PROHIBITED, SUMO_ATTR_PROHIBITOR, SUMO_ATTR_TO, SUMO_ATTR_TYPE, SUMO_TAG_CONNECTION, SUMO_TAG_PROHIBITION, and SUMO_TAG_RESET.

00067                                                                                             {
00068     if (element==SUMO_TAG_RESET) {
00069         bool ok = true;
00070         std::string from = attrs.getStringReporting(SUMO_ATTR_FROM, "reset", 0, ok);
00071         std::string to = attrs.getStringReporting(SUMO_ATTR_TO, "reset", 0, ok);
00072         if (!ok) {
00073             return;
00074         }
00075         NBEdge *fromEdge = myEdgeCont.retrieve(from);
00076         NBEdge *toEdge = myEdgeCont.retrieve(to);
00077         if (fromEdge==0) {
00078             MsgHandler::getErrorInstance()->inform("The connection-source edge '" + from + "' to reset is not known.");
00079             return;
00080         }
00081         if (toEdge==0) {
00082             MsgHandler::getErrorInstance()->inform("The connection-destination edge '" + to + "' to reset is not known.");
00083             return;
00084         }
00085         fromEdge->removeFromConnections(toEdge);
00086     }
00087 
00088     if (element==SUMO_TAG_CONNECTION) {
00089         bool ok = true;
00090         std::string from = attrs.getOptStringReporting(SUMO_ATTR_FROM, "connection", 0, ok, "");
00091         std::string to = attrs.getOptStringReporting(SUMO_ATTR_TO, "connection", 0, ok, "");
00092         std::string laneConn = attrs.getOptStringReporting(SUMO_ATTR_LANE, "connection", 0, ok, "");
00093         if (!ok) {
00094             return;
00095         }
00096         if (from.length()==0) {
00097             MsgHandler::getErrorInstance()->inform("A from-edge is not specified within one of the connections");
00098             return;
00099         }
00100         // extract edges
00101         NBEdge *fromEdge = myEdgeCont.retrieve(from);
00102         NBEdge *toEdge = to.length()!=0 ? myEdgeCont.retrieve(to) : 0;
00103         // check whether they are valid
00104         if (fromEdge==0) {
00105             MsgHandler::getErrorInstance()->inform("The connection-source edge '" + from + "' is not known.");
00106             return;
00107         }
00108         if (toEdge==0 && to.length()!=0) {
00109             MsgHandler::getErrorInstance()->inform("The connection-destination edge '" + to + "' is not known.");
00110             return;
00111         }
00112         // parse optional lane information
00113         if (!myHaveReportedAboutFunctionDeprecation&&attrs.hasAttribute(SUMO_ATTR_TYPE)) {
00114             MsgHandler::getWarningInstance()->inform("While parsing connections: 'type' is deprecated.\n All occurences are ignored.");
00115             myHaveReportedAboutFunctionDeprecation = true;
00116         }
00117         if (laneConn=="") {
00118             fromEdge->addEdge2EdgeConnection(toEdge);
00119         } else {
00120             parseLaneBound(attrs, fromEdge, toEdge);
00121         }
00122     }
00123     if (element==SUMO_TAG_PROHIBITION) {
00124         bool ok = true;
00125         std::string prohibitor = attrs.getOptStringReporting(SUMO_ATTR_PROHIBITOR, "prohibition", 0, ok, "");
00126         std::string prohibited = attrs.getOptStringReporting(SUMO_ATTR_PROHIBITED, "prohibition", 0, ok, "");
00127         if (!ok) {
00128             return;
00129         }
00130         NBConnection prohibitorC = parseConnection("prohibitor", prohibitor);
00131         NBConnection prohibitedC = parseConnection("prohibited", prohibited);
00132         if (prohibitorC.getFrom()==0||prohibitedC.getFrom()==0) {
00133             // something failed
00134             return;
00135         }
00136         NBNode *n = prohibitorC.getFrom()->getToNode();
00137         n->addSortedLinkFoes(prohibitorC, prohibitedC);
00138     }
00139 }

NIXMLConnectionsHandler& NIXMLConnectionsHandler::operator= ( const NIXMLConnectionsHandler &  s  )  [private]

invalidated assignment operator

NBConnection NIXMLConnectionsHandler::parseConnection ( const std::string &  defRole,
const std::string &  def 
) throw () [private]

Returns the connection described by def.

def should have the following format <FROM_EDGE_ID>[_<FROM_LANE_NO>]-><TO_EDGE_ID>[_<TO_LANE_NO>].

Parameters:
[in] defRole "prohibitor" or "prohibited" - used for error reporting
[in] def The definition of the connection
Returns:
The parsed connection

Definition at line 143 of file NIXMLConnectionsHandler.cpp.

References MsgHandler::getErrorInstance(), MsgHandler::inform(), myEdgeCont, and NBEdgeCont::retrieve().

Referenced by myStartElement().

00144                                       {
00145     // split from/to
00146     size_t div = def.find("->");
00147     if (div==std::string::npos) {
00148         MsgHandler::getErrorInstance()->inform("Missing connection divider in " + defRole + " '" + def + "'");
00149         return NBConnection(0, 0);
00150     }
00151     std::string fromDef = def.substr(0, div);
00152     std::string toDef = def.substr(div+2);
00153 
00154     // retrieve the edges
00155     // check whether the definition includes a lane information (do not process it)
00156     if (fromDef.find('_')!=std::string::npos) {
00157         fromDef = fromDef.substr(0, fromDef.find('_'));
00158     }
00159     if (toDef.find('_')!=std::string::npos) {
00160         toDef = toDef.substr(0, toDef.find('_'));
00161     }
00162     // retrieve them now
00163     NBEdge *fromE = myEdgeCont.retrieve(fromDef);
00164     NBEdge *toE = myEdgeCont.retrieve(toDef);
00165     // check
00166     if (fromE==0) {
00167         MsgHandler::getErrorInstance()->inform("Could not find edge '" + fromDef + "' in " + defRole + " '" + def + "'");
00168         return NBConnection(0, 0);
00169     }
00170     if (toE==0) {
00171         MsgHandler::getErrorInstance()->inform("Could not find edge '" + toDef + "' in " + defRole + " '" + def + "'");
00172         return NBConnection(0, 0);
00173     }
00174     return NBConnection(fromE, toE);
00175 }

void NIXMLConnectionsHandler::parseLaneBound ( const SUMOSAXAttributes &  attrs,
NBEdge *  from,
NBEdge *  to 
) throw () [private]

Parses a connection when it describes a lane-2-lane relationship.

Parameters:
[in] attrs The attributes to get further information about the connection from
[in] from The edge at which the connection starts (the on incoming into a node)
[in] to The edge at which the connection ends (the on outgoing from a node)

Definition at line 179 of file NIXMLConnectionsHandler.cpp.

References TplConvertSec< E >::_2intSec(), NBEdge::addLane2LaneConnection(), MsgHandler::getErrorInstance(), NBEdge::getID(), NBNode::getOutgoingEdges(), NBEdge::getToNode(), MsgHandler::inform(), NBEdge::L2L_USER, StringTokenizer::next(), StringTokenizer::size(), SUMO_ATTR_LANE, SUMO_ATTR_PASS, SUMO_ATTR_UNCONTROLLED, toString(), and WRITE_WARNING.

Referenced by myStartElement().

00181                                                             {
00182     if (to==0) {
00183         // do nothing if it's a dead end
00184         return;
00185     }
00186     bool ok = true;
00187     std::string laneConn = attrs.getOptStringReporting(SUMO_ATTR_LANE, "connection", 0, ok, "");
00188     // split the information
00189     StringTokenizer st(laneConn, ':');
00190     if (st.size()!=2) {
00191         MsgHandler::getErrorInstance()->inform("Invalid lane to lane connection from '" +
00192                                                from->getID() + "' to '" + to->getID() + "'.");
00193         return;
00194     }
00195     bool mayDefinitelyPass = attrs.getOptBoolReporting(SUMO_ATTR_PASS, "connection", 0, ok, false);
00196     if (!ok) {
00197         return;
00198     }
00199     // get the begin and the end lane
00200     int fromLane;
00201     int toLane;
00202     try {
00203         fromLane = TplConvertSec<char>::_2intSec(st.next().c_str(), -1);
00204         toLane = TplConvertSec<char>::_2intSec(st.next().c_str(), -1);
00205         if (fromLane<0 || fromLane>=from->getNoLanes() || toLane<0 || toLane>=to->getNoLanes()) {
00206             MsgHandler::getErrorInstance()->inform("False lane index in connection from '" + from->getID() + "' to '" + to->getID() + "'.");
00207             return;
00208         }
00209         if (from->hasConnectionTo(to, toLane)) {
00210             WRITE_WARNING("Target lane '" + to->getID() + "_" + toString(toLane) + "' is already connected from '" + from->getID() + "'.");
00211         }
00212         if (!from->addLane2LaneConnection(fromLane, to, toLane, NBEdge::L2L_USER, true, mayDefinitelyPass)) {
00213             NBEdge *nFrom = from;
00214             bool toNext = true;
00215             do {
00216                 if (nFrom->getToNode()->getOutgoingEdges().size()!=1) {
00217                     toNext = false;
00218                     break;
00219                 }
00220                 NBEdge *t = nFrom->getToNode()->getOutgoingEdges()[0];
00221                 if (t->getID().substr(0, t->getID().find('/'))!=nFrom->getID().substr(0, nFrom->getID().find('/'))) {
00222                     toNext = false;
00223                     break;
00224                 }
00225                 if (toNext) {
00226                     nFrom = t;
00227                 }
00228             } while (toNext);
00229             if (nFrom==0||!nFrom->addLane2LaneConnection(fromLane, to, toLane, NBEdge::L2L_USER, false, mayDefinitelyPass)) {
00230                 WRITE_WARNING("Could not set loaded connection from '" + from->getID() + "_" + toString<int>(fromLane) + "' to '" + to->getID() + "_" + toString<int>(toLane) + "'.");
00231             } else {
00232                 from = nFrom;
00233             }
00234         }
00235     } catch (NumberFormatException &) {
00236         MsgHandler::getErrorInstance()->inform("At least one of the defined lanes was not numeric");
00237     }
00238     //
00239     bool keepUncontrolled = attrs.getOptBoolReporting(SUMO_ATTR_UNCONTROLLED, 0, 0, ok, false);
00240     if (keepUncontrolled) {
00241         from->disableConnection4TLS(fromLane, to, toLane);
00242     }
00243 }

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

NBEdgeCont& NIXMLConnectionsHandler::myEdgeCont [private]

The edge container to fill.

Definition at line 106 of file NIXMLConnectionsHandler.h.

Referenced by myStartElement(), and parseConnection().

bool NIXMLConnectionsHandler::myHaveReportedAboutFunctionDeprecation [private]

Whether an information about an occured, deprecated attributes has bee printed.

Definition at line 103 of file NIXMLConnectionsHandler.h.

Referenced by myStartElement().

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