sax_token_parser.hpp

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#ifndef INCLUDED_ORCUS_SAX_TOKEN_PARSER_HPP
#define INCLUDED_ORCUS_SAX_TOKEN_PARSER_HPP
 
#include "sax_ns_parser.hpp"
#include "types.hpp"
 
#include <vector>
#include <algorithm>
#include <functional>
 
namespace orcus {
 
class tokens;
 
class ORCUS_PSR_DLLPUBLIC sax_token_handler_wrapper_base
{
protected:
    xml_declaration_t m_declaration;
    xml_token_element_t m_elem;
    const tokens& m_tokens;
 
    xml_token_t tokenize(std::string_view name) const;
    void set_element(const sax_ns_parser_element& elem);
 
public:
    sax_token_handler_wrapper_base(const tokens& _tokens);
 
    void attribute(std::string_view name, std::string_view val);
    void attribute(const sax_ns_parser_attribute& attr);
};
 
class sax_token_handler
{
public:

    void declaration(const orcus::xml_declaration_t& decl)
    {
        (void)decl;
    }

    void start_element(const orcus::xml_token_element_t& elem)
    {
        (void)elem;
    }

    void end_element(const orcus::xml_token_element_t& elem)
    {
        (void)elem;
    }

    void characters(std::string_view val, bool transient)
    {
        (void)val; (void)transient;
    }
};

template<typename HandlerT>
class sax_token_parser
{
public:
    typedef HandlerT handler_type;
 
    sax_token_parser(
        std::string_view content, const tokens& _tokens,
        xmlns_context& ns_cxt, handler_type& handler);
 
    ~sax_token_parser() = default;
 
    void parse();
 
private:

    class handler_wrapper : public sax_token_handler_wrapper_base
    {
        handler_type& m_handler;
 
    public:
        handler_wrapper(const tokens& _tokens, handler_type& handler) :
            sax_token_handler_wrapper_base(_tokens), m_handler(handler) {}
 
        void doctype(const sax::doctype_declaration&) {}
 
        void start_declaration(std::string_view) {}
 
        void end_declaration(std::string_view)
        {
            m_handler.declaration(m_declaration);
            m_elem.attrs.clear();
        }
 
        void start_element(const sax_ns_parser_element& elem)
        {
            set_element(elem);
            m_handler.start_element(m_elem);
            m_elem.attrs.clear();
        }
 
        void end_element(const sax_ns_parser_element& elem)
        {
            set_element(elem);
            m_handler.end_element(m_elem);
        }
 
        void characters(std::string_view val, bool transient)
        {
            m_handler.characters(val, transient);
        }
    };
 
private:
    handler_wrapper m_wrapper;
    sax_ns_parser<handler_wrapper> m_parser;
};
 
template<typename HandlerT>
sax_token_parser<HandlerT>::sax_token_parser(
    std::string_view content, const tokens& _tokens, xmlns_context& ns_cxt, handler_type& handler) :
    m_wrapper(_tokens, handler),
    m_parser(content, ns_cxt, m_wrapper)
{
}
 
template<typename HandlerT>
void sax_token_parser<HandlerT>::parse()
{
    m_parser.parse();
}
 
} // namespace orcus
 
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */