simple_traits.hpp

#pragma once
 
#include <wordring/html/simple_node.hpp>
 
#include <wordring/encoding/encoding.hpp>
 
#include <wordring/compatibility.hpp>
#include <wordring/tree/tree.hpp>
 
#include <iterator>
#include <string>
#include <variant>
 
namespace wordring::html
{
    template <typename NodeIterator>
    struct simple_node_traits
    {
        using node_pointer = NodeIterator;
        using node_type    = typename node_pointer::value_type;
 
        using element_type                = typename node_type::element_type;                 // 1.
        using text_type                   = typename node_type::text_type;                    // 3.
        using processing_instruction_type = typename node_type::processing_instruction_type;  // 7.
        using comment_type                = typename node_type::comment_type;                 // 8.
        using document_type               = typename node_type::document_type;                // 9.
        using document_type_type          = typename node_type::document_type_type;           // 10.
        using document_fragment_type      = typename node_type::document_fragment_type;       // 11.
 
        using attribute_type    = typename element_type::attribute_type;
        using attribute_pointer = typename element_type::const_iterator;
 
        using string_type = typename element_type::string_type;
 
        // ----------------------------------------------------------------------------------------
        // Node
        // ----------------------------------------------------------------------------------------
 
        static node_pointer pointer() { return node_pointer(); }
 
        static node_pointer parent(node_pointer it) { return it.parent(); }
 
        static node_pointer begin(node_pointer it) { return it.begin(); }
 
        static node_pointer end(node_pointer it) { return it.end(); }
 
        static node_pointer prev(node_pointer it) { return --it; }
 
        static node_pointer next(node_pointer it) { return ++it; }
 
        static auto& data(node_pointer it) { return it->data(); }
 
        static auto target(node_pointer it) { return it->target(); }
 
        static auto name(node_pointer it) { return it->name(); }
 
        // ----------------------------------------------------------------------------------------
        // Element
        // ----------------------------------------------------------------------------------------
 
        static bool is_element(node_pointer it) { return it->is_element(); }
 
        static void set_document(node_pointer it, node_pointer doc) {}
 
        static ns_name get_namespace_name(node_pointer it)
        {
            return it->namespace_uri_name();
        }
 
        static string_type get_namespace(node_pointer it)
        {
            return it->namespace_uri();
        }
 
        static tag_name get_local_name_name(node_pointer it)
        {
            return it->local_name_name();
        }
 
        static string_type get_local_name(node_pointer it)
        {
            return it->local_name();
        }
 
        static string_type get_qualified_name(node_pointer it)
        {
            return it->qualified_name();
        }
 
        static bool is_html_element_of(node_pointer it, tag_name tag)
        {
            return get_namespace_name(it) == ns_name::HTML && get_local_name_name(it) == tag;
        }
 
        static bool equals(node_pointer lhs, node_pointer rhs)
        {
            return *lhs == *rhs;
        }
 
        static auto abegin(node_pointer it) { return it->begin(); }
 
        static auto aend(node_pointer it) { return it->end(); }
 
        /*
        static auto find(node_pointer it, attribute_name name)
        {
            return wordring::html::find(*it, name);
        }
        */
 
        static void set_non_blocking_flag(node_pointer it, bool b) {}
 
        static void set_already_started_flag(node_pointer it, bool b) {}
 
        // ----------------------------------------------------------------------------------------
        // Attr
        // ----------------------------------------------------------------------------------------
 
        static ns_name get_namespace_name(attribute_type const& attr)
        {
            return attr.namespace_uri_name();
        }
 
        static string_type get_namespace(attribute_type const& attr)
        {
            return attr.namespace_uri();
        }
 
        static attribute_name get_local_name_name(attribute_type const& attr)
        {
            return attr.local_name_name();
        }
 
        static string_type get_local_name(attribute_type const& attr)
        {
            return attr.local_name();
        }
 
        static string_type get_qualified_name(attribute_type const& attr)
        {
            return attr.qualified_name();
        }
 
        static string_type const& value(attribute_type const& attr) { return attr.value(); }
 
        // ----------------------------------------------------------------------------------------
        // Text
        // ----------------------------------------------------------------------------------------
 
        static bool is_text(node_pointer it) { return it->is_text(); }
 
        static text_type create_text(char32_t cp)
        {
            string_type s;
            wordring::to_string(cp, std::back_inserter(s));
            return text_type(s);
        }
 
        static void append_text(node_pointer it, char32_t cp)
        {
            wordring::to_string(cp, std::back_inserter(it->data()));
        }
        
        // ----------------------------------------------------------------------------------------
        // ProcessingInstruction
        // ----------------------------------------------------------------------------------------
 
        static bool is_processing_instruction(node_pointer it) { return it->is_processing_instruction(); }
 
        // ----------------------------------------------------------------------------------------
        // Comment
        // ----------------------------------------------------------------------------------------
 
        static bool is_comment(node_pointer it) { return it->is_comment(); }
 
        static comment_type create_comment(string_type const& data)
        {
            return comment_type(data);
        }
 
        // ----------------------------------------------------------------------------------------
        // Document
        // ----------------------------------------------------------------------------------------
 
        static bool is_document(node_pointer it) { return it->is_document(); }
 
        static document_type_name get_document_type(node_pointer it)
        {
            return it->document_type_name();
        }
 
        static void set_document_type(node_pointer it, document_type_name type)
        {
            it->document_type_name(type);
        }
 
        static document_mode_name get_document_mode(node_pointer it)
        {
            return it->document_mode_name();
        }
 
        static void set_document_mode(node_pointer it, document_mode_name mode)
        {
            it->document_mode_name(mode);
        }
 
        static bool is_iframe_srcdoc_document(node_pointer it) { return false; }
 
        static void set_document_ready_state(string_type const& readiness) {}
 
        // ----------------------------------------------------------------------------------------
        // DocumentType
        // ----------------------------------------------------------------------------------------
 
        static bool is_document_type(node_pointer it) { return it->is_document_type(); }
 
        static document_type_type create_document_type(
            string_type const& name, string_type const& public_id, string_type const& system_id)
        {
            return document_type_type(name, public_id, system_id);
        }
 
        // ----------------------------------------------------------------------------------------
        // CSS Support
        // ----------------------------------------------------------------------------------------
 
        static bool is_root(node_pointer it)
        {
            return is_element(it) && is_html_element_of(it, tag_name::Html);
        }
 
        // ----------------------------------------------------------------------------------------
        // tag_tree Support
        // ----------------------------------------------------------------------------------------
 
        static bool is_single(node_type const& node)
        {
            switch (node.type())
            {
            case node_type::type_name::Text:
            case node_type::type_name::Comment:
            case node_type::type_name::DocumentType:
                return true;
            default:
                break;
            }
            return false;
        }
    };
}