rapidyaml 0.14.0
parse and emit YAML, and do it fast
Loading...
Searching...
No Matches
c4::yml::extra::EventHandlerInts Struct Reference
Parse utilities » Event Handlers

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

#include <event_handler_ints.hpp>

Public Types

types
enum  { requires_strings_on_buffers = true }
using value_type = ievt::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
size_t required_size_arena () const
 get the size needed for the arena from the previous parse
bool fits_buffers () const
 Predicate to test if the event and arena buffers successfully accomodated all the parse events.
void reserve_arena (int)
TagDirectives & tag_directives ()
TagCache & tag_cache ()
parse events
void start_parse (const char *filename, substr src)
void finish_parse ()
void cancel_parse ()
YAML stream events
void begin_stream ()
void end_stream ()
YAML document events
void begin_doc ()
 implicit doc start (without —)
void end_doc ()
 implicit doc end (without ...)
void begin_doc_expl ()
 explicit doc start, with —
void end_doc_expl ()
 explicit doc end, with ...
YAML map functions
void begin_map_key_flow ()
void begin_map_key_block ()
void begin_map_val_flow ()
void begin_map_val_block ()
void end_map_block ()
void end_map_flow (bool)
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.
void actually_val_is_first_key_of_new_map_block ()
 like its flow counterpart, but this function can only be called after the end of a flow-val at root or doc level.
YAML scalar events
void set_key_scalar_plain_empty ()
void set_val_scalar_plain_empty ()
void set_key_scalar_plain (csubstr scalar)
void set_val_scalar_plain (csubstr scalar)
void set_key_scalar_dquoted (csubstr scalar)
void set_val_scalar_dquoted (csubstr scalar)
void set_key_scalar_squoted (csubstr scalar)
void set_val_scalar_squoted (csubstr scalar)
void set_key_scalar_literal (csubstr scalar)
void set_val_scalar_literal (csubstr scalar)
void set_key_scalar_folded (csubstr scalar)
void set_val_scalar_folded (csubstr scalar)
void mark_key_scalar_unfiltered ()
void mark_val_scalar_unfiltered ()
YAML anchor/reference events
void set_key_anchor (csubstr anchor)
void set_val_anchor (csubstr anchor)
void set_key_ref (csubstr ref)
void set_val_ref (csubstr ref)
YAML tag events
void set_key_tag (csubstr tag)
void set_val_tag (csubstr tag)
YAML directive events
void add_directive_yaml (csubstr yaml_version)
void add_directive_tag (csubstr handle, csubstr prefix)
arena events
substr arena ()
substr arena_rem ()
substr alloc_arena (size_t len)
 this may fail, in which case an empty string is returned
implementation helpers
void _push ()
 push a new parent, add a child to the new parent, and set the child as the current node
void _pop ()
 end the current scope
template<c4::yml::type_bits bits>
void _enable__ () noexcept
template<c4::yml::type_bits bits>
void _disable__ () noexcept
template<c4::yml::type_bits bits>
bool _has_any__ () const noexcept
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.
state * m_parent
 parent of the current stack level.
substr m_src

Protected Member Functions

void _stack_start_parse (const char *filename, substr ymlsrc)
void _stack_finish_parse ()
void _stack_reset_root ()
void _stack_reset_non_root ()
void _stack_push ()
void _stack_pop ()
bool _stack_should_push_on_begin_doc () const
bool _stack_should_pop_on_end_doc () const

Detailed Description

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

The integers are ievt::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):

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
};
c4::yml::extra::ievt::DataType
int32_t DataType
data type for integer events.
Definition event_handler_ints.hpp:41
c4::yml::extra::ievt::SCLR
@ SCLR
scalar (=VAL in test suite events)
Definition event_handler_ints.hpp:82
c4::yml::extra::ievt::ESTR
@ ESTR
end stream (-STR in test suite events)
Definition event_handler_ints.hpp:77
c4::yml::extra::ievt::BSTR
@ BSTR
begin stream (+STR in test suite events)
Definition event_handler_ints.hpp:76
c4::yml::extra::ievt::BSEQ
@ BSEQ
begin seq (+SEQ in test suite events)
Definition event_handler_ints.hpp:72
c4::yml::extra::ievt::ESEQ
@ ESEQ
end seq (-SEQ in test suite events)
Definition event_handler_ints.hpp:73
c4::yml::extra::ievt::FLOW
@ FLOW
container: flow: [] for seqs or {} for maps
Definition event_handler_ints.hpp:93
c4::yml::extra::ievt::VAL_
@ VAL_
as value special flag to enable look-back in the event array. it signifies that the previous event ha...
Definition event_handler_ints.hpp:48
c4::yml::extra::ievt::BDOC
@ BDOC
begin doc (+DOC in test suite events)
Definition event_handler_ints.hpp:78
c4::yml::extra::ievt::EDOC
@ EDOC
end doc (-DOC in test suite events)
Definition event_handler_ints.hpp:79

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

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
};
c4::yml::extra::ievt::EMAP
@ EMAP
end map (-MAP in test suite events)
Definition event_handler_ints.hpp:75
c4::yml::extra::ievt::BMAP
@ BMAP
begin map (+MAP in test suite events)
Definition event_handler_ints.hpp:74

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

