c4::yml::extra::EventHandlerInts Struct Reference

A parser event handler that creates a compact representation of the YAML tree in a contiguous buffer of integers. More...

#include <event_handler_ints.hpp>

Public Types
types
enum	{ requires_strings_on_buffers = true }
using	value_type = ievt::evt_bits
using	state = EventHandlerIntsState

Public Member Functions
construction and resetting
	EventHandlerInts (c4::yml::Callbacks const &cb) noexcept
	EventHandlerInts () noexcept
void	reset (substr str, substr arena, ievt::evt_bits *dst, evt_size dst_size)
evt_size	required_size_events () const
	get the size needed for the event buffer from the previous parse
size_t	required_size_arena () const
	get the size needed for the arena from the previous parse
bool	fits_buffers () const
	Predicate to test if the event and arena buffers successfully accomodated all the parse events.
void	reserve_arena (int)
TagDirectives &	tag_directives ()
TagCache &	tag_cache ()
parse events
void	start_parse (const char *filename, substr src)
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 —)
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 functions
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, type_bits=FLOW_ML1)
YAML seq events
void	begin_seq_key_flow ()
void	begin_seq_key_block ()
void	begin_seq_val_flow ()
void	begin_seq_val_block ()
void	end_seq_block ()
void	end_seq_flow (bool, type_bits=FLOW_ML1)
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.
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 ()
void	set_val_scalar_plain_empty ()
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_yaml (csubstr yaml_version)
void	add_directive_tag (csubstr handle, csubstr prefix)
arena events
substr	arena ()
substr	arena_rem ()
substr	alloc_arena (size_t len)
	this may fail, in which case an empty string is returned
implementation helpers
void	_push ()
	push a new parent, add a child to the new parent, and set the child as the current node
void	_pop ()
	end the current scope
template<c4::yml::type_bits bits>
void	enable_ () noexcept
template<c4::yml::type_bits bits>
void	disable_ () noexcept
template<c4::yml::type_bits bits>
bool	has_any_ () const noexcept
evt_size	_next (evt_size pos) const noexcept
evt_size	_prev (evt_size pos) const noexcept
bool	_is_sub_ (csubstr str) const noexcept
void	_send_flag_only_ (ievt::evt_bits flags)
void	_send_str_ (csubstr scalar, ievt::evt_bits flags)
void	_mark_parent_with_children_ ()
csubstr	_get_latest_empty_scalar () const
evt_size	_find_last_bdoc (evt_size pos) const
evt_size	_find_matching_open (ievt::evt_bits open, ievt::evt_bits close, evt_size pos) const
evt_size	_extend_left_to_include_tag_and_or_anchor (evt_size pos) const

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

A parser event handler that creates a compact representation of the YAML tree in a contiguous buffer of integers.

The integers are ievt::EventBits containing masks (to represent events), interleaved with offset+length (to represent strings in the source buffer).

For a description of the events, see Ints Event Handler

This handler must be initialized with the input source buffer, the output arena, and the output event buffer. This handler will not take ownership nor attempt to resize the output buffer. If the size required for the output buffer or arena are larger than their actual size, parsing goes all way to the end, determining the required buffer sizes without writing anything past the end of the respective buffer. After parsing is finished, the user must ensure that the buffer size was enough to accomodate all the data that needs to be written into it, or react accordingly (eg, throw an error, or resize the buffer then retry the parse).

A couple of functions will be helpful to do this. After parsing, EventHandlerInts::fits_buffers() must be used to verify that the output buffers were enough to accomodate the results. Then, EventHandlerInts::required_size_events() and EventHandlerInts::required_size_arena() can be used to retrieve to necessary information. To get an estimation of the number of events before parsing, see estimate_events_ints_size().

Typical code to parse YAML with this handler will look like this:

csubstr filename = ...;
substr src = ...;
// estimate the size required for the events buffer,
// overpredicting it to be safe.
int estimated_size = extra::estimate_events_ints_size(src);
extra::EventHandlerInts handler;
ParseEngine<extra::EventHandlerInts> parser(&handler);
// example with a vector
std::vector<int> evts;
// ensure we have a fighting chance to acommodate the events
evts.resize((size_t)estimated_size);
// arena to place scalars/tags that may have been extended after filtering
std::vector<char> arena;
arena.resize(src.len); // this is generally enough
// initialize the handler
handler.reset(src, arena, evts.data(), (int)evts.size());
// parse the YAML
parser.parse_in_place_ev(filename, src);
if(handler.fits_buffers()) // were the buffer sizes enough?
{
     evts.resize((size_t)handler.required_size_events()); // trim the vector
     ...
}
else
{
     // event size estimation underpredicted, or arena is too small!
     // for the first case, open an issue at
     // https://github.com/biojppm/rapidyaml/issues
     error("buffer could not accomodate all the events");
     // NOTE: see below for notes on doing a parse retry.
}

The result of estimate_events_ints_size() (click to see more info) must be an overprediction: it overpredicts for every single case among the many hundreds covered in the unit tests. This is deliberate, and aims at ensuring that a retry parse is not needed. But conceivably, it may underpredict in some instances not found in the out tests. What to do then?

First, open an issue to allow the estimation to be improved! Second, there are two ways to handle this situation in code:

1) throw an error (as sketched above)

2) grow the buffer to the required size (see EventHandlerInts::required_size_events()), and then parse again

If your code must be able to handle any case including where the prediction undershoots before the estimate function is fixed (after you open the issue), that is, if you are considering a parse retry, there is something important that needs attention. The YAML source buffer is mutated in-place during the parse, and cannot be used to parse again. So if you want to retry, you need to keep a pristine copy of the source, and use it for the retry:

const std::string src = ...;  // the YAML code to be parsed
std::string parsed_src = src; // this is where we will parse (filter during parsing)
std::vector<int> evts((size_t)estimated_size); // ensure we have a fighting change to acommodate the events
std::vector<char> arena(src.size()); // ensure we have a fighting change to acommodate the events
ParseEngine<extra::EventHandlerInts> parser(&handler);
handler.reset(to_substr(parsed_src), to_substr(arena), evts.data(), (int)evts.size());
parser.parse_in_place_ev(filename, to_substr(parsed_src));
if(handler.fits_buffers()) // were the buffer sizes enough?
{
     evts.resize((size_t)handler.required_size()); // trim the vector
     ...
}
else
{
     evts.resize((size_t)handler.required_size_events()); // buffer size was not enough.
     arena.resize(handler.required_size_arena()); // buffer size was not enough.
     // copy again
     parsed_src = src;
     // retry parse
     handler.reset(to_substr(parsed_src), to_substr(arena), evts.data(), (int)evts.size());
     parser.parse_in_place_ev(filename, to_substr(parsed_src));
     assert((size_t)handler.fits_buffers()); // must always be true
}

