c4::yml::extra::ievt Namespace Reference

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) , TAGH = (1 << 24) ,   TAGP = (1 << 25) , UNFILT = (1 << 26) , LAST = UNFILT , MASK = (LAST << 1) - 1 ,   WSTR = SCLR|ALIA|ANCH|TAG_|TAGH|TAGP|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>
TAGH	tag directive, handle: \TAG <handle> ........
TAGP	tag directive, prefix: \TAG ........ <prefix>
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>`
    TAGH = (1 << 24),  ///< tag directive, handle: `\%TAG <handle> ........`
    TAGP = (1 << 25),  ///< tag directive, prefix: `\%TAG ........ <prefix>`
 
    /// 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_|TAGH|TAGP|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);
}

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