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
using	pfn_relocate_arena = detail::pfn_relocate_arena
types
using	state = EventHandlerTreeState

Public Member Functions
void	check_trailing_doc_token () const
	Check whether the current parse tokens are trailing on the previous doc, and raise an error if they are. More...
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
parse events
void	start_parse (const char *filename, csubstr ymlsrc, detail::pfn_relocate_arena relocate_arena, void *relocate_arena_data)
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)
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. 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) noexcept
void	set_val_tag (csubstr tag) noexcept
YAML directive events
void	add_directive (csubstr directive)
arena functions
substr	alloc_arena (size_t len)
substr	alloc_arena (size_t len, substr *relocated)

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...
pfn_relocate_arena	m_relocate_arena
	callback when the arena gets relocated More...
void *	m_relocate_arena_data
csubstr	m_src

Protected Member Functions
void	_stack_start_parse (const char *filename, csubstr ymlsrc, pfn_relocate_arena relocate_arena, void *relocate_arena_data)
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
void	_stack_relocate_to_new_arena (csubstr prev, substr curr)
substr	_stack_relocate_to_new_arena (csubstr s, csubstr prev, substr curr)

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

Member Typedef Documentation

state

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

Definition at line 39 of file event_handler_tree.hpp.

pfn_relocate_arena

using c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::pfn_relocate_arena = detail::pfn_relocate_arena

inherited

Definition at line 47 of file event_handler_stack.hpp.

Constructor & Destructor Documentation

EventHandlerTree() [1/3]

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

inline

Definition at line 66 of file event_handler_tree.hpp.

: EventHandlerStack(), m_tree(), m_id(NONE), m_num_directives(), m_yaml_directive() {}

EventHandlerTree() [2/3]

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

inline

Definition at line 67 of file event_handler_tree.hpp.

: EventHandlerStack(cb), m_tree(), m_id(NONE), m_num_directives(), m_yaml_directive() {}

EventHandlerTree() [3/3]

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

inline

Definition at line 68 of file event_handler_tree.hpp.

                                             : EventHandlerStack(tree->callbacks()), m_tree(tree), m_id(id), m_num_directives(), m_yaml_directive()
    {
        reset(tree, id);
    }

Member Function Documentation

reset()

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

inline

Definition at line 73 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;
        m_id = id;
        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_num_directives = 0;
        m_yaml_directive = false;
    }

References c4::yml::Tree::callbacks(), c4::yml::Tree::capacity(), c4::yml::Tree::has_key(), c4::yml::Tree::is_map(), c4::yml::Tree::is_root(), and c4::yml::Tree::parent().

callbacks()

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

inline

Definition at line 100 of file event_handler_tree.hpp.

{ return m_stack.m_callbacks; }

start_parse()

void c4::yml::EventHandlerTree::start_parse ( const char *  filename, csubstr  ymlsrc, detail::pfn_relocate_arena  relocate_arena, void *  relocate_arena_data  )

inline

Definition at line 108 of file event_handler_tree.hpp.

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

finish_parse()

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

inline

Definition at line 114 of file event_handler_tree.hpp.

    {
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_tree != nullptr);
        if(m_num_directives && !m_tree->is_stream(m_tree->root_id()))
            _RYML_ERR_BASIC_(m_stack.m_callbacks, "directives cannot be used without a document");
        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 135 of file event_handler_tree.hpp.

    {
        m_tree = nullptr;
    }

begin_stream()

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

inlinenoexcept

Definition at line 147 of file event_handler_tree.hpp.

{ /*nothing to do*/ }

end_stream()

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

inlinenoexcept

Definition at line 149 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 159 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);
        }
    }

References c4::yml::DOC.

end_doc()

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

inline

implicit doc end (without ...)

Definition at line 171 of file event_handler_tree.hpp.

    {
        _c4dbgp("end_doc");
        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 183 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("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);
            }
        }
        else
        {
            _c4dbgp("push!");
            _push();
        }
        _enable_(DOC);
    }

References c4::yml::DOC, and c4::yml::NONE.

end_doc_expl()

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

inline

explicit doc end, with ...

Definition at line 221 of file event_handler_tree.hpp.

    {
        _c4dbgp("end_doc_expl");
        _remove_speculative();
        if(_stack_should_pop_on_end_doc())
        {
            _c4dbgp("pop!");
            _pop();
        }
        m_yaml_directive = false;
    }

begin_map_key_flow()

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

inline

Definition at line 240 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 244 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 249 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();
    }

References _has_any_, c4::yml::FLOW_SL, c4::yml::MAP, and c4::yml::VAL.

begin_map_val_block()

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

inline

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

References _has_any_, c4::yml::BLOCK, c4::yml::MAP, and c4::yml::VAL.

