c4::yml::EventHandlerTree Struct Reference

The event handler to create a ryml Tree. More...

#include <event_handler_tree.hpp>

Inheritance diagram for c4::yml::EventHandlerTree:

Public Types
types
enum	{ requires_strings_on_buffers = false }
using	state = EventHandlerTreeState

Public Member Functions
construction and resetting
	EventHandlerTree () noexcept
	EventHandlerTree (Callbacks const &cb) noexcept
	EventHandlerTree (Tree *tree, id_type id)
void	reset (Tree *tree, id_type id)
Callbacks const &	callbacks () const
TagDirectives &	tag_directives ()
TagCache &	tag_cache ()
parse events
void	start_parse (const char *filename, substr ymlsrc)
void	finish_parse ()
void	cancel_parse ()
YAML stream events
void	begin_stream () const noexcept
void	end_stream () const noexcept
YAML document events
void	begin_doc ()
	implicit doc start (without —) More...
void	end_doc ()
	implicit doc end (without ...) More...
void	begin_doc_expl ()
	explicit doc start, with — More...
void	end_doc_expl ()
	explicit doc end, with ... More...
YAML map events
void	begin_map_key_flow ()
void	begin_map_key_block ()
void	begin_map_val_flow ()
void	begin_map_val_block ()
void	end_map_block ()
void	end_map_flow (bool multiline, type_bits multiline_style=FLOW_ML1)
YAML seq events
void	begin_seq_key_flow ()
void	begin_seq_key_block ()
void	begin_seq_val_flow ()
void	begin_seq_val_block ()
void	end_seq_block ()
void	end_seq_flow (bool multiline, type_bits multiline_style=FLOW_ML1)
YAML structure events
void	add_sibling ()
void	actually_val_is_first_key_of_new_map_flow ()
	reset the previous val as the first key of a new map, with flow style. More...
void	actually_val_is_first_key_of_new_map_block ()
	like its flow counterpart, but this function can only be called after the end of a flow-val at root or doc level. More...
YAML scalar events
void	set_key_scalar_plain_empty () noexcept
void	set_val_scalar_plain_empty () noexcept
void	set_key_scalar_plain (csubstr scalar) noexcept
void	set_val_scalar_plain (csubstr scalar) noexcept
void	set_key_scalar_dquoted (csubstr scalar) noexcept
void	set_val_scalar_dquoted (csubstr scalar) noexcept
void	set_key_scalar_squoted (csubstr scalar) noexcept
void	set_val_scalar_squoted (csubstr scalar) noexcept
void	set_key_scalar_literal (csubstr scalar) noexcept
void	set_val_scalar_literal (csubstr scalar) noexcept
void	set_key_scalar_folded (csubstr scalar) noexcept
void	set_val_scalar_folded (csubstr scalar) noexcept
void	mark_key_scalar_unfiltered () noexcept
void	mark_val_scalar_unfiltered () noexcept
YAML anchor/reference events
void	set_key_anchor (csubstr anchor)
void	set_val_anchor (csubstr anchor)
void	set_key_ref (csubstr ref)
void	set_val_ref (csubstr ref)
YAML tag events
void	set_key_tag (csubstr tag)
void	set_val_tag (csubstr tag)
YAML directive events
void	add_directive_yaml (csubstr yaml_version)
void	add_directive_tag (csubstr handle, csubstr prefix)
arena functions
substr	arena ()
substr	arena_rem ()
substr	alloc_arena (size_t len)

Public Attributes
detail::stack< state >	m_stack
state *	m_curr
	current stack level: top of the stack. cached here for easier access. More...
state *	m_parent
	parent of the current stack level. More...
substr	m_src

Protected Member Functions
void	_stack_start_parse (const char *filename, substr ymlsrc)
void	_stack_finish_parse ()
void	_stack_reset_root ()
void	_stack_reset_non_root ()
void	_stack_push ()
void	_stack_pop ()
bool	_stack_should_push_on_begin_doc () const
bool	_stack_should_pop_on_end_doc () const

Detailed Description

The event handler to create a ryml Tree.

