dom.h

#ifndef _MBXMLUTILSHELPER_DOM_H_
#define _MBXMLUTILSHELPER_DOM_H_
 
#include <boost/algorithm/string/trim.hpp>
#include <fmatvec/atom.h>
#include <string>
#include <utility>
#include <vector>
#include <map>
#include <set>
#include <variant>
#include <boost/filesystem.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
#include <xercesc/dom/DOMElement.hpp>
#include <xercesc/dom/DOMText.hpp>
#include <xercesc/dom/DOMLSParser.hpp>
#include <xercesc/dom/DOMLocator.hpp>
#include <xercesc/dom/DOMUserDataHandler.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/util/XMLEntityResolver.hpp>
#include <xercesc/framework/psvi/PSVIHandler.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/container/small_vector.hpp>
#include <boost/functional/hash.hpp>
#include <fmatvec/toString.h>
#include "simdutf.h"
 
namespace XERCES_CPP_NAMESPACE {
  class DOMProcessingInstruction;
  class DOMImplementation;
  class AbstractDOMParser;
}
 
namespace boost {
  template<> std::vector<double> lexical_cast(const std::string& str);
  template<> std::vector<std::vector<double>> lexical_cast(const std::string& str);
  template<> std::vector<int> lexical_cast(const std::string& str);
  template<> std::vector<std::vector<int>> lexical_cast(const std::string& str);
  template<> bool lexical_cast<bool>(const std::string& arg);
}
 
namespace {
 
template<class T>
struct CheckSize {
  static void check(const xercesc::DOMElement *me, const T &value, int r, int c);
};
template<class T>
struct CheckSize<std::vector<T>> {
  static void check(const xercesc::DOMElement *me, const std::vector<T> &value, int r, int c);
};
template<class T>
struct CheckSize<std::vector<std::vector<T>>> {
  static void check(const xercesc::DOMElement *me, const std::vector<std::vector<T>> &value, int r, int c);
};
 
}
 
