Typedefs
using	DataType = int32_t
	data type for integer events. More...

Enumerations
enum	EventFlags : DataType { KEY_ = (1 << 0) , VAL_ = (1 << 1) , PSTR = (1 << 2) , AREN = (1 << 3) , BEG_ = (1 << 5) , END_ = (1 << 6) , SEQ_ = (1 << 7) , MAP_ = (1 << 8) , DOC_ = (1 << 9) , EXPL = (1 << 10) , STRM = (1 << 11) , BSEQ = BEG_\|SEQ_ , ESEQ = END_\|SEQ_ , BMAP = BEG_\|MAP_ , EMAP = END_\|MAP_ , BSTR = BEG_\|STRM , ESTR = END_\|STRM , BDOC = BEG_\|DOC_ , EDOC = END_\|DOC_ , SCLR = (1 << 12) , ALIA = (1 << 13) , ANCH = (1 << 14) , TAG_ = (1 << 15) , PLAI = (1 << 16) , SQUO = (1 << 17) , DQUO = (1 << 18) , LITL = (1 << 19) , FOLD = (1 << 20) , FLOW = (1 << 21) , BLCK = (1 << 22) , YAML = (1 << 23) , TAGD = (1 << 24) , TAGV = (1 << 25) , UNFILT = (1 << 26) , LAST = UNFILT , MASK = (LAST << 1) - 1 , WSTR = SCLR\|ALIA\|ANCH\|TAG_\|TAGD\|TAGV\|YAML }
	enumeration of integer event bits. More...

Functions
size_t	to_chars (substr buf, yml::extra::ievt::DataType flags)
	Convert bit mask of ievt::EventFlags to text. More...

csubstr	to_chars_sub (substr buf, yml::extra::ievt::DataType flags)
	Convert bit mask of ievt::EventFlags to text. More...

Typedef Documentation

◆ DataType

using c4::yml::extra::ievt::DataType = typedef int32_t

data type for integer events.

This is set to a 32 bit signed integer to allow compatibility with a wide range of processing languages.

Definition at line 41 of file event_handler_ints.hpp.

Enumeration Type Documentation

◆ EventFlags

enum c4::yml::extra::ievt::EventFlags : DataType

enumeration of integer event bits.