When bringing this to other programming languages, the semantics will be very similar to this.

Definition at line 460 of file event_handler_ints.hpp.

Member Typedef Documentation

value_type

using c4::yml::extra::EventHandlerInts::value_type = ievt::evt_bits

Definition at line 466 of file event_handler_ints.hpp.

state

using c4::yml::extra::EventHandlerInts::state = EventHandlerIntsState

Definition at line 467 of file event_handler_ints.hpp.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
requires_strings_on_buffers

Definition at line 468 of file event_handler_ints.hpp.

{ requires_strings_on_buffers = true }; // NOLINT

Constructor & Destructor Documentation

EventHandlerInts() [1/2]

c4::yml::extra::EventHandlerInts::EventHandlerInts ( c4::yml::Callbacks const & cb )

inlinenoexcept

Definition at line 496 of file event_handler_ints.hpp.

        : EventHandlerStack(cb)
    {
        reset(substr{}, substr{}, nullptr, 0);
    }

Referenced by EventHandlerInts().

EventHandlerInts() [2/2]

c4::yml::extra::EventHandlerInts::EventHandlerInts ( )

inlinenoexcept

Definition at line 501 of file event_handler_ints.hpp.

        : EventHandlerInts(c4::yml::get_callbacks())
    {
    }

Member Function Documentation

reset()

void c4::yml::extra::EventHandlerInts::reset ( substr str, substr arena, ievt::evt_bits * dst, evt_size dst_size )

inline

Definition at line 506 of file event_handler_ints.hpp.

    {
        _stack_reset_root();
        m_curr->flags |= c4::yml::RUNK|c4::yml::RTOP;
        m_curr->evt_type = {};
        m_curr->evt_id = 0;
        m_arena = arena;
        m_arena_pos = 0;
        m_src = str;
        m_evt = dst;
        m_evt_size = dst_size;
        m_evt_pos = 0;
        m_evt_prev = 0;
        m_curr_doc = 0;
        m_tag_directives.clear();
        m_tag_cache.clear();
    }

Referenced by EventHandlerInts().

required_size_events()

evt_size c4::yml::extra::EventHandlerInts::required_size_events ( ) const

inline

get the size needed for the event buffer from the previous parse

Warning

this is valid only until the next parse

Definition at line 526 of file event_handler_ints.hpp.

    {
        return m_evt_pos;
    }

Referenced by IntsResult::resize_buffers().

required_size_arena()

size_t c4::yml::extra::EventHandlerInts::required_size_arena ( ) const

inline

get the size needed for the arena from the previous parse

Warning

this is valid only until the next parse

Definition at line 533 of file event_handler_ints.hpp.

    {
        return m_arena_pos;
    }

Referenced by IntsResult::resize_buffers().

fits_buffers()

bool c4::yml::extra::EventHandlerInts::fits_buffers ( ) const

inline

Predicate to test if the event and arena buffers successfully accomodated all the parse events.

Warning

this is valid only until the next parse

Definition at line 542 of file event_handler_ints.hpp.

    {
        return m_evt_pos <= m_evt_size && m_arena_pos <= m_arena.len;
    }

reserve_arena()

void c4::yml::extra::EventHandlerInts::reserve_arena ( int )

inline

Definition at line 547 of file event_handler_ints.hpp.

    {
        // does not apply here
    }

tag_directives()

TagDirectives & c4::yml::extra::EventHandlerInts::tag_directives ( )

inline

Definition at line 552 of file event_handler_ints.hpp.

{ return m_tag_directives; }

tag_cache()

TagCache & c4::yml::extra::EventHandlerInts::tag_cache ( )

inline

Definition at line 553 of file event_handler_ints.hpp.

{ return m_tag_cache; }

start_parse()

void c4::yml::extra::EventHandlerInts::start_parse ( const char * filename, substr src )

inline

Definition at line 562 of file event_handler_ints.hpp.

    {
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, src.str == m_src.str);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, src.len == m_src.len);
        this->_stack_start_parse(filename, src);
    }

finish_parse()

void c4::yml::extra::EventHandlerInts::finish_parse ( )

inline

Definition at line 569 of file event_handler_ints.hpp.

    {
        this->_stack_finish_parse();
    }

cancel_parse()

void c4::yml::extra::EventHandlerInts::cancel_parse ( )

inline

Definition at line 574 of file event_handler_ints.hpp.

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

begin_stream()

void c4::yml::extra::EventHandlerInts::begin_stream ( )

inline

Definition at line 587 of file event_handler_ints.hpp.

    {
        _send_flag_only_(ievt::BSTR);
    }

end_stream()

void c4::yml::extra::EventHandlerInts::end_stream ( )

inline

Definition at line 592 of file event_handler_ints.hpp.

    {
        _send_flag_only_(ievt::ESTR);
    }

begin_doc()

void c4::yml::extra::EventHandlerInts::begin_doc ( )

inline

implicit doc start (without —)

Definition at line 605 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: begin_doc", m_evt_pos, m_evt_size);
        _send_flag_only_(ievt::BDOC);
        if(_stack_should_push_on_begin_doc())
        {
            _c4dbgp("push!");
            _push();
            ryml_enable_(DOC);
        }
    }

end_doc()

void c4::yml::extra::EventHandlerInts::end_doc ( )

inline

implicit doc end (without ...)

Definition at line 617 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: end_doc", m_evt_pos, m_evt_size);
        _send_flag_only_(ievt::EDOC);
        if(_stack_should_pop_on_end_doc())
        {
            _c4dbgp("pop!");
            _pop();
        }
        ++m_curr_doc;
    }

begin_doc_expl()

void c4::yml::extra::EventHandlerInts::begin_doc_expl ( )

inline

explicit doc start, with —

