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

A parser event handler that creates a compact representation of the YAML tree in a buffer of integers (see ievt::EventFlags) containing masks (to represent events) and offset+length (to represent strings in the source buffer). More...

#include <event_handler_ints.hpp>

Inheritance diagram for c4::yml::extra::EventHandlerInts:

Public Types
using	pfn_relocate_arena = detail::pfn_relocate_arena
types
using	value_type = ievt::DataType
using	state = EventHandlerIntsState

Public Member Functions
void	_push ()
	push a new parent, add a child to the new parent, and set the child as the current node More...
void	_pop ()
	end the current scope More...
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
void	_mark_parent_with_children_ ()
void	_send_flag_only_ (ievt::DataType flags)
void	_send_key_scalar_ (csubstr scalar, ievt::DataType flags)
void	_send_val_scalar_ (csubstr scalar, ievt::DataType flags)
void	_send_str_ (csubstr scalar, ievt::DataType flags)
void	_clear_tag_directives_ ()
id_type	_num_tag_directives () const
csubstr	_transform_directive (csubstr tag)
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
	EventHandlerInts (c4::yml::Callbacks const &cb)
	EventHandlerInts ()
void	reset (csubstr str, substr arena, ievt::DataType *dst, int32_t dst_size)
int	required_size_events () const
	get the size needed for the event buffer from the previous parse More...
size_t	required_size_arena () const
	get the size needed for the arena from the previous parse More...
bool	fits_buffers () const
	Predicate to test if the event buffer successfully accomodated all the parse events. More...
void	reserve_arena (int)
parse events
void	start_parse (const char *filename, c4::yml::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_empty ()
void	set_val_scalar_plain_empty ()
csubstr	_get_latest_empty_scalar () const
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)
void	_set_tag (csubstr tag, ievt::DataType which)
YAML directive events
void	add_directive (csubstr directive)
YAML arena events
substr	arena_rem ()
substr	alloc_arena (size_t len)
	this may fail, in which case a an empty string is returned More...
substr	alloc_arena (size_t len, substr *relocated)
	this may fail, in which case an empty string is returned More...

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

A parser event handler that creates a compact representation of the YAML tree in a buffer of integers (see ievt::EventFlags) containing masks (to represent events) and offset+length (to represent strings in the source buffer).

This is meant for use by other programming languages, and supports container keys (unlike the ryml tree). It parses faster than the ryml tree parser, because the resulting data structure is much simpler.

The resulting integer buffer is a linear array of integers containing events (as a mask of ievt::EventFlags), which in some cases (see ievt::WSTR) are followed by an encoded string (encoded as an offset and length to the parsed source buffer).

For example, parsing [a, bb, ccc] results in the following event buffer:

{c++}
  using namespace c4::yml::extra::ievt;
  const DataType arr[] = {       // result of parsing: [a, bb, ccc]
    BSTR,                        // begin stream
    BDOC,                        // begin doc
    VAL_|BSEQ|FLOW,              // begin seq as val, flow
    VAL_|SCLR|PLAI,      1, 1,   // val scalar, plain style: "a"   starts at offset 1 and has length 1
    VAL_|SCLR|PLAI|PSTR, 4, 2,   // val scalar, plain style: "bb"  starts at offset 4 and has length 2
    VAL_|SCLR|PLAI|PSTR, 8, 3,   // val scalar, plain style: "ccc" starts at offset 8 and has length 3
    ESEQ|PSTR,                   // end seq
    EDOC,                        // end doc
    ESTR,                        // end stream
  };

Here is a sketch clarifying the meaning of this event sequence:

source  : [a, bb, ccc]
                                                               string offset "a"              string offset "bb"             string offset "ccc"
                                                               |  string length "a"           |  string length "bb"          |  string length "ccc"
                                                               |  |                           |  |                           |  |
           event    event   event [            event "a".......|..|      event "bb"...........|..|      event "ccc"..........|..|      event ]       event    event
           |        |       |                  |               |  |      |                    |  |      |                    |  |      |             |        |
           +--------+-------+------------------+---------------+--+------+--------------------+--+------+--------------------+--+------+-------------+--------+-----|