// 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
{
...
}
}
c4::substr
basic_substring< char > substr
a mutable string view
Definition substr.hpp:2356
c4::csubstr
basic_substring< const char > csubstr
an immutable string view
Definition substr.hpp:2357
c4::yml::extra::ievt::WSTR
@ WSTR
WithSTRing: mask of all the events that encode a string following the event. For such events,...
Definition event_handler_ints.hpp:115
c4::yml::extra::ievt::AREN
@ AREN
IMPORTANT. Marks events whose string was placed in the arena. This happens when the filtered string i...
Definition event_handler_ints.hpp:62
c4::basic_substring::sub
basic_substring sub(size_t first) const noexcept
return [first,len[
Definition substr.hpp:503

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

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

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

csubstr filename = ...;
substr src = ...;
// estimate the size required for the events buffer,
// overpredicting it to be safe.
int estimated_size = extra::estimate_events_ints_size(src);
extra::EventHandlerInts handler;
ParseEngine<extra::EventHandlerInts> parser(&handler);
// example with a vector
std::vector<int> evts;
// ensure we have a fighting chance to acommodate the events
evts.resize((size_t)estimated_size);
// arena to place scalars/tags that may have been extended after filtering
std::vector<char> arena;
arena.resize(src.len); // this is generally enough
// initialize the handler
handler.reset(src, arena, evts.data(), (int)evts.size());
// parse the YAML
parser.parse_in_place_ev(filename, src);
if(handler.fits_buffers()) // were the buffer sizes enough?
{
evts.resize((size_t)handler.required_size_events()); // trim the vector
...
}
else
{
// event size estimation underpredicted, or arena is too small!
// for the first case, open an issue at
// https://github.com/biojppm/rapidyaml/issues
error("buffer could not accomodate all the events");
// NOTE: see below for notes on doing a parse retry.
}
c4::yml::ParseEngine
This is the main driver of parsing logic: it scans the YAML or JSON source for tokens,...
Definition parse_engine.hpp:260
c4::yml::extra::estimate_events_ints_size
int32_t estimate_events_ints_size(csubstr src)
Read YAML source and, without undergoing a full parse, estimate the size of the integer buffer requir...
Definition event_handler_ints.cpp:25
c4::basic_substring::len
size_t len
the length of the substring
Definition substr.hpp:218
c4::yml::extra::EventHandlerInts
A parser event handler that creates a compact representation of the YAML tree in a contiguous buffer ...
Definition event_handler_ints.hpp:437
c4::yml::extra::EventHandlerInts::fits_buffers
bool fits_buffers() const
Predicate to test if the event and arena buffers successfully accomodated all the parse events.
Definition event_handler_ints.hpp:518
c4::yml::extra::EventHandlerInts::required_size_events
int required_size_events() const
get the size needed for the event buffer from the previous parse
Definition event_handler_ints.hpp:502
c4::yml::extra::EventHandlerInts::reset
void reset(substr str, substr arena, ievt::DataType *dst, int32_t dst_size)
Definition event_handler_ints.hpp:482

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

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

1) throw an error (as sketched above)

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

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

const std::string src = ...; // the YAML code to be parsed
std::string parsed_src = src; // this is where we will parse (filter during parsing)
std::vector<int> evts((size_t)estimated_size); // ensure we have a fighting change to acommodate the events
std::vector<char> arena(src.size()); // ensure we have a fighting change to acommodate the events
ParseEngine<extra::EventHandlerInts> parser(&handler);
handler.reset(to_substr(parsed_src), to_substr(arena), evts.data(), (int)evts.size());
parser.parse_in_place_ev(filename, to_substr(parsed_src));
if(handler.fits_buffers()) // were the buffer sizes enough?
{
evts.resize((size_t)handler.required_size()); // trim the vector
...
}
else
{
evts.resize((size_t)handler.required_size_events()); // buffer size was not enough.
arena.resize(handler.required_size_arena()); // buffer size was not enough.
// copy again
parsed_src = src;
// retry parse
handler.reset(to_substr(parsed_src), to_substr(arena), evts.data(), (int)evts.size());
parser.parse_in_place_ev(filename, to_substr(parsed_src));
assert((size_t)handler.fits_buffers()); // must always be true
}
c4::to_substr
substr to_substr(char(&s)[N]) noexcept
Definition substr.hpp:2377
c4::basic_substring::size
size_t size() const noexcept
Definition substr.hpp:358
c4::basic_substring::data
C * data() noexcept
Definition substr.hpp:366
c4::yml::extra::EventHandlerInts::required_size_arena
size_t required_size_arena() const
get the size needed for the arena from the previous parse
Definition event_handler_ints.hpp:509

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 };

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.

473 : EventHandlerStack(cb)
474 {
475 reset(substr{}, substr{}, nullptr, 0);
476 }

◆ EventHandlerInts() [2/2]

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

Definition at line 477 of file event_handler_ints.hpp.

478 : EventHandlerInts(c4::yml::get_callbacks())
479 {
480 }
c4::yml::get_callbacks
Callbacks const & get_callbacks()
get the global callbacks
Definition common.cpp:94

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.

483 {
484 _stack_reset_root();
485 m_curr->flags |= c4::yml::RUNK|c4::yml::RTOP;
486 m_curr->evt_type = {};
487 m_curr->evt_id = 0;
488 m_arena = arena;
489 m_arena_pos = 0;
490 m_src = str;
491 m_evt = dst;
492 m_evt_size = dst_size;
493 m_evt_pos = 0;
494 m_evt_prev = 0;
495 m_curr_doc = 0;
496 m_tag_directives.clear();
497 m_tag_cache.clear();
498 }
c4::yml::RTOP
@ RTOP
reading at top level
Definition parser_state.hpp:18
c4::yml::RUNK
@ RUNK
reading unknown state (when starting): must determine whether scalar, map or seq
Definition parser_state.hpp:19

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

