1 #ifndef _MBXMLUTILSHELPER_DOM_H_
2 #define _MBXMLUTILSHELPER_DOM_H_
4 #include <fmatvec/atom.h>
11 #include <boost/filesystem.hpp>
12 #include <xercesc/dom/DOMErrorHandler.hpp>
13 #include <xercesc/dom/DOMElement.hpp>
14 #include <xercesc/dom/DOMText.hpp>
15 #include <xercesc/dom/DOMLSParser.hpp>
16 #include <xercesc/dom/DOMLocator.hpp>
17 #include <xercesc/dom/DOMUserDataHandler.hpp>
18 #include <xercesc/dom/DOMDocument.hpp>
19 #include <xercesc/util/TransService.hpp>
20 #include <xercesc/util/XMLEntityResolver.hpp>
21 #include <xercesc/framework/psvi/PSVIHandler.hpp>
22 #include <boost/lexical_cast.hpp>
23 #include <boost/container/small_vector.hpp>
24 #include <fmatvec/toString.h>
26 namespace XERCES_CPP_NAMESPACE {
27 class DOMProcessingInstruction;
28 class DOMImplementation;
29 class AbstractDOMParser;
33 template<> std::vector<double> lexical_cast(
const std::string& str);
34 template<> std::vector<std::vector<double>> lexical_cast(
const std::string& str);
35 template<> std::vector<int> lexical_cast(
const std::string& str);
36 template<> std::vector<std::vector<int>> lexical_cast(
const std::string& str);
37 template<>
bool lexical_cast<
bool>(
const std::string& arg);
44 static void check(
const xercesc::DOMElement *me,
const T &value,
int r,
int c);
47 struct CheckSize<std::vector<T>> {
48 static void check(
const xercesc::DOMElement *me,
const std::vector<T> &value,
int r,
int c);
51 struct CheckSize<std::vector<std::vector<T>>> {
52 static void check(
const xercesc::DOMElement *me,
const std::vector<std::vector<T>> &value,
int r,
int c);
57 namespace MBXMLUtils {
61 template<
class T>
using XercesUniquePtr = std::unique_ptr<T, XercesUniquePtrDeleter<T>>;
64 template<
typename DOMDocumentType>
66 template<
typename DOMDocumentType>
68 template<
typename DOMElementType>
70 template<
typename DOMElementType>
77 xercesc::XMLPlatformUtils::Initialize();
80 xercesc::XMLPlatformUtils::Terminate();
88 const XMLCh *operator%(
const std::string &str) {
90 return &xercesc::chNull;
91 const XMLCh *unicode=xercesc::TranscodeFromStr(reinterpret_cast<const XMLByte*>(str.c_str()), str.length(),
"UTF8").adopt();
92 store.emplace_back(unicode, &releaseXMLCh);
95 const XMLCh *operator()(
const std::string &str) {
return operator%(str); }
96 std::string operator%(
const XMLCh *unicode) {
97 if(!unicode || unicode[0]==0)
99 return reinterpret_cast<const char*
>(xercesc::TranscodeToStr(unicode,
"UTF8").str());
101 std::string operator()(
const XMLCh *unicode) {
return operator%(unicode); }
102 static void releaseXMLCh(
const XMLCh *s) { xercesc::XMLPlatformUtils::fgMemoryManager->deallocate(const_cast<XMLCh*>(s)); }
104 boost::container::small_vector<std::unique_ptr<const XMLCh, decltype(&releaseXMLCh)>, 1> store;
109 class FQN :
public std::pair<std::string, std::string> {
114 FQN(
const std::string &name) : std::pair<std::string, std::string>(
"", name) {}
116 FQN(
const char *name) : std::pair<std::string, std::string>(
"", name) {}
118 FQN(
const std::string &ns,
const std::string &name) : std::pair<std::string, std::string>(ns, name) {}
124 NamespaceURI(std::string nsuri_) : nsuri(std::move(nsuri_)) {}
125 FQN operator%(
const std::string &localName)
const {
return {nsuri, localName}; }
126 const std::string& getNamespaceURI()
const {
return nsuri; }
132 const NamespaceURI XINCLUDE(
"http://www.w3.org/2001/XInclude");
134 const NamespaceURI XMLNS(
"http://www.w3.org/2000/xmlns/");
136 const NamespaceURI PV(
"http://www.mbsim-env.de/MBXMLUtils");
138 const NamespaceURI XMLCATALOG(
"urn:oasis:names:tc:entity:xmlns:xml:catalog");
144 EmbedDOMLocator(
const boost::filesystem::path &file_,
int row_,
int embedCount_, std::string xpath_) : DOMLocator(),
145 file(x%file_.string()), row(row_), embedCount(embedCount_), xpath(std::move(xpath_)) {}
147 file(x%(
X()%src.file)), row(src.row), embedCount(src.embedCount), xpath(src.xpath) {}
149 file=x%(
X()%src.file);
151 embedCount=src.embedCount;
158 XMLFileLoc getLineNumber()
const override {
return row; }
159 XMLFileLoc getColumnNumber()
const override {
return 0; }
160 XMLFilePos getByteOffset()
const override {
return ~(XMLFilePos(0)); }
161 XMLFilePos getUtf16Offset()
const override {
return ~(XMLFilePos(0)); }
162 xercesc::DOMNode *getRelatedNode()
const override {
return nullptr; }
163 const XMLCh *getURI()
const override {
return file; }
164 int getEmbedCount()
const {
return embedCount; }
165 const std::string& getRootXPathExpression()
const {
return xpath; }
176 #define RETHROW_AS_DOMEVALEXCEPTION(e) \
177 catch(MBXMLUtils::DOMEvalException &ex) { \
180 catch(const std::exception &ex) { \
181 throw DOMEvalException(ex.what(), e); \
192 void appendContext(
const xercesc::DOMNode *n,
int lineNr=0);
193 const std::string& getMessage()
const {
return errorMsg; }
194 void setMessage(
const std::string& errorMsg_) { errorMsg=errorMsg_; }
195 void setSubsequentError(
bool sse) { subsequentError=sse; }
196 const char* what()
const noexcept
override;
197 xercesc::DOMNode::NodeType getNodeType()
const {
return nodeType; }
199 DOMEvalException(
const std::string &errorMsg_,
const xercesc::DOMLocator &loc);
229 bool subsequentError{
false};
230 std::string errorMsg;
231 std::vector<EmbedDOMLocator> locationStack;
232 mutable std::string whatStr;
233 xercesc::DOMNode::NodeType nodeType {
static_cast<xercesc::DOMNode::NodeType
>(-1) };
241 bool handleError(
const xercesc::DOMError&)
override;
242 bool hasError() {
return errorSet; }
244 void resetError() { errorSet=
false; }
246 bool errorSet{
false};
251 template<
typename DOMElementType>
259 const xercesc::DOMElement *getFirstElementChildNamed(
const FQN &name)
const;
261 xercesc::DOMElement *getFirstElementChildNamed(
const FQN &name);
263 const xercesc::DOMElement *getNextElementSiblingNamed(
const FQN &name)
const;
265 xercesc::DOMElement *getNextElementSiblingNamed(
const FQN &name);
267 const xercesc::DOMProcessingInstruction *getFirstProcessingInstructionChildNamed(
const std::string &target)
const;
269 xercesc::DOMProcessingInstruction *getFirstProcessingInstructionChildNamed(
const std::string &target);
271 void addProcessingInstructionChildNamed(
const std::string &target,
const std::string &data);
273 std::string getEmbedData(
const std::string &name)
const;
276 void addEmbedData(
const std::string &name,
const std::string &data);
278 const xercesc::DOMComment *getFirstCommentChild()
const;
280 xercesc::DOMComment *getFirstCommentChild();
285 const xercesc::DOMText *getFirstTextChild()
const;
290 xercesc::DOMText *getFirstTextChild();
292 template<
class T> T
getText(
int r=0,
int c=0)
const {
294 auto textEle=E(me)->getFirstTextChild();
295 auto text=textEle ?
X()%textEle->getData() :
"";
296 auto ret=boost::lexical_cast<T>(text);
297 CheckSize<T>::check(me, ret, r, c);
300 catch(
const boost::bad_lexical_cast &ex) {
303 catch(
const std::exception &ex) {
308 template<
class T>
void addElementText(
const FQN &name,
const T &value) {
309 xercesc::DOMElement *ele=D(me->getOwnerDocument())->createElement(name);
310 ele->insertBefore(me->getOwnerDocument()->createTextNode(
MBXMLUtils::X()%fmatvec::toString(value)),
nullptr);
311 me->insertBefore(ele,
nullptr);
315 bool isDerivedFrom(
const FQN &baseTypeName)
const;
321 boost::filesystem::path getOriginalFilename(
bool skipThis=
false,
322 const xercesc::DOMElement *&found=DOMElementWrapper<DOMElementType>::dummyArg)
const;
327 void setOriginalFilename(boost::filesystem::path orgFileName=boost::filesystem::path());
330 boost::filesystem::path convertPath(
const boost::filesystem::path &relPath)
const;
333 int getLineNumber()
const;
336 int getEmbedCountNumber()
const;
339 void setEmbedCountNumber(
int embedCount);
342 int getEmbedXPathCount()
const;
345 void setEmbedXPathCount(
int xPathCount);
350 std::string getRootXPathExpression()
const;
353 std::vector<int> getElementLocation()
const;
355 int getOriginalElementLineNumber()
const;
357 void setOriginalElementLineNumber(
int lineNr);
359 std::string getAttribute(
const FQN &name)
const;
361 FQN getAttributeQName(
const FQN &name)
const;
363 const xercesc::DOMAttr* getAttributeNode(
const FQN &name)
const;
365 xercesc::DOMAttr* getAttributeNode(
const FQN &name);
369 me->setAttributeNS(
X()%name.first,
X()%name.second,
X()%fmatvec::toString(value));
372 void setAttribute(
const FQN &name,
const FQN &value);
374 bool hasAttribute(
const FQN &name)
const;
376 void removeAttribute(
const FQN &name);
378 typename std::conditional<std::is_same<DOMElementType, const xercesc::DOMElement>::value,
382 static const xercesc::DOMElement *dummyArg;
387 template<
typename DOMElementType>
388 DOMElementWrapper<DOMElementType> E(DOMElementType *me) {
return DOMElementWrapper<DOMElementType>(me); }
390 template<
typename DOMElementType>
391 DOMElementWrapper<DOMElementType> E(
const std::shared_ptr<DOMElementType> &me) {
return DOMElementWrapper<DOMElementType>(me.get()); }
393 template<
typename DOMElementType>
394 DOMElementWrapper<DOMElementType> E(
const XercesUniquePtr<DOMElementType> &me) {
return DOMElementWrapper<DOMElementType>(me.get()); }
396 template<>
const xercesc::DOMElement *DOMElementWrapper< xercesc::DOMElement>::dummyArg;
397 template<>
const xercesc::DOMElement *DOMElementWrapper<const xercesc::DOMElement>::dummyArg;
400 template<
typename DOMAttrType>
407 bool isDerivedFrom(
const FQN &baseTypeName)
const;
410 std::string getRootXPathExpression()
const;
412 typename std::conditional<std::is_same<DOMAttrType, const xercesc::DOMAttr>::value,
420 template<
typename DOMAttrType>
421 DOMAttrWrapper<DOMAttrType> A(DOMAttrType *me) {
return DOMAttrWrapper<DOMAttrType>(me); }
423 template<
typename DOMAttrType>
424 DOMAttrWrapper<DOMAttrType> A(
const std::shared_ptr<DOMAttrType> &me) {
return DOMAttrWrapper<DOMAttrType>(me.get()); }
426 template<
typename DOMAttrType>
427 DOMAttrWrapper<DOMAttrType> A(
const XercesUniquePtr<DOMAttrType> &me) {
return DOMAttrWrapper<DOMAttrType>(me.get()); }
432 template<
typename DOMDocumentType>
433 class DOMDocumentWrapper {
441 XercesUniquePtr<xercesc::DOMElement> validate();
444 xercesc::DOMElement* createElement(
const FQN &name);
446 std::shared_ptr<DOMParser> getParser()
const;
449 boost::filesystem::path getDocumentFilename()
const;
454 xercesc::DOMNode* evalRootXPathExpression(std::string xpathExpression, xercesc::DOMElement* context=
nullptr);
457 xercesc::DOMElement* locateElement(
const std::vector<int> &idx)
const;
459 typename std::conditional<std::is_same<DOMDocumentType, const xercesc::DOMDocument>::value,
467 template<
typename DOMDocumentType>
468 DOMDocumentWrapper<DOMDocumentType> D(DOMDocumentType *me) {
return DOMDocumentWrapper<DOMDocumentType>(me); }
470 template<
typename DOMDocumentType>
471 DOMDocumentWrapper<DOMDocumentType> D(
const std::shared_ptr<DOMDocumentType> &me) {
return DOMDocumentWrapper<DOMDocumentType>(me.get()); }
473 template<
typename DOMDocumentType>
474 DOMDocumentWrapper<DOMDocumentType> D(
const XercesUniquePtr<DOMDocumentType> &me) {
return DOMDocumentWrapper<DOMDocumentType>(me.get()); }
478 void setParser(
DOMParser *parser_) { parser=parser_; }
479 xercesc::DOMLSParserFilter::FilterAction acceptNode(xercesc::DOMNode *n)
override;
480 xercesc::DOMLSParserFilter::FilterAction startElement(xercesc::DOMElement *e)
override;
481 xercesc::DOMNodeFilter::ShowType getWhatToShow()
const override;
488 void setParser(
DOMParser *parser_) { parser=parser_; }
489 void handleElementPSVI(
const XMLCh *localName,
const XMLCh *uri, xercesc::PSVIElement *info)
override;
490 void handleAttributesPSVI(
const XMLCh *localName,
const XMLCh *uri, xercesc::PSVIAttributeList *psviAttributes)
override;
497 void handle(DOMOperationType operation,
const XMLCh* key,
void *data,
const xercesc::DOMNode *src, xercesc::DOMNode *dst)
override;
504 void setParser(
DOMParser *parser_) { parser=parser_; }
505 xercesc::InputSource* resolveEntity(xercesc::XMLResourceIdentifier *resourceIdentifier)
override;
511 class DOMParser :
public std::enable_shared_from_this<DOMParser> {
523 static std::shared_ptr<DOMParser> create(const std::variant<boost::filesystem::path, xercesc::DOMElement*> &xmlCatalog=static_cast<xercesc::DOMElement*>(nullptr));
527 std::shared_ptr<xercesc::DOMDocument> parse(const boost::filesystem::path &inputSource,
528 std::vector<boost::filesystem::path> *dependencies=nullptr,
529 bool doXInclude=true);
532 static void serialize(xercesc::DOMNode *n, const boost::filesystem::path &outputSource);
535 static void serializeToString(xercesc::DOMNode *n, std::string &outputData);
537 void resetCachedGrammarPool();
539 std::shared_ptr<xercesc::DOMDocument> createDocument();
541 const std::map<FQN, xercesc::XSTypeDefinition*>& getTypeMap() const {
return typeMap; }
543 xercesc::DOMImplementation *domImpl;
544 DOMParser(
const std::variant<boost::filesystem::path, xercesc::DOMElement*> &xmlCatalog);
545 std::shared_ptr<xercesc::DOMLSParser> parser;
546 std::map<FQN, xercesc::XSTypeDefinition*> typeMap;
551 std::map<std::string, boost::filesystem::path> registeredGrammar;
553 static void handleXInclude(xercesc::DOMElement *&e, std::vector<boost::filesystem::path> *dependencies);
561 void CheckSize<T>::check(
const xercesc::DOMElement *me,
const T &value,
int r,
int c) {}
563 void CheckSize<std::vector<T>>::check(
const xercesc::DOMElement *me,
const std::vector<T> &value,
int r,
int c) {
564 if(r!=0 && r!=static_cast<int>(value.size()))
566 " but got vector of size "+fmatvec::toString(value.size())+
".", me);
569 void CheckSize<std::vector<std::vector<T>>>::check(
const xercesc::DOMElement *me,
const std::vector<std::vector<T>> &value,
int r,
int c) {
570 if(r!=0 && r!=static_cast<int>(value.size()))
572 " but got matrix of row-size "+fmatvec::toString(value.size())+
".", me);
573 if(!value.empty() && c!=0 && c!=
static_cast<int>(value[0].size()))
575 " but got matrix of col-size "+fmatvec::toString(value[0].size())+
".", me);
FQN(const char *name)
Anonymous FQN (required for implicit casting of string literals to anonymous FQNs) ...
Definition: dom.h:116
std::conditional< std::is_same< DOMElementType, const xercesc::DOMElement >::value, const DOMElementWrapper *, DOMElementWrapper * >::type operator->()
Treat this object as a pointer (like DOMElement*)
Definition: dom.h:379
Helper class to easily construct full qualified XML names (FQN) using XML namespace prefixes...
Definition: dom.h:122
FQN(const std::string &ns, const std::string &name)
FQN.
Definition: dom.h:118
FQN(const std::string &name)
Anonymous FQN.
Definition: dom.h:114
void setAttribute(const FQN &name, const T &value)
Set attribute.
Definition: dom.h:368
Helper class for extending DOMDocument (use the function D(...)).
Definition: dom.h:65
DOMElementWrapper(DOMElementType *me_)
Wrap DOMElement to my special element.
Definition: dom.h:255
Initialize Xerces on load and terminate it on unload of the library/program.
Definition: dom.h:74
T getText(int r=0, int c=0) const
Get the child text as type T.
Definition: dom.h:292
FQN getTagName() const
Get full qualified tag name.
Definition: dom.h:257
Helper class for extending DOMAttr (use the function A(...)).
Definition: dom.h:401
static std::string convertToString(const EmbedDOMLocator &loc, const std::string &message, bool subsequentError=false)
Definition: dom.cc:934
Print DOM error messages.
Definition: dom.h:237
Helper class for extending DOMElement (use the function E(...)).
Definition: dom.h:69
A XML DOM parser.
Definition: dom.h:511
std::conditional< std::is_same< DOMAttrType, const xercesc::DOMAttr >::value, const DOMAttrWrapper *, DOMAttrWrapper * >::type operator->()
Treat this object as a pointer (like DOMAttr*)
Definition: dom.h:413
DOMAttrWrapper(DOMAttrType *me_)
Wrap DOMAttr to my special element.
Definition: dom.h:404
DOMDocumentWrapper(DOMDocumentType *me_)
Wrap DOMDocument to my special element.
Definition: dom.h:436
std::conditional< std::is_same< DOMDocumentType, const xercesc::DOMDocument >::value, const DOMDocumentWrapper *, DOMDocumentWrapper * >::type operator->()
Treat this object as a pointer (like DOMDocument*)
Definition: dom.h:460