Definition at line 630 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: begin_doc_expl", m_evt_pos, m_evt_size);
        _send_flag_only_(ievt::BDOC|ievt::EXPL);
        _c4dbgp("push!");
        _push();
        ryml_enable_(DOC);
    }

end_doc_expl()

void c4::yml::extra::EventHandlerInts::end_doc_expl ( )

inline

explicit doc end, with ...

Definition at line 639 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: end_doc_expl", m_evt_pos, m_evt_size);
        _send_flag_only_(ievt::EDOC|ievt::EXPL);
        if(_stack_should_pop_on_end_doc())
        {
            _c4dbgp("pop!");
            _pop();
        }
        ++m_curr_doc;
    }

begin_map_key_flow()

void c4::yml::extra::EventHandlerInts::begin_map_key_flow ( )

inline

Definition at line 658 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: bmap key flow", m_evt_pos, m_evt_size);
        _send_flag_only_(ievt::KEY_|ievt::BMAP|ievt::FLOW);
        _mark_parent_with_children_();
        ryml_enable_(c4::yml::KEY|c4::yml::MAP|c4::yml::FLOW_SL);
        _push();
    }

begin_map_key_block()

void c4::yml::extra::EventHandlerInts::begin_map_key_block ( )

inline

Definition at line 666 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: bmap key block", m_evt_pos, m_evt_size);
        _send_flag_only_(ievt::KEY_|ievt::BMAP|ievt::BLCK);
        _mark_parent_with_children_();
        ryml_enable_(c4::yml::KEY|c4::yml::MAP|c4::yml::BLOCK);
        _push();
    }

begin_map_val_flow()

void c4::yml::extra::EventHandlerInts::begin_map_val_flow ( )

inline

Definition at line 675 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: bmap flow", m_evt_pos, m_evt_size);
        _send_flag_only_(ievt::VAL_|ievt::BMAP|ievt::FLOW);
        _mark_parent_with_children_();
        ryml_enable_(c4::yml::MAP|c4::yml::FLOW_SL);
        _push();
    }

begin_map_val_block()

void c4::yml::extra::EventHandlerInts::begin_map_val_block ( )

inline

Definition at line 683 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: bmap block", m_evt_pos, m_evt_size);
        _send_flag_only_(ievt::VAL_|ievt::BMAP|ievt::BLCK);
        _mark_parent_with_children_();
        ryml_enable_(c4::yml::MAP|c4::yml::BLOCK);
        _push();
    }

end_map_block()

void c4::yml::extra::EventHandlerInts::end_map_block ( )

inline

Definition at line 692 of file event_handler_ints.hpp.

    {
        _pop();
        _send_flag_only_(ievt::EMAP);
    }

end_map_flow()

void c4::yml::extra::EventHandlerInts::end_map_flow ( bool , type_bits = FLOW_ML1 )

inline

Definition at line 698 of file event_handler_ints.hpp.

    {
        _pop();
        _send_flag_only_(ievt::EMAP);
    }

begin_seq_key_flow()

void c4::yml::extra::EventHandlerInts::begin_seq_key_flow ( )

inline

Definition at line 711 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: bseq key flow", m_evt_pos, m_evt_size);
        _send_flag_only_(ievt::KEY_|ievt::BSEQ|ievt::FLOW);
        _mark_parent_with_children_();
        ryml_enable_(c4::yml::KEY|c4::yml::SEQ|c4::yml::FLOW_SL);
        _push();
    }

begin_seq_key_block()

void c4::yml::extra::EventHandlerInts::begin_seq_key_block ( )

inline

Definition at line 719 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: bseq key block", m_evt_pos, m_evt_size);
        _send_flag_only_(ievt::KEY_|ievt::BSEQ|ievt::BLCK);
        _mark_parent_with_children_();
        ryml_enable_(c4::yml::KEY|c4::yml::SEQ|c4::yml::BLOCK);
        _push();
    }

begin_seq_val_flow()

void c4::yml::extra::EventHandlerInts::begin_seq_val_flow ( )

inline

Definition at line 728 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: bseq flow", m_evt_pos, m_evt_size);
        _send_flag_only_(ievt::VAL_|ievt::BSEQ|ievt::FLOW);
        _mark_parent_with_children_();
        ryml_enable_(c4::yml::SEQ|c4::yml::FLOW_SL);
        _push();
    }

begin_seq_val_block()

void c4::yml::extra::EventHandlerInts::begin_seq_val_block ( )

inline

Definition at line 736 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: bseq block", m_evt_pos, m_evt_size);
        _send_flag_only_(ievt::VAL_|ievt::BSEQ|ievt::BLCK);
        _mark_parent_with_children_();
        ryml_enable_(c4::yml::SEQ|c4::yml::BLOCK);
        _push();
    }

end_seq_block()

void c4::yml::extra::EventHandlerInts::end_seq_block ( )

inline

Definition at line 745 of file event_handler_ints.hpp.

    {
        _pop();
        _send_flag_only_(ievt::ESEQ);
    }

end_seq_flow()

void c4::yml::extra::EventHandlerInts::end_seq_flow ( bool , type_bits = FLOW_ML1 )

inline

Definition at line 751 of file event_handler_ints.hpp.

    {
        _pop();
        _send_flag_only_(ievt::ESEQ);
    }

add_sibling()

void c4::yml::extra::EventHandlerInts::add_sibling ( )

inline

Definition at line 764 of file event_handler_ints.hpp.

    {
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_parent);
        m_curr->evt_type = {};
    }

set_key_scalar_plain_empty()

void c4::yml::extra::EventHandlerInts::set_key_scalar_plain_empty ( )

inline

Definition at line 778 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_scalar_plain_empty", m_evt_pos, m_evt_size);
        _send_str_(_get_latest_empty_scalar(), ievt::KEY_|ievt::SCLR|ievt::PLAI);
        ryml_enable_(c4::yml::KEY|c4::yml::KEY_PLAIN|c4::yml::KEYNIL);
    }

set_val_scalar_plain_empty()

void c4::yml::extra::EventHandlerInts::set_val_scalar_plain_empty ( )

inline

Definition at line 784 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_scalar_plain_empty", m_evt_pos, m_evt_size);
        _send_str_(_get_latest_empty_scalar(), ievt::VAL_|ievt::SCLR|ievt::PLAI);
        ryml_enable_(c4::yml::VAL|c4::yml::VAL_PLAIN|c4::yml::VALNIL);
    }