503 {
504 return m_evt_pos;
505 }

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

510 {
511 return m_arena_pos;
512 }

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

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

◆ reserve_arena()

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

Definition at line 523 of file event_handler_ints.hpp.

524 {
525 // does not apply here
526 }

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

539 {
540 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, src.str == m_src.str);
541 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, src.len == m_src.len);
542 this->_stack_start_parse(filename, src);
543 }

◆ finish_parse()

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

Definition at line 545 of file event_handler_ints.hpp.

546 {
547 this->_stack_finish_parse();
548 }

◆ cancel_parse()

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

Definition at line 550 of file event_handler_ints.hpp.

551 {
552 while(m_stack.size() > 1)
553 _pop();
554 }

◆ begin_stream()

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

Definition at line 563 of file event_handler_ints.hpp.

564 {
565 _send_flag_only_(ievt::BSTR);
566 }
c4::yml::extra::EventHandlerInts::_send_flag_only_
void _send_flag_only_(ievt::DataType flags)
Definition event_handler_ints.hpp:1187

◆ end_stream()

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

Definition at line 568 of file event_handler_ints.hpp.

569 {
570 _send_flag_only_(ievt::ESTR);
571 }

◆ begin_doc()

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

implicit doc start (without —)

Definition at line 581 of file event_handler_ints.hpp.

582 {
583 _c4dbgpf("{}/{}: begin_doc", m_evt_pos, m_evt_size);
584 _send_flag_only_(ievt::BDOC);
585 if(_stack_should_push_on_begin_doc())
586 {
587 _c4dbgp("push!");
588 _push();
589 _enable_(DOC);
590 }
591 }
c4::yml::DOC
@ DOC
a document
Definition node_type.hpp:41
c4::yml::extra::EventHandlerInts::_push
void _push()
push a new parent, add a child to the new parent, and set the child as the current node
Definition event_handler_ints.hpp:1145

◆ end_doc()

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

implicit doc end (without ...)

Definition at line 593 of file event_handler_ints.hpp.

594 {
595 _c4dbgpf("{}/{}: end_doc", m_evt_pos, m_evt_size);
596 _send_flag_only_(ievt::EDOC);
597 if(_stack_should_pop_on_end_doc())
598 {
599 _c4dbgp("pop!");
600 _pop();
601 }
602 ++m_curr_doc;
603 }

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

607 {
608 _c4dbgpf("{}/{}: begin_doc_expl", m_evt_pos, m_evt_size);
609 _send_flag_only_(ievt::BDOC|ievt::EXPL);
610 _c4dbgp("push!");
611 _push();
612 _enable_(DOC);
613 }
c4::yml::extra::ievt::EXPL
@ EXPL
--- (with BDOC) or ... (with EDOC)
Definition event_handler_ints.hpp:70

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

616 {
617 _c4dbgpf("{}/{}: end_doc_expl", m_evt_pos, m_evt_size);
618 _send_flag_only_(ievt::EDOC|ievt::EXPL);
619 if(_stack_should_pop_on_end_doc())
620 {
621 _c4dbgp("pop!");
622 _pop();
623 }
624 ++m_curr_doc;
625 }

◆ begin_map_key_flow()

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

Definition at line 634 of file event_handler_ints.hpp.