See the documentation for Event Handlers, which has important notes about the event model used by rapidyaml.

Definition at line 43 of file event_handler_tree.hpp.

Member Typedef Documentation

using c4::yml::EventHandlerTree::state = EventHandlerTreeState

Definition at line 49 of file event_handler_tree.hpp.

Member Enumeration Documentation

anonymous enum

Enumerator
requires_strings_on_buffers

Definition at line 50 of file event_handler_tree.hpp.

{ requires_strings_on_buffers = false }; // NOLINT

Constructor & Destructor Documentation

c4::yml::EventHandlerTree::EventHandlerTree ( )

inlinenoexcept

Definition at line 76 of file event_handler_tree.hpp.

: EventHandlerStack(), m_tree(), m_curr_doc() {}

c4::yml::EventHandlerTree::EventHandlerTree ( Callbacks const &  cb )

inlinenoexcept

Definition at line 77 of file event_handler_tree.hpp.

: EventHandlerStack(cb), m_tree(), m_curr_doc() {}

c4::yml::EventHandlerTree::EventHandlerTree ( Tree *  tree, id_type  id  )

inline

Definition at line 78 of file event_handler_tree.hpp.

                                               : EventHandlerStack(tree->callbacks()), m_tree(tree), m_curr_doc()
    {
        reset(tree, id);
    }

Member Function Documentation

void c4::yml::EventHandlerTree::reset ( Tree *  tree, id_type  id  )

inline

Definition at line 83 of file event_handler_tree.hpp.

Referenced by EventHandlerTree().

    {
        if C4_UNLIKELY(!tree)
            RYML_ERR_BASIC_CB_(m_stack.m_callbacks, "null tree");
        if C4_UNLIKELY(id >= tree->capacity())
            RYML_ERR_VISIT_CB_(tree->callbacks(), tree, id, "invalid node");
        if C4_UNLIKELY(!tree->is_root(id))
            if C4_UNLIKELY(tree->is_map(tree->parent(id)))
                if C4_UNLIKELY(!tree->has_key(id))
                    RYML_ERR_BASIC_CB_(tree->callbacks(), "destination node belongs to a map and has no key");
        m_tree = tree;
        if(m_tree->is_root(id))
        {
            _stack_reset_root();
            _reset_parser_state(m_curr, id, m_tree->root_id());
        }
        else
        {
            _stack_reset_non_root();
            _reset_parser_state(m_parent, id, m_tree->parent(id));
            _reset_parser_state(m_curr, id, id);
        }
        m_curr_doc = m_tree->ancestor_doc(id);
        m_tag_cache.clear();
    }

Callbacks const& c4::yml::EventHandlerTree::callbacks ( ) const

inline

Definition at line 109 of file event_handler_tree.hpp.

{ return m_stack.m_callbacks; }

TagDirectives& c4::yml::EventHandlerTree::tag_directives ( )

inline

Definition at line 111 of file event_handler_tree.hpp.

{ return m_tree->m_tag_directives; } // NOLINT(readability-make-member-function-const)

TagCache& c4::yml::EventHandlerTree::tag_cache ( )

inline

Definition at line 112 of file event_handler_tree.hpp.

{ return m_tag_cache; }

void c4::yml::EventHandlerTree::start_parse ( const char *  filename, substr  ymlsrc  )

inline

Definition at line 121 of file event_handler_tree.hpp.

    {
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_tree != nullptr);
        this->_stack_start_parse(filename, ymlsrc);
    }

void c4::yml::EventHandlerTree::finish_parse ( )

inline

Definition at line 127 of file event_handler_tree.hpp.

    {
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_tree != nullptr);
        this->_stack_finish_parse();
        /* This pointer is temporary. Remember that:
         *
         * - this handler object may be held by the user
         * - it may be used with a temporary tree inside the parse function
         * - when the parse function returns the temporary tree, its address
         *   will change
         *
         * As a result, the user could try to read the tree from m_tree, and
         * end up reading the stale temporary object.
         *
         * So it is better to clear it here; then the user will get an obvious
         * segfault if reading from m_tree. */
        m_tree = nullptr;
    }

