Classes
struct	c4::yml::NodeType
	wraps a NodeType_e element with some syntactic sugar and predicates More...

Typedefs
using	c4::yml::type_bits = uint32_t
	the integral type necessary to cover all the bits for NodeType_e More...

Enumerations
enum	c4::yml::NodeType_e : type_bits { c4::yml::NOTYPE = 0 , c4::yml::KEY = __(0) , c4::yml::VAL = __(1) , c4::yml::MAP = __(2) , c4::yml::SEQ = __(3) , c4::yml::DOC = __(4) , c4::yml::STREAM = __(5)\|SEQ , c4::yml::KEYREF = __(6) , c4::yml::VALREF = __(7) , c4::yml::KEYANCH = __(8) , c4::yml::VALANCH = __(9) , c4::yml::KEYTAG = __(10) , c4::yml::VALTAG = __(11) , c4::yml::KEYNIL = __(12) , c4::yml::VALNIL = __(13) , c4::yml::_TYMASK = __(14)-1 , c4::yml::KEY_UNFILT = __(14) , c4::yml::VAL_UNFILT = __(15) , c4::yml::FLOW_SL = __(16) , c4::yml::FLOW_ML = __(17) , c4::yml::BLOCK = __(18) , c4::yml::KEY_LITERAL = __(19) , c4::yml::VAL_LITERAL = __(20) , c4::yml::KEY_FOLDED = __(21) , c4::yml::VAL_FOLDED = __(22) , c4::yml::KEY_SQUO = __(23) , c4::yml::VAL_SQUO = __(24) , c4::yml::KEY_DQUO = __(25) , c4::yml::VAL_DQUO = __(26) , c4::yml::KEY_PLAIN = __(27) , c4::yml::VAL_PLAIN = __(28) , c4::yml::KEYVAL = KEY\|VAL , c4::yml::KEYSEQ = KEY\|SEQ , c4::yml::KEYMAP = KEY\|MAP , c4::yml::DOCMAP = DOC\|MAP , c4::yml::DOCSEQ = DOC\|SEQ , c4::yml::DOCVAL = DOC\|VAL , c4::yml::SCALAR_LITERAL = KEY_LITERAL\|VAL_LITERAL , c4::yml::SCALAR_FOLDED = KEY_FOLDED\|VAL_FOLDED , c4::yml::SCALAR_SQUO = KEY_SQUO\|VAL_SQUO , c4::yml::SCALAR_DQUO = KEY_DQUO\|VAL_DQUO , c4::yml::SCALAR_PLAIN = KEY_PLAIN\|VAL_PLAIN , c4::yml::KEYQUO = KEY_SQUO\|KEY_DQUO\|KEY_FOLDED\|KEY_LITERAL , c4::yml::VALQUO = VAL_SQUO\|VAL_DQUO\|VAL_FOLDED\|VAL_LITERAL , c4::yml::KEY_STYLE = KEY_LITERAL\|KEY_FOLDED\|KEY_SQUO\|KEY_DQUO\|KEY_PLAIN , c4::yml::VAL_STYLE = VAL_LITERAL\|VAL_FOLDED\|VAL_SQUO\|VAL_DQUO\|VAL_PLAIN , c4::yml::SCALAR_STYLE = KEY_STYLE\|VAL_STYLE , c4::yml::CONTAINER_STYLE_FLOW = FLOW_SL\|FLOW_ML , c4::yml::CONTAINER_STYLE_BLOCK = BLOCK , c4::yml::CONTAINER_STYLE = FLOW_SL\|FLOW_ML\|BLOCK , c4::yml::STYLE = SCALAR_STYLE \| CONTAINER_STYLE , c4::yml::_KEYMASK = KEY \| KEYQUO \| KEYANCH \| KEYREF \| KEYTAG , c4::yml::_VALMASK = VAL \| VALQUO \| VALANCH \| VALREF \| VALTAG }
	a bit mask for marking node types and styles More...

Functions
constexpr C4_CONST NodeType_e	c4::yml::operator\| (NodeType_e lhs, NodeType_e rhs) noexcept