value    : BSTR     BDOC    VAL_|BSEQ|FLOW     VAL_|SCLR|PLAI..1..1      VAL_|SCLR|PLAI|PSTR..4..2      VAL_|SCLR|PLAI|PSTR..8..3      ESEQ|PSTR     EDOC     ESTR  (array)
event #  : 0        1       2                  3               .  .      4              |     .  .      5              |     .  .      6             7        8     (event #)
index/pos: 0        1       2                  3               4  5      6              |     7  8      9              |     10 11     12            13       14    (index/pos)
                                                \              |  |       \             |     |  |       \             |     |  |
                                                 has a string--+--+        has a string-+-----+--+        has a string-+-----+--+
                                                                                        |                              |
                                                                                        prev event has string          prev event has string
                                                                                        (jump back 3 to get to it)     (jump back 3 to get to it)

Note that the buffer contains both events and strings encoded as integer pairs. That is, events that have an associated string are immediately followed by two integers providing the offset and length of that string in the source buffer. (In the example above, this happens in the events for the strings a, bb, and ccc at positions 3, 6 and 9, respectively).

The flag ievt::PSTR and the mask ievt::WSTR are provided to enable easier iteration over the array: you can use them to test for presence of a string when iterating over the array.

The flag ievt::PSTR announces that an event is preceded by a string. That is, the previous event has a string, so that when this flag is found while iterating right-to-left, a jump of -3 should be used to get at the bitmask of the previous event. (In the example above, this flag is present for the events for bb and ccc, but not a because it is not preceded by a string).

Likewise, to signify that the current event is followed by a string, there is the mask ievt::WSTR, which is a mask of all the flags of events that have a string: ievt::SCLR, ievt::ALIA, ievt::ANCH and ievt::TAG_. While iterating left-to-right in the array, presence of any of the bits in the mask ievt::WSTR means that a jump of +3 should be employed to get at the bitmask of the next event.

Typical code to iterate left-to-right over the array will look like this:

{c++}
  // source buffer, modified in place during parsing (IMPORTANT!)
  substr src = ...;
  substr arena = ...; // arena used for scalars/tags that are extended during filtering
  // events resulting from parsing
  const int events[] = {...};
  int events_size = ...;
  for(int i = 0; i < events_size; ++i)
  {
      if(events[i] & ievt::WSTR) // this event has a string following it
      {
          size_t offset = (size_t)events[i+1];
          size_t length = (size_t)events[i+2];
          csubstr region = (events[i] & ievt::AREN) ? arena : src; // is the string in the arena?
          csubstr str = region.sub(offset, length); // get the string
          ...
          i += 2; // skip the two ints of the string
                  // (the jump is three places; the loop adds the other place)
      }
      else  // this is a single-int event
      {
          ...
      }
  }

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:

{c++}
  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 of cases 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:

{c++}
  const std::string src = ...;  // the YAML code to be parsed
  std::string parsed_src = src; // this is where we will parse (filter during parsring)
  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 389 of file event_handler_ints.hpp.

Member Typedef Documentation

value_type

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

Definition at line 395 of file event_handler_ints.hpp.

state

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

Definition at line 396 of file event_handler_ints.hpp.

pfn_relocate_arena

using c4::yml::EventHandlerStack< EventHandlerInts , EventHandlerIntsState >::pfn_relocate_arena = detail::pfn_relocate_arena

inherited

Definition at line 47 of file event_handler_stack.hpp.

Constructor & Destructor Documentation

EventHandlerInts() [1/2]

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

inline

Definition at line 425 of file event_handler_ints.hpp.

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

EventHandlerInts() [2/2]

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

inline

Definition at line 430 of file event_handler_ints.hpp.

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

Member Function Documentation

reset()

void c4::yml::extra::EventHandlerInts::reset ( csubstr  str, substr  arena, ievt::DataType *  dst, int32_t  dst_size  )

inline

Definition at line 435 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_str = str;
        m_evt = dst;
        m_evt_size = dst_size;
        m_evt_pos = 0;
        m_evt_prev = 0;
        m_has_docs = false;
        m_has_yaml_directive = false;
        for(TagDirective &td : m_tag_directives)
            td = {};
    }

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

required_size_events()

int 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 456 of file event_handler_ints.hpp.

    {
        return m_evt_pos;
    }

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 463 of file event_handler_ints.hpp.

    {
        return m_arena_pos;
    }

fits_buffers()

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

inline

Predicate to test if the event buffer successfully accomodated all the parse events.

Warning

this is valid only until the next parse

