xml.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <functional>
#include <utility>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/error.h>
#include <promeki/sharedptr.h>
#include <promeki/datastream.h>
#include <pugixml.hpp>
 
PROMEKI_NAMESPACE_BEGIN
 
class XmlName;
class XmlAttribute;
class XmlElement;
class XmlDocument;
class XmlNode;
class XmlParseError;
 
class XmlName {
        public:
                XmlName() = default;
 
                explicit XmlName(const String &local) : _local(local) {}
 
                XmlName(const String &uri, const String &local) : _uri(uri), _local(local) {}
 
                XmlName(const String &uri, const String &prefix, const String &local)
                        : _uri(uri), _prefix(prefix), _local(local) {}
 
                static XmlName parseClark(const String &clark);
 
                bool isValid() const { return !_local.isEmpty(); }
 
                const String &uri() const { return _uri; }
 
                const String &prefix() const { return _prefix; }
 
                const String &local() const { return _local; }
 
                bool hasNamespace() const { return !_uri.isEmpty(); }
 
                String qualified() const;
 
                String clark() const;
 
                String toString() const { return clark(); }
 
                bool operator==(const XmlName &other) const {
                        return _uri == other._uri && _local == other._local;
                }
 
                bool operator!=(const XmlName &other) const { return !(*this == other); }
 
        private:
                String _uri;
                String _prefix;
                String _local;
};
 
class XmlParseError {
        public:
                XmlParseError() = default;
 
                bool ok() const { return _status == pugi::status_ok; }
 
                bool isError() const { return !ok(); }
 
                explicit operator bool() const { return ok(); }
 
                pugi::xml_parse_status pugiStatus() const { return _status; }
 
                const String &message() const { return _message; }
 
                size_t offset() const { return _offset; }
 
                int line() const { return _line; }
 
                int column() const { return _column; }
 
                Error toError() const;
 
                String toString() const;
 
                bool operator==(const XmlParseError &other) const {
                        return _status == other._status && _offset == other._offset &&
                               _message == other._message;
                }
 
                bool operator!=(const XmlParseError &other) const { return !(*this == other); }
 
        private:
                friend class XmlDocument;
                friend class XmlElement;
 
                void setFromPugi(const pugi::xml_parse_result &result, const String &source);
 
                pugi::xml_parse_status _status  = pugi::status_ok;
                String                 _message;
                size_t                 _offset = 0;
                int                    _line   = 0;
                int                    _column = 0;
};
 
struct XmlData {
                PROMEKI_SHARED_FINAL(XmlData)
                pugi::xml_document doc;
 
                XmlData() = default;
                XmlData(const XmlData &other);
                XmlData &operator=(const XmlData &other);
                XmlData(XmlData &&) = delete;
                XmlData &operator=(XmlData &&) = delete;
};
 
class XmlAttribute {
        public:
                XmlAttribute() = default;
 
                XmlAttribute(String rawName, String value)
                        : _name(std::move(rawName)), _value(std::move(value)) {}
 
                XmlAttribute(XmlName qname, String value);
 
                XmlAttribute(String rawName, XmlName qname, String value)
                        : _name(std::move(rawName)), _qname(std::move(qname)), _value(std::move(value)) {}
 
                const String &name() const { return _name; }
 
                const XmlName &qname() const { return _qname; }
 
                const String &value() const { return _value; }
 
                void setName(const String &name) { _name = name; }
 
                void setQName(const XmlName &qname) { _qname = qname; }
 
                void setValue(const String &value) { _value = value; }
 
                bool isValid() const { return !_name.isEmpty(); }
 
                bool operator==(const XmlAttribute &other) const {
                        return _name == other._name && _value == other._value;
                }
 
                bool operator!=(const XmlAttribute &other) const { return !(*this == other); }
 
        private:
                String  _name;
                XmlName _qname;
                String  _value;
};
 
class XmlElement {
        public:
                static XmlElement parse(const String &str, XmlParseError *err = nullptr);
 
                XmlElement() = default;
 
                explicit XmlElement(const String &name);
 
                bool isValid() const;
 
                String name() const;
 
                XmlName qname() const;
 
                void setName(const String &name);
 
                Map<String, String> namespaces() const;
 
                // --- Attributes ---
 
                bool hasAttribute(const String &name) const;
 
