c4::yml::EventHandlerTree Struct Reference

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

#include <event_handler_tree.hpp>

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

Public Member Functions
construction and resetting
	EventHandlerTree ()
	EventHandlerTree (Callbacks const &cb)
	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 —)
void	end_doc ()
	implicit doc end (without ...)
void	begin_doc_expl ()
	explicit doc start, with —
void	end_doc_expl ()
	explicit doc end, with ...
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)
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)
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.
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.
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.
state *	m_parent
	parent of the current stack level.
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 39 of file event_handler_tree.hpp.

Member Typedef Documentation

state

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

Definition at line 45 of file event_handler_tree.hpp.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
requires_strings_on_buffers

Definition at line 46 of file event_handler_tree.hpp.

{ requires_strings_on_buffers = false };

Constructor & Destructor Documentation

EventHandlerTree() [1/3]

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

inline

Definition at line 72 of file event_handler_tree.hpp.

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

EventHandlerTree() [2/3]

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

inline

Definition at line 73 of file event_handler_tree.hpp.

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

EventHandlerTree() [3/3]

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

inline

Definition at line 74 of file event_handler_tree.hpp.

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

Member Function Documentation

reset()

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

inline

Definition at line 79 of file event_handler_tree.hpp.

    {
        if(C4_UNLIKELY(!tree))
            _RYML_ERR_BASIC_(m_stack.m_callbacks, "null tree");
        if(C4_UNLIKELY(id >= tree->capacity()))
            _RYML_ERR_BASIC_(tree->callbacks(), "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_(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()

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

inline

Definition at line 105 of file event_handler_tree.hpp.

{ return m_stack.m_callbacks; }

tag_directives()

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

inline

Definition at line 107 of file event_handler_tree.hpp.

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

tag_cache()

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

inline

Definition at line 108 of file event_handler_tree.hpp.

{ return m_tag_cache; }

start_parse()

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

inline

Definition at line 117 of file event_handler_tree.hpp.

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

finish_parse()

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

inline

Definition at line 123 of file event_handler_tree.hpp.

    {
        _RYML_ASSERT_BASIC_(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;
    }

cancel_parse()

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

inline

Definition at line 142 of file event_handler_tree.hpp.

    {
        m_tree = nullptr;
    }

begin_stream()

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

inlinenoexcept

Definition at line 154 of file event_handler_tree.hpp.

{ /* nothing to do */ }

end_stream()

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

inlinenoexcept

Definition at line 156 of file event_handler_tree.hpp.

{ /* nothing to do */ }

begin_doc()

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

inline

implicit doc start (without —)

Definition at line 166 of file event_handler_tree.hpp.

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

end_doc()

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

inline

implicit doc end (without ...)

Definition at line 179 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();
        }
    }

begin_doc_expl()

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

inline

explicit doc start, with —

Definition at line 192 of file event_handler_tree.hpp.

    {
        _c4dbgp("begin_doc_expl");
        _RYML_ASSERT_VISIT_(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_(m_stack.m_callbacks, m_tree->is_stream(root), m_tree, root);
            _RYML_ASSERT_VISIT_(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);
            }
        }
        _enable_(DOC);
        m_curr_doc = m_curr->node_id;
    }

end_doc_expl()

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

inline

explicit doc end, with ...

Definition at line 231 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();
        }
    }

begin_map_key_flow()

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

inline

Definition at line 250 of file event_handler_tree.hpp.

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

begin_map_key_block()

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

inline

Definition at line 254 of file event_handler_tree.hpp.

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

begin_map_val_flow()

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

inline

Definition at line 259 of file event_handler_tree.hpp.

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

begin_map_val_block()

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

inline

Definition at line 267 of file event_handler_tree.hpp.

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

end_map_block()

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

inline

Definition at line 276 of file event_handler_tree.hpp.

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

end_map_flow()

void c4::yml::EventHandlerTree::end_map_flow ( bool multiline )