end_map_block()

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

inline

Definition at line 266 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 272 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);
        }
    }

References c4::yml::FLOW_ML, and c4::yml::FLOW_SL.

begin_seq_key_flow()

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

inline

Definition at line 290 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 294 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 299 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();
    }

References _has_any_, c4::yml::FLOW_SL, c4::yml::SEQ, and c4::yml::VAL.

begin_seq_val_block()

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

inline

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

References _has_any_, c4::yml::BLOCK, c4::yml::SEQ, and c4::yml::VAL.

end_seq_block()

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

inline

Definition at line 316 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 322 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);
        }
    }

References c4::yml::FLOW_ML, and c4::yml::FLOW_SL.

add_sibling()

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

inline

Definition at line 340 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 357 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;
    }

References c4::yml::_VALMASK, c4::yml::NodeData::m_key, c4::yml::NodeData::m_type, c4::yml::VAL_STYLE, and c4::yml::VALNIL.

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 379 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 392 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);
    }

References c4::yml::KEY, c4::yml::KEY_PLAIN, and c4::yml::KEYNIL.

set_val_scalar_plain_empty()

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

inlinenoexcept

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

References c4::yml::VAL, c4::yml::VAL_PLAIN, and c4::yml::VALNIL.

set_key_scalar_plain()

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

inlinenoexcept

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

References c4::yml::KEY, and c4::yml::KEY_PLAIN.

set_val_scalar_plain()

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

inlinenoexcept

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

References c4::yml::VAL, and c4::yml::VAL_PLAIN.

set_key_scalar_dquoted()

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

inlinenoexcept

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

References c4::yml::KEY, and c4::yml::KEY_DQUO.

set_val_scalar_dquoted()

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

inlinenoexcept

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

References c4::yml::VAL, and c4::yml::VAL_DQUO.

set_key_scalar_squoted()

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

inlinenoexcept

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

References c4::yml::KEY, and c4::yml::KEY_SQUO.

set_val_scalar_squoted()

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

inlinenoexcept

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

References c4::yml::VAL, and c4::yml::VAL_SQUO.

set_key_scalar_literal()

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

inlinenoexcept

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

References c4::yml::KEY, and c4::yml::KEY_LITERAL.

set_val_scalar_literal()

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

inlinenoexcept

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

References c4::yml::VAL, and c4::yml::VAL_LITERAL.

set_key_scalar_folded()

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

inlinenoexcept

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

References c4::yml::KEY, and c4::yml::KEY_FOLDED.

set_val_scalar_folded()

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

inlinenoexcept

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

References c4::yml::VAL, and c4::yml::VAL_FOLDED.

mark_key_scalar_unfiltered()

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

inlinenoexcept

Definition at line 475 of file event_handler_tree.hpp.

    {
        _enable_(KEY_UNFILT);
    }

References c4::yml::KEY_UNFILT.

mark_val_scalar_unfiltered()

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

inlinenoexcept

Definition at line 479 of file event_handler_tree.hpp.

    {
        _enable_(VAL_UNFILT);
    }

References c4::yml::VAL_UNFILT.

set_key_anchor()

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

inline

Definition at line 491 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;
    }

References _has_any_, c4::yml::KEYANCH, and c4::yml::KEYREF.

set_val_anchor()

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

inline

Definition at line 500 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;
    }

References _has_any_, c4::yml::VALANCH, and c4::yml::VALREF.

set_key_ref()

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

inline

Definition at line 510 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;
    }

References _has_any_, c4::yml::KEY, c4::yml::KEYANCH, and c4::yml::KEYREF.

set_val_ref()

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

inline

Definition at line 521 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;
    }

References _has_any_, c4::yml::VAL, c4::yml::VALANCH, and c4::yml::VALREF.

set_key_tag()

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

inlinenoexcept

Definition at line 540 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;
    }

References c4::yml::KEYTAG.

set_val_tag()

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

inlinenoexcept

Definition at line 546 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;
    }

References c4::yml::VALTAG.

add_directive()

void c4::yml::EventHandlerTree::add_directive ( csubstr  directive )

inline

Definition at line 560 of file event_handler_tree.hpp.

    {
        _c4dbgpf("% directive! {}", directive);
        _RYML_ASSERT_PARSE_(m_tree->callbacks(), directive.begins_with('%'), m_curr->pos);
        if(directive.begins_with("%TAG"))
        {
            if(C4_UNLIKELY(!m_tree->add_tag_directive(directive)))
                _RYML_ERR_PARSE_(m_stack.m_callbacks, m_curr->pos, "failed to add directive");
        }
        else if(directive.begins_with("%YAML"))
        {
            _c4dbgpf("%YAML directive! ignoring...: {}", directive);
            if(C4_UNLIKELY(m_yaml_directive))
                _RYML_ERR_PARSE_(m_stack.m_callbacks, m_curr->pos, "multiple yaml directives");
            m_yaml_directive = true;
        }
        else
        {
            _c4dbgpf("unknown directive! ignoring... {}", directive);
        }
        ++m_num_directives;
    }