Enumerator
KEY_	as key
VAL_	as value special flag to enable look-back in the event array. it signifies that the previous event has a string, meaning that the jump back to that event is 3 positions. without this flag it would be impossible to jump to the previous event. see also WSTR
PSTR
AREN	IMPORTANT. Marks events whose string was placed in the arena. This happens when the filtered string is larger than the original string in the YAML code (eg from tags that resolve to a larger string, or from "\L" or "\P" in double quotes, which expand from two to three bytes). Because of this size expansion, the filtered string cannot be placed in the original source and needs to be placed in the arena.
BEG_	scope: begin
END_	scope: end
SEQ_	scope: seq
MAP_	scope: map
DOC_	scope: doc
EXPL	`---` (with BDOC) or `...` (with EDOC)
STRM	scope: stream
BSEQ	begin seq (+SEQ in test suite events)
ESEQ	end seq (-SEQ in test suite events)
BMAP	begin map (+MAP in test suite events)
EMAP	end map (-MAP in test suite events)
BSTR	begin stream (+STR in test suite events)
ESTR	end stream (-STR in test suite events)
BDOC	begin doc (+DOC in test suite events)
EDOC	end doc (-DOC in test suite events)
SCLR	scalar (=VAL in test suite events)
ALIA	*ref (reference)
ANCH	&anchor
TAG_	!tag
PLAI	scalar: plain
SQUO	scalar: single-quoted (')
DQUO	scalar: double-quoted ("")
LITL	scalar: block literal (\|)
FOLD	scalar: block folded (>)
FLOW	container: flow: [] for seqs or {} for maps
BLCK	container: block
YAML	yaml directive: `\YAML <version>`
TAGD	tag directive, name : `\TAG <name> .......`
TAGV	tag directive, value: `\TAG ...... <value>`
UNFILT	special flag to mark a scalar as unfiltered (when the parser is set not to filter).
LAST	the last flag defined above
MASK	a mask of all bits in this enumeration
WSTR	WithSTRing: mask of all the events that encode a string following the event. For such events, the next two integers will provide respectively the string's offset and length. See also PSTR.

Definition at line 44 of file event_handler_ints.hpp.

              : DataType {
  
     // Structure flags
     KEY_ = (1 << 0),  ///< as key
     VAL_ = (1 << 1),  ///< as value
     /// special flag to enable look-back in the event array. it
     /// signifies that the previous event has a string, meaning that
     /// the jump back to that event is 3 positions. without this flag it
     /// would be impossible to jump to the previous event.
     /// see also @ref WSTR
     PSTR = (1 << 2),
     /// IMPORTANT. Marks events whose string was placed in the
     /// arena. This happens when the filtered string is larger than the
     /// original string in the YAML code (eg from tags that resolve to
     /// a larger string, or from "\L" or "\P" in double quotes, which
     /// expand from two to three bytes). Because of this size
     /// expansion, the filtered string cannot be placed in the original
     /// source and needs to be placed in the arena.
     AREN = (1 << 3),
  
     // Event scopes
     BEG_ = (1 <<  5),  ///< scope: begin
     END_ = (1 <<  6),  ///< scope: end
     SEQ_ = (1 <<  7),  ///< scope: seq
     MAP_ = (1 <<  8),  ///< scope: map
     DOC_ = (1 <<  9),  ///< scope: doc
     EXPL = (1 << 10),  ///< `---` (with BDOC) or `...` (with EDOC)
     STRM = (1 << 11),  ///< scope: stream
     BSEQ = BEG_|SEQ_,  ///< begin seq    (+SEQ in test suite events)
     ESEQ = END_|SEQ_,  ///< end seq      (-SEQ in test suite events)
     BMAP = BEG_|MAP_,  ///< begin map    (+MAP in test suite events)
     EMAP = END_|MAP_,  ///< end map      (-MAP in test suite events)
     BSTR = BEG_|STRM,  ///< begin stream (+STR in test suite events)
     ESTR = END_|STRM,  ///< end stream   (-STR in test suite events)
     BDOC = BEG_|DOC_,  ///< begin doc    (+DOC in test suite events)
     EDOC = END_|DOC_,  ///< end doc      (-DOC in test suite events)
  
     // Single events
     SCLR = (1 << 12),  ///< scalar (=VAL in test suite events)
     ALIA = (1 << 13),  ///< *ref (reference)
     ANCH = (1 << 14),  ///< &anchor
     TAG_ = (1 << 15),  ///< !tag
  
     // Style flags
     PLAI = (1 << 16),  ///< scalar: plain
     SQUO = (1 << 17),  ///< scalar: single-quoted (')
     DQUO = (1 << 18),  ///< scalar: double-quoted ("")
     LITL = (1 << 19),  ///< scalar: block literal (|)
     FOLD = (1 << 20),  ///< scalar: block folded (>)
     FLOW = (1 << 21),  ///< container: flow: [] for seqs or {} for maps
     BLCK = (1 << 22),  ///< container: block
  
     // Directive flags
     YAML = (1 << 23),  ///< yaml directive: `\%YAML <version>`
     TAGD = (1 << 24),  ///< tag directive, name : `\%TAG <name> .......`
     TAGV = (1 << 25),  ///< tag directive, value: `\%TAG ...... <value>`
  
     /// special flag to mark a scalar as unfiltered (when the parser
     /// is set not to filter).
     UNFILT = (1 << 26),
  
     // Utility flags/masks
     /// the last flag defined above
     LAST = UNFILT,
     /// a mask of all bits in this enumeration
     MASK = (LAST << 1) - 1,
  
     /// WithSTRing: mask of all the events that encode a string
     /// following the event. For such events, the next two integers
     /// will provide respectively the string's offset and length. See
     /// also @ref PSTR.
     WSTR = SCLR|ALIA|ANCH|TAG_|TAGD|TAGV|YAML,
  
 } EventFlags;

Function Documentation

◆ to_chars()

size_t c4::yml::extra::ievt::to_chars	(	substr	buf,
		ievt::DataType	flags
	)

Convert bit mask of ievt::EventFlags to text.

Definition at line 68 of file ints_utils.cpp.

 {
     flags &= ievt::MASK; // clear any other bits
     return c4::bm2str<ievt::EventFlags>(flags, buf.str, buf.len);
 }

References MASK.

◆ to_chars_sub()

csubstr c4::yml::extra::ievt::to_chars_sub	(	substr	buf,
		ievt::DataType	flags
	)

Convert bit mask of ievt::EventFlags to text.

Definition at line 73 of file ints_utils.cpp.

 {
     size_t reqsize = ievt::to_chars(buf, flags);
     _RYML_CHECK_BASIC(reqsize > 0u);
     _RYML_CHECK_BASIC(reqsize < buf.len);
     return buf.first(reqsize - 1u);
 }

References to_chars().

Typedefs

Enumerations