constexpr C4_CONST NodeType_e	c4::yml::operator& (NodeType_e lhs, NodeType_e rhs) noexcept

constexpr C4_CONST NodeType_e	c4::yml::operator>> (NodeType_e bits, uint32_t n) noexcept

constexpr C4_CONST NodeType_e	c4::yml::operator<< (NodeType_e bits, uint32_t n) noexcept

constexpr C4_CONST NodeType_e	c4::yml::operator~ (NodeType_e bits) noexcept

NodeType_e &	c4::yml::operator&= (NodeType_e &subject, NodeType_e bits) noexcept

NodeType_e &	c4::yml::operator\|= (NodeType_e &subject, NodeType_e bits) noexcept

scalar style helpers
NodeType_e	c4::yml::scalar_style_choose_flow (csubstr scalar) noexcept
	choose a YAML scalar style based on the scalar's contents, while in flow mode. More...

NodeType_e	c4::yml::scalar_style_choose_block (csubstr scalar) noexcept
	choose a YAML scalar style based on the scalar's contents, while in block mode. More...

NodeType_e	c4::yml::scalar_style_choose (csubstr s, bool flow=true) noexcept
	choose a YAML emitting style based on the scalar's contents. More...

NodeType_e	c4::yml::scalar_style_choose_json (csubstr scalar) noexcept
	choose a json scalar style based on the scalar's contents More...

bool	c4::yml::scalar_style_query_squo (csubstr s) noexcept
	query whether a scalar can be encoded using single quotes. More...

bool	c4::yml::scalar_style_query_plain_flow (csubstr s) noexcept
	query whether a scalar can be encoded using plain style while in flow mode. More...

bool	c4::yml::scalar_style_query_plain_block (csubstr s) noexcept
	query whether a scalar can be encoded using plain style while in block mode. More...

bool	c4::yml::scalar_style_query_plain (csubstr s, bool flow=true) noexcept
	query whether a scalar can be encoded using plain style. More...

bool	c4::yml::scalar_is_null (csubstr s) noexcept
	YAML-sense query of nullity. More...

Detailed Description

Typedef Documentation

◆ type_bits

using c4::yml::type_bits = typedef uint32_t

the integral type necessary to cover all the bits for NodeType_e

Definition at line 30 of file node_type.hpp.

Enumeration Type Documentation

◆ NodeType_e

enum c4::yml::NodeType_e : type_bits

a bit mask for marking node types and styles