void c4::yml::EventHandlerTree::cancel_parse ( )

inline

Definition at line 146 of file event_handler_tree.hpp.

    {
        m_tree = nullptr;
    }

void c4::yml::EventHandlerTree::begin_stream ( ) const

inlinenoexcept

Definition at line 158 of file event_handler_tree.hpp.

{ /* nothing to do */ }

void c4::yml::EventHandlerTree::end_stream ( ) const

inlinenoexcept

Definition at line 160 of file event_handler_tree.hpp.

{ /* nothing to do */ }

void c4::yml::EventHandlerTree::begin_doc ( )

inline

implicit doc start (without —)

Definition at line 170 of file event_handler_tree.hpp.

    {
        _c4dbgp("begin_doc");
        if(_stack_should_push_on_begin_doc())
        {
            _c4dbgp("push!");
            _set_root_as_stream();
            _push();
            ryml_enable_(DOC);
        }
        m_curr_doc = m_curr->node_id;
    }

void c4::yml::EventHandlerTree::end_doc ( )

inline

implicit doc end (without ...)

Definition at line 183 of file event_handler_tree.hpp.

    {
        _c4dbgp("end_doc");
        m_curr_doc = m_tree->size();
        if(_stack_should_pop_on_end_doc())
        {
            _remove_speculative();
            _c4dbgp("pop!");
            _pop();
        }
    }

void c4::yml::EventHandlerTree::begin_doc_expl ( )

inline

explicit doc start, with —

Definition at line 196 of file event_handler_tree.hpp.

    {
        _c4dbgp("begin_doc_expl");
        RYML_ASSERT_VISIT_CB_(m_stack.m_callbacks, m_tree->root_id() == m_curr->node_id, m_tree, m_curr->node_id);
        if(m_tree->is_stream(m_tree->root_id())) //if(_should_push_on_begin_doc())
        {
            _c4dbgp("push!");
            _push();
        }
        else
        {
            _c4dbgp("ensure stream");
            _set_root_as_stream();
            const id_type root = m_tree->root_id();
            const id_type first = m_tree->first_child(root);
            RYML_ASSERT_VISIT_CB_(m_stack.m_callbacks, m_tree->is_stream(root), m_tree, root);
            RYML_ASSERT_VISIT_CB_(m_stack.m_callbacks, m_tree->num_children(root) == 1u, m_tree, root);
            if(m_tree->is_container(first) || m_tree->is_val(first))
            {
                _c4dbgp("push!");
                _push();
                #ifdef RYML_WITH_COMMENTS
                m_tree->_p(root)->m_first_comment = NONE;
                m_tree->_p(root)->m_last_comment = NONE;
                #endif
            }
            else
            {
                _c4dbgp("tweak");
                _push();
                _remove_speculative();
                m_curr->node_id = m_tree->last_child(root);
                m_curr->tr_data = m_tree->_p(m_curr->node_id);
            }
        }
        ryml_enable_(DOC);
        m_curr_doc = m_curr->node_id;
    }

void c4::yml::EventHandlerTree::end_doc_expl ( )

inline

explicit doc end, with ...

Definition at line 235 of file event_handler_tree.hpp.

    {
        _c4dbgp("end_doc_expl");
        m_curr_doc = m_tree->size();
        _remove_speculative();
        if(_stack_should_pop_on_end_doc())
        {
            _c4dbgp("pop!");
            _pop();
        }
    }

void c4::yml::EventHandlerTree::begin_map_key_flow ( )

inline

Definition at line 254 of file event_handler_tree.hpp.

    {
        RYML_ERR_PARSE_CB_(m_stack.m_callbacks, m_curr->pos, "ryml trees cannot handle containers as keys");
    }

void c4::yml::EventHandlerTree::begin_map_key_block ( )

inline

Definition at line 258 of file event_handler_tree.hpp.

    {
        RYML_ERR_PARSE_CB_(m_stack.m_callbacks, m_curr->pos, "ryml trees cannot handle containers as keys");
    }

