c4::yml::EventHandlerYamlStd Struct Reference

The event handler producing standard YAML events as used in the YAML test suite. More...

#include <test_suite_event_handler.hpp>

Inheritance diagram for c4::yml::EventHandlerYamlStd:

Public Types
using	pfn_relocate_arena = detail::pfn_relocate_arena
types
using	state = EventHandlerYamlStdState
using	EventSink = extra::string

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
	EventHandlerYamlStd ()
	EventHandlerYamlStd (Callbacks const &cb)
	EventHandlerYamlStd (EventSink *sink, Callbacks const &cb)
	EventHandlerYamlStd (EventSink *sink)
void	reset ()
parse events
void	start_parse (const char *filename, detail::pfn_relocate_arena relocate_arena, void *relocate_arena_data)
void	finish_parse ()
void	cancel_parse ()
YAML stream events
void	begin_stream ()
void	end_stream ()
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 functions
void	begin_map_key_flow ()
void	begin_map_key_block ()
void	begin_map_val_flow ()
void	begin_map_val_block ()
void	end_map ()
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 ()
YAML structure events
void	add_sibling ()
void	actually_val_is_first_key_of_new_map_flow ()
	set 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 (csubstr scalar)
void	set_val_scalar_plain (csubstr scalar)
void	set_key_scalar_dquoted (csubstr scalar)
void	set_val_scalar_dquoted (csubstr scalar)
void	set_key_scalar_squoted (csubstr scalar)
void	set_val_scalar_squoted (csubstr scalar)
void	set_key_scalar_literal (csubstr scalar)
void	set_val_scalar_literal (csubstr scalar)
void	set_key_scalar_folded (csubstr scalar)
void	set_val_scalar_folded (csubstr scalar)
void	mark_key_scalar_unfiltered ()
void	mark_val_scalar_unfiltered ()
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 (csubstr directive)
YAML arena events
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