Enumerator
NOTYPE	no node type or style is set
KEY	is member of a map
VAL	a scalar: has a scalar (ie string) value, possibly empty. must be a leaf node, and cannot be MAP or SEQ
MAP	a map: a parent of KEYVAL/KEYSEQ/KEYMAP nodes
SEQ	a seq: a parent of VAL/SEQ/MAP nodes
DOC	a document
STREAM	a stream: a seq of docs
KEYREF	a *reference: the key references an &anchor
VALREF	a *reference: the val references an &anchor
KEYANCH	the key has an &anchor
VALANCH	the val has an &anchor
KEYTAG	the key has a tag
VALTAG	the val has a tag
KEYNIL	the key is null (eg `{ : b}` results in a null key)
VALNIL	the val is null (eg `{a : }` results in a null val)
_TYMASK	all the bits up to here
KEY_UNFILT	the key scalar was left unfiltered; the parser was set not to filter. See also ParserOptions
VAL_UNFILT	the val scalar was left unfiltered; the parser was set not to filter. See also ParserOptions
FLOW_SL	mark container with single-line flow style (seqs as '[val1,val2], maps as '{key: val,key2: val2}')
FLOW_ML	mark container with multi-line flow style (seqs as '[ val1, val2 ], maps as '{ key: val, key2: val2 }')
BLOCK	mark container with block style (seqs as '- val ', maps as 'key: val')
KEY_LITERAL	mark key scalar as multiline, block literal \|
VAL_LITERAL	mark val scalar as multiline, block literal \|
KEY_FOLDED	mark key scalar as multiline, block folded >
VAL_FOLDED	mark val scalar as multiline, block folded >
KEY_SQUO	mark key scalar as single quoted '
VAL_SQUO	mark val scalar as single quoted '
KEY_DQUO	mark key scalar as double quoted "
VAL_DQUO	mark val scalar as double quoted "
KEY_PLAIN	mark key scalar as plain scalar (unquoted, even when multiline)
VAL_PLAIN	mark val scalar as plain scalar (unquoted, even when multiline)
KEYVAL
KEYSEQ
KEYMAP
DOCMAP
DOCSEQ
DOCVAL
SCALAR_LITERAL
SCALAR_FOLDED
SCALAR_SQUO
SCALAR_DQUO
SCALAR_PLAIN
KEYQUO	key style is one of ', ", > or \|
VALQUO	val style is one of ', ", > or \|
KEY_STYLE	mask of all the scalar styles for key (not container styles!)
VAL_STYLE	mask of all the scalar styles for val (not container styles!)
SCALAR_STYLE
CONTAINER_STYLE_FLOW
CONTAINER_STYLE_BLOCK
CONTAINER_STYLE
STYLE
_KEYMASK
_VALMASK

Definition at line 34 of file node_type.hpp.

              : type_bits { // NOLINT
     #define __(v) (type_bits(1) << v) // a convenience define, undefined below // NOLINT
     NOTYPE  = 0,         ///< no node type or style is set
     KEY     = __(0),     ///< is member of a map
     VAL     = __(1),     ///< a scalar: has a scalar (ie string) value, possibly empty. must be a leaf node, and cannot be MAP or SEQ
     MAP     = __(2),     ///< a map: a parent of KEYVAL/KEYSEQ/KEYMAP nodes
     SEQ     = __(3),     ///< a seq: a parent of VAL/SEQ/MAP nodes
     DOC     = __(4),     ///< a document
     STREAM  = __(5)|SEQ, ///< a stream: a seq of docs
     KEYREF  = __(6),     ///< a *reference: the key references an &anchor
     VALREF  = __(7),     ///< a *reference: the val references an &anchor
     KEYANCH = __(8),     ///< the key has an &anchor
     VALANCH = __(9),     ///< the val has an &anchor
     KEYTAG  = __(10),    ///< the key has a tag
     VALTAG  = __(11),    ///< the val has a tag
     KEYNIL  = __(12),    ///< the key is null (eg `{ : b}` results in a null key)
     VALNIL  = __(13),    ///< the val is null (eg `{a : }` results in a null val)
     _TYMASK = __(14)-1,  ///< all the bits up to here
     //
     // unfiltered flags:
     //
     KEY_UNFILT  = __(14), ///< the key scalar was left unfiltered; the parser was set not to filter. @see ParserOptions
     VAL_UNFILT  = __(15), ///< the val scalar was left unfiltered; the parser was set not to filter. @see ParserOptions
     //
     // style flags:
     //
     FLOW_SL     = __(16), ///< mark container with single-line flow style (seqs as '[val1,val2], maps as '{key: val,key2: val2}')
     FLOW_ML     = __(17), ///< mark container with multi-line flow style (seqs as '[\n  val1,\n  val2\n], maps as '{\n  key: val,\n  key2: val2\n}')
     BLOCK       = __(18), ///< mark container with block style (seqs as '- val\n', maps as 'key: val')
     KEY_LITERAL = __(19), ///< mark key scalar as multiline, block literal |
     VAL_LITERAL = __(20), ///< mark val scalar as multiline, block literal |
     KEY_FOLDED  = __(21), ///< mark key scalar as multiline, block folded >
     VAL_FOLDED  = __(22), ///< mark val scalar as multiline, block folded >
     KEY_SQUO    = __(23), ///< mark key scalar as single quoted '
     VAL_SQUO    = __(24), ///< mark val scalar as single quoted '
     KEY_DQUO    = __(25), ///< mark key scalar as double quoted "
     VAL_DQUO    = __(26), ///< mark val scalar as double quoted "
     KEY_PLAIN   = __(27), ///< mark key scalar as plain scalar (unquoted, even when multiline)
     VAL_PLAIN   = __(28), ///< mark val scalar as plain scalar (unquoted, even when multiline)
     //
     // type combination masks:
     //
     KEYVAL  = KEY|VAL,
     KEYSEQ  = KEY|SEQ,
     KEYMAP  = KEY|MAP,
     DOCMAP  = DOC|MAP,
     DOCSEQ  = DOC|SEQ,
     DOCVAL  = DOC|VAL,
     //
     // style combination masks:
     //
     SCALAR_LITERAL = KEY_LITERAL|VAL_LITERAL,
     SCALAR_FOLDED  = KEY_FOLDED|VAL_FOLDED,
     SCALAR_SQUO    = KEY_SQUO|VAL_SQUO,
     SCALAR_DQUO    = KEY_DQUO|VAL_DQUO,
     SCALAR_PLAIN   = KEY_PLAIN|VAL_PLAIN,
     KEYQUO         = KEY_SQUO|KEY_DQUO|KEY_FOLDED|KEY_LITERAL, ///< key style is one of ', ", > or |
     VALQUO         = VAL_SQUO|VAL_DQUO|VAL_FOLDED|VAL_LITERAL, ///< val style is one of ', ", > or |
     KEY_STYLE      = KEY_LITERAL|KEY_FOLDED|KEY_SQUO|KEY_DQUO|KEY_PLAIN, ///< mask of all the scalar styles for key (not container styles!)
     VAL_STYLE      = VAL_LITERAL|VAL_FOLDED|VAL_SQUO|VAL_DQUO|VAL_PLAIN, ///< mask of all the scalar styles for val (not container styles!)
     SCALAR_STYLE   = KEY_STYLE|VAL_STYLE,
     CONTAINER_STYLE_FLOW  = FLOW_SL|FLOW_ML,
     CONTAINER_STYLE_BLOCK = BLOCK,
     CONTAINER_STYLE       = FLOW_SL|FLOW_ML|BLOCK,
     STYLE          = SCALAR_STYLE | CONTAINER_STYLE,
     //
     // mixed masks
     _KEYMASK = KEY | KEYQUO | KEYANCH | KEYREF | KEYTAG,
     _VALMASK = VAL | VALQUO | VALANCH | VALREF | VALTAG,
     #undef __
 } NodeType_e;

Function Documentation

◆ operator|()

constexpr C4_CONST NodeType_e c4::yml::operator\|	(	NodeType_e	lhs,
		NodeType_e	rhs
	)

inlineconstexprnoexcept

Definition at line 106 of file node_type.hpp.

106 { return (NodeType_e)(((type_bits)lhs) | ((type_bits)rhs)); }

◆ operator&()

constexpr C4_CONST NodeType_e c4::yml::operator&	(	NodeType_e	lhs,
		NodeType_e	rhs
	)

inlineconstexprnoexcept

Definition at line 107 of file node_type.hpp.

107 { return (NodeType_e)(((type_bits)lhs) & ((type_bits)rhs)); }

◆ operator>>()

constexpr C4_CONST NodeType_e c4::yml::operator>>	(	NodeType_e	bits,
		uint32_t	n
	)

inlineconstexprnoexcept

Definition at line 108 of file node_type.hpp.

108 { return (NodeType_e)(((type_bits)bits) >> n); }

◆ operator<<()

constexpr C4_CONST NodeType_e c4::yml::operator<<	(	NodeType_e	bits,
		uint32_t	n
	)

inlineconstexprnoexcept

Definition at line 109 of file node_type.hpp.

109 { return (NodeType_e)(((type_bits)bits) << n); }

◆ operator~()

constexpr C4_CONST NodeType_e c4::yml::operator~ ( NodeType_e bits )

inlineconstexprnoexcept

Definition at line 110 of file node_type.hpp.

110 { return (NodeType_e)(~(type_bits)bits); }

◆ operator&=()

NodeType_e& c4::yml::operator&=	(	NodeType_e &	subject,
		NodeType_e	bits
	)

inlinenoexcept

Definition at line 111 of file node_type.hpp.

111 { subject = (NodeType_e)((type_bits)subject & (type_bits)bits); return subject; }

◆ operator|=()

NodeType_e& c4::yml::operator\|=	(	NodeType_e &	subject,
		NodeType_e	bits
	)

inlinenoexcept

Definition at line 112 of file node_type.hpp.

112 { subject = (NodeType_e)((type_bits)subject | (type_bits)bits); return subject; }

◆ scalar_style_choose_flow()

NodeType_e c4::yml::scalar_style_choose_flow ( csubstr scalar )

noexcept

choose a YAML scalar style based on the scalar's contents, while in flow mode.

Plain scalars [have more constraints in flow mode than in block mode](https://www.yaml.info/learn/quote.html#noplain). scalar_style_choose_block() is the block mode analogous function.

Definition at line 262 of file node_type.cpp.

 {
     if(s.len)
     {
         if(scalar_style_query_plain_flow(s))
             return SCALAR_PLAIN;
         else if(scalar_style_query_squo(s))
             return SCALAR_SQUO;
         return SCALAR_DQUO;
     }
     return s.str ? SCALAR_SQUO : SCALAR_PLAIN;
 }

◆ scalar_style_choose_block()

NodeType_e c4::yml::scalar_style_choose_block ( csubstr scalar )

noexcept

choose a YAML scalar style based on the scalar's contents, while in block mode.

Plain scalars [have more constraints in flow mode than in block mode](https://www.yaml.info/learn/quote.html#noplain). scalar_style_choose_block() is the flow mode analogous function.

Definition at line 275 of file node_type.cpp.

 {
     if(s.len)
     {
         if(scalar_style_query_plain_block(s))
             return SCALAR_PLAIN;
         _RYML_ASSERT_BASIC(scalar_style_query_squo(s)
                            && "if this assertion fires, please submit an issue!");
         return SCALAR_SQUO;
     }
     return s.str ? SCALAR_SQUO : SCALAR_PLAIN;
 }

◆ scalar_style_choose()

NodeType_e c4::yml::scalar_style_choose	(	csubstr	s,
		bool	flow = `true`
	)

inlinenoexcept

choose a YAML emitting style based on the scalar's contents.

Legacy compatibility function: assumes flow mode which is more constraining, and delegates to either scalar_style_choose_flow() or scalar_style_choose_block().

Definition at line 273 of file node_type.hpp.

 {
     return flow ? scalar_style_choose_flow(s) : scalar_style_choose_block(s);
 }

◆ scalar_style_choose_json()

NodeType_e c4::yml::scalar_style_choose_json ( csubstr s )

noexcept

choose a json scalar style based on the scalar's contents

Definition at line 359 of file node_type.cpp.

 {
     // do not quote numbers or special scalars
     return json_is_plain_number(s) || json_is_special_scalar(s) ? SCALAR_PLAIN : SCALAR_DQUO;
 }

◆ scalar_style_query_squo()

bool c4::yml::scalar_style_query_squo ( csubstr s )

noexcept

query whether a scalar can be encoded using single quotes.

It may not be possible, notably when there is leading whitespace after a newline.

Definition at line 138 of file node_type.cpp.

 {
     // cannot have leading whitespace after a newline
     for(size_t i = 0; i < s.len; ++i)
     {
         if(s.str[i] == '\n' && i + 1 < s.len)
         {
             char next = s.str[i + 1];
             if(next == ' ' || next == '\t')
                 return false;
         }
     }
     return true;
 }

◆ scalar_style_query_plain_flow()

bool c4::yml::scalar_style_query_plain_flow ( csubstr s )

noexcept

query whether a scalar can be encoded using plain style while in flow mode.

Plain scalars [have more constraints in flow mode than in block mode](https://www.yaml.info/learn/quote.html#noplain). scalar_style_query_plain_block() is the block mode analogous function.

Definition at line 171 of file node_type.cpp.

 {
     if(!s.len)
         return !s.str;
     // first
     switch(s.str[0])
     {
     case ' ': case '\n': case '\t': case '\r':
     case '!': case '&': case '*': case ',':
     case '"': case '\'': case '|': case '>':
     case '{': case '}': case '[': case ']':
     case '#': case '`': case '%': case '@':
         return false;
     case '-': case ':': case '?':
         if(s.len == 1 || (s.str[1] == ' ' || s.str[1] == '\t'))
             return false;
         break;
     }
     // bulk
     for(size_t i = 1; i + 1 < s.len; ++i)
     {
         switch(s.str[i])
         {
         case ',': case '{': case '}': case '[': case ']':
             return false;
         case ':': case '#':
             if(!_is_valid_bulk(s, i))
                 return false;
             break;
         }
     }
     // last
     if(s.len > 1)
     {
         switch(s.back())
         {
         case ' ': case '\n': case '\t': case '\r':
         case ',':
         case '{': case '}':
         case '[': case ']':
         case '#':
         case ':':
             return false;
         }
     }
     return true;
 }

◆ scalar_style_query_plain_block()

bool c4::yml::scalar_style_query_plain_block ( csubstr s )

noexcept

query whether a scalar can be encoded using plain style while in block mode.

Plain scalars [have more constraints in flow mode than in block mode](https://www.yaml.info/learn/quote.html#noplain). scalar_style_query_plain_flow() is the flow mode analogous function.

Definition at line 219 of file node_type.cpp.

 {
     if(!s.len)
         return !s.str;
     // first
     switch(s.str[0])
     {
     case ' ': case '\n': case '\t': case '\r':
     case '!': case '&': case '*': case ',':
     case '"': case '\'': case '|': case '>':
     case '{': case '}': case '[': case ']':
     case '#': case '`': case '%': case '@':
         return false;
     case '-': case ':': case '?':
         if (s.len == 1 || (s.str[1] == ' ' || s.str[1] == '\t'))
             return false;
         break;
     }
     // bulk
     for(size_t i = 1; i + 1 < s.len; ++i)
     {
         switch(s.str[i])
         {
         case ':': case '#':
             if(!_is_valid_bulk(s, i))
                 return false;
             break;
         }
     }
     // last
     if(s.len > 1)
     {
         switch(s.back())
         {
         case ' ': case '\n': case '\t': case '\r':
         case '#':
         case ':':
             return false;
         }
     }
     return true;
 }

◆ scalar_style_query_plain()

bool c4::yml::scalar_style_query_plain	(	csubstr	s,
		bool	flow = `true`
	)

inlinenoexcept

query whether a scalar can be encoded using plain style.

Legacy compatibility function: assumes flow mode which is more constraining, and delegates to either scalar_style_query_plain_flow() or scalar_style_query_plain_block().

Definition at line 314 of file node_type.hpp.

 {
     return flow ? scalar_style_query_plain_flow(s) : scalar_style_query_plain_block(s);
 }

◆ scalar_is_null()

bool c4::yml::scalar_is_null ( csubstr s )

noexcept

YAML-sense query of nullity.

returns true if the scalar points to nullptr or is otherwise equal to one of the strings "~","null","Null","NULL"

Definition at line 289 of file node_type.cpp.

 {
     return s.str == nullptr ||
         (s.len == 1 && (s.str[0] == '~')) ||
         (s.len == 4 && ((0 == memcmp("null", s.str, 4))
                         || (0 == memcmp("Null", s.str, 4))
                         || (0 == memcmp("NULL", s.str, 4))));
 }

Classes

Typedefs

Enumerations

Functions

scalar style helpers

Detailed Description

Typedef Documentation

◆ type_bits

Enumeration Type Documentation

◆ NodeType_e

Function Documentation

◆ operator|()

◆ operator&()

◆ operator>>()

◆ operator<<()

◆ operator~()

◆ operator&=()

◆ operator|=()

◆ scalar_style_choose_flow()

◆ scalar_style_choose_block()

◆ scalar_style_choose()

◆ scalar_style_choose_json()

◆ scalar_style_query_squo()

◆ scalar_style_query_plain_flow()

◆ scalar_style_query_plain_block()

◆ scalar_style_query_plain()

◆ scalar_is_null()