void c4::yml::EventHandlerTree::begin_map_val_flow ( )

inline

Definition at line 263 of file event_handler_tree.hpp.

Referenced by actually_val_is_first_key_of_new_map_flow().

    {
        _c4dbgpf("node[{}]: begin_map_val_flow", m_curr->node_id);
        RYML_CHECK_BASIC_CB_(m_stack.m_callbacks, !ryml_hasany_(VAL));
        ryml_enable_(MAP|FLOW_SL);
        _save_loc();
        _push();
    }

void c4::yml::EventHandlerTree::begin_map_val_block ( )

inline

Definition at line 271 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: begin_map_val_block", m_curr->node_id);
        RYML_CHECK_BASIC_CB_(m_stack.m_callbacks, !ryml_hasany_(VAL));
        ryml_enable_(MAP|BLOCK);
        _save_loc();
        _push();
    }

void c4::yml::EventHandlerTree::end_map_block ( )

inline

Definition at line 280 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: end_map_block", m_parent->node_id, m_parent->pos.line, m_curr->pos.line);
        _pop();
    }

void c4::yml::EventHandlerTree::end_map_flow ( bool  multiline, type_bits  multiline_style = FLOW_ML1  )

inline

Definition at line 286 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: end_map. multiline={} startline={} endline={}", m_parent->node_id, multiline, m_parent->pos.line, m_curr->pos.line);
        _pop();
        if(multiline)
        {
            ryml_disable_(FLOW_SL);
            enable_(multiline_style);
        }
    }

void c4::yml::EventHandlerTree::begin_seq_key_flow ( )

inline

Definition at line 304 of file event_handler_tree.hpp.

    {
        RYML_ERR_PARSE_CB_(m_stack.m_callbacks, m_curr->pos, "ryml trees cannot handle containers as keys");
    }

void c4::yml::EventHandlerTree::begin_seq_key_block ( )

inline

Definition at line 308 of file event_handler_tree.hpp.

    {
        RYML_ERR_PARSE_CB_(m_stack.m_callbacks, m_curr->pos, "ryml trees cannot handle containers as keys");
    }

void c4::yml::EventHandlerTree::begin_seq_val_flow ( )

inline

Definition at line 313 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: begin_seq_val_flow", m_curr->node_id);
        RYML_CHECK_BASIC_CB_(m_stack.m_callbacks, !ryml_hasany_(VAL));
        ryml_enable_(SEQ|FLOW_SL);
        _save_loc();
        _push();
    }

void c4::yml::EventHandlerTree::begin_seq_val_block ( )

inline

Definition at line 321 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: begin_seq_val_block", m_curr->node_id);
        RYML_CHECK_BASIC_CB_(m_stack.m_callbacks, !ryml_hasany_(VAL));
        ryml_enable_(SEQ|BLOCK);
        _save_loc();
        _push();
    }

void c4::yml::EventHandlerTree::end_seq_block ( )

inline

Definition at line 330 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: end_seq_block", m_parent->node_id, m_parent->pos.line, m_curr->pos.line);
        _pop();
    }

void c4::yml::EventHandlerTree::end_seq_flow ( bool  multiline, type_bits  multiline_style = FLOW_ML1  )

inline

Definition at line 336 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: end_seq. multiline={} startline={} endline={}", m_parent->node_id, multiline, m_parent->pos.line, m_curr->pos.line);
        _pop();
        if(multiline)
        {
            ryml_disable_(FLOW_SL);
            enable_(multiline_style);
        }
    }

void c4::yml::EventHandlerTree::add_sibling ( )

inline

Definition at line 354 of file event_handler_tree.hpp.

    {
        #if defined(__GNUC__) && (__GNUC__ >= 6)
        C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wnull-dereference")
        #endif
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_tree);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_parent);
        RYML_ASSERT_VISIT_CB_(m_stack.m_callbacks, m_tree->has_children(m_parent->node_id), m_tree, m_parent->node_id);
        NodeData const* const prev = m_tree->m_buf; // watchout against relocation of the tree nodes
        _set_state_(m_curr, m_tree->_append_child__unprotected(m_parent->node_id));
        if(prev != m_tree->m_buf)
            _refresh_after_relocation();
        _c4dbgpf("node[{}]: added sibling={} prev={}", m_parent->node_id, m_curr->node_id, m_tree->prev_sibling(m_curr->node_id));
        #if defined(__GNUC__) && (__GNUC__ >= 6)
        C4_SUPPRESS_WARNING_GCC_POP
        #endif
    }