Protected Member Functions
void	_stack_start_parse (const char *filename, 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 producing standard YAML events as used in the YAML test suite.

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

This class is used only in the CI of this project, and in the application used as part of the standard YAML playground. It is not part of the library and is not installed. *

Definition at line 49 of file test_suite_event_handler.hpp.

Member Typedef Documentation

state

using c4::yml::EventHandlerYamlStd::state = EventHandlerYamlStdState

Definition at line 56 of file test_suite_event_handler.hpp.

EventSink

using c4::yml::EventHandlerYamlStd::EventSink = extra::string

Definition at line 58 of file test_suite_event_handler.hpp.

pfn_relocate_arena

using c4::yml::EventHandlerStack< EventHandlerYamlStd , EventHandlerYamlStdState >::pfn_relocate_arena = detail::pfn_relocate_arena

inherited

Definition at line 41 of file event_handler_stack.hpp.

Constructor & Destructor Documentation

EventHandlerYamlStd() [1/4]

c4::yml::EventHandlerYamlStd::EventHandlerYamlStd ( )

inline

Definition at line 85 of file test_suite_event_handler.hpp.

: EventHandlerStack(), m_sink(), m_val_buffers(), m_key_tag_buf(), m_val_tag_buf(), m_tag_directives(), m_has_yaml_directive(), m_arena(), m_has_docs() {}

EventHandlerYamlStd() [2/4]

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

inline

Definition at line 86 of file test_suite_event_handler.hpp.

: EventHandlerStack(cb), m_sink(), m_val_buffers(), m_key_tag_buf(), m_val_tag_buf(), m_tag_directives(), m_has_yaml_directive(), m_arena(), m_has_docs()  {}

EventHandlerYamlStd() [3/4]

c4::yml::EventHandlerYamlStd::EventHandlerYamlStd ( EventSink *  sink, Callbacks const &  cb  )

inline

Definition at line 87 of file test_suite_event_handler.hpp.

                                                              : EventHandlerStack(cb), m_sink(sink), m_val_buffers(), m_key_tag_buf(), m_val_tag_buf(), m_tag_directives(), m_has_yaml_directive(), m_arena(), m_has_docs()
    {
        reset();
    }

EventHandlerYamlStd() [4/4]

c4::yml::EventHandlerYamlStd::EventHandlerYamlStd ( EventSink *  sink )

inline

Definition at line 91 of file test_suite_event_handler.hpp.

: EventHandlerYamlStd(sink, get_callbacks()) {}

Member Function Documentation

reset()

void c4::yml::EventHandlerYamlStd::reset ( )

inline

Definition at line 93 of file test_suite_event_handler.hpp.

    {
        _stack_reset_root();
        m_curr->flags |= RUNK|RTOP;
        m_has_yaml_directive = false;
        for(TagDirective &td : m_tag_directives)
            td = {};
        m_val_buffers.clear();
        m_val_buffers.resize((size_t)m_stack.size());
        m_arena.clear();
        m_arena.reserve(1024);
        m_key_tag_buf.resize(256);
        m_val_tag_buf.resize(256);
        m_has_docs = false;
    }

References c4::yml::RTOP, and c4::yml::RUNK.

start_parse()

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

inline

Definition at line 116 of file test_suite_event_handler.hpp.

    {
        this->_stack_start_parse(filename, relocate_arena, relocate_arena_data);
    }

finish_parse()

void c4::yml::EventHandlerYamlStd::finish_parse ( )

inline

Definition at line 121 of file test_suite_event_handler.hpp.

    {
        if((_num_tag_directives() || m_has_yaml_directive) && !m_has_docs)
            _RYML_CB_ERR_(m_stack.m_callbacks, "directives cannot be used without a document", {});
        this->_stack_finish_parse();
    }

cancel_parse()

void c4::yml::EventHandlerYamlStd::cancel_parse ( )

inline

Definition at line 128 of file test_suite_event_handler.hpp.

    {
        while(m_stack.size() > 1)
            _pop();
        _buf_flush_();
    }

begin_stream()

void c4::yml::EventHandlerYamlStd::begin_stream ( )

inline

Definition at line 142 of file test_suite_event_handler.hpp.

    {
        _send_("+STR\n");
    }

end_stream()

void c4::yml::EventHandlerYamlStd::end_stream ( )

inline

Definition at line 147 of file test_suite_event_handler.hpp.

    {
        _send_("-STR\n");
        _buf_flush_();
    }

begin_doc()

void c4::yml::EventHandlerYamlStd::begin_doc ( )

inline

implicit doc start (without —)

Definition at line 161 of file test_suite_event_handler.hpp.

    {
        _c4dbgp("begin_doc");
        if(_stack_should_push_on_begin_doc())
        {
            _c4dbgp("push!");
            _push();
            _enable_(DOC);
        }
        _send_("+DOC\n");
        m_has_docs = true;
    }

References c4::yml::DOC.

end_doc()

void c4::yml::EventHandlerYamlStd::end_doc ( )

inline

implicit doc end (without ...)

Definition at line 174 of file test_suite_event_handler.hpp.

    {
        _c4dbgp("end_doc");
        _send_("-DOC\n");
        if(_stack_should_pop_on_end_doc())
        {
            _c4dbgp("pop!");
            _pop();
        }
    }

begin_doc_expl()

void c4::yml::EventHandlerYamlStd::begin_doc_expl ( )

inline

explicit doc start, with —

Definition at line 186 of file test_suite_event_handler.hpp.

    {
        _c4dbgp("begin_doc_expl");
        if(_stack_should_push_on_begin_doc())
        {
            _c4dbgp("push!");
            _push();
        }
        _send_("+DOC ---\n");
        _enable_(DOC);
        m_has_docs = true;
    }

References c4::yml::DOC.

end_doc_expl()

void c4::yml::EventHandlerYamlStd::end_doc_expl ( )

inline

explicit doc end, with ...

Definition at line 199 of file test_suite_event_handler.hpp.

    {
        _c4dbgp("end_doc_expl");
        _send_("-DOC ...\n");
        if(_stack_should_pop_on_end_doc())
        {
            _c4dbgp("pop!");
            _pop();
        }
        m_has_yaml_directive = false;
    }

begin_map_key_flow()

void c4::yml::EventHandlerYamlStd::begin_map_key_flow ( )

inline

Definition at line 218 of file test_suite_event_handler.hpp.

    {
        _RYML_CB_CHECK(m_stack.m_callbacks, !_has_any_(VAL));
        _send_("+MAP {}");
        _send_key_props_();
        _send_('\n');
        _mark_parent_with_children_();
        _enable_(MAP|FLOW_SL);
        _push();
    }

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

begin_map_key_block()

void c4::yml::EventHandlerYamlStd::begin_map_key_block ( )

inline

Definition at line 228 of file test_suite_event_handler.hpp.

    {
        _RYML_CB_CHECK(m_stack.m_callbacks, !_has_any_(VAL));
        _send_("+MAP");
        _send_key_props_();
        _send_('\n');
        _mark_parent_with_children_();
        _enable_(MAP|BLOCK);
        _push();
    }

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

begin_map_val_flow()

void c4::yml::EventHandlerYamlStd::begin_map_val_flow ( )

inline

Definition at line 239 of file test_suite_event_handler.hpp.

    {
        _RYML_CB_CHECK(m_stack.m_callbacks, !_has_any_(VAL));
        _send_("+MAP {}");
        _send_val_props_();
        _send_('\n');
        _mark_parent_with_children_();
        _enable_(MAP|FLOW_SL);
        _push();
    }

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

begin_map_val_block()

void c4::yml::EventHandlerYamlStd::begin_map_val_block ( )

inline

Definition at line 249 of file test_suite_event_handler.hpp.

    {
        _RYML_CB_CHECK(m_stack.m_callbacks, !_has_any_(VAL));
        _send_("+MAP");
        _send_val_props_();
        _send_('\n');
        _mark_parent_with_children_();
        _enable_(MAP|BLOCK);
        _push();
    }

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

end_map()

void c4::yml::EventHandlerYamlStd::end_map ( )

inline

Definition at line 260 of file test_suite_event_handler.hpp.

    {
        _pop();
        _send_("-MAP\n");
    }

begin_seq_key_flow()

void c4::yml::EventHandlerYamlStd::begin_seq_key_flow ( )

inline

Definition at line 273 of file test_suite_event_handler.hpp.

    {
        _RYML_CB_CHECK(m_stack.m_callbacks, !_has_any_(VAL));
        _send_("+SEQ []");
        _send_key_props_();
        _send_('\n');
        _mark_parent_with_children_();
        _enable_(SEQ|FLOW_SL);
        _push();
    }

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

begin_seq_key_block()

void c4::yml::EventHandlerYamlStd::begin_seq_key_block ( )

inline

Definition at line 283 of file test_suite_event_handler.hpp.

    {
        _RYML_CB_CHECK(m_stack.m_callbacks, !_has_any_(VAL));
        _send_("+SEQ");
        _send_key_props_();
        _send_('\n');
        _mark_parent_with_children_();
        _enable_(SEQ|BLOCK);
        _push();
    }

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

begin_seq_val_flow()

void c4::yml::EventHandlerYamlStd::begin_seq_val_flow ( )

inline

Definition at line 294 of file test_suite_event_handler.hpp.

    {
        _RYML_CB_CHECK(m_stack.m_callbacks, !_has_any_(VAL));
        _send_("+SEQ []");
        _send_val_props_();
        _send_('\n');
        _mark_parent_with_children_();
        _enable_(SEQ|FLOW_SL);
        _push();
    }

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

begin_seq_val_block()

void c4::yml::EventHandlerYamlStd::begin_seq_val_block ( )

inline

Definition at line 304 of file test_suite_event_handler.hpp.

    {
        _RYML_CB_CHECK(m_stack.m_callbacks, !_has_any_(VAL));
        _send_("+SEQ");
        _send_val_props_();
        _send_('\n');
        _mark_parent_with_children_();
        _enable_(SEQ|BLOCK);
        _push();
    }

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

end_seq()

void c4::yml::EventHandlerYamlStd::end_seq ( )

inline

Definition at line 315 of file test_suite_event_handler.hpp.

    {
        _pop();
        _send_("-SEQ\n"); // before popping
    }

add_sibling()

void c4::yml::EventHandlerYamlStd::add_sibling ( )

inline

Definition at line 328 of file test_suite_event_handler.hpp.

    {
        _RYML_CB_ASSERT(m_stack.m_callbacks, m_parent);
        _buf_flush_to_(m_curr->level, m_parent->level);
        m_curr->ev_data = {};
    }

actually_val_is_first_key_of_new_map_flow()

void c4::yml::EventHandlerYamlStd::actually_val_is_first_key_of_new_map_flow ( )

inline

set 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 340 of file test_suite_event_handler.hpp.

    {
        // ensure we have a temporary buffer to save the current val
        const id_type tmp = m_curr->level + id_type(2);
        _buf_ensure_(tmp + id_type(2));
        // save the current val to the temporary buffer
        _buf_flush_to_(m_curr->level, tmp);
        _disable_(_VALMASK|VAL_STYLE);
        // create the map.
        // this will push a new level, and tmp is one further
        begin_map_val_flow();
        _RYML_CB_ASSERT(m_stack.m_callbacks, tmp != m_curr->level);
        // now move the saved val as the first key
        _buf_flush_to_(tmp, m_curr->level);
    }

References c4::yml::_VALMASK, and c4::yml::VAL_STYLE.

actually_val_is_first_key_of_new_map_block()

void c4::yml::EventHandlerYamlStd::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 362 of file test_suite_event_handler.hpp.

    {
        EventSink &sink = _buf_();
        substr full = sink;(void)full;
        // interpolate +MAP\n after the last +DOC\n
        _RYML_CB_ASSERT(m_stack.m_callbacks, full.len);
        _RYML_CB_ASSERT(m_stack.m_callbacks, !full.count('\r'));
        size_t docpos = sink.find_last("+DOC\n");
        if(docpos != npos)
        {
            _RYML_CB_ASSERT(m_stack.m_callbacks, (m_stack.size() == 1u) ? (docpos >= 5u) : (docpos == 0u));
            _RYML_CB_ASSERT(m_stack.m_callbacks, docpos + 5u < full.len);
            sink.insert("+MAP\n", docpos + 5u);
        }
        else
        {
            // ... or interpolate +MAP\n after the last +DOC ---\n
            docpos = sink.find_last("+DOC ---\n");
            _RYML_CB_ASSERT(m_stack.m_callbacks, docpos != npos);
            _RYML_CB_ASSERT(m_stack.m_callbacks, (m_stack.size() == 1u) ? (docpos >= 5u) : (docpos == 0u));
            _RYML_CB_ASSERT(m_stack.m_callbacks, docpos + 9u < full.len);
            sink.insert("+MAP\n", docpos + 9u);
        }
        _push();
    }

References c4::yml::npos.

set_key_scalar_plain()

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

inline

Definition at line 396 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set key scalar plain: [{}]~~~{}~~~ ({})", m_curr->node_id, scalar.len, scalar, reinterpret_cast<void const*>(scalar.str));
        _send_key_scalar_(scalar, ':');
        _enable_(KEY|KEY_PLAIN);
    }

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

