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 <fmatvec/toString.h> 25 namespace XERCES_CPP_NAMESPACE {
26 class DOMProcessingInstruction;
27 class DOMImplementation;
28 class AbstractDOMParser;
32 template<> std::vector<double> lexical_cast(
const std::string& str);
33 template<> std::vector<std::vector<double>> lexical_cast(
const std::string& str);
34 template<> std::vector<int> lexical_cast(
const std::string& str);
35 template<> std::vector<std::vector<int>> lexical_cast(
const std::string& str);
36 template<>
bool lexical_cast<bool>(
const std::string& arg);
43 static void check(
const xercesc::DOMElement *me,
const T &value,
int r,
int c);
46 struct CheckSize<std::vector<T>> {
47 static void check(
const xercesc::DOMElement *me,
const std::vector<T> &value,
int r,
int c);
50 struct CheckSize<std::vector<std::vector<T>>> {
51 static void check(
const xercesc::DOMElement *me,
const std::vector<std::vector<T>> &value,
int r,
int c);
56 namespace MBXMLUtils {
59 template<
typename DOMDocumentType>
61 template<
typename DOMDocumentType>
63 template<
typename DOMElementType>
65 template<
typename DOMElementType>
72 xercesc::XMLPlatformUtils::Initialize();
75 xercesc::XMLPlatformUtils::Terminate();
83 const XMLCh *operator%(
const std::string &str) {
85 return &xercesc::chNull;
86 const XMLCh *unicode=xercesc::TranscodeFromStr(reinterpret_cast<const XMLByte*>(str.c_str()), str.length(),
"UTF8").adopt();
87 store.push_back(std::shared_ptr<const XMLCh>(unicode, &releaseXMLCh));
90 const XMLCh *operator()(
const std::string &str) {
return operator%(str); }
91 std::string operator%(
const XMLCh *unicode) {
92 if(!unicode || unicode[0]==0)
94 return reinterpret_cast<const char*>(xercesc::TranscodeToStr(unicode,
"UTF8").str());
96 std::string operator()(
const XMLCh *unicode) {
return operator%(unicode); }
97 static void releaseXMLCh(
const XMLCh *s) { xercesc::XMLPlatformUtils::fgMemoryManager->deallocate(const_cast<XMLCh*>(s)); }
99 std::vector<std::shared_ptr<const XMLCh> > store;
104 class FQN :
public std::pair<std::string, std::string> {
109 FQN(
const std::string &name) : std::pair<std::string, std::string>(
"", name) {}
111 FQN(
const char *name) : std::pair<std::string, std::string>(
"", name) {}
113 FQN(
const std::string &ns,
const std::string &name) : std::pair<std::string, std::string>(ns, name) {}
119 NamespaceURI(std::string nsuri_) : nsuri(std::move(nsuri_)) {}
120 FQN operator%(
const std::string &localName)
const {
return FQN(nsuri, localName); }
121 std::string getNamespaceURI()
const {
return nsuri; }
127 const NamespaceURI XINCLUDE(
"http://www.w3.org/2001/XInclude");
129 const NamespaceURI XMLNS(
"http://www.w3.org/2000/xmlns/");
131 const NamespaceURI PV(
"http://www.mbsim-env.de/MBXMLUtils");
133 const NamespaceURI XMLCATALOG(
"urn:oasis:names:tc:entity:xmlns:xml:catalog");
139 EmbedDOMLocator(
const boost::filesystem::path &file_,
int row_,
int embedCount_, std::string xpath_) : DOMLocator(),
140 file(x%file_.string()), row(row_), embedCount(embedCount_), xpath(std::move(xpath_)) {}
142 file(x%(
X()%src.file)), row(src.row), embedCount(src.embedCount), xpath(src.xpath) {}
144 file=x%(
X()%src.file);
146 embedCount=src.embedCount;
153 XMLFileLoc getLineNumber()
const override {
return row; }
154 XMLFileLoc getColumnNumber()
const override {
return 0; }
155 XMLFilePos getByteOffset()
const override {
return ~(XMLFilePos(0)); }
156 XMLFilePos getUtf16Offset()
const override {
return ~(XMLFilePos(0)); }
157 xercesc::DOMNode *getRelatedNode()
const override {
return nullptr; }
158 const XMLCh *getURI()
const override {
return file; }
159 int getEmbedCount()
const {
return embedCount; }
160 std::string getRootXPathExpression()
const {
return xpath; }
171 #define RETHROW_AS_DOMEVALEXCEPTION(e) \ 172 catch(MBXMLUtils::DOMEvalException &ex) { \ 175 catch(const std::exception &ex) { \ 176 throw DOMEvalException(ex.what(), e); \ 186 DOMEvalException(
const std::string &errorMsg_,
const xercesc::DOMLocator &loc);
188 locationStack(src.locationStack) {}
190 errorMsg=src.errorMsg; locationStack=src.locationStack;
194 void appendContext(
const xercesc::DOMNode *n,
int lineNr=0);
195 const std::string& getMessage()
const {
return errorMsg; }
196 void setMessage(
const std::string& errorMsg_) { errorMsg=errorMsg_; }
197 void setSubsequentError(
bool sse) { subsequentError=sse; }
198 const char* what()
const noexcept
override;
228 bool subsequentError{
false};
229 std::string errorMsg;
230 std::vector<EmbedDOMLocator> locationStack;
231 mutable std::string whatStr;
239 bool handleError(
const xercesc::DOMError&)
override;
240 bool hasError() {
return errorSet; }
242 void resetError() { errorSet=
false; }
244 bool errorSet{
false};
249 template<
typename DOMElementType>
273 template<
class T> T
getText(
int r=0,
int c=0)
const {
276 CheckSize<T>::check(me, ret, r, c);
279 catch(
const boost::bad_lexical_cast &ex) {
282 catch(
const std::exception &ex) {
287 template<
class T>
void addElementText(
const FQN &name,
const T &value) {
288 xercesc::DOMElement *ele=D(me->getOwnerDocument())->createElement(name);
289 ele->insertBefore(me->getOwnerDocument()->createTextNode(
MBXMLUtils::X()%fmatvec::toString(value)),
nullptr);
290 me->insertBefore(ele,
nullptr);
301 const xercesc::DOMElement *&found=DOMElementWrapper<DOMElementType>::dummyArg)
const;
309 boost::filesystem::path
convertPath(
const boost::filesystem::path &relPath)
const;
343 me->setAttributeNS(
X()%name.first,
X()%name.second,
X()%fmatvec::toString(value));
354 typename std::conditional<std::is_same<DOMElementType, const xercesc::DOMElement>::value,
358 static const xercesc::DOMElement *dummyArg;
363 template<
typename DOMElementType>
364 DOMElementWrapper<DOMElementType> E(DOMElementType *me) {
return DOMElementWrapper<DOMElementType>(me); }
366 template<
typename DOMElementType>
367 DOMElementWrapper<DOMElementType> E(std::shared_ptr<DOMElementType> me) {
return DOMElementWrapper<DOMElementType>(me.get()); }
369 template<>
const xercesc::DOMElement *DOMElementWrapper< xercesc::DOMElement>::dummyArg;
370 template<>
const xercesc::DOMElement *DOMElementWrapper<const xercesc::DOMElement>::dummyArg;
373 template<
typename DOMAttrType>
385 typename std::conditional<std::is_same<DOMAttrType, const xercesc::DOMAttr>::value,
393 template<
typename DOMAttrType>
394 DOMAttrWrapper<DOMAttrType> A(DOMAttrType *me) {
return DOMAttrWrapper<DOMAttrType>(me); }
396 template<
typename DOMAttrType>
397 DOMAttrWrapper<DOMAttrType> A(std::shared_ptr<DOMAttrType> me) {
return DOMAttrWrapper<DOMAttrType>(me.get()); }
402 template<
typename DOMDocumentType>
403 class DOMDocumentWrapper {
415 std::shared_ptr<DOMParser>
getParser()
const;
424 typename std::conditional<std::is_same<DOMDocumentType, const xercesc::DOMDocument>::value,
432 template<
typename DOMDocumentType>
433 DOMDocumentWrapper<DOMDocumentType> D(DOMDocumentType *me) {
return DOMDocumentWrapper<DOMDocumentType>(me); }
435 template<
typename DOMDocumentType>
436 DOMDocumentWrapper<DOMDocumentType> D(std::shared_ptr<DOMDocumentType> me) {
return DOMDocumentWrapper<DOMDocumentType>(me.get()); }
440 void setParser(
DOMParser *parser_) { parser=parser_; }
441 xercesc::DOMLSParserFilter::FilterAction acceptNode(xercesc::DOMNode *n)
override;
442 xercesc::DOMLSParserFilter::FilterAction startElement(xercesc::DOMElement *e)
override;
443 xercesc::DOMNodeFilter::ShowType getWhatToShow()
const override;
446 static const std::string lineNumberKey;
451 void setParser(
DOMParser *parser_) { parser=parser_; }
452 void handleElementPSVI(
const XMLCh *localName,
const XMLCh *uri, xercesc::PSVIElement *info)
override;
453 void handleAttributesPSVI(
const XMLCh *localName,
const XMLCh *uri, xercesc::PSVIAttributeList *psviAttributes)
override;
460 void handle(DOMOperationType operation,
const XMLCh* key,
void *data,
const xercesc::DOMNode *src, xercesc::DOMNode *dst)
override;
465 void setParser(
DOMParser *parser_) { parser=parser_; }
466 xercesc::InputSource* resolveEntity(xercesc::XMLResourceIdentifier *resourceIdentifier)
override;
472 class DOMParser :
public std::enable_shared_from_this<DOMParser> {
473 friend bool isDerivedFrom(
const xercesc::DOMNode *me,
const FQN &baseTypeName);
483 static std::shared_ptr<DOMParser>
create(
const std::variant<boost::filesystem::path, xercesc::DOMElement*> &xmlCatalog=
nullptr);
487 std::shared_ptr<xercesc::DOMDocument>
parse(
const boost::filesystem::path &inputSource,
488 std::vector<boost::filesystem::path> *dependencies=
nullptr,
bool doXInclude=
true);
491 static void serialize(xercesc::DOMNode *n,
const boost::filesystem::path &outputSource,
bool prettyPrint=
true);
494 static void serializeToString(xercesc::DOMNode *n, std::string &outputData,
bool prettyPrint=
true);
503 static const std::string domParserKey;
505 xercesc::DOMImplementation *domImpl;
506 DOMParser(
const std::variant<boost::filesystem::path, xercesc::DOMElement*> &xmlCatalog);
507 std::shared_ptr<xercesc::DOMLSParser> parser;
508 std::map<FQN, xercesc::XSTypeDefinition*> typeMap;
514 std::map<std::string, boost::filesystem::path> registeredGrammar;
516 static void handleXInclude(xercesc::DOMElement *&e, std::vector<boost::filesystem::path> *dependencies);
524 void CheckSize<T>::check(
const xercesc::DOMElement *me,
const T &value,
int r,
int c) {}
526 void CheckSize<std::vector<T>>::check(
const xercesc::DOMElement *me,
const std::vector<T> &value,
int r,
int c) {
527 if(r!=0 && r!=static_cast<int>(value.size()))
529 " but got vector of size "+fmatvec::toString(value.size())+
".", me);
532 void CheckSize<std::vector<std::vector<T>>>::check(
const xercesc::DOMElement *me,
const std::vector<std::vector<T>> &value,
int r,
int c) {
533 if(r!=0 && r!=static_cast<int>(value.size()))
535 " but got matrix of row-size "+fmatvec::toString(value.size())+
".", me);
536 if(!value.empty() && c!=0 && c!=static_cast<int>(value[0].size()))
538 " but got matrix of col-size "+fmatvec::toString(value[0].size())+
".", me);
const xercesc::DOMText * getFirstTextChild() const
Get first child text.
Definition: dom.cc:253
xercesc::DOMElement * createElement(const FQN &name)
Definition: dom.cc:577
void validate()
(re)validate the document using the parser this document was created
Definition: dom.cc:546
FQN(const char *name)
Anonymous FQN (required for implicit casting of string literals to anonymous FQNs)
Definition: dom.h:111
int getOriginalElementLineNumber() const
Get the line number of the original element.
Definition: dom.cc:469
std::string getRootXPathExpression() const
Definition: dom.cc:425
FQN getTagName() const
Get full qualified tag name.
Definition: dom.h:255
void workaroundDefaultAttributesOnImportNode()
Workaround: convert default attributes to normal attributes (must be used before importNode to also i...
Definition: dom.cc:486
xercesc::DOMNode * evalRootXPathExpression(std::string xpathExpression, xercesc::DOMElement *context=nullptr)
Definition: dom.cc:632
void setEmbedCountNumber(int embedCount)
Definition: dom.cc:400
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:355
Helper class to easily construct full qualified XML names (FQN) using XML namespace prefixes.
Definition: dom.h:117
FQN(const std::string &ns, const std::string &name)
FQN.
Definition: dom.h:113
const xercesc::DOMAttr * getAttributeNode(const FQN &name) const
Get attribute node named name.
Definition: dom.cc:331
FQN(const std::string &name)
Anonymous FQN.
Definition: dom.h:109
void setAttribute(const FQN &name, const T &value)
Set attribute.
Definition: dom.h:342
bool isDerivedFrom(const FQN &baseTypeName) const
Definition: dom.cc:531
Helper class for extending DOMDocument (use the function D(...)).
Definition: dom.h:60
DOMElementWrapper(DOMElementType *me_)
Wrap DOMElement to my special element.
Definition: dom.h:253
T getText(int r=0, int c=0) const
Get the child text as type T.
Definition: dom.h:273
void setEmbedXPathCount(int xPathCount)
Definition: dom.cc:417
bool isDerivedFrom(const FQN &baseTypeName) const
Definition: dom.cc:522
FQN getAttributeQName(const FQN &name) const
Get attribute named name of type QName.
Definition: dom.cc:320
bool hasAttribute(const FQN &name) const
check if this element has a attibute named name.
Definition: dom.cc:500
std::shared_ptr< xercesc::DOMDocument > createDocument()
create a empty document
Definition: dom.cc:1130
int getLineNumber() const
Definition: dom.cc:377
Initialize Xerces on load and terminate it on unload of the library/program.
Definition: dom.h:69
boost::filesystem::path convertPath(const boost::filesystem::path &relPath) const
Definition: dom.cc:306
std::string getRootXPathExpression() const
Definition: dom.cc:537
static void handleCDATA(xercesc::DOMElement *e)
Definition: dom.cc:985
const xercesc::DOMElement * getNextElementSiblingNamed(const FQN &name) const
Get next sibling element of the specified full qualified name.
Definition: dom.cc:213
const xercesc::DOMElement * getFirstElementChildNamed(const FQN &name) const
Get first child element of the specified full qualified name.
Definition: dom.cc:196
void normalizeDocument()
Just calls normalizeDocument of the DOMDocument but with a workaround for a xerces-c bug,...
Definition: dom.cc:585
Helper class for extending DOMAttr (use the function A(...)).
Definition: dom.h:374
void setOriginalElementLineNumber(int lineNr)
Set the line number of the original element.
Definition: dom.cc:478
static std::string convertToString(const EmbedDOMLocator &loc, const std::string &message, bool subsequentError=false)
Definition: dom.cc:749
boost::filesystem::path getOriginalFilename(bool skipThis=false, const xercesc::DOMElement *&found=DOMElementWrapper< DOMElementType >::dummyArg) const
Definition: dom.cc:270
void resetCachedGrammarPool()
reset all loaded grammars
Definition: dom.cc:1125
Print DOM error messages.
Definition: dom.h:235
Helper class for extending DOMElement (use the function E(...)).
Definition: dom.h:64
boost::filesystem::path getDocumentFilename() const
Definition: dom.cc:607
void removeAttribute(const FQN &name)
remove from this element the attibute named name.
Definition: dom.cc:386
std::shared_ptr< DOMParser > getParser() const
Get full qualified tag name.
Definition: dom.cc:601
A XML DOM parser.
Definition: dom.h:472
const xercesc::DOMProcessingInstruction * getFirstProcessingInstructionChildNamed(const std::string &target) const
Get first child processing instruction of the specified target.
Definition: dom.cc:230
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:386
static std::shared_ptr< DOMParser > create(const std::variant< boost::filesystem::path, xercesc::DOMElement * > &xmlCatalog=nullptr)
Definition: dom.cc:886
std::shared_ptr< xercesc::DOMDocument > parse(const boost::filesystem::path &inputSource, std::vector< boost::filesystem::path > *dependencies=nullptr, bool doXInclude=true)
Definition: dom.cc:1034
DOMAttrWrapper(DOMAttrType *me_)
Wrap DOMAttr to my special element.
Definition: dom.h:377
DOMDocumentWrapper(DOMDocumentType *me_)
Wrap DOMDocument to my special element.
Definition: dom.h:406
static void serialize(xercesc::DOMNode *n, const boost::filesystem::path &outputSource, bool prettyPrint=true)
Definition: dom.cc:1090
static void serializeToString(xercesc::DOMNode *n, std::string &outputData, bool prettyPrint=true)
Definition: dom.cc:1101
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:425
void setOriginalFilename(boost::filesystem::path orgFileName=boost::filesystem::path())
Definition: dom.cc:297
int getEmbedCountNumber() const
Definition: dom.cc:391
int getEmbedXPathCount() const
Definition: dom.cc:408
std::string getAttribute(const FQN &name) const
Get attribute named name.
Definition: dom.cc:314