                bool hasAttribute(const XmlName &qname) const;
 
                String attribute(const String &name, Error *err = nullptr) const;
 
                String attribute(const XmlName &qname, Error *err = nullptr) const;
 
                void setAttribute(const String &name, const String &value);
 
                void setAttribute(const XmlName &qname, const String &value);
 
                bool removeAttribute(const String &name);
 
                bool removeAttribute(const XmlName &qname);
 
                List<XmlAttribute> attributes() const;
 
                // --- Element children ---
 
                bool hasChild(const String &name) const;
 
                bool hasChild(const XmlName &qname) const;
 
                XmlElement child(const String &name) const;
 
                XmlElement child(const XmlName &qname) const;
 
                List<XmlElement> elements() const;
 
                List<XmlElement> elementsNamed(const String &name) const;
 
                List<XmlElement> elementsNamed(const XmlName &qname) const;
 
                // --- XPath ---
 
                XmlElement selectFirst(const String &query, Error *err = nullptr) const;
 
                List<XmlElement> selectAll(const String &query, Error *err = nullptr) const;
 
                XmlAttribute selectFirstAttribute(const String &query, Error *err = nullptr) const;
 
                List<XmlAttribute> selectAllAttributes(const String &query, Error *err = nullptr) const;
 
                // --- Path navigation (lightweight) ---
 
                XmlElement elementByPath(const String &path) const;
 
                List<XmlNode> children() const;
 
                // --- Text content ---
 
                String text() const;
 
                void setText(const String &text);
 
                // --- Mutation: append children ---
 
                void appendElement(const String &name);
 
                void appendElement(const String &name, const String &text);
 
                void appendElement(const XmlName &qname);
 
                void appendElement(const XmlName &qname, const String &text);
 
                void appendText(const String &text);
 
                void appendCData(const String &text);
 
                void appendComment(const String &text);
 
                void appendProcessingInstruction(const String &target, const String &data);
 
                void appendChild(const XmlElement &child);
 
                void appendChild(const XmlNode &node);
 
                void appendChild(const XmlDocument &doc);
 
                XmlDocument toDocument() const;
 
                // --- Prepend / insert at position ---
 
                void prependElement(const String &name);
 
                void prependElement(const String &name, const String &text);
 
                void prependChild(const XmlElement &child);
 
                void prependChild(const XmlNode &node);
 
                void prependChild(const XmlDocument &doc);
 
                void insertChildAt(size_t index, const XmlElement &child);
 
                void insertChildAt(size_t index, const XmlNode &node);
 
                // --- Targeted removal ---
 
                bool removeChild(const String &name);
 
                bool removeChild(const XmlName &qname);
 
                bool removeChildAt(size_t index);
 
                size_t removeAllNamed(const String &name);
 
                size_t removeAllNamed(const XmlName &qname);
 
                size_t childCount() const;
 
                // --- Attribute order primitives ---
 
                void prependAttribute(const String &name, const String &value);
 
                void prependAttribute(const XmlName &qname, const String &value);
 
                void insertAttributeAt(size_t index, const String &name, const String &value);
 
                void insertAttributeAt(size_t index, const XmlName &qname, const String &value);
 
                size_t attributeCount() const;
 
                void clear();
 
                String toString(unsigned int indent = 0) const;
 
                void forEachElement(Function<void(const XmlElement &)> func) const;
 
                bool operator==(const XmlElement &other) const;
 
                bool operator!=(const XmlElement &other) const { return !(*this == other); }
 
        private:
                friend class XmlDocument;
                friend class XmlNode;
 
                SharedPtr<XmlData> _d = SharedPtr<XmlData>::create();
 
                explicit XmlElement(const SharedPtr<XmlData> &d) : _d(d) {}
 
                pugi::xml_node rootNode() const;
 
                void resetTo(const pugi::xml_node &node);
};
 
class XmlDocument {
        public:
                PROMEKI_DATATYPE(XmlDocument, DataTypeXmlDocument, 1)
 
                
                Error writeToStream(DataStream &s) const;
 
                template <uint32_t V> static Result<XmlDocument> readFromStream(DataStream &s);
 
                static XmlDocument parse(const String &str, XmlParseError *err = nullptr);
 
                static Result<XmlDocument> fromString(const String &str);
 