set_val_scalar_plain()

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

inline

Definition at line 402 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set val scalar plain: [{}]~~~{}~~~ ({})", m_curr->node_id, scalar.len, scalar, reinterpret_cast<void const*>(scalar.str));
        _send_val_scalar_(scalar, ':');
        _enable_(VAL|VAL_PLAIN);
    }

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

set_key_scalar_dquoted()

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

inline

Definition at line 410 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set key scalar dquot: [{}]~~~{}~~~ ({})", m_curr->node_id, scalar.len, scalar, reinterpret_cast<void const*>(scalar.str));
        _send_key_scalar_(scalar, '"');
        _enable_(KEY|KEY_DQUO);
    }

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

set_val_scalar_dquoted()

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

inline

Definition at line 416 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set val scalar dquot: [{}]~~~{}~~~ ({})", m_curr->node_id, scalar.len, scalar, reinterpret_cast<void const*>(scalar.str));
        _send_val_scalar_(scalar, '"');
        _enable_(VAL|VAL_DQUO);
    }

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

set_key_scalar_squoted()

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

inline

Definition at line 424 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set key scalar squot: [{}]~~~{}~~~ ({})", m_curr->node_id, scalar.len, scalar, reinterpret_cast<void const*>(scalar.str));
        _send_key_scalar_(scalar, '\'');
        _enable_(KEY|KEY_SQUO);
    }

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

