xml.hpp

Go to the documentation of this file.

#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;
 
    void set_limits(size_t value_size_limit, size_t path_size_limit);
 
private:
    bool FZ_PRIVATE_SYMBOL decode_ref();
    bool FZ_PRIVATE_SYMBOL is_valid_tag_or_attr(std::string_view s) const;
    bool FZ_PRIVATE_SYMBOL normalize_value();
 
    bool FZ_PRIVATE_SYMBOL parse_valid_utf8(std::string_view data);
    bool FZ_PRIVATE_SYMBOL parse(char const* const begin, char const* const end);
    void FZ_PRIVATE_SYMBOL set_error(std::string_view msg, size_t offset);
 
    bool FZ_PRIVATE_SYMBOL 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_name,
        attribute_equal,
        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 name_;
    std::string value_;
    size_t processed_{};
    std::string converted_{};
 
    size_t path_size_limit_{1024*1024};
    size_t value_size_limit_{10*1024*1024};
 
    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 FZ_PRIVATE_SYMBOL apply_namespaces(std::string_view in);
    bool FZ_PRIVATE_SYMBOL apply_namespace_to_path();
 
    bool FZ_PRIVATE_SYMBOL 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 FZ_PRIVATE_SYMBOL finish_line();
    void FZ_PRIVATE_SYMBOL print_line();
 
    size_t depth_{};
    std::string value_;
    std::string line_;
};
 
class FZ_PUBLIC_SYMBOL pretty_logger final : 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