Definition at line 471 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 476 of file event_handler_ints.hpp.

    {
        // does not apply here
    }

start_parse()

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

inline

Definition at line 488 of file event_handler_ints.hpp.

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

finish_parse()

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

inline

Definition at line 493 of file event_handler_ints.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::extra::EventHandlerInts::cancel_parse ( )

inline

Definition at line 500 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 513 of file event_handler_ints.hpp.

    {
        _send_flag_only_(ievt::BSTR);
    }

References c4::yml::extra::ievt::BSTR.

end_stream()

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

inline

Definition at line 518 of file event_handler_ints.hpp.

    {
        _send_flag_only_(ievt::ESTR);
    }

References c4::yml::extra::ievt::ESTR.

begin_doc()

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

inline

implicit doc start (without —)

Definition at line 531 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();
            _enable_(DOC);
        }
        m_has_docs = true;
    }

References c4::yml::extra::ievt::BDOC, and c4::yml::DOC.

end_doc()

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

inline

implicit doc end (without ...)

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

References c4::yml::extra::ievt::EDOC.

begin_doc_expl()

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

inline

explicit doc start, with —

Definition at line 556 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();
        _enable_(DOC);
        m_has_docs = true;
    }

References c4::yml::extra::ievt::BDOC, c4::yml::DOC, and c4::yml::extra::ievt::EXPL.

end_doc_expl()

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

inline

explicit doc end, with ...

Definition at line 566 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_has_yaml_directive = false;
    }

References c4::yml::extra::ievt::EDOC, and c4::yml::extra::ievt::EXPL.

begin_map_key_flow()

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

inline

Definition at line 585 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_();
        _enable_(c4::yml::KEY|c4::yml::MAP|c4::yml::FLOW_SL);
        _push();
    }

References c4::yml::extra::ievt::BMAP, c4::yml::extra::ievt::FLOW, c4::yml::FLOW_SL, c4::yml::KEY, c4::yml::extra::ievt::KEY_, and c4::yml::MAP.

begin_map_key_block()

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

inline

Definition at line 593 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_();
        _enable_(c4::yml::KEY|c4::yml::MAP|c4::yml::BLOCK);
        _push();
    }

References c4::yml::extra::ievt::BLCK, c4::yml::BLOCK, c4::yml::extra::ievt::BMAP, c4::yml::KEY, c4::yml::extra::ievt::KEY_, and c4::yml::MAP.

begin_map_val_flow()

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

inline

Definition at line 602 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_();
        _enable_(c4::yml::MAP|c4::yml::FLOW_SL);
        _push();
    }

References c4::yml::extra::ievt::BMAP, c4::yml::extra::ievt::FLOW, c4::yml::FLOW_SL, c4::yml::MAP, and c4::yml::extra::ievt::VAL_.

begin_map_val_block()

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

inline

Definition at line 610 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_();
        _enable_(c4::yml::MAP|c4::yml::BLOCK);
        _push();
    }

References c4::yml::extra::ievt::BLCK, c4::yml::BLOCK, c4::yml::extra::ievt::BMAP, c4::yml::MAP, and c4::yml::extra::ievt::VAL_.

end_map()

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

inline

Definition at line 619 of file event_handler_ints.hpp.

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

References c4::yml::extra::ievt::EMAP.

begin_seq_key_flow()

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

inline

Definition at line 632 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_();
        _enable_(c4::yml::KEY|c4::yml::SEQ|c4::yml::FLOW_SL);
        _push();
    }

References c4::yml::extra::ievt::BSEQ, c4::yml::extra::ievt::FLOW, c4::yml::FLOW_SL, c4::yml::KEY, c4::yml::extra::ievt::KEY_, and c4::yml::SEQ.

begin_seq_key_block()

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

inline

Definition at line 640 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_();
        _enable_(c4::yml::KEY|c4::yml::SEQ|c4::yml::BLOCK);
        _push();
    }

References c4::yml::extra::ievt::BLCK, c4::yml::BLOCK, c4::yml::extra::ievt::BSEQ, c4::yml::KEY, c4::yml::extra::ievt::KEY_, and c4::yml::SEQ.

begin_seq_val_flow()

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

inline

Definition at line 649 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_();
        _enable_(c4::yml::SEQ|c4::yml::FLOW_SL);
        _push();
    }