                static XmlDocument loadFromPath(const String &path, XmlParseError *err = nullptr);
 
                Error saveToPath(const String &path, unsigned int indent = 0) const;
 
                XmlDocument() = default;
 
                explicit XmlDocument(const XmlElement &root);
 
                bool isValid() const;
 
                // --- Declaration ---
 
                String declarationVersion() const;
 
                String declarationEncoding() const;
 
                String declarationStandalone() const;
 
                void setDeclaration(const String &version = "1.0",
                                    const String &encoding = "UTF-8",
                                    const String &standalone = String());
 
                // --- Doctype ---
 
                String doctype() const;
 
                void setDoctype(const String &doctype);
 
                // --- Root element ---
 
                XmlElement root() const;
 
                XmlElement selectFirst(const String &query, Error *err = nullptr) const {
                        return root().selectFirst(query, err);
                }
 
                List<XmlElement> selectAll(const String &query, Error *err = nullptr) const {
                        return root().selectAll(query, err);
                }
 
                XmlElement elementByPath(const String &path) const { return root().elementByPath(path); }
 
                void setRoot(const XmlElement &elem);
 
                void appendComment(const String &text);
 
                void appendProcessingInstruction(const String &target, const String &data);
 
                void clear();
 
                String toString(unsigned int indent = 0) const;
 
                bool operator==(const XmlDocument &other) const;
 
                bool operator!=(const XmlDocument &other) const { return !(*this == other); }
 
        private:
                friend class XmlElement;
                friend class XmlNode;
 
                SharedPtr<XmlData> _d = SharedPtr<XmlData>::create();
 
                explicit XmlDocument(const SharedPtr<XmlData> &d) : _d(d) {}
};
 
class XmlNode {
        public:
                enum Type {
                        Null,                  
                        Element,               
                        Text,                  
                        CData,                 
                        Comment,               
                        ProcessingInstruction, 
                        Undefined              
                };
 
                XmlNode() = default;
 
                static XmlNode undefined();
 
                XmlNode(const XmlElement &elem);
 
                static XmlNode makeText(const String &body);
 
                static XmlNode makeCData(const String &body);
 
                static XmlNode makeComment(const String &body);
 
                static XmlNode makeProcessingInstruction(const String &target, const String &data);
 
                Type type() const { return _type; }
 
                bool isNull() const { return _type == Null; }
                bool isUndefined() const { return _type == Undefined; }
                bool isElement() const { return _type == Element; }
                bool isText() const { return _type == Text; }
                bool isCData() const { return _type == CData; }
                bool isComment() const { return _type == Comment; }
                bool isProcessingInstruction() const { return _type == ProcessingInstruction; }
 
                XmlElement toElement() const;
 
                String text() const;
 
                String piTarget() const;
 
                String toString() const;
 
                bool operator==(const XmlNode &other) const;
 
                bool operator!=(const XmlNode &other) const { return !(*this == other); }
 
        private:
                Type       _type = Null;
                XmlElement _element;
                String     _content;
                String     _piTarget;
};
 
// ============================================================================
// DataStream serialization (text-form, length-prefixed, matching JSON pattern)
// ============================================================================
 
inline DataStream &operator<<(DataStream &stream, const XmlElement &elem) {
        stream.beginFrame(DataTypeXmlElement, 1);
        stream << elem.toString(0);
        stream.endFrame();
        return stream;
}
 
inline DataStream &operator>>(DataStream &stream, XmlElement &elem) {
        if (!stream.readFrame(DataTypeXmlElement)) {
                elem = XmlElement();
                return stream;
        }
        String text;
        stream >> text;
        if (stream.status() != DataStream::Ok) {
                elem = XmlElement();
                return stream;
        }
        // A default-constructed XmlElement serializes to an empty
        // string; round-trip it as a default rather than feeding the
        // parser an empty buffer.
        if (text.isEmpty()) {
                elem = XmlElement();
                return stream;
        }
        XmlParseError perr;
        elem = XmlElement::parse(text, &perr);
        if (!perr) {
                stream.setError(DataStream::ReadCorruptData,
                                String("XmlElement::parse failed: ") + perr.toString());
        }
        return stream;
}
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::XmlDocument);
PROMEKI_FORMAT_VIA_TOSTRING(promeki::XmlElement);
 
#endif // PROMEKI_ENABLE_CORE