Node types

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

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_ML1 = __(17) ,   c4::yml::FLOW_MLN = __(18) , c4::yml::FLOW_SPC = __(19) , c4::yml::BLOCK = __(20) , c4::yml::KEY_LITERAL = __(21) ,   c4::yml::VAL_LITERAL = __(22) , c4::yml::KEY_FOLDED = __(23) , c4::yml::VAL_FOLDED = __(24) , c4::yml::KEY_SQUO = __(25) ,   c4::yml::VAL_SQUO = __(26) , c4::yml::KEY_DQUO = __(27) , c4::yml::VAL_DQUO = __(28) , c4::yml::KEY_PLAIN = __(29) ,   c4::yml::VAL_PLAIN = __(30) , 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 = KEYQUO|KEY_PLAIN , c4::yml::VAL_STYLE = VALQUO|VAL_PLAIN ,   c4::yml::SCALAR_STYLE = KEY_STYLE|VAL_STYLE , c4::yml::FLOW_MLX = FLOW_ML1|FLOW_MLN , c4::yml::CONTAINER_STYLE_FLOW = FLOW_SL|FLOW_MLX|FLOW_SPC , c4::yml::CONTAINER_STYLE_BLOCK = BLOCK ,   c4::yml::CONTAINER_STYLE = CONTAINER_STYLE_FLOW|CONTAINER_STYLE_BLOCK , c4::yml::STYLE = SCALAR_STYLE | CONTAINER_STYLE }
	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.
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.
NodeType_e	c4::yml::scalar_style_choose (csubstr s, bool flow=true) noexcept
	choose a YAML emitting style based on the scalar's contents.
NodeType_e	c4::yml::scalar_style_choose_json (csubstr scalar) noexcept
	choose a json scalar style based on the scalar's contents
bool	c4::yml::scalar_style_query_squo (csubstr s) noexcept
	query whether a scalar can be encoded using single quotes.
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.
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.
bool	c4::yml::scalar_style_query_plain (csubstr s, bool flow=true) noexcept
	query whether a scalar can be encoded using plain style.
bool	c4::yml::scalar_is_null (csubstr s) noexcept
	YAML-sense query of nullity.

Detailed Description

Typedef Documentation

type_bits