635 {
636 _c4dbgpf("{}/{}: bmap key flow", m_evt_pos, m_evt_size);
637 _send_flag_only_(ievt::KEY_|ievt::BMAP|ievt::FLOW);
638 _mark_parent_with_children_();
639 _enable_(c4::yml::KEY|c4::yml::MAP|c4::yml::FLOW_SL);
640 _push();
641 }
c4::yml::MAP
@ MAP
a map: a parent of KEYVAL/KEYSEQ/KEYMAP nodes
Definition node_type.hpp:39
c4::yml::KEY
@ KEY
is member of a map
Definition node_type.hpp:37
c4::yml::FLOW_SL
@ FLOW_SL
mark container with single-line flow style (seqs as '[val1,val2], maps as '{key: val,...
Definition node_type.hpp:60

◆ begin_map_key_block()

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

Definition at line 642 of file event_handler_ints.hpp.

643 {
644 _c4dbgpf("{}/{}: bmap key block", m_evt_pos, m_evt_size);
645 _send_flag_only_(ievt::KEY_|ievt::BMAP|ievt::BLCK);
646 _mark_parent_with_children_();
647 _enable_(c4::yml::KEY|c4::yml::MAP|c4::yml::BLOCK);
648 _push();
649 }
c4::yml::BLOCK
@ BLOCK
mark container with block style (seqs as '- val ', maps as 'key: val')
Definition node_type.hpp:62

◆ begin_map_val_flow()

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

Definition at line 651 of file event_handler_ints.hpp.

652 {
653 _c4dbgpf("{}/{}: bmap flow", m_evt_pos, m_evt_size);
654 _send_flag_only_(ievt::VAL_|ievt::BMAP|ievt::FLOW);
655 _mark_parent_with_children_();
656 _enable_(c4::yml::MAP|c4::yml::FLOW_SL);
657 _push();
658 }

◆ begin_map_val_block()

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

Definition at line 659 of file event_handler_ints.hpp.

660 {
661 _c4dbgpf("{}/{}: bmap block", m_evt_pos, m_evt_size);
662 _send_flag_only_(ievt::VAL_|ievt::BMAP|ievt::BLCK);
663 _mark_parent_with_children_();
664 _enable_(c4::yml::MAP|c4::yml::BLOCK);
665 _push();
666 }

◆ end_map_block()

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

Definition at line 668 of file event_handler_ints.hpp.

669 {
670 _pop();
671 _send_flag_only_(ievt::EMAP);
672 }

◆ end_map_flow()

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

Definition at line 674 of file event_handler_ints.hpp.

675 {
676 _pop();
677 _send_flag_only_(ievt::EMAP);
678 }

◆ begin_seq_key_flow()

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

Definition at line 687 of file event_handler_ints.hpp.

688 {
689 _c4dbgpf("{}/{}: bseq key flow", m_evt_pos, m_evt_size);
690 _send_flag_only_(ievt::KEY_|ievt::BSEQ|ievt::FLOW);
691 _mark_parent_with_children_();
692 _enable_(c4::yml::KEY|c4::yml::SEQ|c4::yml::FLOW_SL);
693 _push();
694 }
c4::yml::SEQ
@ SEQ
a seq: a parent of VAL/SEQ/MAP nodes
Definition node_type.hpp:40

◆ begin_seq_key_block()

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

Definition at line 695 of file event_handler_ints.hpp.

696 {
697 _c4dbgpf("{}/{}: bseq key block", m_evt_pos, m_evt_size);
698 _send_flag_only_(ievt::KEY_|ievt::BSEQ|ievt::BLCK);
699 _mark_parent_with_children_();
700 _enable_(c4::yml::KEY|c4::yml::SEQ|c4::yml::BLOCK);
701 _push();
702 }

◆ begin_seq_val_flow()

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

Definition at line 704 of file event_handler_ints.hpp.

705 {
706 _c4dbgpf("{}/{}: bseq flow", m_evt_pos, m_evt_size);
707 _send_flag_only_(ievt::VAL_|ievt::BSEQ|ievt::FLOW);
708 _mark_parent_with_children_();
709 _enable_(c4::yml::SEQ|c4::yml::FLOW_SL);
710 _push();
711 }

◆ begin_seq_val_block()

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

Definition at line 712 of file event_handler_ints.hpp.

713 {
714 _c4dbgpf("{}/{}: bseq block", m_evt_pos, m_evt_size);
715 _send_flag_only_(ievt::VAL_|ievt::BSEQ|ievt::BLCK);
716 _mark_parent_with_children_();
717 _enable_(c4::yml::SEQ|c4::yml::BLOCK);
718 _push();
719 }

◆ end_seq_block()

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

Definition at line 721 of file event_handler_ints.hpp.

722 {
723 _pop();
724 _send_flag_only_(ievt::ESEQ);
725 }

◆ end_seq_flow()

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

Definition at line 727 of file event_handler_ints.hpp.

728 {
729 _pop();
730 _send_flag_only_(ievt::ESEQ);
731 }

◆ add_sibling()

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

Definition at line 740 of file event_handler_ints.hpp.

741 {
742 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_parent);
743 m_curr->evt_type = {};
744 }

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

755 {
756 _c4dbgpf("{}/{}: set_key_scalar_plain_empty", m_evt_pos, m_evt_size);
757 _send_str_(_get_latest_empty_scalar(), ievt::KEY_|ievt::SCLR|ievt::PLAI);
758 _enable_(c4::yml::KEY|c4::yml::KEY_PLAIN|c4::yml::KEYNIL);
759 }
c4::yml::KEY_PLAIN
@ KEY_PLAIN
mark key scalar as plain scalar (unquoted, even when multiline)
Definition node_type.hpp:71
c4::yml::KEYNIL
@ KEYNIL
the key is null (eg { : b} results in a null key)
Definition node_type.hpp:49
c4::yml::extra::EventHandlerInts::_send_str_
void _send_str_(csubstr scalar, ievt::DataType flags)
Definition event_handler_ints.hpp:1199

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

761 {
762 _c4dbgpf("{}/{}: set_val_scalar_plain_empty", m_evt_pos, m_evt_size);
763 _send_str_(_get_latest_empty_scalar(), ievt::VAL_|ievt::SCLR|ievt::PLAI);
764 _enable_(c4::yml::VAL|c4::yml::VAL_PLAIN|c4::yml::VALNIL);
765 }
c4::yml::VALNIL
@ VALNIL
the val is null (eg {a : } results in a null val)
Definition node_type.hpp:50
c4::yml::VAL
@ VAL
a scalar: has a scalar (ie string) value, possibly empty. must be a leaf node, and cannot be MAP or S...
Definition node_type.hpp:38
c4::yml::VAL_PLAIN
@ VAL_PLAIN
mark val scalar as plain scalar (unquoted, even when multiline)
Definition node_type.hpp:72

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

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

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

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

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

783 {
784 _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{});
785 _send_str_(scalar, ievt::KEY_|ievt::SCLR|ievt::DQUO);
786 _enable_(c4::yml::KEY|c4::yml::KEY_DQUO);
787 }
c4::yml::KEY_DQUO
@ KEY_DQUO
mark key scalar as double quoted "
Definition node_type.hpp:69
c4::yml::extra::ievt::DQUO
@ DQUO
scalar: double-quoted ("")
Definition event_handler_ints.hpp:90

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

789 {
790 _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{});
791 _send_str_(scalar, ievt::VAL_|ievt::SCLR|ievt::DQUO);
792 _enable_(c4::yml::VAL|c4::yml::VAL_DQUO);
793 }
c4::yml::VAL_DQUO
@ VAL_DQUO
mark val scalar as double quoted "
Definition node_type.hpp:70

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