void c4::yml::EventHandlerTree::actually_val_is_first_key_of_new_map_flow ( )

inline

reset the previous val as the first key of a new map, with flow style.

See the documentation for Event Handlers, which has important notes about this event.

Definition at line 377 of file event_handler_tree.hpp.

    {
        if C4_UNLIKELY(m_tree->is_container(m_curr->node_id))
            RYML_ERR_PARSE_CB_(m_stack.m_callbacks, m_curr->pos, "ryml trees cannot handle containers as keys");
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_parent);
        RYML_ASSERT_VISIT_CB_(m_stack.m_callbacks, m_tree->is_seq(m_parent->node_id), m_tree, m_parent->node_id);
        RYML_ASSERT_VISIT_CB_(m_stack.m_callbacks, !m_tree->is_container(m_curr->node_id), m_tree, m_curr->node_id);
        RYML_ASSERT_VISIT_CB_(m_stack.m_callbacks, !m_tree->has_key(m_curr->node_id), m_tree, m_curr->node_id);
        const NodeData tmp = _val2key_(*m_curr->tr_data);
        ryml_disable_(VALMASK_|VAL_STYLE|VALNIL);
        m_curr->tr_data->m_val = {};
        begin_map_val_flow();
        m_curr->tr_data->m_type = tmp.m_type;
        m_curr->tr_data->m_key = tmp.m_key;
    }

void c4::yml::EventHandlerTree::actually_val_is_first_key_of_new_map_block ( )

inline

like its flow counterpart, but this function can only be called after the end of a flow-val at root or doc level.

See the documentation for Event Handlers, which has important notes about this event.

Definition at line 399 of file event_handler_tree.hpp.

    {
        RYML_ERR_PARSE_CB_(m_stack.m_callbacks, m_curr->pos, "ryml trees cannot handle containers as keys");
    }

void c4::yml::EventHandlerTree::set_key_scalar_plain_empty ( )

inlinenoexcept

Definition at line 412 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set key scalar plain as empty", m_curr->node_id);
        m_curr->tr_data->m_key.scalar = {};
        ryml_enable_(KEY|KEY_PLAIN|KEYNIL);
    }

void c4::yml::EventHandlerTree::set_val_scalar_plain_empty ( )

inlinenoexcept

Definition at line 418 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set val scalar plain as empty", m_curr->node_id);
        m_curr->tr_data->m_val.scalar = {};
        ryml_enable_(VAL|VAL_PLAIN|VALNIL);
    }

void c4::yml::EventHandlerTree::set_key_scalar_plain ( csubstr  scalar )

inlinenoexcept

Definition at line 425 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set key scalar plain: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
        m_curr->tr_data->m_key.scalar = scalar;
        ryml_enable_(KEY|KEY_PLAIN);
    }

void c4::yml::EventHandlerTree::set_val_scalar_plain ( csubstr  scalar )

inlinenoexcept

Definition at line 431 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set val scalar plain: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
        m_curr->tr_data->m_val.scalar = scalar;
        ryml_enable_(VAL|VAL_PLAIN);
    }

void c4::yml::EventHandlerTree::set_key_scalar_dquoted ( csubstr  scalar )

inlinenoexcept

Definition at line 439 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set key scalar dquot: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
        m_curr->tr_data->m_key.scalar = scalar;
        ryml_enable_(KEY|KEY_DQUO);
    }

void c4::yml::EventHandlerTree::set_val_scalar_dquoted ( csubstr  scalar )

inlinenoexcept

Definition at line 445 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set val scalar dquot: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
        m_curr->tr_data->m_val.scalar = scalar;
        ryml_enable_(VAL|VAL_DQUO);
    }