References c4::yml::extra::ievt::BSEQ, c4::yml::extra::ievt::FLOW, c4::yml::FLOW_SL, c4::yml::SEQ, and c4::yml::extra::ievt::VAL_.

begin_seq_val_block()

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

inline

Definition at line 657 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_();
        _enable_(c4::yml::SEQ|c4::yml::BLOCK);
        _push();
    }

References c4::yml::extra::ievt::BLCK, c4::yml::BLOCK, c4::yml::extra::ievt::BSEQ, c4::yml::SEQ, and c4::yml::extra::ievt::VAL_.

end_seq()

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

inline

Definition at line 666 of file event_handler_ints.hpp.

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

References c4::yml::extra::ievt::ESEQ.

add_sibling()

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

inline

Definition at line 679 of file event_handler_ints.hpp.

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

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 690 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_CB_ASSERT(m_stack.m_callbacks, m_evt_pos > 2);
        _RYML_CB_ASSERT(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_prev + 1 < m_evt_size)
        {
            if(m_evt[m_evt_prev] & ievt::WSTR)
            {
                _c4dbgpf("{}/{}: WSTR", m_evt_pos, m_evt_size);
                _RYML_CB_ASSERT(m_stack.m_callbacks, m_evt_prev > 0);
                int32_t pos = _extend_left_to_include_tag_and_or_anchor(m_evt_prev);
                if(m_evt_pos + 1 < m_evt_size)
                {
                    for(int32_t i = pos; i <= m_evt_prev; i = _next(i))
                    {
                        m_evt[i] |= ievt::KEY_;
                        m_evt[i] &= ~ievt::VAL_;
                    }
                    int32_t num_move = m_evt_pos + 1 - pos;
                    _RYML_CB_ASSERT(m_stack.m_callbacks, num_move > 0);
                    memmove(m_evt + pos + 1, m_evt + pos, (size_t)num_move * sizeof(ievt::DataType));
                }
                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_CB_ASSERT(m_stack.m_callbacks, (m_evt[m_evt_prev] & (ievt::EMAP|ievt::ESEQ)));
                int32_t pos;
                _c4dbgpf("{}/{}: find matching open for {}", m_evt_pos, m_evt_size, m_evt_prev);
                if(m_evt[m_evt_prev] & ievt::EMAP)
                {
                    pos = _find_matching_open(ievt::BMAP, ievt::EMAP, m_evt_prev);
                }
                else
                {
                    _RYML_CB_ASSERT(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_CB_CHECK(m_stack.m_callbacks, pos >= 0); // internal error
                _RYML_CB_CHECK(m_stack.m_callbacks, pos < m_evt_prev); // internal error
                _RYML_CB_ASSERT(m_stack.m_callbacks, (m_evt[pos] & ievt::ESEQ) == (m_evt[m_evt_prev] & ievt::BSEQ));
                _RYML_CB_ASSERT(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
                int32_t posp1 = pos + 1;
                if(m_evt_pos + 1 < m_evt_size)
                {
                    int32_t num_move = m_evt_pos + 1 - pos;
                    _RYML_CB_ASSERT(m_stack.m_callbacks, num_move > 0);
                    memmove(m_evt + posp1, m_evt + pos, (size_t)num_move * sizeof(ievt::DataType));
                }
                _RYML_CB_ASSERT(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;
        _enable_(c4::yml::MAP|c4::yml::FLOW_SL);
        _push();
    }

References c4::yml::extra::ievt::BMAP, c4::yml::extra::ievt::BSEQ, c4::yml::extra::ievt::EMAP, c4::yml::extra::ievt::ESEQ, c4::yml::extra::ievt::FLOW, c4::yml::FLOW_SL, c4::yml::extra::ievt::KEY_, c4::yml::MAP, c4::yml::extra::ievt::PSTR, c4::yml::extra::ievt::VAL_, and c4::yml::extra::ievt::WSTR.

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 784 of file event_handler_ints.hpp.

    {
        if(m_evt_prev < m_evt_size)
        {
            // interpolate BMAP|VAL|BLCK after the last BDOC
            int32_t pos = _find_last_bdoc(m_evt_pos);
            if(pos >= 0)
            {
                _RYML_CB_ASSERT(m_stack.m_callbacks, pos < m_evt_size);
                _RYML_CB_ASSERT(m_stack.m_callbacks, pos < m_evt_pos);
                _RYML_CB_ASSERT(m_stack.m_callbacks, (m_evt[pos] & ievt::BDOC));
                if(m_evt_pos < m_evt_size)
                {
                    ++pos; // add 1 to write after BDOC
                    int32_t num_move = m_evt_pos - pos;
                    int32_t posp1 = pos + 1;
                    _RYML_CB_ASSERT(m_stack.m_callbacks, (m_evt[pos] & (ievt::BSEQ|ievt::BMAP)));
                    _RYML_CB_ASSERT(m_stack.m_callbacks, num_move > 0);
                    _RYML_CB_ASSERT(m_stack.m_callbacks, 0 == (m_evt[posp1] & ievt::PSTR));
                    memmove(m_evt + posp1, m_evt + pos, (size_t)num_move * sizeof(ievt::DataType));
                    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();
    }

References c4::yml::extra::ievt::BDOC, c4::yml::extra::ievt::BLCK, c4::yml::extra::ievt::BMAP, c4::yml::extra::ievt::BSEQ, c4::yml::extra::ievt::KEY_, c4::yml::extra::ievt::PSTR, and c4::yml::extra::ievt::VAL_.

set_key_scalar_plain_empty()

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

inline

Definition at line 891 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_scalar_plain_empty", m_evt_pos, m_evt_size);
        _send_key_scalar_(_get_latest_empty_scalar(), ievt::PLAI);
        _enable_(c4::yml::KEY|c4::yml::KEY_PLAIN|c4::yml::KEYNIL);
    }

References c4::yml::KEY, c4::yml::KEY_PLAIN, c4::yml::KEYNIL, and c4::yml::extra::ievt::PLAI.

set_val_scalar_plain_empty()

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

inline

Definition at line 897 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_scalar_plain_empty", m_evt_pos, m_evt_size);
        _send_val_scalar_(_get_latest_empty_scalar(), ievt::PLAI);
        _enable_(c4::yml::VAL|c4::yml::VAL_PLAIN|c4::yml::VALNIL);
    }

References c4::yml::extra::ievt::PLAI, c4::yml::VAL, c4::yml::VAL_PLAIN, and c4::yml::VALNIL.

_get_latest_empty_scalar()

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

inline

Definition at line 903 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_str.first(0);
    }

set_key_scalar_plain()

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

inline

Definition at line 912 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_scalar_plain: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_str.str, scalar.len, scalar);
        _send_key_scalar_(scalar, ievt::PLAI);
        _enable_(c4::yml::KEY|c4::yml::KEY_PLAIN);
    }

References c4::yml::KEY, c4::yml::KEY_PLAIN, and c4::yml::extra::ievt::PLAI.

set_val_scalar_plain()

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

inline

Definition at line 918 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_scalar_plain: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_str.str, scalar.len, scalar);
        _send_val_scalar_(scalar, ievt::PLAI);
        _enable_(c4::yml::VAL|c4::yml::VAL_PLAIN);
    }

References c4::yml::extra::ievt::PLAI, c4::yml::VAL, and c4::yml::VAL_PLAIN.

set_key_scalar_dquoted()

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

inline

Definition at line 926 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_scalar_dquo: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_str.str, scalar.len, scalar);
        _send_key_scalar_(scalar, ievt::DQUO);
        _enable_(c4::yml::KEY|c4::yml::KEY_DQUO);
    }