namespace MBXMLUtils {
 
template<class T> struct XercesUniquePtrDeleter { void operator()(T *n) { if(n) n->release(); } };
template<class T> using XercesUniquePtr = std::unique_ptr<T, XercesUniquePtrDeleter<T>>;
 
// forward declaration
template<typename DOMDocumentType>
class DOMDocumentWrapper;
template<typename DOMDocumentType>
DOMDocumentWrapper<DOMDocumentType> D(DOMDocumentType *me);
template<typename DOMElementType>
class DOMElementWrapper;
template<typename DOMElementType>
DOMElementWrapper<DOMElementType> E(DOMElementType *me);
 
class InitXerces {
  public:
    InitXerces() {
      xercesc::XMLPlatformUtils::Initialize();
    }
    ~InitXerces() {
      xercesc::XMLPlatformUtils::Terminate();
    }
};
 
class X {
  public:
    const XMLCh *operator%(const std::string &in) {
      auto &out = store.emplace_back(in.size()*2+1); // utf16 is at most 2 words per character plus 1 null at the end
      auto outSize = simdutf::convert_valid_utf8_to_utf16(in.data(), in.size(), out.data());
      out[outSize] = 0; // set null at the end, the rest of the memory is skipped
      return out.data();
    }
    const XMLCh *operator()(const std::string &in) { return operator%(in); }
    std::string operator%(const XMLCh *in) {
      if(!in || in[0]==0)
        return {};
      auto inSize = std::char_traits<char16_t>::length(in);
      std::string out(inSize*4, 0); // utf8 is at most 4 bytes per character
      auto outSize = simdutf::convert_valid_utf16_to_utf8(in, inSize, out.data());
      out.resize(outSize); // now shrink out to the real size
      return out;
    }
    std::string operator()(const XMLCh *in) { return operator%(in); }
  private:
    // store 1 string of at most 100 characters on the stack -> more/larger string are stored on the heap
    boost::container::small_vector<boost::container::small_vector<char16_t, 100*2+1>, 1> store;
};
 
class FQN : public std::pair<std::string, std::string> {
  public:
    FQN()  = default;
    FQN(const std::string &name) : std::pair<std::string, std::string>("", name) {}
    FQN(const char *name) : std::pair<std::string, std::string>("", name) {}
    FQN(const std::string &ns, const std::string &name) : std::pair<std::string, std::string>(ns, name) {}
};
 
class EmbedDOMLocator : public xercesc::DOMLocator {
  public:
    EmbedDOMLocator(const boost::filesystem::path &file_, int row_, int embedCount_, std::string xpath_) : DOMLocator(),
      file(x%file_.string()), row(row_), embedCount(embedCount_), xpath(std::move(xpath_)) {}
    EmbedDOMLocator(const EmbedDOMLocator &src) : DOMLocator(),
      file(x%(X()%src.file)), row(src.row), embedCount(src.embedCount), xpath(src.xpath) {}
    EmbedDOMLocator& operator=(const EmbedDOMLocator &src) {
      file=x%(X()%src.file);
      row=src.row;
      embedCount=src.embedCount;
      xpath=src.xpath;
      return *this;
    }
    ~EmbedDOMLocator() override = default;
    EmbedDOMLocator(const EmbedDOMLocator &&src) = delete;
    EmbedDOMLocator& operator=(const EmbedDOMLocator &&src) = delete;
    XMLFileLoc getLineNumber() const override { return row; }
    XMLFileLoc getColumnNumber() const override { return 0; }
    XMLFilePos getByteOffset() const override { return ~(XMLFilePos(0)); }
    XMLFilePos getUtf16Offset() const override { return ~(XMLFilePos(0)); }
    xercesc::DOMNode *getRelatedNode() const override { return nullptr; }
    const XMLCh *getURI() const override { return file; }
    int getEmbedCount() const { return embedCount; }
    const std::string& getRootXPathExpression() const { return xpath; }
    static std::string convertToRootHRXPathExpression(const std::string &xpath);
    static void addNSURIPrefix(std::string nsuri, const std::vector<std::string> &prefix);
    static const std::map<std::string, std::string>& getNSURIPrefix() { return nsURIPrefix(); }
  private:
    X x;
    const XMLCh *file;
    int row;
    int embedCount;
    std::string xpath;
    static std::map<std::string, std::string>& nsURIPrefix();
};
 
class NamespaceURI {
  public:
    NamespaceURI(std::string nsuri_, const std::vector<std::string> &preferredPrefix={}) : nsuri(std::move(nsuri_)) {
      EmbedDOMLocator::addNSURIPrefix(nsuri, preferredPrefix);
    }
    FQN operator%(const std::string &localName) const { return {nsuri, localName}; }
    const std::string& getNamespaceURI() const { return nsuri; }
  private:
    std::string nsuri;
};
 
const NamespaceURI XINCLUDE("http://www.w3.org/2001/XInclude", {"xi", "xinc", "xinclude"});
const NamespaceURI XMLNS("http://www.w3.org/2000/xmlns/", {"xmlns"});
const NamespaceURI PV("http://www.mbsim-env.de/MBXMLUtils", {"p", "pv", "mbxmlutils"});
const NamespaceURI XMLCATALOG("urn:oasis:names:tc:entity:xmlns:xml:catalog", {"catalog", "xmlcatalog"});
 
// Exception wrapping for DOMEvalException.
// Rethrow a exception as DOMEvalException with context e, a DOMEvalException is just rethrown unchanged.
#define RETHROW_AS_DOMEVALEXCEPTION(e) \
  catch(MBXMLUtils::DOMEvalException &ex) { \
    throw; \
  } \
  catch(const std::exception &ex) { \
    throw DOMEvalException(ex.what(), e); \
  }
 
class DOMEvalException : public std::exception {
  friend class DOMParser;
  friend class DOMErrorPrinter;
  public:
    DOMEvalException() = default;
    DOMEvalException(const std::string &errorMsg_, const xercesc::DOMNode *n);
    void appendContext(const xercesc::DOMNode *n, int lineNr=0);
    const std::string& getMessage() const { return errorMsg; }
    void setMessage(const std::string& errorMsg_) { errorMsg=errorMsg_; }
    void setSubsequentError(bool sse) { subsequentError=sse; }
    const char* what() const noexcept override;
    xercesc::DOMNode::NodeType getNodeType() const { return nodeType; }
    static bool isHTMLOutputEnabled();
    static void htmlEscaping(std::string &msg);
  protected:
    DOMEvalException(const std::string &errorMsg_, const xercesc::DOMLocator &loc);
  private:
    static std::string convertToString(const EmbedDOMLocator &loc, const std::string &message, bool subsequentError=false);
 