void c4::yml::EventHandlerTree::set_key_scalar_squoted ( csubstr  scalar )

inlinenoexcept

Definition at line 453 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set key scalar squot: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
        m_curr->tr_data->m_key.scalar = scalar;
        ryml_enable_(KEY|KEY_SQUO);
    }

void c4::yml::EventHandlerTree::set_val_scalar_squoted ( csubstr  scalar )

inlinenoexcept

Definition at line 459 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set val scalar squot: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
        m_curr->tr_data->m_val.scalar = scalar;
        ryml_enable_(VAL|VAL_SQUO);
    }

void c4::yml::EventHandlerTree::set_key_scalar_literal ( csubstr  scalar )

inlinenoexcept

Definition at line 467 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set key scalar literal: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
        m_curr->tr_data->m_key.scalar = scalar;
        ryml_enable_(KEY|KEY_LITERAL);
    }

void c4::yml::EventHandlerTree::set_val_scalar_literal ( csubstr  scalar )

inlinenoexcept

Definition at line 473 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set val scalar literal: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
        m_curr->tr_data->m_val.scalar = scalar;
        ryml_enable_(VAL|VAL_LITERAL);
    }

void c4::yml::EventHandlerTree::set_key_scalar_folded ( csubstr  scalar )

inlinenoexcept

Definition at line 481 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set key scalar folded: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
        m_curr->tr_data->m_key.scalar = scalar;
        ryml_enable_(KEY|KEY_FOLDED);
    }

void c4::yml::EventHandlerTree::set_val_scalar_folded ( csubstr  scalar )

inlinenoexcept

Definition at line 487 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set val scalar folded: [{}]~~~{}~~~", m_curr->node_id, scalar.len, scalar);
        m_curr->tr_data->m_val.scalar = scalar;
        ryml_enable_(VAL|VAL_FOLDED);
    }

void c4::yml::EventHandlerTree::mark_key_scalar_unfiltered ( )

inlinenoexcept

Definition at line 495 of file event_handler_tree.hpp.

    {
        ryml_enable_(KEY_UNFILT);
    }

void c4::yml::EventHandlerTree::mark_val_scalar_unfiltered ( )

inlinenoexcept

Definition at line 499 of file event_handler_tree.hpp.

    {
        ryml_enable_(VAL_UNFILT);
    }

void c4::yml::EventHandlerTree::set_key_anchor ( csubstr  anchor )

inline

Definition at line 511 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set key anchor: [{}]~~~{}~~~", m_curr->node_id, anchor.len, anchor);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_tree);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, !ryml_hasany_(KEYREF));
        RYML_ASSERT_PARSE_CB_(m_tree->callbacks(), !anchor.begins_with('&'), m_curr->pos);
        ryml_enable_(KEYANCH);
        m_curr->tr_data->m_key.anchor = anchor;
    }

void c4::yml::EventHandlerTree::set_val_anchor ( csubstr  anchor )

inline

Definition at line 520 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set val anchor: [{}]~~~{}~~~", m_curr->node_id, anchor.len, anchor);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_tree);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, !ryml_hasany_(VALREF));
        RYML_ASSERT_PARSE_CB_(m_tree->callbacks(), !anchor.begins_with('&'), m_curr->pos);
        ryml_enable_(VALANCH);
        m_curr->tr_data->m_val.anchor = anchor;
    }

void c4::yml::EventHandlerTree::set_key_ref ( csubstr  ref )

inline

Definition at line 530 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set key ref: [{}]~~~{}~~~", m_curr->node_id, ref.len, ref);
        RYML_ASSERT_PARSE_CB_(m_stack.m_callbacks, ref.begins_with('*'), m_curr->pos);
        RYML_ASSERT_PARSE_CB_(m_stack.m_callbacks, !ryml_hasany_(KEYANCH), m_curr->pos);
        ryml_enable_(KEY|KEYREF);
        m_curr->tr_data->m_key.anchor = ref.sub(1);
        m_curr->tr_data->m_key.scalar = ref;
    }