set_val_scalar_squoted()

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

inline

Definition at line 430 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set val scalar squot: [{}]~~~{}~~~ ({})", m_curr->node_id, scalar.len, scalar, reinterpret_cast<void const*>(scalar.str));
        _send_val_scalar_(scalar, '\'');
        _enable_(VAL|VAL_SQUO);
    }

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

set_key_scalar_literal()

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

inline

Definition at line 438 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set key scalar literal: [{}]~~~{}~~~ ({})", m_curr->node_id, scalar.len, scalar, reinterpret_cast<void const*>(scalar.str));
        _send_key_scalar_(scalar, '|');
        _enable_(KEY|KEY_LITERAL);
    }

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

set_val_scalar_literal()

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

inline

Definition at line 444 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set val scalar literal: [{}]~~~{}~~~ ({})", m_curr->node_id, scalar.len, scalar, reinterpret_cast<void const*>(scalar.str));
        _send_val_scalar_(scalar, '|');
        _enable_(VAL|VAL_LITERAL);
    }

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

set_key_scalar_folded()

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

inline

Definition at line 452 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set key scalar folded: [{}]~~~{}~~~ ({})", m_curr->node_id, scalar.len, scalar, reinterpret_cast<void const*>(scalar.str));
        _send_key_scalar_(scalar, '>');
        _enable_(KEY|KEY_FOLDED);
    }

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

