Eclipse SUMO - Simulation of Urban MObility
SUMOSAXReader.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2012-2022 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
20// SAX-reader encapsulation
21/****************************************************************************/
22#include <config.h>
23
24#include <string>
25#include <memory>
26#include <iostream>
27#include <xercesc/sax2/XMLReaderFactory.hpp>
28#include <xercesc/framework/LocalFileInputSource.hpp>
29#include <xercesc/framework/MemBufInputSource.hpp>
30
35#include "GenericSAXHandler.h"
36#ifdef HAVE_ZLIB
37#include <foreign/zstr/zstr.hpp>
38#endif
39#include "IStreamInputSource.h"
40#include "SUMOSAXReader.h"
41
42using XERCES_CPP_NAMESPACE::SAX2XMLReader;
43using XERCES_CPP_NAMESPACE::XMLUni;
44
45
46// ===========================================================================
47// method definitions
48// ===========================================================================
49SUMOSAXReader::SUMOSAXReader(GenericSAXHandler& handler, const std::string& validationScheme, XERCES_CPP_NAMESPACE::XMLGrammarPool* grammarPool)
50 : myHandler(nullptr), myValidationScheme(validationScheme), myGrammarPool(grammarPool), myXMLReader(nullptr),
51 myIStream(nullptr), myInputStream(nullptr), mySchemaResolver(true, false), myLocalResolver(false, false), myNoOpResolver(false, true), myNextSection(-1, nullptr) {
52 setHandler(handler);
53}
54
55
57 delete myXMLReader;
58 delete myNextSection.second;
59}
60
61
62void
64 myHandler = &handler;
65 if (myXMLReader != nullptr) {
66 myXMLReader->setContentHandler(&handler);
67 myXMLReader->setErrorHandler(&handler);
68 }
69}
70
71
72void
73SUMOSAXReader::setValidation(std::string validationScheme) {
74 // The settings ensure that by default (validationScheme "local" or "never") no network access occurs
75 // this is achieved by either resolving no entities at all (myNoOpResolver) or resolving only
76 // to local files (myLocalResolver). Thus we can safely disable the Sonar warnings in the parse methods below.
77 if (myXMLReader != nullptr && validationScheme != myValidationScheme) {
78 if (validationScheme == "") {
79 validationScheme = myValidationScheme;
80 }
81 // see here https://svn.apache.org/repos/asf/xerces/c/trunk/samples/src/SAX2Count/SAX2Count.cpp for the way to set features
82 if (validationScheme == "never") {
83 myXMLReader->setEntityResolver(&myNoOpResolver);
84 myXMLReader->setProperty(XMLUni::fgXercesScannerName, (void*)XMLUni::fgWFXMLScanner);
85 } else {
86 myXMLReader->setEntityResolver(validationScheme == "local" ? &myLocalResolver : &mySchemaResolver);
87 myXMLReader->setProperty(XMLUni::fgXercesScannerName, (void*)XMLUni::fgIGXMLScanner);
88 myXMLReader->setFeature(XMLUni::fgXercesSchema, true);
89 myXMLReader->setFeature(XMLUni::fgSAX2CoreValidation, true);
90 myXMLReader->setFeature(XMLUni::fgXercesDynamic, validationScheme == "local" || validationScheme == "auto");
91 myXMLReader->setFeature(XMLUni::fgXercesUseCachedGrammarInParse, myValidationScheme == "always");
92 }
93 }
94 myValidationScheme = validationScheme;
95}
96
97
98void
99SUMOSAXReader::parse(std::string systemID) {
100 if (!FileHelpers::isReadable(systemID)) {
101 throw ProcessError("Cannot read file '" + systemID + "'!");
102 }
103 if (FileHelpers::isDirectory(systemID)) {
104 throw ProcessError("File '" + systemID + "' is a directory!");
105 }
107#ifdef HAVE_ZLIB
108 zstr::ifstream istream(StringUtils::transcodeToLocal(systemID).c_str(), std::fstream::in | std::fstream::binary);
109 myXMLReader->parse(IStreamInputSource(istream)); // NOSONAR
110#else
111 myXMLReader->parse(StringUtils::transcodeToLocal(systemID).c_str()); // NOSONAR
112#endif
113}
114
115
116void
117SUMOSAXReader::parseString(std::string content) {
119 XERCES_CPP_NAMESPACE::MemBufInputSource memBufIS((const XMLByte*)content.c_str(), content.size(), "registrySettings");
120 myXMLReader->parse(memBufIS); // NOSONAR
121}
122
123
124bool
125SUMOSAXReader::parseFirst(std::string systemID) {
126 if (!FileHelpers::isReadable(systemID)) {
127 throw ProcessError("Cannot read file '" + systemID + "'!");
128 }
129 if (FileHelpers::isDirectory(systemID)) {
130 throw ProcessError("File '" + systemID + "' is a directory!");
131 }
133 myToken = XERCES_CPP_NAMESPACE::XMLPScanToken();
134#ifdef HAVE_ZLIB
135 myIStream = std::unique_ptr<zstr::ifstream>(new zstr::ifstream(StringUtils::transcodeToLocal(systemID).c_str(), std::fstream::in | std::fstream::binary));
136 myInputStream = std::unique_ptr<IStreamInputSource>(new IStreamInputSource(*myIStream));
137 return myXMLReader->parseFirst(*myInputStream, myToken); // NOSONAR
138#else
139 return myXMLReader->parseFirst(StringUtils::transcodeToLocal(systemID).c_str(), myToken); // NOSONAR
140#endif
141}
142
143
144bool
146 if (myXMLReader == nullptr) {
147 throw ProcessError("The XML-parser was not initialized.");
148 }
149 return myXMLReader->parseNext(myToken);
150}
151
152
153bool
155 if (myXMLReader == nullptr) {
156 throw ProcessError("The XML-parser was not initialized.");
157 }
158 bool started = false;
159 if (myNextSection.first != -1) {
160 started = myNextSection.first == element;
162 delete myNextSection.second;
163 myNextSection.first = -1;
164 myNextSection.second = nullptr;
165 }
166 myHandler->setSection(element, started);
167 while (!myHandler->sectionFinished()) {
168 if (!myXMLReader->parseNext(myToken)) {
169 return false;
170 }
171 }
173 return true;
174}
175
176
177void
179 if (myXMLReader == nullptr) {
180 myXMLReader = XERCES_CPP_NAMESPACE::XMLReaderFactory::createXMLReader(XERCES_CPP_NAMESPACE::XMLPlatformUtils::fgMemoryManager, myGrammarPool);
181 if (myXMLReader == nullptr) {
182 throw ProcessError("The XML-parser could not be build.");
183 }
185 myXMLReader->setContentHandler(myHandler);
186 myXMLReader->setErrorHandler(myHandler);
187 }
188}
189
190
191XERCES_CPP_NAMESPACE::InputSource*
192SUMOSAXReader::LocalSchemaResolver::resolveEntity(const XMLCh* const /* publicId */, const XMLCh* const systemId) {
193 if (myNoOp) {
194 return new XERCES_CPP_NAMESPACE::MemBufInputSource((const XMLByte*)"", 0, "");
195 }
196 const std::string url = StringUtils::transcode(systemId);
197 const std::string::size_type pos = url.find("/xsd/");
198 if (pos != std::string::npos) {
199 const char* sumoPath = std::getenv("SUMO_HOME");
200 // no need for a warning if SUMO_HOME is not set, global preparsing should have done it.
201 if (sumoPath != nullptr) {
202 const std::string file = sumoPath + std::string("/data") + url.substr(pos);
203 if (FileHelpers::isReadable(file)) {
204 XMLCh* t = XERCES_CPP_NAMESPACE::XMLString::transcode(file.c_str());
205 XERCES_CPP_NAMESPACE::InputSource* const result = new XERCES_CPP_NAMESPACE::LocalFileInputSource(t);
206 XERCES_CPP_NAMESPACE::XMLString::release(&t);
207 return result;
208 } else {
209 WRITE_WARNING("Cannot read local schema '" + file + (myHaveFallback ? "', will try website lookup." : "', XML validation will fail."));
210 }
211 }
212 }
213 if (myHaveFallback || (!StringUtils::startsWith(url, "http:") && !StringUtils::startsWith(url, "https:") && !StringUtils::startsWith(url, "ftp:"))) {
214 return nullptr;
215 }
216 return new XERCES_CPP_NAMESPACE::MemBufInputSource((const XMLByte*)"", 0, "");
217}
218
219
220/****************************************************************************/
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
static bool isReadable(std::string path)
Checks whether the given file is readable.
Definition: FileHelpers.cpp:51
static bool isDirectory(std::string path)
Checks whether the given file is a directory.
Definition: FileHelpers.cpp:65
A handler which converts occuring elements and attributes into enums.
bool sectionFinished() const
void setSection(const int element, const bool seen)
std::pair< int, SUMOSAXAttributes * > retrieveNextSectionStart()
virtual void myStartElement(int element, const SUMOSAXAttributes &attrs)
Callback method for an opening tag to implement by derived classes.
Xerces InputSource reading from arbitrary std::istream.
XERCES_CPP_NAMESPACE::InputSource * resolveEntity(const XMLCh *const publicId, const XMLCh *const systemId)
bool parseSection(int element)
Continue a progressive parse started by parseFirst until the given element is encountered.
std::unique_ptr< IStreamInputSource > myInputStream
std::string myValidationScheme
Information whether built reader/parser shall validate XML-documents against schemata.
SUMOSAXReader(GenericSAXHandler &handler, const std::string &validationScheme, XERCES_CPP_NAMESPACE::XMLGrammarPool *grammarPool)
Constructor.
std::pair< int, SUMOSAXAttributes * > myNextSection
void setHandler(GenericSAXHandler &handler)
Sets the given handler as content and error handler for the reader.
void parseString(std::string content)
Parse XML from the given string.
LocalSchemaResolver myLocalResolver
bool parseFirst(std::string systemID)
Start parsing the given file using parseFirst of myXMLReader.
std::unique_ptr< std::istream > myIStream
LocalSchemaResolver mySchemaResolver
void setValidation(std::string validationScheme="")
Sets a new validation scheme and applies the validation settings to the XML reader.
~SUMOSAXReader()
Destructor.
GenericSAXHandler * myHandler
void parse(std::string systemID)
Parse the given file completely by calling parse of myXMLReader.
XERCES_CPP_NAMESPACE::SAX2XMLReader * myXMLReader
LocalSchemaResolver myNoOpResolver
XERCES_CPP_NAMESPACE::XMLGrammarPool * myGrammarPool
Schema cache to be used for grammars which are not declared.
XERCES_CPP_NAMESPACE::XMLPScanToken myToken
void ensureSAXReader()
Builds a reader, if needed.
bool parseNext()
Continue a progressive parse started by parseFirst.
static bool startsWith(const std::string &str, const std::string prefix)
Checks whether a given string starts with the prefix.
static std::string transcode(const XMLCh *const data)
converts a 0-terminated XMLCh* array (usually UTF-16, stemming from Xerces) into std::string in UTF-8
Definition: StringUtils.h:140
static std::string transcodeToLocal(const std::string &utf8String)
convert a string from UTF-8 to the local codepage