using c4::yml::type_bits = 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	the scalar to the left of : in a map's member
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::scalar_filtering()
VAL_UNFILT	the val scalar was left unfiltered; the parser was set not to filter. See also ParserOptions::scalar_filtering()
FLOW_SL	mark container with single-line flow style seqs as [val1,val2] when FLOW_SPC is not set, or [val1, val2] when FLOW_SPC is set (or EmitOptions::force_flow_spc() is set) maps as {key1: val1,key2: val2} when FLOW_SPC is not set, or {key1: val1, key2: val2} when FLOW_SPC is set (or EmitOptions::force_flow_spc() is set)
FLOW_ML1	mark container with multi-line flow style, 1 element per line seqs as [ val1, val2 ] maps as { key: val, key2: val2 }
FLOW_MLN	mark container with multi-line flow style, n elements per line, wrapped (as set by EmitOptions::max_cols()): seqs as [ val,val,... val,val,... val,val,... ... val ] when FLOW_SPC is not set, or [ val, val,... val, val,... val, val,... ... val ] when FLOW_SPC is set (or EmitOptions::force_flow_spc() is set) maps as { key: val,key: val,... key: val,key: val,... ... key: val } when FLOW_SPC is not set, or { key: val, key: val,... key: val, key: val,... ... key: val } when FLOW_SPC is set (or EmitOptions::force_flow_spc() is set)
FLOW_SPC	mark container with spaces after comma when in flow mode. Applies to both FLOW_SL and FLOW_MLN (but not to FLOW_ML1), and can be overriden globally by EmitOptions::force_flow_spc().
BLOCK	mark container with block style seqs as - val1 - val2 maps as key1: val1 key2: val2
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	mask of KEY|VAL
KEYSEQ	mask of KEY|SEQ
KEYMAP	mask of KEY|MAP
DOCMAP	mask of DOC|MAP
DOCSEQ	mask of DOC|SEQ
DOCVAL	mask of DOC|VAL
SCALAR_LITERAL	mask of KEY_LITERAL|VAL_LITERAL,
SCALAR_FOLDED	mask of KEY_FOLDED|VAL_FOLDED,
SCALAR_SQUO	mask of KEY_SQUO|VAL_SQUO,
SCALAR_DQUO	mask of KEY_DQUO|VAL_DQUO,
SCALAR_PLAIN	mask of KEY_PLAIN|VAL_PLAIN,
KEYQUO	key style is one of '">|. mask of KEY_SQUO|KEY_DQUO|KEY_FOLDED|KEY_LITERAL
VALQUO	val style is one of '">|. mask of VAL_SQUO|VAL_DQUO|VAL_FOLDED|VAL_LITERAL
KEY_STYLE	mask of KEYQUO|KEY_PLAIN : all the key scalar styles for key (not container styles!)
VAL_STYLE	mask of VALQUO|VAL_PLAIN : all the val scalar styles for val (not container styles!)
SCALAR_STYLE	mask of KEY_STYLE|VAL_STYLE : all the key+val scalar styles
FLOW_MLX	mask of FLOW_ML1|FLOW_MLN : all the flow multiline styles
CONTAINER_STYLE_FLOW	mask of FLOW_SL|FLOW_MLX|FLOW_SPC : all flow flags
CONTAINER_STYLE_BLOCK	alias to BLOCK
CONTAINER_STYLE	mask of CONTAINER_STYLE_FLOW|CONTAINER_STYLE_BLOCK : all container style flags
STYLE	mask of SCALAR_STYLE | CONTAINER_STYLE : all style flags

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),     ///< the scalar to the left of `:` in a map's member
    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 @ref ParserOptions::scalar_filtering()
    VAL_UNFILT  = __(15), ///< the val scalar was left unfiltered; the parser was set not to filter. @see @ref ParserOptions::scalar_filtering()
    //
    // style flags:
    //
    FLOW_SL     = __(16), ///< mark container with single-line flow style
                          ///<  - seqs as
                          ///<    @code{yaml}
                          ///<    [val1,val2]
                          ///<    @endcode
                          ///<    when @ref FLOW_SPC is not set, or
                          ///<    @code{yaml}
                          ///<    [val1, val2]
                          ///<    @endcode
                          ///<    when @ref FLOW_SPC is set (or @ref EmitOptions::force_flow_spc() is set)
                          ///<  - maps as
                          ///<    @code{yaml}
                          ///<    {key1: val1,key2: val2}
                          ///<    @endcode
                          ///<    when @ref FLOW_SPC is not set, or
                          ///<    @code{yaml}
                          ///<    {key1: val1, key2: val2}
                          ///<    @endcode
                          ///<    when @ref FLOW_SPC is set (or @ref EmitOptions::force_flow_spc() is set)
    FLOW_ML1    = __(17), ///< mark container with multi-line flow style, 1 element per line
                          ///<  - seqs as
                          ///<    @code{yaml}
                          ///<    [
                          ///<      val1,
                          ///<      val2
                          ///<    ]
                          ///<    @endcode
                          ///<  - maps as
                          ///<    @code{yaml}
                          ///<    {
                          ///<      key: val,
                          ///<      key2: val2
                          ///<    }
                          ///<    @endcode
    FLOW_MLN    = __(18), ///< mark container with multi-line flow style, n elements per line,
                          ///< wrapped (as set by @ref EmitOptions::max_cols()):
                          ///<  - seqs as
                          ///<    @code{yaml}
                          ///<    [
                          ///<      val,val,...
                          ///<      val,val,...
                          ///<      val,val,...
                          ///<      ...
                          ///<      val
                          ///<    ]
                          ///<    @endcode
                          ///<    when @ref FLOW_SPC is not set, or
                          ///<    @code{yaml}
                          ///<    [
                          ///<      val, val,...
                          ///<      val, val,...
                          ///<      val, val,...
                          ///<      ...
                          ///<      val
                          ///<    ]
                          ///<    @endcode
                          ///<    when @ref FLOW_SPC is set (or @ref EmitOptions::force_flow_spc() is set)
                          ///<  - maps as
                          ///<    @code{yaml}
                          ///<    {
                          ///<      key: val,key: val,...
                          ///<      key: val,key: val,...
                          ///<      ...
                          ///<      key: val
                          ///<    }
                          ///<    @endcode
                          ///<    when @ref FLOW_SPC is not set, or
                          ///<    @code{yaml}
                          ///<    {
                          ///<      key: val, key: val,...
                          ///<      key: val, key: val,...
                          ///<      ...
                          ///<      key: val
                          ///<    }
                          ///<    @endcode
                          ///<    when @ref FLOW_SPC is set (or @ref EmitOptions::force_flow_spc() is set)
    FLOW_SPC    = __(19), ///< mark container with spaces after comma when in flow mode.
                          ///< Applies to both @ref FLOW_SL and @ref FLOW_MLN (but not
                          ///< to @ref FLOW_ML1), and can be overriden globally by
                          ///< @ref EmitOptions::force_flow_spc().
    BLOCK       = __(20), ///< mark container with block style
                          ///<  - seqs as
                          ///<    @code{yaml}
                          ///<    - val1
                          ///<    - val2
                          ///<    @endcode
                          ///<  - maps as
                          ///<    @code{yaml}
                          ///<    key1: val1
                          ///<    key2: val2
                          ///<    @endcode
    KEY_LITERAL = __(21), ///< mark key scalar as multiline, block literal |
    VAL_LITERAL = __(22), ///< mark val scalar as multiline, block literal |
    KEY_FOLDED  = __(23), ///< mark key scalar as multiline, block folded >
    VAL_FOLDED  = __(24), ///< mark val scalar as multiline, block folded >
    KEY_SQUO    = __(25), ///< mark key scalar as single quoted '
    VAL_SQUO    = __(26), ///< mark val scalar as single quoted '
    KEY_DQUO    = __(27), ///< mark key scalar as double quoted "
    VAL_DQUO    = __(28), ///< mark val scalar as double quoted "
    KEY_PLAIN   = __(29), ///< mark key scalar as plain scalar (unquoted, even when multiline)
    VAL_PLAIN   = __(30), ///< mark val scalar as plain scalar (unquoted, even when multiline)
    //
    // type combination masks:
    //
    KEYVAL  = KEY|VAL, ///< mask of @ref KEY|@ref VAL
    KEYSEQ  = KEY|SEQ, ///< mask of @ref KEY|@ref SEQ
    KEYMAP  = KEY|MAP, ///< mask of @ref KEY|@ref MAP
    DOCMAP  = DOC|MAP, ///< mask of @ref DOC|@ref MAP
    DOCSEQ  = DOC|SEQ, ///< mask of @ref DOC|@ref SEQ
    DOCVAL  = DOC|VAL, ///< mask of @ref DOC|@ref VAL
    //
    // style combination masks:
    //
    SCALAR_LITERAL = KEY_LITERAL|VAL_LITERAL,  ///< mask of @ref KEY_LITERAL|@ref VAL_LITERAL,
    SCALAR_FOLDED  = KEY_FOLDED|VAL_FOLDED,  ///< mask of @ref KEY_FOLDED|@ref VAL_FOLDED,
    SCALAR_SQUO    = KEY_SQUO|VAL_SQUO,  ///< mask of @ref KEY_SQUO|@ref VAL_SQUO,
    SCALAR_DQUO    = KEY_DQUO|VAL_DQUO,  ///< mask of @ref KEY_DQUO|@ref VAL_DQUO,
    SCALAR_PLAIN   = KEY_PLAIN|VAL_PLAIN,  ///< mask of @ref KEY_PLAIN|@ref VAL_PLAIN,
    KEYQUO         = KEY_SQUO|KEY_DQUO|KEY_FOLDED|KEY_LITERAL, ///< key style is one of `'">|`. mask of @ref KEY_SQUO|@ref KEY_DQUO|@ref KEY_FOLDED|@ref KEY_LITERAL
    VALQUO         = VAL_SQUO|VAL_DQUO|VAL_FOLDED|VAL_LITERAL, ///< val style is one of `'">|`. mask of @ref VAL_SQUO|@ref VAL_DQUO|@ref VAL_FOLDED|@ref VAL_LITERAL
    KEY_STYLE      = KEYQUO|KEY_PLAIN, ///< mask of @ref KEYQUO|@ref KEY_PLAIN : all the key scalar styles for key (not container styles!)
    VAL_STYLE      = VALQUO|VAL_PLAIN, ///< mask of @ref VALQUO|@ref VAL_PLAIN : all the val scalar styles for val (not container styles!)
    SCALAR_STYLE   = KEY_STYLE|VAL_STYLE, ///< mask of @ref KEY_STYLE|@ref VAL_STYLE : all the key+val scalar styles
    FLOW_MLX       = FLOW_ML1|FLOW_MLN, ///< mask of @ref FLOW_ML1|@ref FLOW_MLN : all the flow multiline styles
    CONTAINER_STYLE_FLOW  = FLOW_SL|FLOW_MLX|FLOW_SPC, ///< mask of @ref FLOW_SL|@ref FLOW_MLX|@ref FLOW_SPC : all flow flags
    CONTAINER_STYLE_BLOCK = BLOCK, ///< alias to @ref BLOCK
    CONTAINER_STYLE       = CONTAINER_STYLE_FLOW|CONTAINER_STYLE_BLOCK, ///< mask of @ref CONTAINER_STYLE_FLOW|@ref CONTAINER_STYLE_BLOCK : all container style flags
    STYLE          = SCALAR_STYLE | CONTAINER_STYLE, ///< mask of @ref SCALAR_STYLE | @ref CONTAINER_STYLE : all style flags
    /** @cond dev */
    //
    // mixed masks
    _KEYMASK = KEY | KEYQUO | KEYANCH | KEYREF | KEYTAG,
    _VALMASK = VAL | VALQUO | VALANCH | VALREF | VALTAG,
    #undef __
    #if C4_CPP >= 17                                  \
        || (defined(__GNUC__) && __GNUC__ >= 6)       \
        || (defined(_MSC_VER) && !defined(__clang__))
    #define RYML_HAS_DEPRECATED_ENUMS__
    FLOW_ML RYML_DEPRECATED("use one of FLOW_ML{1,N,X}") = FLOW_ML1,
    #endif
    /** @endcond */
} NodeType_e;

Function Documentation

operator|()

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

inlineconstexprnoexcept

Definition at line 211 of file node_type.hpp.

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

operator&()

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

inlineconstexprnoexcept

Definition at line 212 of file node_type.hpp.

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

operator>>()

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

inlineconstexprnoexcept

Definition at line 213 of file node_type.hpp.

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

operator<<()

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

inlineconstexprnoexcept

Definition at line 214 of file node_type.hpp.

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

operator~()

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

inlineconstexprnoexcept

Definition at line 215 of file node_type.hpp.

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

operator&=()

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

inlinenoexcept

Definition at line 216 of file node_type.hpp.

{ 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 217 of file node_type.hpp.

{ 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 264 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 277 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 388 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 361 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 140 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 173 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 221 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 427 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 291 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))));
}