set_val_scalar_folded()

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

inline

Definition at line 458 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set val scalar folded: [{}]~~~{}~~~ ({})", m_curr->node_id, scalar.len, scalar, reinterpret_cast<void const*>(scalar.str));
        _send_val_scalar_(scalar, '>');
        _enable_(VAL|VAL_FOLDED);
    }

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

mark_key_scalar_unfiltered()

void c4::yml::EventHandlerYamlStd::mark_key_scalar_unfiltered ( )

inline

Definition at line 466 of file test_suite_event_handler.hpp.

    {
        C4_NOT_IMPLEMENTED();
    }

mark_val_scalar_unfiltered()

void c4::yml::EventHandlerYamlStd::mark_val_scalar_unfiltered ( )

inline

Definition at line 470 of file test_suite_event_handler.hpp.

    {
        C4_NOT_IMPLEMENTED();
    }

set_key_anchor()

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

inline

Definition at line 482 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set key anchor: [{}]~~~{}~~~", m_curr->node_id, anchor.len, anchor);
        if(C4_UNLIKELY(_has_any_(KEYANCH)))
            _RYML_CB_ERR_(m_stack.m_callbacks, "key cannot have both anchor and ref", m_curr->pos);
        _RYML_CB_ASSERT(m_stack.m_callbacks, !anchor.begins_with('&'));
        _enable_(KEYANCH);
        m_curr->ev_data.m_key.anchor = anchor;
    }

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

set_val_anchor()

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

inline

Definition at line 491 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set val anchor: [{}]~~~{}~~~", m_curr->node_id, anchor.len, anchor);
        if(C4_UNLIKELY(_has_any_(VALREF)))
            _RYML_CB_ERR_(m_stack.m_callbacks, "val cannot have both anchor and ref", m_curr->pos);
        _RYML_CB_ASSERT(m_stack.m_callbacks, !anchor.begins_with('&'));
        _enable_(VALANCH);
        m_curr->ev_data.m_val.anchor = anchor;
    }

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