inline

Definition at line 282 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)
        {
            _disable_(FLOW_SL);
            _enable_(FLOW_ML);
        }
    }

begin_seq_key_flow()

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

inline

Definition at line 300 of file event_handler_tree.hpp.

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

begin_seq_key_block()

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

inline

Definition at line 304 of file event_handler_tree.hpp.

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

begin_seq_val_flow()

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

inline

Definition at line 309 of file event_handler_tree.hpp.

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

begin_seq_val_block()

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

inline

Definition at line 317 of file event_handler_tree.hpp.

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

end_seq_block()

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

inline

Definition at line 326 of file event_handler_tree.hpp.

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

end_seq_flow()

void c4::yml::EventHandlerTree::end_seq_flow ( bool multiline )

inline

Definition at line 332 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)
        {
            _disable_(FLOW_SL);
            _enable_(FLOW_ML);
        }
    }

add_sibling()

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

inline

Definition at line 350 of file event_handler_tree.hpp.

    {
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_tree);
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_parent);
        _RYML_ASSERT_VISIT_(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));
    }

actually_val_is_first_key_of_new_map_flow()

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 367 of file event_handler_tree.hpp.

    {
        if(C4_UNLIKELY(m_tree->is_container(m_curr->node_id)))
            _RYML_ERR_PARSE_(m_stack.m_callbacks, m_curr->pos, "ryml trees cannot handle containers as keys");
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_parent);
        _RYML_ASSERT_VISIT_(m_stack.m_callbacks, m_tree->is_seq(m_parent->node_id), m_tree, m_parent->node_id);
        _RYML_ASSERT_VISIT_(m_stack.m_callbacks, !m_tree->is_container(m_curr->node_id), m_tree, m_curr->node_id);
        _RYML_ASSERT_VISIT_(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);
        _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;
    }

actually_val_is_first_key_of_new_map_block()

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 389 of file event_handler_tree.hpp.

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

set_key_scalar_plain_empty()

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

inlinenoexcept

Definition at line 402 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 = {};
        _enable_(KEY|KEY_PLAIN|KEYNIL);
    }

set_val_scalar_plain_empty()

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

inlinenoexcept

Definition at line 408 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 = {};
        _enable_(VAL|VAL_PLAIN|VALNIL);
    }

set_key_scalar_plain()

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

inlinenoexcept

Definition at line 415 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;
        _enable_(KEY|KEY_PLAIN);
    }

set_val_scalar_plain()

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

inlinenoexcept

Definition at line 421 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;
        _enable_(VAL|VAL_PLAIN);
    }

set_key_scalar_dquoted()

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

inlinenoexcept

Definition at line 429 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;
        _enable_(KEY|KEY_DQUO);
    }

set_val_scalar_dquoted()

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

inlinenoexcept

Definition at line 435 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;
        _enable_(VAL|VAL_DQUO);
    }

set_key_scalar_squoted()

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

inlinenoexcept

Definition at line 443 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;
        _enable_(KEY|KEY_SQUO);
    }

set_val_scalar_squoted()

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

inlinenoexcept

Definition at line 449 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;
        _enable_(VAL|VAL_SQUO);
    }

set_key_scalar_literal()

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

inlinenoexcept

Definition at line 457 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;
        _enable_(KEY|KEY_LITERAL);
    }

set_val_scalar_literal()

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

inlinenoexcept

Definition at line 463 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;
        _enable_(VAL|VAL_LITERAL);
    }

set_key_scalar_folded()

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

inlinenoexcept

Definition at line 471 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;
        _enable_(KEY|KEY_FOLDED);
    }

set_val_scalar_folded()

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

inlinenoexcept

Definition at line 477 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;
        _enable_(VAL|VAL_FOLDED);
    }

mark_key_scalar_unfiltered()

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

inlinenoexcept