References c4::yml::extra::ievt::DQUO, c4::yml::KEY, and c4::yml::KEY_DQUO.

set_val_scalar_dquoted()

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

inline

Definition at line 932 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_scalar_dquo: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_str.str, scalar.len, scalar);
        _send_val_scalar_(scalar, ievt::DQUO);
        _enable_(c4::yml::VAL|c4::yml::VAL_DQUO);
    }

References c4::yml::extra::ievt::DQUO, c4::yml::VAL, and c4::yml::VAL_DQUO.

set_key_scalar_squoted()

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

inline

Definition at line 940 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_scalar_squo: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_str.str, scalar.len, scalar);
        _send_key_scalar_(scalar, ievt::SQUO);
        _enable_(c4::yml::KEY|c4::yml::KEY_SQUO);
    }

References c4::yml::KEY, c4::yml::KEY_SQUO, and c4::yml::extra::ievt::SQUO.

set_val_scalar_squoted()

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

inline

Definition at line 946 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_scalar_squo: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_str.str, scalar.len, scalar);
        _send_val_scalar_(scalar, ievt::SQUO);
        _enable_(c4::yml::VAL|c4::yml::VAL_SQUO);
    }

References c4::yml::extra::ievt::SQUO, c4::yml::VAL, and c4::yml::VAL_SQUO.

