element.hpp

#ifndef ETREE_ELEMENT_H
#define ETREE_ELEMENT_H

/*
 * Copyright David Wilson, 2013.
 * License: http://opensource.org/licenses/MIT
 */

#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
#include <mutex>


#if __cplusplus >= 201103L
#   include <initializer_list>
#   include <utility>
#   define ETREE_0X
#   define ETREE_EXPLICIT explicit
#else
#   define ETREE_EXPLICIT
#endif


// libxml forwards.
struct _xmlAttr;
struct _xmlDoc;
struct _xmlNode;
struct _xmlNs;
struct _xmlXPathCompExpr;
struct _xmlXPathContext;


namespace etree {

using std::string;
using std::vector;

class AttrMap;
class Element;
class ElementTree;
class QName;
class ChildIterator;
class XPath;
class XPathContext;

#ifdef ETREE_0X
typedef std::pair<string, string> kv_pair;
typedef std::pair<string, string> ns_pair;
typedef std::initializer_list<kv_pair> kv_list;
#endif


Element SubElement(Element &parent, const QName &qname);


#ifdef ETREE_0X

Element SubElement(Element &parent, const QName &qname, kv_list attribs);
#endif


Element fromstring(const char *s, size_t n=0);

string tostring(const Element &e);

string tostring(const ElementTree &e);

ElementTree parse(std::istream &is);

ElementTree parse(const string &path);

ElementTree parse(int fd);


namespace html {
    Element fromstring(const char *s);

    Element fromstring(const std::string &s);

    std::string tostring(const Element &e);

    ElementTree parse(std::istream &is);

    ElementTree parse(const std::string &path);

    ElementTree parse(int fd);
} // namespace etree::html


std::ostream &operator<< (std::ostream &out, const ElementTree &elem);

std::ostream &operator<< (std::ostream &out, const Element &elem);

std::ostream &operator<< (std::ostream &out, const QName &qname);


template<typename T>
class Nullable {
    //no constructed value, and also allows the value type to lack a default
    //constructor.
    unsigned char val_[sizeof(T)];

    bool set_;

    public:
    Nullable();

    Nullable(const T &val);

    Nullable(const Nullable<T> &val);

    #ifdef ETREE_0X

    Nullable(T &&val);
    #endif

    ~Nullable();

    bool operator==(const Nullable<T> &other) const;

    bool operator==(const T &other) const;

    Nullable<T> &operator=(const Nullable<T> &other);

    ETREE_EXPLICIT operator bool() const;

    T &operator *();

    /*
     * Return the contained value, or throw missing_value_error().
     */
    T *operator ->();

    const T &operator *() const;

    const T *operator ->() const;
};

typedef Nullable<Element> NullableElement;


class QName {
    string ns_;

    string tag_;

    public:
    QName(const string &ns, const string &tag);

    QName(const QName &other);

    QName(const string &qname);

    QName(const char *qname);

    string tostring() const;

    const string &tag() const;

    const string &ns() const;

    bool equals(const char *ns, const char *tag) const;

    bool operator==(const QName &other) const;

    bool operator!=(const QName &other) const;
};


typedef std::vector<std::pair<std::string, std::string>> ns_list;


class XPathContext {
    _xmlXPathContext *context_;
    std::mutex mtx_;

    // For mutex().
    friend XPath;

    public:
    ~XPathContext();
    XPathContext(const ns_list &ns_list = {});
    XPathContext(const XPathContext &other);
};


class XPath {
    const XPathContext *context_;

    _xmlXPathCompExpr *expr_;

    string s_;

    public:
    ~XPath();

    XPath(const char *s);

    XPath(const string &s);

    XPath(const string &s, const XPathContext &context);

    XPath(const XPath &other);

    const string &expr() const;

    XPath &operator =(const XPath &other);

    Nullable<Element> find(const Element &e) const;

    vector<Element> findall(const Element &e) const;

    vector<Element> removeall(Element &expr) const;

    string findtext(const Element &e, const string &default_="") const;
};


class Attribute
{
    _xmlAttr *attr_;

    public:
    Attribute(_xmlAttr *attr);

    string tag() const;

    string ns() const;

    QName qname() const;

    string value() const;
};


class AttrIterator
{
    _xmlNode *node_;
    _xmlAttr *attr_;