set_key_scalar_plain()

void c4::yml::extra::EventHandlerInts::set_key_scalar_plain ( csubstr scalar )

inline

Definition at line 792 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_scalar_plain: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_src.str, scalar.len, scalar);
        _send_str_(scalar, ievt::KEY_|ievt::SCLR|ievt::PLAI);
        ryml_enable_(c4::yml::KEY|c4::yml::KEY_PLAIN);
    }

set_val_scalar_plain()

void c4::yml::extra::EventHandlerInts::set_val_scalar_plain ( csubstr scalar )

inline

Definition at line 798 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_scalar_plain: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_src.str, scalar.len, scalar);
        _send_str_(scalar, ievt::VAL_|ievt::SCLR|ievt::PLAI);
        ryml_enable_(c4::yml::VAL|c4::yml::VAL_PLAIN);
    }

set_key_scalar_dquoted()

void c4::yml::extra::EventHandlerInts::set_key_scalar_dquoted ( csubstr scalar )

inline

Definition at line 806 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_scalar_dquo: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str?size_t(scalar.str-m_src.str):m_src.len, scalar.len, scalar.str?scalar:csubstr{});
        _send_str_(scalar, ievt::KEY_|ievt::SCLR|ievt::DQUO);
        ryml_enable_(c4::yml::KEY|c4::yml::KEY_DQUO);
    }

set_val_scalar_dquoted()

void c4::yml::extra::EventHandlerInts::set_val_scalar_dquoted ( csubstr scalar )

inline

Definition at line 812 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_scalar_dquo: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str?size_t(scalar.str-m_src.str):m_src.len, scalar.len, scalar.str?scalar:csubstr{});
        _send_str_(scalar, ievt::VAL_|ievt::SCLR|ievt::DQUO);
        ryml_enable_(c4::yml::VAL|c4::yml::VAL_DQUO);
    }

set_key_scalar_squoted()

void c4::yml::extra::EventHandlerInts::set_key_scalar_squoted ( csubstr scalar )

inline

Definition at line 820 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_scalar_squo: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_src.str, scalar.len, scalar);
        _send_str_(scalar, ievt::KEY_|ievt::SCLR|ievt::SQUO);
        ryml_enable_(c4::yml::KEY|c4::yml::KEY_SQUO);
    }

set_val_scalar_squoted()

void c4::yml::extra::EventHandlerInts::set_val_scalar_squoted ( csubstr scalar )

inline

Definition at line 826 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_scalar_squo: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_src.str, scalar.len, scalar);
        _send_str_(scalar, ievt::VAL_|ievt::SCLR|ievt::SQUO);
        ryml_enable_(c4::yml::VAL|c4::yml::VAL_SQUO);
    }

set_key_scalar_literal()

void c4::yml::extra::EventHandlerInts::set_key_scalar_literal ( csubstr scalar )

inline

Definition at line 834 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_scalar_literal: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str?size_t(scalar.str-m_src.str):m_src.len, scalar.len, scalar.str?scalar:csubstr{});
        _send_str_(scalar, ievt::KEY_|ievt::SCLR|ievt::LITL);
        ryml_enable_(c4::yml::KEY|c4::yml::KEY_LITERAL);
    }

set_val_scalar_literal()

void c4::yml::extra::EventHandlerInts::set_val_scalar_literal ( csubstr scalar )

inline

Definition at line 840 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_scalar_literal: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str?size_t(scalar.str-m_src.str):m_src.len, scalar.len, scalar.str?scalar:csubstr{});
        _send_str_(scalar, ievt::VAL_|ievt::SCLR|ievt::LITL);
        ryml_enable_(c4::yml::VAL|c4::yml::VAL_LITERAL);
    }

set_key_scalar_folded()

void c4::yml::extra::EventHandlerInts::set_key_scalar_folded ( csubstr scalar )

inline

Definition at line 848 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_scalar_folded: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str?size_t(scalar.str-m_src.str):m_src.len, scalar.len, scalar.str?scalar:csubstr{});
        _send_str_(scalar, ievt::KEY_|ievt::SCLR|ievt::FOLD);
        ryml_enable_(c4::yml::KEY|c4::yml::KEY_FOLDED);
    }

set_val_scalar_folded()

void c4::yml::extra::EventHandlerInts::set_val_scalar_folded ( csubstr scalar )

inline

Definition at line 854 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_scalar_folded: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str?size_t(scalar.str-m_src.str):m_src.len, scalar.len, scalar.str?scalar:csubstr{});
        _send_str_(scalar, ievt::VAL_|ievt::SCLR|ievt::FOLD);
        ryml_enable_(c4::yml::VAL|c4::yml::VAL_FOLDED);
    }

mark_key_scalar_unfiltered()

void c4::yml::extra::EventHandlerInts::mark_key_scalar_unfiltered ( )

inline

Definition at line 862 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: mark_key_scalar_unfiltered", m_evt_pos, m_evt_size);
        if(m_evt_pos < m_evt_size)
            m_evt[m_evt_pos] |= ievt::UNFILT;
    }

mark_val_scalar_unfiltered()

void c4::yml::extra::EventHandlerInts::mark_val_scalar_unfiltered ( )

inline

Definition at line 868 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: mark_val_scalar_unfiltered", m_evt_pos, m_evt_size);
        if(m_evt_pos < m_evt_size)
            m_evt[m_evt_pos] |= ievt::UNFILT;
    }

set_key_anchor()

void c4::yml::extra::EventHandlerInts::set_key_anchor ( csubstr anchor )

inline

Definition at line 904 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_anchor: {}", m_evt_pos, m_evt_size, anchor);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, !ryml_has_any_(KEYREF));
        ryml_enable_(c4::yml::KEYANCH);
        if(m_evt_pos + 3 < m_evt_size)
        {
            m_evt[m_evt_pos] |= ievt::KEY_|ievt::ANCH;
            _add_scalar_(m_evt_pos, anchor);
        }
        m_evt_prev = m_evt_pos;
        m_evt_pos += 3;
    }

set_val_anchor()

void c4::yml::extra::EventHandlerInts::set_val_anchor ( csubstr anchor )

inline