797 {
798 _c4dbgpf("{}/{}: set_key_scalar_squo: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_src.str, scalar.len, scalar);
799 _send_str_(scalar, ievt::KEY_|ievt::SCLR|ievt::SQUO);
800 _enable_(c4::yml::KEY|c4::yml::KEY_SQUO);
801 }
c4::yml::KEY_SQUO
@ KEY_SQUO
mark key scalar as single quoted '
Definition node_type.hpp:67
c4::yml::extra::ievt::SQUO
@ SQUO
scalar: single-quoted (')
Definition event_handler_ints.hpp:89

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

803 {
804 _c4dbgpf("{}/{}: set_val_scalar_squo: @{} [{}]~~~{}~~~", m_evt_pos, m_evt_size, scalar.str-m_src.str, scalar.len, scalar);
805 _send_str_(scalar, ievt::VAL_|ievt::SCLR|ievt::SQUO);
806 _enable_(c4::yml::VAL|c4::yml::VAL_SQUO);
807 }
c4::yml::VAL_SQUO
@ VAL_SQUO
mark val scalar as single quoted '
Definition node_type.hpp:68

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

811 {
812 _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{});
813 _send_str_(scalar, ievt::KEY_|ievt::SCLR|ievt::LITL);
814 _enable_(c4::yml::KEY|c4::yml::KEY_LITERAL);
815 }
c4::yml::KEY_LITERAL
@ KEY_LITERAL
mark key scalar as multiline, block literal |
Definition node_type.hpp:63
c4::yml::extra::ievt::LITL
@ LITL
scalar: block literal (|)
Definition event_handler_ints.hpp:91

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

817 {
818 _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{});
819 _send_str_(scalar, ievt::VAL_|ievt::SCLR|ievt::LITL);
820 _enable_(c4::yml::VAL|c4::yml::VAL_LITERAL);
821 }
c4::yml::VAL_LITERAL
@ VAL_LITERAL
mark val scalar as multiline, block literal |
Definition node_type.hpp:64

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

825 {
826 _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{});
827 _send_str_(scalar, ievt::KEY_|ievt::SCLR|ievt::FOLD);
828 _enable_(c4::yml::KEY|c4::yml::KEY_FOLDED);
829 }
c4::yml::KEY_FOLDED
@ KEY_FOLDED
mark key scalar as multiline, block folded >
Definition node_type.hpp:65
c4::yml::extra::ievt::FOLD
@ FOLD
scalar: block folded (>)
Definition event_handler_ints.hpp:92

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

831 {
832 _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{});
833 _send_str_(scalar, ievt::VAL_|ievt::SCLR|ievt::FOLD);
834 _enable_(c4::yml::VAL|c4::yml::VAL_FOLDED);
835 }
c4::yml::VAL_FOLDED
@ VAL_FOLDED
mark val scalar as multiline, block folded >
Definition node_type.hpp:66

◆ mark_key_scalar_unfiltered()

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

Definition at line 838 of file event_handler_ints.hpp.

839 {
840 _c4dbgpf("{}/{}: mark_key_scalar_unfiltered", m_evt_pos, m_evt_size);
841 if(m_evt_pos < m_evt_size)
842 m_evt[m_evt_pos] |= ievt::UNFILT;
843 }
c4::yml::extra::ievt::UNFILT
@ UNFILT
special flag to mark a scalar as unfiltered (when the parser is set not to filter).
Definition event_handler_ints.hpp:103

◆ mark_val_scalar_unfiltered()

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

Definition at line 844 of file event_handler_ints.hpp.

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

◆ set_key_anchor()

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

Definition at line 880 of file event_handler_ints.hpp.

881 {
882 _c4dbgpf("{}/{}: set_key_anchor: {}", m_evt_pos, m_evt_size, anchor);
883 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, !_has_any_(KEYREF));
884 _enable_(c4::yml::KEYANCH);
885 if(m_evt_pos + 3 < m_evt_size)
886 {
887 m_evt[m_evt_pos] |= ievt::KEY_|ievt::ANCH;
888 _add_scalar_(m_evt_pos, anchor);
889 }
890 m_evt_prev = m_evt_pos;
891 m_evt_pos += 3;
892 }
_has_any_
#define _has_any_(bits)
Definition event_handler_stack.hpp:115
c4::yml::KEYREF
@ KEYREF
a *reference: the key references an &anchor
Definition node_type.hpp:43
c4::yml::KEYANCH
@ KEYANCH
the key has an &anchor
Definition node_type.hpp:45

◆ set_val_anchor()

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

Definition at line 893 of file event_handler_ints.hpp.

894 {
895 _c4dbgpf("{}/{}: set_val_anchor: {}", m_evt_pos, m_evt_size, anchor);
896 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, !_has_any_(VALREF));
897 _enable_(c4::yml::VALANCH);
898 if(m_evt_pos + 3 < m_evt_size)
899 {
900 m_evt[m_evt_pos] |= ievt::VAL_|ievt::ANCH;
901 _add_scalar_(m_evt_pos, anchor);
902 }
903 m_evt_prev = m_evt_pos;
904 m_evt_pos += 3;
905 }
c4::yml::VALANCH
@ VALANCH
the val has an &anchor
Definition node_type.hpp:46
c4::yml::VALREF
@ VALREF
a *reference: the val references an &anchor
Definition node_type.hpp:44

◆ set_key_ref()

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

Definition at line 907 of file event_handler_ints.hpp.

908 {
909 _c4dbgpf("{}/{}: set_key_ref: {}", m_evt_pos, m_evt_size, ref);
910 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, ref.begins_with('*'));
911 if(C4_UNLIKELY(_has_any_(KEYANCH)))
912 _RYML_ERR_PARSE_(m_stack.m_callbacks, m_curr->pos, "key cannot have both anchor and ref");
913 _enable_(c4::yml::KEY|c4::yml::KEYREF);
914 _send_str_(ref.sub(1), ievt::KEY_|ievt::ALIA); // skip the leading *
915 }

