xml.hpp

#ifndef LIBFILEZILLA_XML_HEADER
#define LIBFILEZILLA_XML_HEADER

#include <functional>
#include <string>
#include <tuple>
#include <vector>

#include "buffer.hpp"
#include "logger.hpp"

namespace fz {

namespace xml {

enum class callback_event
{
    open,

    close,

    attribute,

    value,

    parsing_instruction,

    doctype,
};

class FZ_PUBLIC_SYMBOL parser final
{
public:
    typedef std::function<bool(callback_event type, std::string_view path, std::string_view name, std::string && value)> callback_t;

    parser();
    parser(callback_t const& cb);
    parser(callback_t && cb);

    void set_callback(callback_t && cb);
    void set_callback(callback_t const& cb);

    bool parse(std::string_view data);

    bool finalize();

    std::string get_error() const;

private:
    bool decode_ref();
    bool is_valid_tag_or_attr(std::string_view s) const;
    bool normalize_value();

    bool parse_valid_utf8(std::string_view data);
    bool parse(char const* const begin, char const* const end);
    void set_error(std::string_view msg, size_t offset);

    bool deduce_encoding(std::string_view & data);

    enum class state {
        content,
        tag_start, // Just after reading <
        tag_name, // Reading tag name
        tag_closing, // In a closing tag, matching the tag name
        tag_end, // Just before reading >

        attributes,
        attribute_quote,
        attribute_value,

        // <?xml and other parsing intructions
        pi,
        pi_value,

        // entity and character references
        reference,
        attrvalue_reference,

        comment_start,
        comment_end,

        doctype_start,
        doctype_name,
        doctype_value,

        cdata_start,
        cdata_end,

        done,
        error
    };

    callback_t cb_;

    std::string path_;
    std::vector<size_t> nodes_;
    std::string value_;
    size_t processed_{};
    std::string converted_{};

    union {
        size_t utf8_state_{};
        uint32_t utf16_state_;
    };

    state s_{ state::content };

    enum class encoding {
        unknown,
        utf8,
        utf16le,
        utf16be
    };
    encoding encoding_{};

    union {
        size_t tag_match_pos_{};
        char quotes_;
        unsigned char dashes_;
    };

    bool got_xmldecl_{};
    bool got_doctype_{};
    bool got_element_{};
};

class FZ_PUBLIC_SYMBOL namespace_parser final
{
public:
    namespace_parser();
    namespace_parser(parser::callback_t const& cb);
    namespace_parser(parser::callback_t && cb);

    void set_callback(parser::callback_t && cb);
    void set_callback(parser::callback_t const& cb);

    bool parse(std::string_view data);
    bool finalize();

    std::string get_error() const;

    typedef std::function<bool(callback_event type, std::string_view path, std::string_view name, std::string_view value)> raw_callback_t;
    void set_raw_callback(raw_callback_t && cb);
    void set_raw_callback(raw_callback_t const& cb);
private:
    std::string_view apply_namespaces(std::string_view in);
    bool apply_namespace_to_path();

    bool on_callback(callback_event type, std::string_view path, std::string_view name, std::string && value);

    parser parser_;

    parser::callback_t cb_;
    raw_callback_t raw_cb_;

    std::string path_;
    fz::buffer applied_;
    std::vector<size_t> nodes_;
    std::vector<std::pair<std::string, std::string>> attributes_;
    std::vector<std::tuple<size_t, std::string, std::string>> namespaces_;
    bool needs_namespace_expansion_{};
    bool error_{};
};

class FZ_PUBLIC_SYMBOL pretty_printer
{
public:
    pretty_printer() = default;
    virtual ~pretty_printer();

    void log(callback_event type, std::string_view, std::string_view name, std::string_view value);

protected:
    virtual void on_line(std::string_view line) = 0;

private:
    void finish_line();
    void print_line();

    size_t depth_{};
    std::string value_;
    std::string line_;
};

class FZ_PUBLIC_SYMBOL pretty_logger : public pretty_printer
{
public:
    pretty_logger(logger_interface & logger, logmsg::type level);

protected:
    virtual void on_line(std::string_view line) override;

    logmsg::type level_;
    logger_interface & logger_;
};


}
}

#endif