Definition at line 917 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_anchor: {}", m_evt_pos, m_evt_size, anchor);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, !ryml_has_any_(VALREF));
        ryml_enable_(c4::yml::VALANCH);
        if(m_evt_pos + 3 < m_evt_size)
        {
            m_evt[m_evt_pos] |= ievt::VAL_|ievt::ANCH;
            _add_scalar_(m_evt_pos, anchor);
        }
        m_evt_prev = m_evt_pos;
        m_evt_pos += 3;
    }

set_key_ref()

void c4::yml::extra::EventHandlerInts::set_key_ref ( csubstr ref )

inline

Definition at line 931 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_ref: {}", m_evt_pos, m_evt_size, ref);
        RYML_ASSERT_PARSE_CB_(m_stack.m_callbacks, ref.begins_with('*'), m_curr->pos);
        RYML_ASSERT_PARSE_CB_(m_stack.m_callbacks, !ryml_has_any_(KEYANCH), m_curr->pos);
        ryml_enable_(c4::yml::KEY|c4::yml::KEYREF);
        _send_str_(ref.sub(1), ievt::KEY_|ievt::ALIA); // skip the leading *
    }

set_val_ref()

void c4::yml::extra::EventHandlerInts::set_val_ref ( csubstr ref )

inline

Definition at line 939 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_ref: {}", m_evt_pos, m_evt_size, ref);
        RYML_ASSERT_PARSE_CB_(m_stack.m_callbacks, ref.begins_with('*'), m_curr->pos);
        RYML_ASSERT_PARSE_CB_(m_stack.m_callbacks, !ryml_has_any_(VALANCH), m_curr->pos);
        ryml_enable_(c4::yml::VAL|c4::yml::VALREF);
        _send_str_(ref.sub(1), ievt::VAL_|ievt::ALIA); // skip the leading *
    }

set_key_tag()

void c4::yml::extra::EventHandlerInts::set_key_tag ( csubstr tag )

inline

Definition at line 955 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set key tag [{}]~~~{}~~~", m_evt_pos, m_evt_size, tag.len, tag.str ? tag : csubstr("(arena full)"));
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, _is_sub_(tag));
        ryml_enable_(c4::yml::KEYTAG);
        _send_str_(tag, ievt::KEY_|ievt::TAG_);
    }

set_val_tag()

void c4::yml::extra::EventHandlerInts::set_val_tag ( csubstr tag )

inline

Definition at line 962 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set val tag [{}]~~~{}~~~", m_evt_pos, m_evt_size, tag.len, tag.str ? tag : csubstr("(arena full)"));
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, _is_sub_(tag));
        ryml_enable_(c4::yml::VALTAG);
        _send_str_(tag, ievt::VAL_|ievt::TAG_);
    }

add_directive_yaml()

void c4::yml::extra::EventHandlerInts::add_directive_yaml ( csubstr yaml_version )

inline

Definition at line 977 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: %YAML directive! version={}", m_evt_pos, m_evt_size, yaml_version);
        _send_str_(yaml_version, ievt::YAML);
    }

add_directive_tag()

void c4::yml::extra::EventHandlerInts::add_directive_tag ( csubstr handle, csubstr prefix )

inline

Definition at line 983 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: %TAG directive! handle={} prefix={} doc_id={}", m_evt_pos, m_evt_size, handle, prefix, m_curr_doc);
        if C4_UNLIKELY(!m_tag_directives.add(handle, prefix, m_curr_doc))
            RYML_ERR_PARSE_CB_(m_stack.m_callbacks, m_curr->pos, "too many %TAG directives");
        _send_str_(handle, ievt::TAGH);
        _send_str_(prefix, ievt::TAGP);
    }

actually_val_is_first_key_of_new_map_flow()

void c4::yml::extra::EventHandlerInts::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 1004 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: prev={} actually_val_is_first_key_of_new_map_flow", m_evt_pos, m_evt_size, m_evt_prev);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_evt_pos > 2);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_evt_prev > 0);
        // BEFORE
        // ... flag start len (free)
        //     |              |
        //     prev           curr
        // AFTER
        // ... BMAP flag start len (free)
        //          |              |
        //          prev           curr
        if(m_evt_pos < m_evt_size)
        {
            if(m_evt[m_evt_prev] & ievt::WSTR)
            {
                _c4dbgpf("{}/{}: WSTR", m_evt_pos, m_evt_size);
                RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, m_evt_prev > 0);
                evt_size pos = _extend_left_to_include_tag_and_or_anchor(m_evt_prev);
                if(m_evt_pos + 1 < m_evt_size)
                {
                    for(evt_size i = pos; i <= m_evt_prev; i = _next(i))
                    {
                        m_evt[i] |= ievt::KEY_;
                        m_evt[i] &= ~ievt::VAL_;
                    }
                    evt_size num_move = m_evt_pos + 1 - pos;
                    RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, num_move > 0);
                    memmove(m_evt + pos + 1, m_evt + pos, (size_t)num_move * sizeof(ievt::evt_bits));
                }
                m_evt[pos] = ievt::BMAP|ievt::FLOW|ievt::VAL_;
                // move PSTR to prev
                if(m_evt[pos + 1] & ievt::PSTR)
                {
                    m_evt[pos    ] |= ievt::PSTR;
                    m_evt[pos + 1] &= ~ievt::PSTR;
                }
            }
            else
            {
                _c4dbgpf("{}/{}: container key", m_evt_pos, m_evt_size);
                RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, (m_evt[m_evt_prev] & (ievt::EMAP|ievt::ESEQ)));
                evt_size pos;
                _c4dbgpf("{}/{}: find matching open for {}", m_evt_pos, m_evt_size, m_evt_prev);
                if((m_evt[m_evt_prev] & ievt::EMAP) == ievt::EMAP)
                {
                    pos = _find_matching_open(ievt::BMAP, ievt::EMAP, m_evt_prev);
                }
                else
                {
                    RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, (m_evt[m_evt_prev] & ievt::ESEQ));
                    pos = _find_matching_open(ievt::BSEQ, ievt::ESEQ, m_evt_prev);
                }
                _c4dbgpf("{}/{}: matching open for {}={}", m_evt_pos, m_evt_size, m_evt_prev, pos);
                RYML_CHECK_BASIC_CB_(m_stack.m_callbacks, pos >= 0); // internal error
                RYML_CHECK_BASIC_CB_(m_stack.m_callbacks, pos < m_evt_prev); // internal error
                RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, (m_evt[pos] & ievt::ESEQ) == (m_evt[m_evt_prev] & ievt::BSEQ));
                RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, (m_evt[pos] & ievt::EMAP) == (m_evt[m_evt_prev] & ievt::BMAP));
                // shift the array one position to the right, starting at pos
                evt_size posp1 = pos + 1;
                if(m_evt_pos + 1 < m_evt_size)
                {
                    evt_size num_move = m_evt_pos + 1 - pos;
                    RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, num_move > 0);
                    memmove(m_evt + posp1, m_evt + pos, (size_t)num_move * sizeof(ievt::evt_bits));
                }
                RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, posp1 < m_evt_pos);
                // start the map
                m_evt[pos] = ievt::BMAP|ievt::FLOW|ievt::VAL_;
                // set next as key, not val
                m_evt[posp1] |= ievt::KEY_;
                m_evt[posp1] &= ~ievt::VAL_;
                // move PSTR to pos
                if(m_evt[posp1] & ievt::PSTR)
                {
                    m_evt[pos] |= ievt::PSTR;
                    m_evt[posp1] &= ~ievt::PSTR;
                }
            }
        }
        m_curr->evt_id = m_evt_pos - 2;
        ++m_evt_prev;
        ++m_evt_pos;
        ryml_enable_(c4::yml::MAP|c4::yml::FLOW_SL);
        _push();
    }