set_key_scalar_literal()

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

inline

Definition at line 954 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_scalar_literal: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_str.str, scalar.len, scalar);
        _send_key_scalar_(scalar, ievt::LITL);
        _enable_(c4::yml::KEY|c4::yml::KEY_LITERAL);
    }

References c4::yml::KEY, c4::yml::KEY_LITERAL, and c4::yml::extra::ievt::LITL.

set_val_scalar_literal()

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

inline

Definition at line 960 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_scalar_literal: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_str.str, scalar.len, scalar);
        _send_val_scalar_(scalar, ievt::LITL);
        _enable_(c4::yml::VAL|c4::yml::VAL_LITERAL);
    }

References c4::yml::extra::ievt::LITL, c4::yml::VAL, and c4::yml::VAL_LITERAL.

set_key_scalar_folded()

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

inline

Definition at line 968 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_scalar_folded: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_str.str, scalar.len, scalar);
        _send_key_scalar_(scalar, ievt::FOLD);
        _enable_(c4::yml::KEY|c4::yml::KEY_FOLDED);
    }

References c4::yml::extra::ievt::FOLD, c4::yml::KEY, and c4::yml::KEY_FOLDED.

set_val_scalar_folded()

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

inline

Definition at line 974 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_scalar_folded: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_str.str, scalar.len, scalar);
        _send_val_scalar_(scalar, ievt::FOLD);
        _enable_(c4::yml::VAL|c4::yml::VAL_FOLDED);
    }

References c4::yml::extra::ievt::FOLD, c4::yml::VAL, and c4::yml::VAL_FOLDED.

mark_key_scalar_unfiltered()

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

inline

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

References c4::yml::extra::ievt::UNFILT.

mark_val_scalar_unfiltered()

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

inline

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

References c4::yml::extra::ievt::UNFILT.

set_key_anchor()

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

inline

Definition at line 1022 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_key_anchor", m_evt_pos, m_evt_size);
        _RYML_CB_ASSERT(m_stack.m_callbacks, !_has_any_(KEYREF));
        _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;
    }

References _has_any_, c4::yml::extra::ievt::ANCH, c4::yml::extra::ievt::KEY_, c4::yml::KEYANCH, and c4::yml::KEYREF.

set_val_anchor()

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

inline

Definition at line 1035 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set_val_anchor", m_evt_pos, m_evt_size);
        _RYML_CB_ASSERT(m_stack.m_callbacks, !_has_any_(VALREF));
        _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;
    }

References _has_any_, c4::yml::extra::ievt::ANCH, c4::yml::extra::ievt::VAL_, c4::yml::VALANCH, and c4::yml::VALREF.

set_key_ref()

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

inline

Definition at line 1049 of file event_handler_ints.hpp.

    {
        _RYML_CB_ASSERT(m_stack.m_callbacks, ref.begins_with('*'));
        if(C4_UNLIKELY(_has_any_(KEYANCH)))
            _RYML_CB_ERR_(m_stack.m_callbacks, "key cannot have both anchor and ref", m_curr->pos);
        _enable_(c4::yml::KEY|c4::yml::KEYREF);
        _send_str_(ref.sub(1), ievt::KEY_|ievt::ALIA); // skip the leading *
    }

References _has_any_, c4::yml::extra::ievt::ALIA, c4::yml::KEY, c4::yml::extra::ievt::KEY_, c4::yml::KEYANCH, and c4::yml::KEYREF.

set_val_ref()

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

inline

Definition at line 1057 of file event_handler_ints.hpp.

    {
        _RYML_CB_ASSERT(m_stack.m_callbacks, ref.begins_with('*'));
        if(C4_UNLIKELY(_has_any_(VALANCH)))
            _RYML_CB_ERR_(m_stack.m_callbacks, "val cannot have both anchor and ref", m_curr->pos);
        _enable_(c4::yml::VAL|c4::yml::VALREF);
        _send_str_(ref.sub(1), ievt::VAL_|ievt::ALIA); // skip the leading *
    }