    public:
    ~AttrIterator();
    AttrIterator();
    AttrIterator(_xmlNode *elem, _xmlAttr *attr);

    bool operator ==(const AttrIterator &other);
    bool operator !=(const AttrIterator &other);

    const Attribute operator *();

    AttrIterator &operator++();
};


class AttrMap
{
    _xmlNode *node_;

    public:
    ~AttrMap();
    AttrMap(_xmlNode *elem);

    AttrIterator begin() const;

    AttrIterator end() const;

    bool has(const QName &qname) const;

    string get(const QName &qname, const string &default_="") const;

    void set(const QName &qname, const string &s);

    #ifdef ETREE_0X

    void set(kv_list attribs);
    #endif

    vector<QName> keys() const;

    bool remove(const QName &qname);

    size_t size() const;
};


class ElementTree
{
    template<typename P, typename T>
    friend P nodeFor__(const T &);

    _xmlDoc *node_;

    public:
    ~ElementTree();
    ElementTree();
    ElementTree(_xmlDoc *doc);
    Element getroot() const;

    bool operator==(const ElementTree &other) const;

    bool operator!=(const ElementTree &other) const;

    ElementTree &operator=(const ElementTree&);
};


class Element
{
    template<typename P, typename T>
    friend P nodeFor__(const T &);

    _xmlNode *node_;

    Element();

    public:
    ~Element();

    Element(const Element &e);

    Element(_xmlNode *node);

    Element(const QName &qname);

    #ifdef ETREE_0X

    Element(const QName &qname, kv_list attribs);
    #endif

    void ensurens(const string &uri);

    QName qname() const;

    void qname(const QName &qname);

    string tag() const;

    void tag(const string &tag);

    string ns() const;

    void ns(const string &ns);

    AttrMap attrib() const;

    string get(const QName &qname, const string &default_="") const;

    size_t size() const;

    Element operator[] (size_t i);

    bool operator==(const Element &other) const;

    bool operator!=(const Element &other) const;

    Element &operator=(const Element&);

    Nullable<Element> child() const;

    Nullable<Element> child(const QName &qn) const;

    Element ensurechild(const QName &qn);

    vector<Element> children(const QName &qn) const;

    vector<Element> children() const;

    Nullable<Element> find(const XPath &expr) const;

    string findtext(const XPath &expr, const string &default_="") const;

    vector<Element> findall(const XPath &expr) const;

    vector<Element> removeall(const XPath &expr);

    void append(Element &e);

    void insert(size_t i, Element &e);

    void remove(Element &e);

    void remove();

    void graft();

    Element copy();

    bool ancestorOf(const Element &e) const;

    Nullable<Element> getnext() const;

    Nullable<Element> getparent() const;

    Nullable<Element> getprev() const;

    ElementTree getroottree() const;

    string text() const;

    void text(const string &s);

    string tail() const;

    void tail(const string &s);

    ChildIterator begin() const;

    ChildIterator end() const;
};


class ChildIterator
{
    Nullable<Element> elem_;

    public:
    ChildIterator();
    ChildIterator(const Element &);
    ChildIterator(const ChildIterator &);
    ChildIterator operator++(int);
    ChildIterator operator++();
    bool operator==(const ChildIterator &) const;
    bool operator!=(const ChildIterator &) const;

    Element &operator*();
};


template<typename Function>
void
visit(Element elem, Function func)
{
    func(elem);
    for(auto &child : elem.children()) {
        visit(child, func);
    }
}


#define EXCEPTION(name)                                 \
    struct name : public std::runtime_error {           \
        name() : std::runtime_error("etree::"#name) {}  \
    };

EXCEPTION(cyclical_tree_error)
EXCEPTION(internal_error)
EXCEPTION(invalid_xpath_error)
EXCEPTION(memory_error)
EXCEPTION(missing_namespace_error)
EXCEPTION(missing_value_error)
EXCEPTION(out_of_bounds_error)
EXCEPTION(parse_error)
EXCEPTION(qname_error)
EXCEPTION(serialization_error)

#undef EXCEPTION


struct xml_error : public std::runtime_error
{
    xml_error(const char *s)
        : std::runtime_error(s) {}
};


} // namespace


namespace std {
    template<>
    struct hash<etree::QName>
    {
        size_t operator()(const etree::QName &x) const;
    };
} // namespace


#endif