void c4::yml::EventHandlerTree::set_val_ref ( csubstr  ref )

inline

Definition at line 539 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set val ref: [{}]~~~{}~~~", m_curr->node_id, ref.len, ref);
        RYML_ASSERT_PARSE_CB_(m_stack.m_callbacks, ref.begins_with('*'), m_curr->pos);
        RYML_ASSERT_PARSE_CB_(m_stack.m_callbacks, !ryml_hasany_(VALANCH), m_curr->pos);
        ryml_enable_(VAL|VALREF);
        m_curr->tr_data->m_val.anchor = ref.sub(1);
        m_curr->tr_data->m_val.scalar = ref;
    }

void c4::yml::EventHandlerTree::set_key_tag ( csubstr  tag )

inline

Definition at line 556 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set key tag: [{}]~~~{}~~~", m_curr->node_id, tag.len, tag);
        ryml_enable_(KEYTAG);
        m_curr->tr_data->m_key.tag = tag;
    }

void c4::yml::EventHandlerTree::set_val_tag ( csubstr  tag )

inline

Definition at line 562 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set val tag: [{}]~~~{}~~~", m_curr->node_id, tag.len, tag);
        ryml_enable_(VALTAG);
        m_curr->tr_data->m_val.tag = tag;
    }

void c4::yml::EventHandlerTree::add_directive_yaml ( csubstr  yaml_version )

inline

Definition at line 576 of file event_handler_tree.hpp.

    {
        _c4dbgpf("%YAML directive! version={}", yaml_version);
        (void)yaml_version;
    }

void c4::yml::EventHandlerTree::add_directive_tag ( csubstr  handle, csubstr  prefix  )

inline

Definition at line 582 of file event_handler_tree.hpp.

    {
        _c4dbgpf("%TAG directive! handle={} prefix={} id={}", handle, prefix, m_curr_doc);
        if C4_UNLIKELY(!m_tree->m_tag_directives.add(handle, prefix, m_curr_doc))
            RYML_ERR_PARSE_CB_(m_stack.m_callbacks, m_curr->pos, "too many %TAG directives");
    }

substr c4::yml::EventHandlerTree::arena ( )

inline

Definition at line 596 of file event_handler_tree.hpp.

    {
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_tree);
        return m_tree->m_arena.first(m_tree->m_arena_pos);
    }

substr c4::yml::EventHandlerTree::arena_rem ( )

inline

Definition at line 601 of file event_handler_tree.hpp.

    {
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_tree);
        return m_tree->m_arena.sub(m_tree->m_arena_pos);
    }

substr c4::yml::EventHandlerTree::alloc_arena ( size_t  len )

inline

Definition at line 606 of file event_handler_tree.hpp.

    {
        return m_tree->alloc_arena(len);
    }

void c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::_stack_start_parse ( const char *  filename, substr  ymlsrc  )

inlineprotectedinherited

Definition at line 58 of file event_handler_stack.hpp.

Referenced by start_parse().

    {
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_curr != nullptr);
        m_curr->start_parse(filename, m_curr->node_id);
        m_src = ymlsrc;
    }

void c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::_stack_finish_parse ( )

inlineprotectedinherited

Definition at line 65 of file event_handler_stack.hpp.

Referenced by finish_parse().

    {
    }

void c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::_stack_reset_root ( )

inlineprotectedinherited

Definition at line 71 of file event_handler_stack.hpp.

Referenced by reset().

    {
        m_stack.clear();
        m_stack.push({});
        m_parent = nullptr;
        m_curr = &m_stack.top();
    }

void c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::_stack_reset_non_root ( )

inlineprotectedinherited

Definition at line 79 of file event_handler_stack.hpp.

Referenced by reset().

    {
        m_stack.clear();
        m_stack.push({}); // parent
        m_stack.push({}); // node
        m_parent = &m_stack.top(1);
        m_curr = &m_stack.top();
    }

void c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::_stack_push ( )

inlineprotectedinherited