    bool subsequentError{false};
    std::string errorMsg;
    std::vector<EmbedDOMLocator> locationStack;
    mutable std::string whatStr;
    xercesc::DOMNode::NodeType nodeType { static_cast<xercesc::DOMNode::NodeType>(-1) };
};
 
class DOMErrorPrinter: public xercesc::DOMErrorHandler, virtual public fmatvec::Atom
{
  public:
    DOMErrorPrinter() = default;
    bool handleError(const xercesc::DOMError&) override;
    bool hasError() { return errorSet; }
    const DOMEvalException& getError() { return error; }
    void resetError() { errorSet=false; }
  private:
    bool errorSet{false};
    DOMEvalException error;
};
 
template<typename DOMElementType>
class DOMElementWrapper {
  public:
    DOMElementWrapper(DOMElementType *me_) : me(me_) {}
    FQN getTagName() const { return FQN(X()%me->getNamespaceURI(), X()%me->getLocalName()); }
    const xercesc::DOMElement *getFirstElementChildNamed(const FQN &name) const;
    xercesc::DOMElement *getFirstElementChildNamed(const FQN &name);
    const xercesc::DOMElement *getNextElementSiblingNamed(const FQN &name) const;
    xercesc::DOMElement *getNextElementSiblingNamed(const FQN &name);
    const xercesc::DOMProcessingInstruction *getFirstProcessingInstructionChildNamed(const std::string &target) const;
    xercesc::DOMProcessingInstruction *getFirstProcessingInstructionChildNamed(const std::string &target);
    void addProcessingInstructionChildNamed(const std::string &target, const std::string &data);
    std::string getEmbedData(const std::string &name) const;
    void addEmbedData(const std::string &name, const std::string &data);
    const xercesc::DOMComment *getFirstCommentChild() const;
    xercesc::DOMComment *getFirstCommentChild();
    const xercesc::DOMText *getFirstTextChild() const;
    xercesc::DOMText *getFirstTextChild();
    template<class T> T getText(int r=0, int c=0) const {
      try {
        auto textEle=E(me)->getFirstTextChild();
        if(!textEle) {
          if constexpr(std::is_same_v<T, std::string>) {
            for(auto *n=me->getFirstChild(); n; n=n->getNextSibling())
              if(n->getNodeType()==xercesc_3_2::DOMNode::TEXT_NODE || n->getNodeType()==xercesc_3_2::DOMNode::CDATA_SECTION_NODE)
                if(!boost::trim_copy(X()%static_cast<xercesc::DOMText*>(n)->getData()).empty())
                  throw std::runtime_error("There must be no or a single, none empty, text node but the text node is split by a comment or processing-instruction node.");
            return "";
          }
          else
            throw std::runtime_error("There must be a single, none empty, text node but either, no text node exists at all, or the text node is split by a comment or processing-instruction node.");
        }
        auto text=X()%textEle->getData();
        if constexpr(!std::is_same_v<T, std::string>)
          boost::trim(text); // do not trim whitespaces for a string but for anything else
        auto ret=boost::lexical_cast<T>(text);
        CheckSize<T>::check(me, ret, r, c);
        return ret;
      }
      catch(const boost::bad_lexical_cast &ex) {
        throw DOMEvalException(ex.what(), me);
      }
      catch(const std::exception &ex) {
        throw DOMEvalException(ex.what(), me);
      }
    }
 
