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>

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

Public Types
types
enum	{ requires_strings_on_buffers = true }

using	value_type = ievt::DataType

using	state = EventHandlerIntsState

Public Member Functions
construction and resetting
	EventHandlerInts (c4::yml::Callbacks const &cb)

	EventHandlerInts ()

void	reset (substr 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 and arena buffers successfully accomodated all the parse events. More...

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 —) 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_block ()

void	end_map_flow (bool)

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)

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

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 More...

implementation helpers
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

int32_t	_next (int32_t pos) const noexcept

int32_t	_prev (int32_t pos) const noexcept

bool	_is_sub_ (csubstr str) const noexcept

void	_send_flag_only_ (ievt::DataType flags)

void	_send_str_ (csubstr scalar, ievt::DataType flags)

void	_mark_parent_with_children_ ()

csubstr	_get_latest_empty_scalar () const

int32_t	_find_last_bdoc (int32_t pos) const

int32_t	_find_matching_open (ievt::DataType open, ievt::DataType close, int32_t pos) const

int32_t	_extend_left_to_include_tag_and_or_anchor (int32_t pos) const

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...

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::EventFlags containing masks (to represent events), interleaved with 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 (grouped to highlight the event sequence structure):

{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; preceded by a string event (PSTR)
    VAL_|SCLR|PLAI|PSTR, 8, 3,   // val scalar, plain style: "ccc" starts at offset 8 and has length 3; preceded by a string event (PSTR)
    ESEQ|PSTR,                   // end seq; preceded by a string event (PSTR)
    EDOC,                        // end doc
    ESTR,                        // end stream
  };

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

source  : [a, bb, ccc]
                                               has a string........
                                               |               offset "a"
                                               |               |  length "a"
                                               |               |  |
           event0   event1  event2 [           event3 "a"......|..|
           |        |       |                  |               |  |
(start)    +--------+-------+------------------+---------------+--+-----> (continued)
arr[i] :   BSTR     BDOC    VAL_|BSEQ|FLOW     VAL_|SCLR|PLAI..1..1
i      :   0        1       2                  3               4  5
 
 
                has a string.............              has a string.............
                |                    offset "bb"       |                    offset "ccc"
                |                    |  length "bb"    |                    |  length "ccc"
                |                    |  |              |                    |  |
                event4 "bb"..........|..|              event5 "ccc".........|..|
                |                    |  |              |                    |  |
 (cont)--> -----+--------------------+--+--------------+--------------------+--+-----> (continued)
arr[i] :        VAL_|SCLR|PLAI|PSTR..4..2              VAL_|SCLR|PLAI|PSTR..8..3
i      :        6              |     7  8              9              |     10 11
                               |                                      |
                               prev event has string                  prev event has string
                               (to get to prev, jump                  (to get to prev, jump
                               back 3 slots: ie 6->3)                 back 3 slots: ie 9->6)
 
 
 
                event6 ]      event7   event8
                |             |        |
 (cont)--> -----+-------------+--------+-----|    (end)
arr[i] :        ESEQ|PSTR     EDOC     ESTR
i      :        12   |        13       14
                     |
                     prev event has string
                     (to get to it, jump
                     back 3 slots: ie 12->9)

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.

Here's another example with the result of parsing a: bb

{c++}
  const DataType arr[] = {       // result of parsing: `a: bb`
    BSTR,                        // begin stream
    BDOC,                        // begin doc
    VAL_|BMAP|BLCK,              // begin map as val, block
    KEY_|SCLR|PLAI,      0, 1,   // key scalar, plain style: "a"   starts at offset 0 and has length 1
    VAL_|SCLR|PLAI|PSTR, 3, 2,   // val scalar, plain style: "bb"  starts at offset 3 and has length 2
    EMAP|PSTR,                   // end map
    EDOC,                        // end doc
    ESTR,                        // end stream
  };

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

Member Typedef Documentation

◆ value_type

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

Definition at line 442 of file event_handler_ints.hpp.

◆ state

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

Definition at line 443 of file event_handler_ints.hpp.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
requires_strings_on_buffers

Definition at line 444 of file event_handler_ints.hpp.

444 { requires_strings_on_buffers = true };

c4::yml::extra::EventHandlerInts::requires_strings_on_buffers

@ requires_strings_on_buffers

Definition: event_handler_ints.hpp:444

Constructor & Destructor Documentation

◆ EventHandlerInts() [1/2]

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

inline

Definition at line 472 of file event_handler_ints.hpp.

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

◆ EventHandlerInts() [2/2]

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

inline

Definition at line 477 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::DataType *	dst,
		int32_t	dst_size
	)

inline

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

◆ 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 502 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 509 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 and arena buffers successfully accomodated all the parse events.

Warning: this is valid only until the next parse

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

     {
         // does not apply here
     }

◆ tag_directives()

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

inline

Definition at line 528 of file event_handler_ints.hpp.

528 { return m_tag_directives; }

◆ tag_cache()

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

inline