Definition at line 88 of file event_handler_stack.hpp.

    {
        m_stack.push_top();
        m_parent = &m_stack.top(1); // don't use m_curr. watch out for relocations inside the prev push
        m_curr = &m_stack.top();
        m_curr->reset_after_push();
    }

void c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::_stack_pop ( )

inlineprotectedinherited

Definition at line 96 of file event_handler_stack.hpp.

    {
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_parent);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_stack.size() > 1);
        m_parent->reset_before_pop(*m_curr);
        m_stack.pop();
        m_parent = m_stack.size() > 1 ? &m_stack.top(1) : nullptr;
        m_curr = &m_stack.top();
        #ifdef RYML_DBG
        if(m_parent)
            _c4dbgpf("popped! top is now node={} (parent={})", m_curr->node_id, m_parent->node_id);
        else
            _c4dbgpf("popped! top is now node={} @ ROOT", m_curr->node_id);
        #endif
    }

bool c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::_stack_should_push_on_begin_doc ( ) const

inlineprotectedinherited

Definition at line 121 of file event_handler_stack.hpp.

Referenced by begin_doc().

    {
        const bool is_root = (m_stack.size() == 1u);
        return is_root && (m_curr->has_children || ryml_has_any_(DOC|VAL|MAP|SEQ));
    }

bool c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::_stack_should_pop_on_end_doc ( ) const

inlineprotectedinherited

Definition at line 127 of file event_handler_stack.hpp.

Referenced by end_doc(), and end_doc_expl().

    {
        const bool is_root = (m_stack.size() == 1u);
        return !is_root && ryml_has_any_(DOC);
    }

Member Data Documentation

detail::stack<state> c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::m_stack

inherited

Definition at line 46 of file event_handler_stack.hpp.

Referenced by actually_val_is_first_key_of_new_map_block(), actually_val_is_first_key_of_new_map_flow(), add_directive_tag(), add_sibling(), arena(), arena_rem(), begin_doc_expl(), begin_map_key_block(), begin_map_key_flow(), begin_map_val_block(), begin_map_val_flow(), begin_seq_key_block(), begin_seq_key_flow(), begin_seq_val_block(), begin_seq_val_flow(), callbacks(), finish_parse(), reset(), set_key_anchor(), set_key_ref(), set_val_anchor(), set_val_ref(), and start_parse().

state* c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::m_curr

inherited

current stack level: top of the stack. cached here for easier access.

Definition at line 47 of file event_handler_stack.hpp.

Referenced by actually_val_is_first_key_of_new_map_block(), actually_val_is_first_key_of_new_map_flow(), add_directive_tag(), add_sibling(), begin_doc(), begin_doc_expl(), begin_map_key_block(), begin_map_key_flow(), begin_map_val_block(), begin_map_val_flow(), begin_seq_key_block(), begin_seq_key_flow(), begin_seq_val_block(), begin_seq_val_flow(), end_map_block(), end_map_flow(), end_seq_block(), end_seq_flow(), reset(), set_key_anchor(), set_key_ref(), set_key_scalar_dquoted(), set_key_scalar_folded(), set_key_scalar_literal(), set_key_scalar_plain(), set_key_scalar_plain_empty(), set_key_scalar_squoted(), set_key_tag(), set_val_anchor(), set_val_ref(), set_val_scalar_dquoted(), set_val_scalar_folded(), set_val_scalar_literal(), set_val_scalar_plain(), set_val_scalar_plain_empty(), set_val_scalar_squoted(), and set_val_tag().

state* c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::m_parent

inherited

parent of the current stack level.

Definition at line 48 of file event_handler_stack.hpp.

Referenced by actually_val_is_first_key_of_new_map_flow(), add_sibling(), end_map_block(), end_map_flow(), end_seq_block(), end_seq_flow(), and reset().

substr c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::m_src

inherited

Definition at line 49 of file event_handler_stack.hpp.

---

The documentation for this struct was generated from the following file:

• /tmp/B.egjz6vsx/BUILD/rapidyaml-0.16.0-build/rapidyaml-0.16.0/src/c4/yml/event_handler_tree.hpp