    template<class T> void addElementText(const FQN &name, const T &value) {
      xercesc::DOMElement *ele=D(me->getOwnerDocument())->createElement(name);
      ele->insertBefore(me->getOwnerDocument()->createTextNode(MBXMLUtils::X()%fmatvec::toString(value)), nullptr);
      me->insertBefore(ele, nullptr);
    }
    bool isDerivedFrom(const FQN &baseTypeName) const;
    boost::filesystem::path getOriginalFilename(bool skipThis=false,
                                                const xercesc::DOMElement *&found=DOMElementWrapper<DOMElementType>::dummyArg) const;
    void setOriginalFilename(boost::filesystem::path orgFileName=boost::filesystem::path());
    boost::filesystem::path convertPath(const boost::filesystem::path &relPath) const;
    int getLineNumber() const;
    int getEmbedCountNumber() const;
    void setEmbedCountNumber(int embedCount);
    int getEmbedXPathCount() const;
    void setEmbedXPathCount(int xPathCount);
    std::string getRootXPathExpression() const;
    std::vector<int> getElementLocation() const;
    int getOriginalElementLineNumber() const;
    void setOriginalElementLineNumber(int lineNr);
    std::string getAttribute(const FQN &name) const;
    FQN getAttributeQName(const FQN &name) const;
    const xercesc::DOMAttr* getAttributeNode(const FQN &name) const;
    xercesc::DOMAttr* getAttributeNode(const FQN &name);
    template<class T>
    void setAttribute(const FQN &name, const T &value) {
      me->setAttributeNS(X()%name.first, X()%name.second, X()%fmatvec::toString(value));
    }
    void setAttribute(const FQN &name, const FQN &value);
    bool hasAttribute(const FQN &name) const;
    void removeAttribute(const FQN &name);
    typename std::conditional<std::is_same<DOMElementType, const xercesc::DOMElement>::value,
      const DOMElementWrapper*, DOMElementWrapper*>::type operator->() {
      return this;
    }
    static const xercesc::DOMElement *dummyArg;
  private:
    DOMElementType *me;
};
template<typename DOMElementType>
DOMElementWrapper<DOMElementType> E(DOMElementType *me) { return DOMElementWrapper<DOMElementType>(me); }
template<typename DOMElementType>
DOMElementWrapper<DOMElementType> E(const std::shared_ptr<DOMElementType> &me) { return DOMElementWrapper<DOMElementType>(me.get()); }
template<typename DOMElementType>
DOMElementWrapper<DOMElementType> E(const XercesUniquePtr<DOMElementType> &me) { return DOMElementWrapper<DOMElementType>(me.get()); }
 
template<> const xercesc::DOMElement *DOMElementWrapper<      xercesc::DOMElement>::dummyArg;
template<> const xercesc::DOMElement *DOMElementWrapper<const xercesc::DOMElement>::dummyArg;
 
template<typename DOMAttrType>
class DOMAttrWrapper {
  public:
    DOMAttrWrapper(DOMAttrType *me_) : me(me_) {}
    bool isDerivedFrom(const FQN &baseTypeName) const;
    std::string getRootXPathExpression() const;
    typename std::conditional<std::is_same<DOMAttrType, const xercesc::DOMAttr>::value,
      const DOMAttrWrapper*, DOMAttrWrapper*>::type operator->() {
      return this;
    }
  private:
    DOMAttrType *me;
};
template<typename DOMAttrType>
DOMAttrWrapper<DOMAttrType> A(DOMAttrType *me) { return DOMAttrWrapper<DOMAttrType>(me); }
template<typename DOMAttrType>
DOMAttrWrapper<DOMAttrType> A(const std::shared_ptr<DOMAttrType> &me) { return DOMAttrWrapper<DOMAttrType>(me.get()); }
template<typename DOMAttrType>
DOMAttrWrapper<DOMAttrType> A(const XercesUniquePtr<DOMAttrType> &me) { return DOMAttrWrapper<DOMAttrType>(me.get()); }
 
class DOMParser;
 
template<typename DOMDocumentType>
class DOMDocumentWrapper {
  public:
    DOMDocumentWrapper(DOMDocumentType *me_) : me(me_) {}
    XercesUniquePtr<xercesc::DOMElement> validate();
    xercesc::DOMElement* createElement(const FQN &name);
    std::shared_ptr<DOMParser> getParser() const;
    boost::filesystem::path getDocumentFilename() const;
    xercesc::DOMNode* evalRootXPathExpression(std::string xpathExpression, xercesc::DOMElement* context=nullptr);
    xercesc::DOMElement* locateElement(const std::vector<int> &idx) const;
    typename std::conditional<std::is_same<DOMDocumentType, const xercesc::DOMDocument>::value,
      const DOMDocumentWrapper*, DOMDocumentWrapper*>::type operator->() {
      return this;
    }
  private:
    DOMDocumentType *me;
};
template<typename DOMDocumentType>
DOMDocumentWrapper<DOMDocumentType> D(DOMDocumentType *me) { return DOMDocumentWrapper<DOMDocumentType>(me); }
template<typename DOMDocumentType>
DOMDocumentWrapper<DOMDocumentType> D(const std::shared_ptr<DOMDocumentType> &me) { return DOMDocumentWrapper<DOMDocumentType>(me.get()); }
template<typename DOMDocumentType>
DOMDocumentWrapper<DOMDocumentType> D(const XercesUniquePtr<DOMDocumentType> &me) { return DOMDocumentWrapper<DOMDocumentType>(me.get()); }
 
class LocationInfoFilter : public xercesc::DOMLSParserFilter {
  public:
    void setParser(DOMParser *parser_) { parser=parser_; }
    xercesc::DOMLSParserFilter::FilterAction acceptNode(xercesc::DOMNode *n) override;
    xercesc::DOMLSParserFilter::FilterAction startElement(xercesc::DOMElement *e) override;
    xercesc::DOMNodeFilter::ShowType getWhatToShow() const override;
    void setLineNumberOffset(int offset) { lineNumberOffset=offset; }
  private:
    DOMParser *parser;
    int lineNumberOffset { 0 };
};
 
class TypeDerivativeHandler : public xercesc::PSVIHandler, virtual public fmatvec::Atom {
  public:
    void setParser(DOMParser *parser_) { parser=parser_; }
    void handleElementPSVI(const XMLCh *localName, const XMLCh *uri, xercesc::PSVIElement *info) override;
    void handleAttributesPSVI(const XMLCh *localName, const XMLCh *uri, xercesc::PSVIAttributeList *psviAttributes) override;
  private:
    DOMParser *parser;
};
 
class UserDataHandler : public xercesc::DOMUserDataHandler {
  public:
    void handle(DOMOperationType operation, const XMLCh* key, void *data, const xercesc::DOMNode *src, xercesc::DOMNode *dst) override;
};
 
extern UserDataHandler userDataHandler;
 
class EntityResolver : public xercesc::XMLEntityResolver {
  public:
    void setParser(DOMParser *parser_) { parser=parser_; }
    xercesc::InputSource* resolveEntity(xercesc::XMLResourceIdentifier *resourceIdentifier) override;
  private:
    DOMParser *parser;
};
 
class DOMParser : public std::enable_shared_from_this<DOMParser> {
  friend class TypeDerivativeHandler;
  friend class LocationInfoFilter;
  friend class UserDataHandler;
  friend class EntityResolver;
  friend class DOMElementWrapper<xercesc::DOMElement>;
  friend class DOMElementWrapper<const xercesc::DOMElement>;
  template<typename> friend class DOMDocumentWrapper;
  public:
    static std::shared_ptr<DOMParser> create(const std::variant<boost::filesystem::path, xercesc::DOMElement*> &xmlCatalog=static_cast<xercesc::DOMElement*>(nullptr));
    std::shared_ptr<xercesc::DOMDocument> parse(const boost::filesystem::path &inputSource,
                                                std::vector<boost::filesystem::path> *dependencies=nullptr,
                                                bool doXInclude=true);
    std::shared_ptr<xercesc::DOMDocument> parse(std::istream &inputStream,
                                                std::vector<boost::filesystem::path> *dependencies=nullptr,
                                                bool doXInclude=true, const boost::filesystem::path& filename={});
    xercesc::DOMElement* parseWithContext(const std::string &str, xercesc::DOMNode *contextNode, xercesc::DOMLSParser::ActionType action,
                                          std::vector<boost::filesystem::path> *dependencies=nullptr,
                                          bool doXInclude=true);
    static void serialize(xercesc::DOMNode *n, const boost::filesystem::path &outputSource, bool plain=false);
    static void serializeToString(xercesc::DOMNode *n, std::string &outputData, bool plain=false);
    void resetCachedGrammarPool();
    std::shared_ptr<xercesc::DOMDocument> createDocument();
    