◆ set_val_ref()

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

Definition at line 916 of file event_handler_ints.hpp.

917 {
918 _c4dbgpf("{}/{}: set_val_ref: {}", m_evt_pos, m_evt_size, ref);
919 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, ref.begins_with('*'));
920 if(C4_UNLIKELY(_has_any_(VALANCH)))
921 _RYML_ERR_PARSE_(m_stack.m_callbacks, m_curr->pos, "val cannot have both anchor and ref");
922 _enable_(c4::yml::VAL|c4::yml::VALREF);
923 _send_str_(ref.sub(1), ievt::VAL_|ievt::ALIA); // skip the leading *
924 }

◆ set_key_tag()

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

Definition at line 933 of file event_handler_ints.hpp.

934 {
935 _c4dbgpf("{}/{}: set key tag [{}]~~~{}~~~", m_evt_pos, m_evt_size, tag.len, tag.str ? tag : csubstr("(arena full)"));
936 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, _is_sub_(tag));
937 _enable_(c4::yml::KEYTAG);
938 _send_str_(tag, ievt::KEY_|ievt::TAG_);
939 }
c4::yml::KEYTAG
@ KEYTAG
the key has a tag
Definition node_type.hpp:47
c4::yml::extra::EventHandlerInts::_is_sub_
bool _is_sub_(csubstr str) const noexcept
Definition event_handler_ints.hpp:1182

◆ set_val_tag()

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

Definition at line 940 of file event_handler_ints.hpp.

941 {
942 _c4dbgpf("{}/{}: set val tag [{}]~~~{}~~~", m_evt_pos, m_evt_size, tag.len, tag.str ? tag : csubstr("(arena full)"));
943 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, _is_sub_(tag));
944 _enable_(c4::yml::VALTAG);
945 _send_str_(tag, ievt::VAL_|ievt::TAG_);
946 }
c4::yml::VALTAG
@ VALTAG
the val has a tag
Definition node_type.hpp:48

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

956 {
957 _c4dbgpf("{}/{}: %YAML directive! version={}", m_evt_pos, m_evt_size, yaml_version);
958 _send_str_(yaml_version, ievt::YAML);
959 }
c4::yml::extra::ievt::YAML
@ YAML
yaml directive: \YAML <version>
Definition event_handler_ints.hpp:97

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

962 {
963 _c4dbgpf("{}/{}: %TAG directive! handle={} prefix={} doc_id={}", m_evt_pos, m_evt_size, handle, prefix, m_curr_doc);
964 if(C4_UNLIKELY(!m_tag_directives.add(handle, prefix, m_curr_doc)))
965 _RYML_ERR_PARSE_(m_stack.m_callbacks, m_curr->pos, "too many %TAG directives");
966 _send_str_(handle, ievt::TAGH);
967 _send_str_(prefix, ievt::TAGP);
968 }
c4::yml::extra::ievt::TAGH
@ TAGH
tag directive, handle: \TAG <handle> ........
Definition event_handler_ints.hpp:98
c4::yml::extra::ievt::TAGP
@ TAGP
tag directive, prefix: \TAG ........ <prefix>
Definition event_handler_ints.hpp:99

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