set_key_ref()

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

inline

Definition at line 501 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set key ref: [{}]~~~{}~~~", m_curr->node_id, ref.len, ref);
        if(C4_UNLIKELY(_has_any_(KEYANCH)))
            _RYML_CB_ERR_(m_stack.m_callbacks, "key cannot have both anchor and ref", m_curr->pos);
        _RYML_CB_ASSERT(m_stack.m_callbacks, ref.begins_with('*'));
        _enable_(KEY|KEYREF);
        _send_("=ALI ");
        _send_(ref);
        _send_('\n');
    }

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

set_val_ref()

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

inline

Definition at line 512 of file test_suite_event_handler.hpp.

    {
        _c4dbgpf("node[{}]: set val ref: [{}]~~~{}~~~", m_curr->node_id, ref.len, ref);
        if(C4_UNLIKELY(_has_any_(VALANCH)))
            _RYML_CB_ERR_(m_stack.m_callbacks, "val cannot have both anchor and ref", m_curr->pos);
        _RYML_CB_ASSERT(m_stack.m_callbacks, ref.begins_with('*'));
        _enable_(VAL|VALREF);
        _send_("=ALI ");
        _send_(ref);
        _send_('\n');
    }

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

set_key_tag()

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

inline

Definition at line 531 of file test_suite_event_handler.hpp.

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

References c4::yml::KEYTAG.

set_val_tag()

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

inline

Definition at line 537 of file test_suite_event_handler.hpp.

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

References c4::yml::VALTAG.

add_directive()

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

inline

Definition at line 551 of file test_suite_event_handler.hpp.

    {
        _RYML_CB_ASSERT(m_stack.m_callbacks, directive.begins_with('%'));
        if(directive.begins_with("%TAG"))
        {
            const id_type pos = _num_tag_directives();
            if(C4_UNLIKELY(pos >= RYML_MAX_TAG_DIRECTIVES))
                _RYML_CB_ERR_(m_stack.m_callbacks, "too many directives", m_curr->pos);
            if(C4_UNLIKELY(!m_tag_directives[pos].create_from_str(directive)))
                _RYML_CB_ERR_(m_stack.m_callbacks, "failed to add directive", m_curr->pos);
        }
        else if(directive.begins_with("%YAML"))
        {
            _c4dbgpf("%YAML directive! ignoring...: {}", directive);
            if(C4_UNLIKELY(m_has_yaml_directive))
                _RYML_CB_ERR_(m_stack.m_callbacks, "multiple yaml directives", m_curr->pos);
            m_has_yaml_directive = true;
        }
        else
        {
            _c4dbgpf("unknown directive! ignoring... {}", directive);
        }
    }

References RYML_MAX_TAG_DIRECTIVES.

alloc_arena() [1/2]

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

inline

Definition at line 582 of file test_suite_event_handler.hpp.

    {
        const size_t sz = m_arena.size();
        csubstr prev = m_arena;
        m_arena.resize(sz + len);
        substr out = to_substr(m_arena).sub(sz);
        substr curr = to_substr(m_arena);
        if(curr.str != prev.str)
            _stack_relocate_to_new_arena(prev, curr);
        return out;
    }

References c4::to_substr().

alloc_arena() [2/2]

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

inline

Definition at line 594 of file test_suite_event_handler.hpp.

    {
        csubstr prev = m_arena;
        if(!prev.is_super(*relocated))
            return alloc_arena(len);
        substr out = alloc_arena(len);
        substr curr = to_substr(m_arena);
        if(curr.str != prev.str)
            *relocated = _stack_relocate_to_new_arena(*relocated, prev, curr);
        return out;
    }

References c4::to_substr().

_stack_start_parse()

void c4::yml::EventHandlerStack< EventHandlerYamlStd , EventHandlerYamlStdState >::_stack_start_parse ( const char *  filename, pfn_relocate_arena  relocate_arena, void *  relocate_arena_data  )