    const std::unordered_map<FQN, xercesc::XSTypeDefinition*, boost::hash<FQN>>& getTypeMap() const { return typeMap; }
  private:
    xercesc::DOMImplementation *domImpl;
    DOMParser(const std::variant<boost::filesystem::path, xercesc::DOMElement*> &xmlCatalog);
    std::shared_ptr<xercesc::DOMLSParser> parser;
    std::unordered_map<FQN, xercesc::XSTypeDefinition*, boost::hash<FQN>> typeMap;
    DOMErrorPrinter errorHandler;
    LocationInfoFilter locationFilter;
    TypeDerivativeHandler typeDerHandler;
    EntityResolver entityResolver;
    std::map<std::string, boost::filesystem::path> registeredGrammar;
 
    static void handleXInclude(xercesc::DOMElement *&e, std::vector<boost::filesystem::path> *dependencies);
};
 
}
 
namespace {
 
template<class T>
void CheckSize<T>::check(const xercesc::DOMElement *me, const T &value, int r, int c) {}
template<class T>
void CheckSize<std::vector<T>>::check(const xercesc::DOMElement *me, const std::vector<T> &value, int r, int c) {
  if(r!=0 && r!=static_cast<int>(value.size()))
    throw MBXMLUtils::DOMEvalException("Expected vector of size "+fmatvec::toString(r)+
                           " but got vector of size "+fmatvec::toString(value.size())+".", me);
}
template<class T>
void CheckSize<std::vector<std::vector<T>>>::check(const xercesc::DOMElement *me, const std::vector<std::vector<T>> &value, int r, int c) {
  if(r!=0 && r!=static_cast<int>(value.size()))
    throw MBXMLUtils::DOMEvalException("Expected matrix of row-size "+fmatvec::toString(r)+
                           " but got matrix of row-size "+fmatvec::toString(value.size())+".", me);
  if(!value.empty() && c!=0 && c!=static_cast<int>(value[0].size()))
    throw MBXMLUtils::DOMEvalException("Expected matrix of col-size "+fmatvec::toString(c)+
                           " but got matrix of col-size "+fmatvec::toString(value[0].size())+".", me);
}
 
}
 
#endif