983 {
984 _c4dbgpf("{}/{}: prev={} actually_val_is_first_key_of_new_map_flow", m_evt_pos, m_evt_size, m_evt_prev);
985 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_evt_pos > 2);
986 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_evt_prev > 0);
987 // BEFORE
988 // ... flag start len (free)
989 // | |
990 // prev curr
991 // AFTER
992 // ... BMAP flag start len (free)
993 // | |
994 // prev curr
995 if(m_evt_pos < m_evt_size)
996 {
997 if(m_evt[m_evt_prev] & ievt::WSTR)
998 {
999 _c4dbgpf("{}/{}: WSTR", m_evt_pos, m_evt_size);
1000 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_evt_prev > 0);
1001 int32_t pos = _extend_left_to_include_tag_and_or_anchor(m_evt_prev);
1002 if(m_evt_pos + 1 < m_evt_size)
1003 {
1004 for(int32_t i = pos; i <= m_evt_prev; i = _next(i))
1005 {
1006 m_evt[i] |= ievt::KEY_;
1007 m_evt[i] &= ~ievt::VAL_;
1008 }
1009 int32_t num_move = m_evt_pos + 1 - pos;
1010 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, num_move > 0);
1011 memmove(m_evt + pos + 1, m_evt + pos, (size_t)num_move * sizeof(ievt::DataType));
1012 }
1013 m_evt[pos] = ievt::BMAP|ievt::FLOW|ievt::VAL_;
1014 // move PSTR to prev
1015 if(m_evt[pos + 1] & ievt::PSTR)
1016 {
1017 m_evt[pos ] |= ievt::PSTR;
1018 m_evt[pos + 1] &= ~ievt::PSTR;
1019 }
1020 }
1021 else
1022 {
1023 _c4dbgpf("{}/{}: container key", m_evt_pos, m_evt_size);
1024 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, (m_evt[m_evt_prev] & (ievt::EMAP|ievt::ESEQ)));
1025 int32_t pos;
1026 _c4dbgpf("{}/{}: find matching open for {}", m_evt_pos, m_evt_size, m_evt_prev);
1027 if((m_evt[m_evt_prev] & ievt::EMAP) == ievt::EMAP)
1028 {
1029 pos = _find_matching_open(ievt::BMAP, ievt::EMAP, m_evt_prev);
1030 }
1031 else
1032 {
1033 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, (m_evt[m_evt_prev] & ievt::ESEQ));
1034 pos = _find_matching_open(ievt::BSEQ, ievt::ESEQ, m_evt_prev);
1035 }
1036 _c4dbgpf("{}/{}: matching open for {}={}", m_evt_pos, m_evt_size, m_evt_prev, pos);
1037 _RYML_CHECK_BASIC_(m_stack.m_callbacks, pos >= 0); // internal error
1038 _RYML_CHECK_BASIC_(m_stack.m_callbacks, pos < m_evt_prev); // internal error
1039 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, (m_evt[pos] & ievt::ESEQ) == (m_evt[m_evt_prev] & ievt::BSEQ));
1040 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, (m_evt[pos] & ievt::EMAP) == (m_evt[m_evt_prev] & ievt::BMAP));
1041 // shift the array one position to the right, starting at pos
1042 int32_t posp1 = pos + 1;
1043 if(m_evt_pos + 1 < m_evt_size)
1044 {
1045 int32_t num_move = m_evt_pos + 1 - pos;
1046 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, num_move > 0);
1047 memmove(m_evt + posp1, m_evt + pos, (size_t)num_move * sizeof(ievt::DataType));
1048 }
1049 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, posp1 < m_evt_pos);
1050 // start the map
1051 m_evt[pos] = ievt::BMAP|ievt::FLOW|ievt::VAL_;
1052 // set next as key, not val
1053 m_evt[posp1] |= ievt::KEY_;
1054 m_evt[posp1] &= ~ievt::VAL_;
1055 // move PSTR to pos
1056 if(m_evt[posp1] & ievt::PSTR)
1057 {
1058 m_evt[pos] |= ievt::PSTR;
1059 m_evt[posp1] &= ~ievt::PSTR;
1060 }
1061 }
1062 }
1063 m_curr->evt_id = m_evt_pos - 2;
1064 ++m_evt_prev;
1065 ++m_evt_pos;
1066 _enable_(c4::yml::MAP|c4::yml::FLOW_SL);
1067 _push();
1068 }
c4::yml::extra::EventHandlerInts::_next
int32_t _next(int32_t pos) const noexcept
Definition event_handler_ints.hpp:1170
c4::yml::extra::EventHandlerInts::_find_matching_open
int32_t _find_matching_open(ievt::DataType open, ievt::DataType close, int32_t pos) const
Definition event_handler_ints.hpp:1239
c4::yml::extra::EventHandlerInts::_extend_left_to_include_tag_and_or_anchor
int32_t _extend_left_to_include_tag_and_or_anchor(int32_t pos) const
Definition event_handler_ints.hpp:1270

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

1077 {
1078 _c4dbgpf("{}/{}: prev={} actually_val_is_first_key_of_new_map_block", m_evt_pos, m_evt_size, m_evt_prev);
1079 if(m_evt_pos < m_evt_size)
1080 {
1081 // interpolate BMAP|VAL|BLCK after the last BDOC
1082 int32_t pos = _find_last_bdoc(m_evt_pos);
1083 if(pos >= 0)
1084 {
1085 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, pos < m_evt_size);
1086 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, pos < m_evt_pos);
1087 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, (m_evt[pos] & ievt::BDOC) == ievt::BDOC);
1088 if(m_evt_pos < m_evt_size)
1089 {
1090 ++pos; // add 1 to write after BDOC
1091 int32_t num_move = m_evt_pos - pos;
1092 int32_t posp1 = pos + 1;
1093 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, ((m_evt[pos] & ievt::BSEQ) == ievt::BSEQ) || ((m_evt[pos] & ievt::BMAP) == ievt::BMAP));
1094 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, num_move > 0);
1095 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, 0 == (m_evt[posp1] & ievt::PSTR));
1096 memmove(m_evt + posp1, m_evt + pos, (size_t)num_move * sizeof(ievt::DataType));
1097 m_evt[pos] = ievt::VAL_|ievt::BMAP|ievt::BLCK;
1098 m_evt[posp1] &= ~ievt::VAL_;
1099 m_evt[posp1] |= ievt::KEY_;
1100 }
1101 }
1102 }
1103 ++m_curr->evt_id;
1104 ++m_evt_prev;
1105 ++m_evt_pos;
1106 _push();
1107 }
c4::yml::extra::EventHandlerInts::_find_last_bdoc
int32_t _find_last_bdoc(int32_t pos) const
Definition event_handler_ints.hpp:1226

◆ arena()

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

Definition at line 1116 of file event_handler_ints.hpp.

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

◆ arena_rem()

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

Definition at line 1120 of file event_handler_ints.hpp.

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

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

1126 {
1127 substr s = arena_rem();
1128 if(C4_LIKELY(len <= s.len))
1129 s.len = len;
1130 else
1131 s.str = nullptr;
1132 m_arena_pos += len;
1133 return s;
1134 }

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

1146 {
1147 _stack_push();
1148 m_curr->evt_type = {};
1149 }

◆ _pop()

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

end the current scope

Definition at line 1152 of file event_handler_ints.hpp.

1153 {
1154 _stack_pop();
1155 }

◆ _enable__()

template<c4::yml::type_bits bits>
void c4::yml::extra::EventHandlerInts::_enable__ ( )
inlinenoexcept

Definition at line 1157 of file event_handler_ints.hpp.

1158 {
1159 m_curr->evt_type |= bits;
1160 }

◆ _disable__()