actually_val_is_first_key_of_new_map_block()

void c4::yml::extra::EventHandlerInts::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 1098 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: prev={} actually_val_is_first_key_of_new_map_block", m_evt_pos, m_evt_size, m_evt_prev);
        if(m_evt_pos < m_evt_size)
        {
            // interpolate BMAP|VAL|BLCK after the last BDOC
            evt_size pos = _find_last_bdoc(m_evt_pos);
            if(pos >= 0)
            {
                RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, pos < m_evt_size);
                RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, pos < m_evt_pos);
                RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, (m_evt[pos] & ievt::BDOC) == ievt::BDOC);
                if(m_evt_pos < m_evt_size)
                {
                    ++pos; // add 1 to write after BDOC
                    evt_size num_move = m_evt_pos - pos;
                    evt_size posp1 = pos + 1;
                    RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, ((m_evt[pos] & ievt::BSEQ) == ievt::BSEQ) || ((m_evt[pos] & ievt::BMAP) == ievt::BMAP));
                    RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, num_move > 0);
                    RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, 0 == (m_evt[posp1] & ievt::PSTR));
                    memmove(m_evt + posp1, m_evt + pos, (size_t)num_move * sizeof(ievt::evt_bits));
                    m_evt[pos] = ievt::VAL_|ievt::BMAP|ievt::BLCK;
                    m_evt[posp1] &= ~ievt::VAL_;
                    m_evt[posp1] |= ievt::KEY_;
                }
            }
        }
        ++m_curr->evt_id;
        ++m_evt_prev;
        ++m_evt_pos;
        _push();
    }

arena()

substr c4::yml::extra::EventHandlerInts::arena ( )

inline

Definition at line 1138 of file event_handler_ints.hpp.

    {
        return m_arena.first(m_arena_pos < m_arena.len ? m_arena_pos : m_arena.len);
    }

Referenced by reset().

arena_rem()

substr c4::yml::extra::EventHandlerInts::arena_rem ( )

inline

Definition at line 1142 of file event_handler_ints.hpp.

    {
        return C4_EXPECT(m_arena_pos <= m_arena.len, 1) ? m_arena.sub(m_arena_pos) : m_arena.last(0);
    }

Referenced by alloc_arena().

alloc_arena()

substr c4::yml::extra::EventHandlerInts::alloc_arena ( size_t len )

inline

this may fail, in which case an empty string is returned

Definition at line 1147 of file event_handler_ints.hpp.

    {
        substr s = arena_rem();
        if C4_LIKELY(len <= s.len)
            s.len = len;
        else
            s.str = nullptr;
        m_arena_pos += len;
        return s;
    }

_push()

void c4::yml::extra::EventHandlerInts::_push ( )

inline

push a new parent, add a child to the new parent, and set the child as the current node

Definition at line 1167 of file event_handler_ints.hpp.

    {
        _stack_push();
        m_curr->evt_type = {};
    }

Referenced by actually_val_is_first_key_of_new_map_block(), actually_val_is_first_key_of_new_map_flow(), begin_doc(), begin_doc_expl(), begin_map_key_block(), begin_map_key_flow(), begin_map_val_block(), begin_map_val_flow(), begin_seq_key_block(), begin_seq_key_flow(), begin_seq_val_block(), and begin_seq_val_flow().

_pop()

void c4::yml::extra::EventHandlerInts::_pop ( )

inline

end the current scope

Definition at line 1174 of file event_handler_ints.hpp.

    {
        _stack_pop();
    }

Referenced by cancel_parse(), end_doc(), end_doc_expl(), end_map_block(), end_map_flow(), end_seq_block(), and end_seq_flow().

enable_()

template<c4::yml::type_bits bits>

void c4::yml::extra::EventHandlerInts::enable_ ( )

inlinenoexcept

Definition at line 1179 of file event_handler_ints.hpp.

    {
        m_curr->evt_type |= bits;
    }

disable_()

template<c4::yml::type_bits bits>

void c4::yml::extra::EventHandlerInts::disable_ ( )

inlinenoexcept

Definition at line 1183 of file event_handler_ints.hpp.

    {
        m_curr->evt_type &= ~bits;
    }

has_any_()

template<c4::yml::type_bits bits>

bool c4::yml::extra::EventHandlerInts::has_any_ ( ) const

inlinenoexcept

Definition at line 1187 of file event_handler_ints.hpp.

    {
        return (m_curr->evt_type & bits) != c4::yml::type_bits(0);
    }

_next()

evt_size c4::yml::extra::EventHandlerInts::_next ( evt_size pos ) const

inlinenoexcept

Definition at line 1192 of file event_handler_ints.hpp.

    {
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, pos < m_evt_size);
        return pos + ((m_evt[pos] & ievt::WSTR) ? 3 : 1);
    }

Referenced by actually_val_is_first_key_of_new_map_flow().

_prev()

evt_size c4::yml::extra::EventHandlerInts::_prev ( evt_size pos ) const

inlinenoexcept