Definition at line 485 of file event_handler_tree.hpp.

    {
        _enable_(KEY_UNFILT);
    }

mark_val_scalar_unfiltered()

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

inlinenoexcept

Definition at line 489 of file event_handler_tree.hpp.

    {
        _enable_(VAL_UNFILT);
    }

set_key_anchor()

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

inline

Definition at line 501 of file event_handler_tree.hpp.

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

set_val_anchor()

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

inline

Definition at line 510 of file event_handler_tree.hpp.

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

set_key_ref()

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

inline

Definition at line 520 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set key ref: [{}]~~~{}~~~", m_curr->node_id, ref.len, ref);
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_tree);
        if(C4_UNLIKELY(_has_any_(KEYANCH)))
            _RYML_ERR_PARSE_(m_tree->callbacks(), m_curr->pos, "key cannot have both anchor and ref");
        _RYML_ASSERT_PARSE_(m_tree->callbacks(), ref.begins_with('*'), m_curr->pos);
        _enable_(KEY|KEYREF);
        m_curr->tr_data->m_key.anchor = ref.sub(1);
        m_curr->tr_data->m_key.scalar = ref;
    }

set_val_ref()

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

inline

Definition at line 531 of file event_handler_tree.hpp.

    {
        _c4dbgpf("node[{}]: set val ref: [{}]~~~{}~~~", m_curr->node_id, ref.len, ref);
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_tree);
        if(C4_UNLIKELY(_has_any_(VALANCH)))
            _RYML_ERR_PARSE_(m_tree->callbacks(), m_curr->pos, "val cannot have both anchor and ref");
        _RYML_ASSERT_PARSE_(m_tree->callbacks(), ref.begins_with('*'), m_curr->pos);
        _enable_(VAL|VALREF);
        m_curr->tr_data->m_val.anchor = ref.sub(1);
        m_curr->tr_data->m_val.scalar = ref;
    }

set_key_tag()

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

inline

Definition at line 550 of file event_handler_tree.hpp.

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

set_val_tag()

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

inline

Definition at line 556 of file event_handler_tree.hpp.

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

add_directive_yaml()

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

inline

Definition at line 570 of file event_handler_tree.hpp.

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

add_directive_tag()

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

inline

Definition at line 576 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_(m_stack.m_callbacks, m_curr->pos, "too many %TAG directives");
    }

arena()

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

inline

Definition at line 590 of file event_handler_tree.hpp.

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

arena_rem()

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

inline

Definition at line 595 of file event_handler_tree.hpp.

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

alloc_arena()

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

inline

Definition at line 600 of file event_handler_tree.hpp.

    {
        return m_tree->alloc_arena(len);
    }

_stack_start_parse()

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.

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

_stack_finish_parse()

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

inlineprotectedinherited

Definition at line 65 of file event_handler_stack.hpp.

    {
    }

_stack_reset_root()

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

inlineprotectedinherited

Definition at line 71 of file event_handler_stack.hpp.

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

_stack_reset_non_root()

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

inlineprotectedinherited

Definition at line 79 of file event_handler_stack.hpp.

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

_stack_push()

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();
    }

_stack_pop()

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

inlineprotectedinherited

Definition at line 96 of file event_handler_stack.hpp.

    {
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_parent);
        _RYML_ASSERT_BASIC_(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
    }

_stack_should_push_on_begin_doc()

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

inlineprotectedinherited

Definition at line 121 of file event_handler_stack.hpp.

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

_stack_should_pop_on_end_doc()

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

inlineprotectedinherited

Definition at line 127 of file event_handler_stack.hpp.

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

Member Data Documentation

m_stack

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

inherited

Definition at line 46 of file event_handler_stack.hpp.

m_curr

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.

m_parent

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.

m_src

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:

• /home/docs/checkouts/readthedocs.org/user_builds/rapidyaml/checkouts/v0.14.0/src/c4/yml/event_handler_tree.hpp