References _has_any_, c4::yml::extra::ievt::ALIA, c4::yml::VAL, c4::yml::extra::ievt::VAL_, c4::yml::VALANCH, and c4::yml::VALREF.

set_key_tag()

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

inline

Definition at line 1073 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set key tag ~~~{}~~~", m_evt_pos, m_evt_size, tag);
        _enable_(c4::yml::KEYTAG);
        _set_tag(tag, ievt::KEY_);
    }

References c4::yml::extra::ievt::KEY_, and c4::yml::KEYTAG.

set_val_tag()

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

inline

Definition at line 1079 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: set val tag [{}]~~~{}~~~", m_evt_pos, m_evt_size, tag.len, tag);
        _enable_(c4::yml::VALTAG);
        _set_tag(tag, ievt::VAL_);
    }

References c4::yml::extra::ievt::VAL_, and c4::yml::VALTAG.

_set_tag()

void c4::yml::extra::EventHandlerInts::_set_tag ( csubstr  tag, ievt::DataType  which  )

inline

Definition at line 1085 of file event_handler_ints.hpp.

    {
        csubstr ttag = _transform_directive(tag);
        _c4dbgpf("{}/{}: transformed_tag [{}]~~~{}~~~", m_evt_pos, m_evt_size, ttag.len, ttag);
        if(m_evt_pos + 3 < m_evt_size)
        {
            m_evt[m_evt_pos] |= which|ievt::TAG_;
            _add_scalar_(m_evt_pos, ttag);
        }
        m_evt_prev = m_evt_pos;
        m_evt_pos += 3;
    }

References c4::yml::extra::ievt::TAG_.

add_directive()

void c4::yml::extra::EventHandlerInts::add_directive ( csubstr  directive )

inline

Definition at line 1105 of file event_handler_ints.hpp.

    {
        _c4dbgpf("{}/{}: add directive ~~~{}~~~", m_evt_pos, m_evt_size, directive);
        _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);
            TagDirective &td = m_tag_directives[pos];
            if(C4_UNLIKELY(!td.create_from_str(directive)))
                _RYML_CB_ERR_(m_stack.m_callbacks, "failed to add directive", m_curr->pos);
            td.next_node_id = (id_type)m_evt_pos;
            _send_str_(td.handle, ievt::TAGD);
            _send_str_(td.prefix, ievt::TAGV);
        }
        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;
            csubstr rest = directive.sub(5).triml(' ');
            _send_str_(rest, ievt::YAML);
        }
        else
        {
            _c4dbgpf("unknown directive! ignoring... {}", directive);
        }
    }

References c4::yml::TagDirective::create_from_str(), c4::yml::TagDirective::handle, c4::yml::TagDirective::next_node_id, c4::yml::TagDirective::prefix, RYML_MAX_TAG_DIRECTIVES, c4::yml::extra::ievt::TAGD, c4::yml::extra::ievt::TAGV, and c4::yml::extra::ievt::YAML.

arena_rem()

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

inline

Definition at line 1143 of file event_handler_ints.hpp.

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

alloc_arena() [1/2]

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

inline

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

Definition at line 1149 of file event_handler_ints.hpp.

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

alloc_arena() [2/2]

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

inline

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

Definition at line 1161 of file event_handler_ints.hpp.

    {
        (void)relocated;
        return alloc_arena(len);
    }

_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 1173 of file event_handler_ints.hpp.

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

_pop()

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

inline

end the current scope

Definition at line 1180 of file event_handler_ints.hpp.

    {
        _stack_pop();
    }

_enable__()

template<c4::yml::type_bits bits>

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

inlinenoexcept

Definition at line 1185 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 1189 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 1193 of file event_handler_ints.hpp.

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

_mark_parent_with_children_()

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

inline

Definition at line 1198 of file event_handler_ints.hpp.

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

_send_flag_only_()

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

inline

Definition at line 1204 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] = {};
    }

_send_key_scalar_()

void c4::yml::extra::EventHandlerInts::_send_key_scalar_ ( csubstr  scalar, ievt::DataType  flags  )

inline

Definition at line 1216 of file event_handler_ints.hpp.

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

References c4::yml::extra::ievt::KEY_, and c4::yml::extra::ievt::SCLR.

_send_val_scalar_()