template<c4::yml::type_bits bits>
void c4::yml::extra::EventHandlerInts::_disable__ ( )
inlinenoexcept

Definition at line 1161 of file event_handler_ints.hpp.

1162 {
1163 m_curr->evt_type &= ~bits;
1164 }

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

1166 {
1167 return (m_curr->evt_type & bits) != c4::yml::type_bits(0);
1168 }
c4::yml::type_bits
uint32_t type_bits
the integral type necessary to cover all the bits for NodeType_e
Definition node_type.hpp:30

◆ _next()

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

Definition at line 1170 of file event_handler_ints.hpp.

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

◆ _prev()

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

Definition at line 1176 of file event_handler_ints.hpp.

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

◆ _is_sub_()

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

Definition at line 1182 of file event_handler_ints.hpp.

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

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

1188 {
1189 _c4dbgpf("{}/{}: flag only", m_evt_pos, m_evt_size);
1190 if(m_evt_pos < m_evt_size)
1191 m_evt[m_evt_pos] |= flags;
1192 m_curr->evt_id = m_evt_pos;
1193 m_evt_prev = m_evt_pos;
1194 ++m_evt_pos;
1195 if(m_evt_pos < m_evt_size)
1196 m_evt[m_evt_pos] = {};
1197 }

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

1200 {
1201 _c4dbgpf("{}/{}: send str", m_evt_pos, m_evt_size);
1202 if(m_evt_pos + 3 < m_evt_size)
1203 {
1204 m_evt[m_evt_pos] |= flags;
1205 _add_scalar_(m_evt_pos, scalar);
1206 }
1207 m_curr->evt_id = m_evt_pos;
1208 m_evt_prev = m_evt_pos;
1209 m_evt_pos += 3;
1210 }

◆ _mark_parent_with_children_()

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

Definition at line 1212 of file event_handler_ints.hpp.

1213 {
1214 if(m_parent)
1215 m_parent->has_children = true;
1216 }

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

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

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

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

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

1240 {
1241 _c4dbgpf("find_matching: start at {}", pos);
1242 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, pos < m_evt_size);
1243 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, (m_evt[pos] & close) == close);
1244 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, (m_evt[pos] & open) == (close & ~ievt::END_));
1245 pos = _prev(pos); // don't count the starting close token
1246 uint32_t count = 0;
1247 while(pos >= 0)
1248 {
1249 ievt::DataType e = m_evt[pos];
1250 _c4dbgpf("find_matching: pos={} count={} e={}", pos, count, m_evt[pos]);
1251 if((e & close) == close)
1252 {
1253 _c4dbgpf(".............: pos={} close! count={} e={}", pos, count, m_evt[pos]);
1254 ++count;
1255 }
1256 else if((e & open) == open)
1257 {
1258 _c4dbgpf(".............: pos={} open! count={} e={}", pos, count, m_evt[pos]);
1259 if(!count)
1260 return pos;
1261 else
1262 --count;
1263 }
1264 pos = _prev(pos);
1265 }
1266 _c4dbgpf("find_matching: not found!", 0); // LCOV_EXCL_LINE
1267 return -1; // LCOV_EXCL_LINE
1268 }
c4::yml::extra::EventHandlerInts::_prev
int32_t _prev(int32_t pos) const noexcept
Definition event_handler_ints.hpp:1176

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

1271 {
1272 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, pos < m_evt_size);
1273 int32_t prev = _prev(pos);
1274 while((prev > 0) && (m_evt[prev] & (ievt::TAG_|ievt::ANCH)))
1275 {
1276 _c4dbgpf("{}/{}: {} is anchor/tag. extend to {}", m_evt_pos, m_evt_size, prev, prev);
1277 pos = prev;
1278 prev = _prev(prev);
1279 }
1280 return pos;
1281 }

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

59 {
60 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_curr != nullptr);
61 m_curr->start_parse(filename, m_curr->node_id);
62 m_src = ymlsrc;
63 }
c4::yml::EventHandlerStack
Use this class a base of implementations of event handler to simplify the stack logic.
Definition event_handler_stack.hpp:38

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

72 {
73 m_stack.clear();
74 m_stack.push({});
75 m_parent = nullptr;
76 m_curr = &m_stack.top();
77 }

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

80 {
81 m_stack.clear();
82 m_stack.push({}); // parent
83 m_stack.push({}); // node
84 m_parent = &m_stack.top(1);
85 m_curr = &m_stack.top();
86 }

◆ _stack_push()

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

Definition at line 88 of file event_handler_stack.hpp.

89 {
90 m_stack.push_top();
91 m_parent = &m_stack.top(1); // don't use m_curr. watch out for relocations inside the prev push
92 m_curr = &m_stack.top();
93 m_curr->reset_after_push();
94 }

◆ _stack_pop()

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

Definition at line 96 of file event_handler_stack.hpp.

97 {
98 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_parent);
99 _RYML_ASSERT_BASIC_(m_stack.m_callbacks, m_stack.size() > 1);
100 m_parent->reset_before_pop(*m_curr);
101 m_stack.pop();
102 m_parent = m_stack.size() > 1 ? &m_stack.top(1) : nullptr;
103 m_curr = &m_stack.top();
104 #ifdef RYML_DBG
105 if(m_parent)
106 _c4dbgpf("popped! top is now node={} (parent={})", m_curr->node_id, m_parent->node_id);
107 else
108 _c4dbgpf("popped! top is now node={} @ ROOT", m_curr->node_id);
109 #endif
110 }

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

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

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

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

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.14.0/src_extra/c4/yml/extra/event_handler_ints.hpp