Definition at line 1198 of file event_handler_ints.hpp.

    {
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, pos < m_evt_size);
        return pos - ((m_evt[pos] & ievt::PSTR) ? 3 : 1);
    }

Referenced by _extend_left_to_include_tag_and_or_anchor(), and _find_matching_open().

_is_sub_()

bool c4::yml::extra::EventHandlerInts::_is_sub_ ( csubstr str ) const

inlinenoexcept

Definition at line 1204 of file event_handler_ints.hpp.

    {
        return (!str.str || str.is_sub(m_src) || str.is_sub(m_arena));
    }

Referenced by set_key_tag(), and set_val_tag().

_send_flag_only_()

void c4::yml::extra::EventHandlerInts::_send_flag_only_ ( ievt::evt_bits flags )

inline

Definition at line 1209 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: flag only", m_evt_pos, m_evt_size);
        if(m_evt_pos < m_evt_size)
            m_evt[m_evt_pos] |= flags;
        m_curr->evt_id = m_evt_pos;
        m_evt_prev = m_evt_pos;
        ++m_evt_pos;
        if(m_evt_pos < m_evt_size)
            m_evt[m_evt_pos] = {};
    }

Referenced by begin_doc(), begin_doc_expl(), begin_map_key_block(), begin_map_key_flow(), begin_map_val_block(), begin_map_val_flow(), begin_seq_key_block(), begin_seq_key_flow(), begin_seq_val_block(), begin_seq_val_flow(), begin_stream(), end_doc(), end_doc_expl(), end_map_block(), end_map_flow(), end_seq_block(), end_seq_flow(), and end_stream().

_send_str_()

void c4::yml::extra::EventHandlerInts::_send_str_ ( csubstr scalar, ievt::evt_bits flags )

inline

Definition at line 1221 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: send str", m_evt_pos, m_evt_size);
        if(m_evt_pos + 3 < m_evt_size)
        {
            m_evt[m_evt_pos] |= flags;
            _add_scalar_(m_evt_pos, scalar);
        }
        m_curr->evt_id = m_evt_pos;
        m_evt_prev = m_evt_pos;
        m_evt_pos += 3;
    }

Referenced by add_directive_tag(), add_directive_yaml(), set_key_ref(), set_key_scalar_dquoted(), set_key_scalar_folded(), set_key_scalar_literal(), set_key_scalar_plain(), set_key_scalar_plain_empty(), set_key_scalar_squoted(), set_key_tag(), set_val_ref(), set_val_scalar_dquoted(), set_val_scalar_folded(), set_val_scalar_literal(), set_val_scalar_plain(), set_val_scalar_plain_empty(), set_val_scalar_squoted(), and set_val_tag().

_mark_parent_with_children_()

void c4::yml::extra::EventHandlerInts::_mark_parent_with_children_ ( )

inline

Definition at line 1234 of file event_handler_ints.hpp.

    {
        if(m_parent)
            m_parent->has_children = true;
    }

Referenced by begin_map_key_block(), begin_map_key_flow(), begin_map_val_block(), begin_map_val_flow(), begin_seq_key_block(), begin_seq_key_flow(), begin_seq_val_block(), and begin_seq_val_flow().

_get_latest_empty_scalar()

csubstr c4::yml::extra::EventHandlerInts::_get_latest_empty_scalar ( ) const

inline

Definition at line 1240 of file event_handler_ints.hpp.

    {
        // ideally we should search back in the latest event that has
        // a scalar, then select a zero-length scalar immediately
        // after that scalar. But this also works for now:
        return m_src.first(0);
    }

Referenced by set_key_scalar_plain_empty(), and set_val_scalar_plain_empty().

_find_last_bdoc()

evt_size c4::yml::extra::EventHandlerInts::_find_last_bdoc ( evt_size pos ) const

inline

Definition at line 1248 of file event_handler_ints.hpp.

    {
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, pos < m_evt_size); // it's safe to read from the array
        while(pos >= 0)
        {
            ievt::evt_bits e = m_evt[pos];
            if((e & ievt::BDOC) == ievt::BDOC)
                return pos;
            pos -= (e & ievt::PSTR) ? 3 : 1;
        }
        return -1; // LCOV_EXCL_LINE
    }

Referenced by actually_val_is_first_key_of_new_map_block().

_find_matching_open()

evt_size c4::yml::extra::EventHandlerInts::_find_matching_open ( ievt::evt_bits open, ievt::evt_bits close, evt_size pos ) const

inline

Definition at line 1261 of file event_handler_ints.hpp.

    {
        _c4dbgpf("find_matching: start at {}", pos);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, pos < m_evt_size);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, (m_evt[pos] & close) == close);
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, (m_evt[pos] & open) == (close & ~ievt::END_));
        pos = _prev(pos); // don't count the starting close token
        uint32_t count = 0;
        while(pos >= 0)
        {
            ievt::evt_bits e = m_evt[pos];
            _c4dbgpf("find_matching: pos={} count={} e={}", pos, count, m_evt[pos]);
            if((e & close) == close)
            {
                _c4dbgpf(".............: pos={} close! count={} e={}", pos, count, m_evt[pos]);
                ++count;
            }
            else if((e & open) == open)
            {
                _c4dbgpf(".............: pos={} open! count={} e={}", pos, count, m_evt[pos]);
                if(!count)
                    return pos;
                else
                    --count;
            }
            pos = _prev(pos);
        }
        _c4dbgpf("find_matching: not found!", 0); // LCOV_EXCL_LINE
        return -1;  // LCOV_EXCL_LINE
    }

Referenced by actually_val_is_first_key_of_new_map_flow().

_extend_left_to_include_tag_and_or_anchor()

evt_size c4::yml::extra::EventHandlerInts::_extend_left_to_include_tag_and_or_anchor ( evt_size pos ) const

inline

Definition at line 1292 of file event_handler_ints.hpp.

    {
        RYML_ASSERT_BASIC_CB_(m_stack.m_callbacks, pos < m_evt_size);
        evt_size prev = _prev(pos);
        while((prev > 0) && (m_evt[prev] & (ievt::TAG_|ievt::ANCH)))
        {
            _c4dbgpf("{}/{}: {} is anchor/tag. extend to {}", m_evt_pos, m_evt_size, prev, prev);
            pos = prev;
            prev = _prev(prev);
        }
        return pos;
    }