void c4::yml::extra::EventHandlerInts::_send_val_scalar_ ( csubstr  scalar, ievt::DataType  flags  )

inline

Definition at line 1229 of file event_handler_ints.hpp.

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

References c4::yml::extra::ievt::SCLR, and c4::yml::extra::ievt::VAL_.

_send_str_()

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

inline

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

_clear_tag_directives_()

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

inline

Definition at line 1255 of file event_handler_ints.hpp.

    {
        for(TagDirective &td : m_tag_directives)
            td = {};
    }

_num_tag_directives()

id_type c4::yml::extra::EventHandlerInts::_num_tag_directives ( ) const

inline

Definition at line 1260 of file event_handler_ints.hpp.

    {
        // this assumes we have a very small number of tag directives
        id_type i = 0;
        for(; i < RYML_MAX_TAG_DIRECTIVES; ++i)
            if(m_tag_directives[i].handle.empty())
                break;
        return i;
    }

References RYML_MAX_TAG_DIRECTIVES.

_transform_directive()

csubstr c4::yml::extra::EventHandlerInts::_transform_directive ( csubstr  tag )

inline

Definition at line 1269 of file event_handler_ints.hpp.

    {
        // lookup from the end. We want to find the first directive that
        // matches the tag and has a target node id leq than the given
        // node_id.
        for(id_type i = RYML_MAX_TAG_DIRECTIVES-1; i != NONE; --i)
        {
            TagDirective const& td = m_tag_directives[i];
            if(td.handle.empty())
                continue;
            if(tag.begins_with(td.handle) && (td.handle != td.prefix))
            {
                substr rem = arena_rem();
                size_t len = td.transform(tag, rem, m_stack.m_callbacks, /*with_brackets*/false);
                if(len == 0)
                    return tag;
                alloc_arena(len);
                return rem.first(len <= rem.len ? len : 0);
            }
        }
        if(tag.begins_with('!'))
        {
            if(is_custom_tag(tag))
            {
                _RYML_CB_ERR_(m_stack.m_callbacks, "tag not found", m_curr->pos);
            }
        }
        return tag;
    }

References c4::yml::TagDirective::handle, c4::yml::is_custom_tag(), c4::yml::NONE, c4::yml::TagDirective::prefix, RYML_MAX_TAG_DIRECTIVES, and c4::yml::TagDirective::transform().

_stack_start_parse()

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

inlineprotectedinherited

Definition at line 64 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< EventHandlerInts , EventHandlerIntsState >::_stack_finish_parse ( )

inlineprotectedinherited

Definition at line 74 of file event_handler_stack.hpp.

    {
    }

_stack_reset_root()

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

inlineprotectedinherited

Definition at line 80 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< EventHandlerInts , EventHandlerIntsState >::_stack_reset_non_root ( )

inlineprotectedinherited

Definition at line 88 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 97 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< EventHandlerInts , EventHandlerIntsState >::_stack_pop ( )

inlineprotectedinherited

Definition at line 105 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< EventHandlerInts , EventHandlerIntsState >::_stack_should_push_on_begin_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|VAL|MAP|SEQ) || m_curr->has_children);
    }

_stack_should_pop_on_end_doc()

bool c4::yml::EventHandlerStack< EventHandlerInts , EventHandlerIntsState >::_stack_should_pop_on_end_doc ( ) const

inlineprotectedinherited

Definition at line 132 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< EventHandlerInts , EventHandlerIntsState >::_stack_relocate_to_new_arena ( csubstr  prev, substr  curr  )

inlineprotectedinherited

Definition at line 140 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< EventHandlerInts , EventHandlerIntsState >::_stack_relocate_to_new_arena ( csubstr  s, csubstr  prev, substr  curr  )

inlineprotectedinherited

Definition at line 156 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< EventHandlerInts , EventHandlerIntsState >::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 171 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< EventHandlerInts , EventHandlerIntsState >::m_stack

inherited

Definition at line 51 of file event_handler_stack.hpp.

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 52 of file event_handler_stack.hpp.

m_parent

state* c4::yml::EventHandlerStack< EventHandlerInts , EventHandlerIntsState >::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< EventHandlerInts , EventHandlerIntsState >::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< EventHandlerInts , EventHandlerIntsState >::m_relocate_arena_data

inherited

Definition at line 55 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.10.0/src_extra/c4/yml/extra/event_handler_ints.hpp