inlineprotectedinherited

Definition at line 58 of file event_handler_stack.hpp.

    {
        _RYML_CB_ASSERT(m_stack.m_callbacks, m_curr != nullptr);
        _RYML_CB_ASSERT(m_stack.m_callbacks, relocate_arena != nullptr);
        _RYML_CB_ASSERT(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;
    }

_stack_finish_parse()

void c4::yml::EventHandlerStack< EventHandlerYamlStd , EventHandlerYamlStdState >::_stack_finish_parse ( )

inlineprotectedinherited

Definition at line 68 of file event_handler_stack.hpp.

    {
    }

_stack_reset_root()

void c4::yml::EventHandlerStack< EventHandlerYamlStd , EventHandlerYamlStdState >::_stack_reset_root ( )

inlineprotectedinherited

Definition at line 74 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< EventHandlerYamlStd , EventHandlerYamlStdState >::_stack_reset_non_root ( )

inlineprotectedinherited

Definition at line 82 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< EventHandlerYamlStd , EventHandlerYamlStdState >::_stack_push ( )

inlineprotectedinherited

Definition at line 91 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< EventHandlerYamlStd , EventHandlerYamlStdState >::_stack_pop ( )

inlineprotectedinherited

Definition at line 99 of file event_handler_stack.hpp.

    {
        _RYML_CB_ASSERT(m_stack.m_callbacks, m_parent);
        _RYML_CB_ASSERT(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< EventHandlerYamlStd , EventHandlerYamlStdState >::_stack_should_push_on_begin_doc ( ) const

inlineprotectedinherited

Definition at line 120 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< EventHandlerYamlStd , EventHandlerYamlStdState >::_stack_should_pop_on_end_doc ( ) const

inlineprotectedinherited

Definition at line 126 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< EventHandlerYamlStd , EventHandlerYamlStdState >::_stack_relocate_to_new_arena ( csubstr  prev, substr  curr  )

inlineprotectedinherited

Definition at line 134 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);
            if(st.line_contents.stripped.is_sub(prev))
                st.line_contents.stripped = _stack_relocate_to_new_arena(st.line_contents.stripped, prev, curr);
        }
        _RYML_CB_ASSERT(m_stack.m_callbacks, m_relocate_arena != nullptr);
        _RYML_CB_ASSERT(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< EventHandlerYamlStd , EventHandlerYamlStdState >::_stack_relocate_to_new_arena ( csubstr  s, csubstr  prev, substr  curr  )

inlineprotectedinherited

Definition at line 150 of file event_handler_stack.hpp.

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

check_trailing_doc_token()

void c4::yml::EventHandlerStack< EventHandlerYamlStd , EventHandlerYamlStdState >::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 165 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_CB_ERR_(m_stack.m_callbacks, "parse error", m_curr->pos);
    }

Member Data Documentation

m_stack

detail::stack<state> c4::yml::EventHandlerStack< EventHandlerYamlStd , EventHandlerYamlStdState >::m_stack

inherited

Definition at line 45 of file event_handler_stack.hpp.

m_curr

state* c4::yml::EventHandlerStack< EventHandlerYamlStd , EventHandlerYamlStdState >::m_curr

inherited

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

Definition at line 46 of file event_handler_stack.hpp.

m_parent

state* c4::yml::EventHandlerStack< EventHandlerYamlStd , EventHandlerYamlStdState >::m_parent

inherited

parent of the current stack level.

Definition at line 47 of file event_handler_stack.hpp.

m_relocate_arena

pfn_relocate_arena c4::yml::EventHandlerStack< EventHandlerYamlStd , EventHandlerYamlStdState >::m_relocate_arena

inherited

callback when the arena gets relocated

Definition at line 48 of file event_handler_stack.hpp.

m_relocate_arena_data

void* c4::yml::EventHandlerStack< EventHandlerYamlStd , EventHandlerYamlStdState >::m_relocate_arena_data

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.7.2/test/test_suite/test_suite_event_handler.hpp