Referenced by actually_val_is_first_key_of_new_map_flow().

_stack_start_parse()

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

inlineprotectedinherited

Definition at line 58 of file event_handler_stack.hpp.

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

Referenced by c4::yml::extra::EventHandlerInts::start_parse().

_stack_finish_parse()

void c4::yml::EventHandlerStack< EventHandlerInts, EventHandlerIntsState >::_stack_finish_parse ( )

inlineprotectedinherited

Definition at line 65 of file event_handler_stack.hpp.

    {
    }

Referenced by c4::yml::extra::EventHandlerInts::finish_parse().

_stack_reset_root()

void c4::yml::EventHandlerStack< EventHandlerInts, EventHandlerIntsState >::_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();
    }

Referenced by c4::yml::extra::EventHandlerInts::reset().

_stack_reset_non_root()

void c4::yml::EventHandlerStack< EventHandlerInts, EventHandlerIntsState >::_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< EventHandlerInts, EventHandlerIntsState >::_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();
    }

Referenced by c4::yml::extra::EventHandlerInts::_push().

_stack_pop()

void c4::yml::EventHandlerStack< EventHandlerInts, EventHandlerIntsState >::_stack_pop ( )

inlineprotectedinherited

Definition at line 96 of file event_handler_stack.hpp.

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

Referenced by c4::yml::extra::EventHandlerInts::_pop().

_stack_should_push_on_begin_doc()

bool c4::yml::EventHandlerStack< EventHandlerInts, EventHandlerIntsState >::_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 || ryml_has_any_(DOC|VAL|MAP|SEQ));
    }

Referenced by c4::yml::extra::EventHandlerInts::begin_doc().

_stack_should_pop_on_end_doc()

bool c4::yml::EventHandlerStack< EventHandlerInts, EventHandlerIntsState >::_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 && ryml_has_any_(DOC);
    }

Referenced by c4::yml::extra::EventHandlerInts::end_doc(), and c4::yml::extra::EventHandlerInts::end_doc_expl().

Member Data Documentation

m_stack

detail::stack<state> c4::yml::EventHandlerStack< EventHandlerInts, EventHandlerIntsState >::m_stack

inherited

Definition at line 46 of file event_handler_stack.hpp.

Referenced by c4::yml::extra::EventHandlerInts::_extend_left_to_include_tag_and_or_anchor(), c4::yml::extra::EventHandlerInts::_find_last_bdoc(), c4::yml::extra::EventHandlerInts::_find_matching_open(), c4::yml::extra::EventHandlerInts::_next(), c4::yml::extra::EventHandlerInts::_prev(), c4::yml::extra::EventHandlerInts::actually_val_is_first_key_of_new_map_block(), c4::yml::extra::EventHandlerInts::actually_val_is_first_key_of_new_map_flow(), c4::yml::extra::EventHandlerInts::add_directive_tag(), c4::yml::extra::EventHandlerInts::add_sibling(), c4::yml::extra::EventHandlerInts::cancel_parse(), c4::yml::extra::EventHandlerInts::set_key_anchor(), c4::yml::extra::EventHandlerInts::set_key_ref(), c4::yml::extra::EventHandlerInts::set_key_tag(), c4::yml::extra::EventHandlerInts::set_val_anchor(), c4::yml::extra::EventHandlerInts::set_val_ref(), c4::yml::extra::EventHandlerInts::set_val_tag(), and c4::yml::extra::EventHandlerInts::start_parse().

m_curr

state* c4::yml::EventHandlerStack< EventHandlerInts, EventHandlerIntsState >::m_curr

inherited

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

Definition at line 47 of file event_handler_stack.hpp.

Referenced by c4::yml::extra::EventHandlerInts::_push(), c4::yml::extra::EventHandlerInts::_send_flag_only_(), c4::yml::extra::EventHandlerInts::_send_str_(), c4::yml::extra::EventHandlerInts::actually_val_is_first_key_of_new_map_block(), c4::yml::extra::EventHandlerInts::actually_val_is_first_key_of_new_map_flow(), c4::yml::extra::EventHandlerInts::add_directive_tag(), c4::yml::extra::EventHandlerInts::add_sibling(), c4::yml::extra::EventHandlerInts::disable_(), c4::yml::extra::EventHandlerInts::enable_(), c4::yml::extra::EventHandlerInts::has_any_(), c4::yml::extra::EventHandlerInts::reset(), c4::yml::extra::EventHandlerInts::set_key_ref(), and c4::yml::extra::EventHandlerInts::set_val_ref().

m_parent

state* c4::yml::EventHandlerStack< EventHandlerInts, EventHandlerIntsState >::m_parent

inherited

parent of the current stack level.

Definition at line 48 of file event_handler_stack.hpp.

Referenced by c4::yml::extra::EventHandlerInts::_mark_parent_with_children_(), and c4::yml::extra::EventHandlerInts::add_sibling().

m_src

substr c4::yml::EventHandlerStack< EventHandlerInts, EventHandlerIntsState >::m_src

inherited

Definition at line 49 of file event_handler_stack.hpp.

Referenced by c4::yml::extra::EventHandlerInts::_get_latest_empty_scalar(), c4::yml::extra::EventHandlerInts::_is_sub_(), c4::yml::extra::EventHandlerInts::reset(), c4::yml::extra::EventHandlerInts::set_key_scalar_dquoted(), c4::yml::extra::EventHandlerInts::set_key_scalar_folded(), c4::yml::extra::EventHandlerInts::set_key_scalar_literal(), c4::yml::extra::EventHandlerInts::set_key_scalar_plain(), c4::yml::extra::EventHandlerInts::set_key_scalar_squoted(), c4::yml::extra::EventHandlerInts::set_val_scalar_dquoted(), c4::yml::extra::EventHandlerInts::set_val_scalar_folded(), c4::yml::extra::EventHandlerInts::set_val_scalar_literal(), c4::yml::extra::EventHandlerInts::set_val_scalar_plain(), c4::yml::extra::EventHandlerInts::set_val_scalar_squoted(), and c4::yml::extra::EventHandlerInts::start_parse().

---

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

• /home/docs/checkouts/readthedocs.org/user_builds/rapidyaml/checkouts/v0.16.0/src_extra/c4/yml/extra/event_handler_ints.hpp