XMLUtils.h

Go to the documentation of this file.

#ifndef GeneratorInterface_LHEInterface_XMLUtils_h
#define GeneratorInterface_LHEInterface_XMLUtils_h
 
#include <iostream>
#include <string>
#include <memory>
#include <vector>
 
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/XMLUni.hpp>
#include <xercesc/util/XMLChar.hpp>
#include <xercesc/util/BinInputStream.hpp>
#include <xercesc/framework/XMLPScanToken.hpp>
#include <xercesc/sax/InputSource.hpp>
#include <xercesc/sax2/DefaultHandler.hpp>
#include <xercesc/sax2/SAX2XMLReader.hpp>
#include <lzma.h>
 
class Storage;
 
namespace lhef {
 
  class StorageWrap {
  public:
    StorageWrap(std::unique_ptr<Storage> storage);
    ~StorageWrap();
 
    Storage *operator->() { return storage.get(); }
    const Storage *operator->() const { return storage.get(); }
 
  private:
    std::unique_ptr<Storage> storage;
  };
 
  class XMLDocument {
  public:
    class Handler : public XERCES_CPP_NAMESPACE_QUALIFIER DefaultHandler {};
 
    XMLDocument(std::unique_ptr<std::istream> &in, Handler &handler);
    XMLDocument(std::unique_ptr<StorageWrap> &in, Handler &handler);
    virtual ~XMLDocument();
 
    bool parse();
 
    static std::shared_ptr<void> platformHandle() { return std::make_shared<XercesPlatform>(); }
 
  private:
    class XercesPlatform {
    public:
      XercesPlatform();
      ~XercesPlatform();
 
    private:
      // do not make any kind of copies
      XercesPlatform(const XercesPlatform &orig) = delete;
      XercesPlatform &operator=(const XercesPlatform &orig) = delete;
 
      static unsigned int instances;
    };
 
    void init(Handler &handler);
 
    std::unique_ptr<XercesPlatform> platform;
 
    std::unique_ptr<XERCES_CPP_NAMESPACE_QUALIFIER InputSource> source;
    std::unique_ptr<XERCES_CPP_NAMESPACE_QUALIFIER SAX2XMLReader> parser;
 
    XERCES_CPP_NAMESPACE_QUALIFIER XMLPScanToken token;
 
    bool done;
  };
 
  class XMLSimpleStr {
  public:
    XMLSimpleStr(const XMLCh *str) : string(XERCES_CPP_NAMESPACE_QUALIFIER XMLString::transcode(str)) {}
 
    ~XMLSimpleStr() { XERCES_CPP_NAMESPACE_QUALIFIER XMLString::release(&string); }
 
    inline operator const char *() const { return string; }
 
    inline static bool isAllSpaces(const XMLCh *str, unsigned int length) {
      return XERCES_CPP_NAMESPACE_QUALIFIER XMLChar1_0::isAllSpaces(str, length);
    }
 
    inline static bool isSpace(XMLCh ch) { return XERCES_CPP_NAMESPACE_QUALIFIER XMLChar1_0::isWhitespace(ch); }
 
  private:
    char *string;
  };
 
  class XMLUniStr {
  public:
    XMLUniStr(const char *str) : unicode(XERCES_CPP_NAMESPACE_QUALIFIER XMLString::transcode(str)) {}
 
    ~XMLUniStr() { XERCES_CPP_NAMESPACE_QUALIFIER XMLString::release(&unicode); }
 
    operator const XMLCh *() const { return unicode; }
 
  private:
    XMLCh *unicode;
  };
 
  template <typename T>
  class XMLInputSourceWrapper : public XERCES_CPP_NAMESPACE_QUALIFIER InputSource {
  public:
    typedef typename T::Stream_t Stream_t;
 
    XMLInputSourceWrapper(std::unique_ptr<Stream_t> &obj) : obj(std::move(obj)) {}
    ~XMLInputSourceWrapper() override {}
 
    XERCES_CPP_NAMESPACE_QUALIFIER BinInputStream *makeStream() const override { return new T(*obj); }
 
  private:
    std::unique_ptr<Stream_t> obj;
  };
 
  class CBInputStream : public XERCES_CPP_NAMESPACE_QUALIFIER BinInputStream {
  public:
    class Reader {
    public:
      virtual ~Reader();
      virtual const std::string &data() = 0;
    };
 
    typedef Reader Stream_t;
 
    CBInputStream(Reader &in);
    ~CBInputStream() override;
 
    XMLFilePos curPos() const override { return pos; }
 
    XMLSize_t readBytes(XMLByte *const buf, const XMLSize_t size) override;
 
    const XMLCh *getContentType() const override { return nullptr; }
 
  private:
    Reader &reader;
    std::string buffer;
    unsigned int pos;
  };
 
  class STLInputStream : public XERCES_CPP_NAMESPACE_QUALIFIER BinInputStream {
  public:
    typedef std::istream Stream_t;
 
    STLInputStream(std::istream &in);
    ~STLInputStream() override;
 
    XMLFilePos curPos() const override { return pos; }
 
    XMLSize_t readBytes(XMLByte *const buf, const XMLSize_t size) override;
 
    const XMLCh *getContentType() const override { return nullptr; }
 
  private:
    std::istream &in;
    unsigned int pos;
  };
 
  class StorageInputStream : public XERCES_CPP_NAMESPACE_QUALIFIER BinInputStream {
  public:
    typedef StorageWrap Stream_t;
 
    StorageInputStream(StorageWrap &in);
    ~StorageInputStream() override;
 
    XMLFilePos curPos() const override { return pos; }
 
    XMLSize_t readBytes(XMLByte *const buf, const XMLSize_t size) override;
 
    const XMLCh *getContentType() const override { return nullptr; }
 
  private:
    StorageWrap &in;
    unsigned int pos;
    lzma_stream lstr;
    bool compression_;
    unsigned int lasttotal_;
 
    unsigned int buffLoc_ = 0, buffTotal_ = 0;
    std::vector<uint8_t> buffer_;
    static constexpr unsigned bufferSize_ = 16 * 1024 * 1024;
  };
 
  typedef XMLInputSourceWrapper<CBInputStream> CBInputSource;
  typedef XMLInputSourceWrapper<STLInputStream> STLInputSource;
  typedef XMLInputSourceWrapper<StorageInputStream> StorageInputSource;
 
}  // namespace lhef
 
#endif  // GeneratorInterface_LHEInterface_XMLUtils_h