alloc_arena() [1/2]

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

inline

Definition at line 590 of file event_handler_tree.hpp.

    {
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_tree);
        csubstr prev = m_tree->arena();
        substr out = m_tree->alloc_arena(len);
        substr curr = m_tree->arena();
        if(curr.str != prev.str)
            _stack_relocate_to_new_arena(prev, curr);
        return out;
    }

alloc_arena() [2/2]

substr c4::yml::EventHandlerTree::alloc_arena ( size_t  len, substr *  relocated  )

inline

Definition at line 601 of file event_handler_tree.hpp.

    {
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_tree);
        csubstr prev = m_tree->arena();
        if(!prev.is_super(*relocated))
            return alloc_arena(len);
        substr out = alloc_arena(len);
        substr curr = m_tree->arena();
        if(curr.str != prev.str)
            *relocated = _stack_relocate_to_new_arena(*relocated, prev, curr);
        return out;
    }

_stack_start_parse()

void c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::_stack_start_parse ( const char *  filename, csubstr  ymlsrc, pfn_relocate_arena  relocate_arena, void *  relocate_arena_data  )

inlineprotectedinherited

Definition at line 65 of file event_handler_stack.hpp.

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

_stack_finish_parse()

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

inlineprotectedinherited

Definition at line 76 of file event_handler_stack.hpp.

    {
        m_src = {};
    }

_stack_reset_root()

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

inlineprotectedinherited

Definition at line 83 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 91 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 100 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 108 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 129 of file event_handler_stack.hpp.

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

_stack_should_pop_on_end_doc()

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

inlineprotectedinherited

Definition at line 135 of file event_handler_stack.hpp.

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

_stack_relocate_to_new_arena() [1/2]

void c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::_stack_relocate_to_new_arena ( csubstr  prev, substr  curr  )

inlineprotectedinherited

Definition at line 143 of file event_handler_stack.hpp.

    {
        for(state &st : m_stack)
        {
            if(st.line_contents.rem.is_sub(prev))
                st.line_contents.rem = _stack_relocate_to_new_arena(st.line_contents.rem, prev, curr);
            if(st.line_contents.full.is_sub(prev))
                st.line_contents.full = _stack_relocate_to_new_arena(st.line_contents.full, prev, curr);
        }
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_relocate_arena != nullptr);
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_relocate_arena_data != nullptr);
        m_relocate_arena(m_relocate_arena_data, prev, curr);
    }

_stack_relocate_to_new_arena() [2/2]

substr c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::_stack_relocate_to_new_arena ( csubstr  s, csubstr  prev, substr  curr  )

inlineprotectedinherited

Definition at line 157 of file event_handler_stack.hpp.

    {
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, prev.is_super(s));
        auto pos = s.str - prev.str;
        substr out = {curr.str + pos, s.len};
        _RYML_ASSERT_BASIC_(m_stack.m_callbacks, curr.is_super(out));
        return out;
    }

check_trailing_doc_token()

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

inlineinherited

Check whether the current parse tokens are trailing on the previous doc, and raise an error if they are.

This function is called by the parse engine (not the event handler) before a doc is started.

Definition at line 172 of file event_handler_stack.hpp.

    {
        const bool is_root = (m_stack.size() == 1u);
        const bool isndoc = (m_curr->flags & NDOC) != 0;
        const bool suspicious = _has_any_(MAP|SEQ|VAL);
        _c4dbgpf("target={} isroot={} suspicious={} ndoc={}", m_curr->node_id, is_root, suspicious, isndoc);
        if((is_root || _has_any_(DOC)) && suspicious && !isndoc)
            _RYML_ERR_PARSE_(m_stack.m_callbacks, m_curr->pos, "parse error");
    }

Member Data Documentation

m_stack

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

inherited

Definition at line 51 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 52 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 53 of file event_handler_stack.hpp.

m_relocate_arena

pfn_relocate_arena c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::m_relocate_arena

inherited

callback when the arena gets relocated

Definition at line 54 of file event_handler_stack.hpp.

m_relocate_arena_data

void* c4::yml::EventHandlerStack< EventHandlerTree , EventHandlerTreeState >::m_relocate_arena_data

inherited

Definition at line 55 of file event_handler_stack.hpp.

m_src

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

inherited

Definition at line 56 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.11.0/src/c4/yml/event_handler_tree.hpp