Definition at line 529 of file event_handler_ints.hpp.

529 { return m_tag_cache; }

◆ start_parse()

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

inline

Definition at line 538 of file event_handler_ints.hpp.

     {
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, src.str == m_src.str);
         _RYML_ASSERT_BASIC_(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 545 of file event_handler_ints.hpp.

     {
         this->_stack_finish_parse();
     }

◆ cancel_parse()

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

inline

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

     {
         _send_flag_only_(ievt::BSTR);
     }

◆ end_stream()

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

inline

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

◆ end_doc()

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

inline

implicit doc end (without ...)

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

◆ end_doc_expl()

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

inline

explicit doc end, with ...

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

◆ begin_map_key_block()

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

inline

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

◆ begin_map_val_flow()

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

inline

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

◆ begin_map_val_block()

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

inline

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

◆ end_map_block()

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

inline

Definition at line 668 of file event_handler_ints.hpp.

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

◆ end_map_flow()

void c4::yml::extra::EventHandlerInts::end_map_flow ( bool )

inline

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

◆ begin_seq_key_block()

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

inline

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

◆ begin_seq_val_flow()

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

inline

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

◆ begin_seq_val_block()

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

inline

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

◆ end_seq_block()

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

inline

Definition at line 721 of file event_handler_ints.hpp.

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

◆ end_seq_flow()

void c4::yml::extra::EventHandlerInts::end_seq_flow ( bool )

inline

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

     {
         _RYML_ASSERT_BASIC_(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 754 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);
         _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 760 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);
         _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 768 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);
         _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 774 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);
         _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 782 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);
         _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 788 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);
         _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 796 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);
         _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 802 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);
         _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 810 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);
         _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 816 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);
         _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 824 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);
         _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 830 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);
         _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 838 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 844 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 880 of file event_handler_ints.hpp.

     {
         _c4dbgpf("{}/{}: set_key_anchor: {}", m_evt_pos, m_evt_size, anchor);
         _RYML_ASSERT_BASIC_(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;
     }

◆ set_val_anchor()

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

inline

Definition at line 893 of file event_handler_ints.hpp.

     {
         _c4dbgpf("{}/{}: set_val_anchor: {}", m_evt_pos, m_evt_size, anchor);
         _RYML_ASSERT_BASIC_(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;
     }

◆ set_key_ref()

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

inline

Definition at line 907 of file event_handler_ints.hpp.

     {
         _c4dbgpf("{}/{}: set_key_ref: {}", m_evt_pos, m_evt_size, ref);
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, ref.begins_with('*'));
         if(C4_UNLIKELY(_has_any_(KEYANCH)))
             _RYML_ERR_PARSE_(m_stack.m_callbacks, m_curr->pos, "key cannot have both anchor and ref");
         _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 916 of file event_handler_ints.hpp.

     {
         _c4dbgpf("{}/{}: set_val_ref: {}", m_evt_pos, m_evt_size, ref);
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, ref.begins_with('*'));
         if(C4_UNLIKELY(_has_any_(VALANCH)))
             _RYML_ERR_PARSE_(m_stack.m_callbacks, m_curr->pos, "val cannot have both anchor and ref");
         _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 933 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_(m_stack.m_callbacks, _is_sub_(tag));
         _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 940 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_(m_stack.m_callbacks, _is_sub_(tag));
         _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 955 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 961 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_(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 982 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_(m_stack.m_callbacks, m_evt_pos > 2);
         _RYML_ASSERT_BASIC_(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_(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_ASSERT_BASIC_(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_ASSERT_BASIC_(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) == ievt::EMAP)
                 {
                     pos = _find_matching_open(ievt::BMAP, ievt::EMAP, m_evt_prev);
                 }
                 else
                 {
                     _RYML_ASSERT_BASIC_(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_(m_stack.m_callbacks, pos >= 0); // internal error
                 _RYML_CHECK_BASIC_(m_stack.m_callbacks, pos < m_evt_prev); // internal error
                 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, (m_evt[pos] & ievt::ESEQ) == (m_evt[m_evt_prev] & ievt::BSEQ));
                 _RYML_ASSERT_BASIC_(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_ASSERT_BASIC_(m_stack.m_callbacks, num_move > 0);
                     memmove(m_evt + posp1, m_evt + pos, (size_t)num_move * sizeof(ievt::DataType));
                 }
                 _RYML_ASSERT_BASIC_(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();
     }

◆ 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 1076 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
             int32_t pos = _find_last_bdoc(m_evt_pos);
             if(pos >= 0)
             {
                 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, pos < m_evt_size);
                 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, pos < m_evt_pos);
                 _RYML_ASSERT_BASIC_(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
                     int32_t num_move = m_evt_pos - pos;
                     int32_t posp1 = pos + 1;
                     _RYML_ASSERT_BASIC_(m_stack.m_callbacks, ((m_evt[pos] & ievt::BSEQ) == ievt::BSEQ) || ((m_evt[pos] & ievt::BMAP) == ievt::BMAP));
                     _RYML_ASSERT_BASIC_(m_stack.m_callbacks, num_move > 0);
                     _RYML_ASSERT_BASIC_(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();
     }

◆ arena()

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

inline

Definition at line 1116 of file event_handler_ints.hpp.

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

◆ arena_rem()

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

inline

Definition at line 1120 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()

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 1125 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 1145 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 1152 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 1157 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 1161 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 1165 of file event_handler_ints.hpp.

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

◆ _next()

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

inlinenoexcept

Definition at line 1170 of file event_handler_ints.hpp.

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

◆ _prev()

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

inlinenoexcept

Definition at line 1176 of file event_handler_ints.hpp.

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

◆ _is_sub_()

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

inlinenoexcept

Definition at line 1182 of file event_handler_ints.hpp.

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

◆ _send_flag_only_()

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

inline

Definition at line 1187 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_str_()

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

inline

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

◆ _mark_parent_with_children_()

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

inline

Definition at line 1212 of file event_handler_ints.hpp.

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

◆ _get_latest_empty_scalar()

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

inline

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

◆ _find_last_bdoc()

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

inline

Definition at line 1226 of file event_handler_ints.hpp.

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

◆ _find_matching_open()

int32_t c4::yml::extra::EventHandlerInts::_find_matching_open	(	ievt::DataType	open,
		ievt::DataType	close,
		int32_t	pos
	)		const

inline

Definition at line 1239 of file event_handler_ints.hpp.

     {
         _c4dbgpf("find_matching: start at {}", pos);
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, pos < m_evt_size);
         _RYML_ASSERT_BASIC_(m_stack.m_callbacks, (m_evt[pos] & close) == close);
         _RYML_ASSERT_BASIC_(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::DataType 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
     }

◆ _extend_left_to_include_tag_and_or_anchor()

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

inline

Definition at line 1270 of file event_handler_ints.hpp.

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

◆ _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_(m_stack.m_callbacks, m_curr != nullptr);
         m_curr->start_parse(filename, m_curr->node_id);
         m_src = ymlsrc;
     }

◆ _stack_finish_parse()

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

inlineprotectedinherited

Definition at line 65 of file event_handler_stack.hpp.

66 {

67 }

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

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

◆ _stack_pop()

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

inlineprotectedinherited

Definition at line 96 of file event_handler_stack.hpp.

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

◆ _stack_should_push_on_begin_doc()

bool c4::yml::EventHandlerStack< 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 || _has_any_(DOC|VAL|MAP|SEQ));
     }

◆ _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 && _has_any_(DOC);
     }

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.

◆ 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.

◆ 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.

◆ m_src

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

inherited

Definition at line 49 of file event_handler_stack.hpp.

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

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

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Detailed Description

Member Typedef Documentation

◆ value_type

◆ state

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ EventHandlerInts() [1/2]

◆ EventHandlerInts() [2/2]

Member Function Documentation

◆ reset()

◆ required_size_events()

◆ required_size_arena()

◆ fits_buffers()

◆ reserve_arena()

◆ tag_directives()

◆ tag_cache()

◆ start_parse()

◆ finish_parse()

◆ cancel_parse()

◆ begin_stream()

◆ end_stream()

◆ begin_doc()

◆ end_doc()

◆ begin_doc_expl()

◆ end_doc_expl()

◆ begin_map_key_flow()

◆ begin_map_key_block()

◆ begin_map_val_flow()

◆ begin_map_val_block()

◆ end_map_block()

◆ end_map_flow()

◆ begin_seq_key_flow()

◆ begin_seq_key_block()

◆ begin_seq_val_flow()

◆ begin_seq_val_block()

◆ end_seq_block()

◆ end_seq_flow()

◆ add_sibling()

◆ set_key_scalar_plain_empty()

◆ set_val_scalar_plain_empty()

◆ set_key_scalar_plain()

◆ set_val_scalar_plain()

◆ set_key_scalar_dquoted()

◆ set_val_scalar_dquoted()

◆ set_key_scalar_squoted()

◆ set_val_scalar_squoted()

◆ set_key_scalar_literal()

◆ set_val_scalar_literal()

◆ set_key_scalar_folded()

◆ set_val_scalar_folded()

◆ mark_key_scalar_unfiltered()

◆ mark_val_scalar_unfiltered()

◆ set_key_anchor()

◆ set_val_anchor()

◆ set_key_ref()

◆ set_val_ref()

◆ set_key_tag()

◆ set_val_tag()

◆ add_directive_yaml()

◆ add_directive_tag()

◆ actually_val_is_first_key_of_new_map_flow()

◆ actually_val_is_first_key_of_new_map_block()

◆ arena()

◆ arena_rem()

◆ alloc_arena()

◆ _push()

◆ _pop()

◆ _enable__()

◆ _disable__()

◆ _has_any__()

◆ _next()

◆ _prev()

◆ _is_sub_()

◆ _send_flag_only_()

◆ _send_str_()