c4::yml Namespace Reference

Namespaces
namespace	detail
namespace	extra

Classes
struct	ReadResult
	A lightweight truthy type, used to enable reporting the offending node when a deserializing error happens in nested reads. More...
struct	Location
	holds a source or yaml file position, for example when an error is detected; See also location_format() and location_format_with_context(). More...
struct	ErrorDataBasic
	Data for a basic error. More...
struct	ErrorDataParse
	Data for a parse error. More...
struct	ErrorDataVisit
	Data for a visit error. More...
struct	Callbacks
	A c-style callbacks class to customize behavior on errors or allocation. More...
struct	EmitOptions
	A lightweight object containing options to be used when emitting. More...
struct	as_json
	tag type to mark a tree or node to be emitted as yaml when using operator<<, with options. More...
struct	as_yaml
	tag type to mark a tree or node to be emitted as yaml when using operator<< . More...
class	Emitter
	A YAML/JSON emitter, templated on a writer class such as WriterBuf, WriterFile, or WriterOStream. More...
struct	ExceptionBasic
	Exception thrown by the default basic error implementation. More...
struct	ExceptionParse
	Exception thrown by the default parse error implementation. More...
struct	ExceptionVisit
	Exception thrown by the default visit error implementation. More...
struct	escaped_scalar
	formatting helper to escape a scalar with escape_scalar_fn() More...
struct	EventHandlerStack
	Use this class a base of implementations of event handler to simplify the stack logic. More...
struct	EventHandlerTree
	The event handler to create a ryml Tree. More...
struct	FilterResult
	Result for filtering a scalar which not fit in the intended memory. More...
struct	FilterResultExtending
	Result for filtering a scalar which not fit in the intended memory. More...
struct	FilterProcessorSrcDst
	Filters an input string into a different output string. More...
struct	FilterProcessorInplaceEndExtending
	Filters in place. More...
struct	FilterProcessorInplaceMidExtending
	Filters in place. More...
class	ParseEngine
	This is the main driver of parsing logic: it scans the YAML or JSON source for tokens, and emits the appropriate sequence of parsing events to its event handler. More...
class	ConstNodeRef
	Holds a pointer to an existing tree, and a node id. More...
class	NodeRef
	A reference to a node in an existing yaml tree, offering a more convenient API than the index-based API used in the tree. More...
struct	NodeType
	Wraps a type_bits mask of NodeTypeBits flags with some syntactic sugar and predicates. More...
struct	ParserOptions
	Options to give to the ParseEngine to control its behavior. More...
struct	LineContents
	Helper to control the line contents while parsing a buffer. More...
struct	ParserState
struct	ReferenceResolver
	Reusable object to resolve references/aliases in a Tree. More...
struct	TagCache
	Accelerator structure to reduce memory requirements by enabling reuse of resolved tags. More...
struct	TagDirective
struct	TagDirectiveRange
struct	TagDirectives
struct	NodeScalar
	a node scalar is a csubstr, which may be tagged and anchored. More...
struct	NodeData
	contains the data for each YAML node. More...
class	Tree
struct	WriterBuf
	A writer to a memory buffer, in the form of a substr . More...
struct	WriterFile
	A writer that outputs to a C file handle, defaulting to stdout. More...
struct	WriterOStream
	A writer that outputs to an STL-like ostream. More...

Typedefs
using	id_type = RYML_ID_TYPE
	The type of a node id in the YAML tree; to override the default type, define the macro RYML_ID_TYPE to a suitable integer type.
typedef enum c4::yml::Encoding_	Encoding_e
using	pfn_allocate = void* (*)(size_t len, void* hint, void *user_data)
	the type of the function used to allocate memory; ryml will only allocate memory through this callback.
using	pfn_free = void (*)(void* mem, size_t size, void *user_data)
	the type of the function used to free memory; ryml will only free memory through this callback.
using	pfn_error_basic = void (*) (csubstr msg, ErrorDataBasic const& errdata, void *user_data)
	the type of the function used to report basic errors.
using	pfn_error_parse = void (*) (csubstr msg, ErrorDataParse const& errdata, void *user_data)
	the type of the function used to report parse errors.
using	pfn_error_visit = void (*) (csubstr msg, ErrorDataVisit const& errdata, void *user_data)
	the type of the function used to report visit errors.
using	EmitterBuf = Emitter<WriterBuf>
using	EmitterFile = Emitter<WriterFile>
template<class OStream>
using	EmitterOStream = Emitter<WriterOStream<OStream>>
using	Parser = ParseEngine<EventHandlerTree>
	This is the main ryml parser, where the parser events are handled to create a ryml tree (see Event Handlers).
using	type_bits = uint32_t
	the integral type necessary to cover all the bits for NodeType_e
using	ParserFlag_t = int
	data type for ParserState_e
using	tag_bits = uint16_t
	the integral type necessary to cover all the bits marking node tags

Enumerations
enum	: id_type { NONE = id_type(-1) }
enum	: size_t { npos = size_t(-1) }
enum	Encoding_ {   NOBOM , UTF8 , UTF16LE , UTF16BE ,   UTF32LE , UTF32BE }
enum	NodeTypeBits : type_bits {   NOTYPE = 0 , KEY = b_(0) , VAL = b_(1) , MAP = b_(2) ,   SEQ = b_(3) , DOC = b_(4) , STREAM = b_(5)|SEQ , KEYREF = b_(6) ,   VALREF = b_(7) , KEYANCH = b_(8) , VALANCH = b_(9) , KEYTAG = b_(10) ,   VALTAG = b_(11) , KEYNIL = b_(12) , VALNIL = b_(13) , TYMASK_ = b_(14)-1 ,   KEY_UNFILT = b_(14) , VAL_UNFILT = b_(15) , FLOW_SL = b_(16) , FLOW_ML1 = b_(17) ,   FLOW_MLN = b_(18) , FLOW_SPC = b_(19) , BLOCK = b_(20) , KEY_LITERAL = b_(21) ,   VAL_LITERAL = b_(22) , KEY_FOLDED = b_(23) , VAL_FOLDED = b_(24) , KEY_SQUO = b_(25) ,   VAL_SQUO = b_(26) , KEY_DQUO = b_(27) , VAL_DQUO = b_(28) , KEY_PLAIN = b_(29) ,   VAL_PLAIN = b_(30) , KEYVAL = KEY|VAL , KEYSEQ = KEY|SEQ , KEYMAP = KEY|MAP ,   DOCMAP = DOC|MAP , DOCSEQ = DOC|SEQ , DOCVAL = DOC|VAL , 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 , VALQUO = VAL_SQUO|VAL_DQUO|VAL_FOLDED|VAL_LITERAL , KEY_STYLE = KEYQUO|KEY_PLAIN , VAL_STYLE = VALQUO|VAL_PLAIN ,   SCALAR_STYLE = KEY_STYLE|VAL_STYLE , FLOW_MLX = FLOW_ML1|FLOW_MLN , CONTAINER_STYLE_FLOW = FLOW_SL|FLOW_MLX|FLOW_SPC , CONTAINER_STYLE_BLOCK = BLOCK ,   CONTAINER_STYLE = CONTAINER_STYLE_FLOW|CONTAINER_STYLE_BLOCK , STYLE = SCALAR_STYLE | CONTAINER_STYLE }
	a bit mask for marking node types and styles More...
enum	ParserState_e : ParserFlag_t {   RTOP = 0x01 << 0 , RUNK = 0x01 << 1 , RMAP = 0x01 << 2 , RSEQ = 0x01 << 3 ,   RFLOW = 0x01 << 4 , RBLCK = 0x01 << 5 , QMRK = 0x01 << 6 , RKEY = 0x01 << 7 ,   RVAL = 0x01 << 9 , RKCL = 0x01 << 8 , RNXT = 0x01 << 10 , SSCL = 0x01 << 11 ,   QSCL = 0x01 << 12 , RSET = 0x01 << 13 , RDOC = 0x01 << 14 , NDOC = 0x01 << 15 ,   USTY = 0x01 << 16 , RSEQIMAP = 0x01 << 17 }
	Enumeration of the state flags for the parser. More...
enum	YamlTag_e : tag_bits {   TAG_NONE = 0 , TAG_MAP = 1 , TAG_OMAP = 2 , TAG_PAIRS = 3 ,   TAG_SET = 4 , TAG_SEQ = 5 , TAG_BINARY = 6 , TAG_BOOL = 7 ,   TAG_FLOAT = 8 , TAG_INT = 9 , TAG_MERGE = 10 , TAG_NULL = 11 ,   TAG_STR = 12 , TAG_TIMESTAMP = 13 , TAG_VALUE = 14 , TAG_YAML = 15 }
	a bit mask for marking tags for types More...

Functions
void	set_callbacks (Callbacks const &c)
	set the global callbacks for the library; after a call to this function, these callbacks will be used by newly created objects (unless they are copying older objects with different callbacks).
Callbacks const &	get_callbacks ()
	get the global callbacks
void	reset_callbacks ()
	set the global callbacks back to their defaults.
void	err_basic (ErrorDataBasic const &errdata, const char *msg)
	trigger a basic error to its respective handler, with a non-formatted error message.
void	err_basic (Callbacks const &callbacks, ErrorDataBasic const &errdata, const char *msg_)
	trigger a basic error to its respective handler, with a non-formatted error message.
void	err_parse (ErrorDataParse const &errdata, const char *msg)
	trigger a parse error to its respective handler, with a non-formatted error message.
void	err_parse (Callbacks const &callbacks, ErrorDataParse const &errdata, const char *msg)
	trigger a parse error to its respective handler, with a non-formatted error message
void	err_visit (ErrorDataVisit const &errdata, const char *msg)
	trigger a visit error to its respective handler, with a non-formatted error message.
void	err_visit (Callbacks const &callbacks, ErrorDataVisit const &errdata, const char *msg)
	trigger a visit error to its respective handler, with a non-formatted error message
substr	emit_yaml (Tree const &t, EmitOptions const &opts, substr buf, bool error_on_excess=true)
	(1) emit YAML to the given buffer.
substr	emit_yaml (Tree const &t, substr buf, bool error_on_excess=true)
	(2) like (1), but use default emit options
substr	emit_json (Tree const &t, EmitOptions const &opts, substr buf, bool error_on_excess=true)
	(1) emit JSON to the given buffer.
substr	emit_json (Tree const &t, substr buf, bool error_on_excess=true)
	(2) like (1), but use default emit options
substr	emit_yaml (Tree const &t, id_type id, EmitOptions const &opts, substr buf, bool error_on_excess=true)
	(1) emit YAML to the given buffer.
substr	emit_yaml (Tree const &t, id_type id, substr buf, bool error_on_excess=true)
	(2) like (1), but use default emit options
substr	emit_json (Tree const &t, id_type id, EmitOptions const &opts, substr buf, bool error_on_excess=true)
	(1) emit JSON to the given buffer.
substr	emit_json (Tree const &t, id_type id, substr buf, bool error_on_excess=true)
	(2) like (1), but use default emit options
substr	emit_yaml (ConstNodeRef const &r, EmitOptions const &opts, substr buf, bool error_on_excess=true)
	(1) emit YAML to the given buffer.
substr	emit_yaml (ConstNodeRef const &r, substr buf, bool error_on_excess=true)
	(2) like (1), but use default emit options
substr	emit_json (ConstNodeRef const &r, EmitOptions const &opts, substr buf, bool error_on_excess=true)
	(1) emit JSON to the given buffer.
substr	emit_json (ConstNodeRef const &r, substr buf, bool error_on_excess=true)
	(2) like (1), but use default emit options
template<class CharOwningContainer>
substr	emitrs_yaml (Tree const &t, id_type id, EmitOptions const &opts, CharOwningContainer *cont, bool append=false)
	(1) emit+resize: emit YAML to the given std::string/std::vector<char>-like container, resizing it as needed to fit the emitted YAML.
template<class CharOwningContainer>
substr	emitrs_yaml (Tree const &t, id_type id, CharOwningContainer *cont, bool append=false)
	(2) like (1), but use default emit options
template<class CharOwningContainer>
substr	emitrs_json (Tree const &t, id_type id, EmitOptions const &opts, CharOwningContainer *cont, bool append=false)
	(1) emit+resize: emit JSON to the given std::string/std::vector<char>-like container, resizing it as needed to fit the emitted JSON.
template<class CharOwningContainer>
substr	emitrs_json (Tree const &t, id_type id, CharOwningContainer *cont, bool append=false)
	(2) like (1), but use default emit options
template<class CharOwningContainer>
CharOwningContainer	emitrs_yaml (Tree const &t, id_type id, EmitOptions const &opts={})
	(3) emit+resize: YAML to a newly-created std::string/std::vector<char>-like container.
template<class CharOwningContainer>
CharOwningContainer	emitrs_json (Tree const &t, id_type id, EmitOptions const &opts={})
	(3) emit+resize: JSON to a newly-created std::string/std::vector<char>-like container.
template<class CharOwningContainer>
substr	emitrs_yaml (Tree const &t, EmitOptions const &opts, CharOwningContainer *cont, bool append=false)
	(1) emit+resize: YAML to the given std::string/std::vector<char>-like container, resizing it as needed to fit the emitted YAML.
template<class CharOwningContainer>
substr	emitrs_yaml (Tree const &t, CharOwningContainer *cont, bool append=false)
	(2) like (1), but use default emit options
template<class CharOwningContainer>
substr	emitrs_json (Tree const &t, EmitOptions const &opts, CharOwningContainer *cont, bool append=false)
	(1) emit+resize: JSON to the given std::string/std::vector<char>-like container, resizing it as needed to fit the emitted JSON.
template<class CharOwningContainer>
substr	emitrs_json (Tree const &t, CharOwningContainer *cont, bool append=false)
	(2) like (1), but use default emit options
template<class CharOwningContainer>
CharOwningContainer	emitrs_yaml (Tree const &t, EmitOptions const &opts={})
	(3) emit+resize: YAML to a newly-created std::string/std::vector<char>-like container.
template<class CharOwningContainer>
CharOwningContainer	emitrs_json (Tree const &t, EmitOptions const &opts={})
	(3) emit+resize: JSON to a newly-created std::string/std::vector<char>-like container.
template<class CharOwningContainer>
substr	emitrs_yaml (ConstNodeRef const &n, EmitOptions const &opts, CharOwningContainer *cont, bool append=false)
	(1) emit+resize: YAML to the given std::string/std::vector<char>-like container, resizing it as needed to fit the emitted YAML.
template<class CharOwningContainer>
substr	emitrs_yaml (ConstNodeRef const &n, CharOwningContainer *cont, bool append=false)
	(2) like (1), but use default emit options
template<class CharOwningContainer>
substr	emitrs_json (ConstNodeRef const &n, EmitOptions const &opts, CharOwningContainer *cont, bool append=false)
	(1) emit+resize: JSON to the given std::string/std::vector<char>-like container, resizing it as needed to fit the emitted JSON.
template<class CharOwningContainer>
substr	emitrs_json (ConstNodeRef const &n, CharOwningContainer *cont, bool append=false)
	(2) like (1), but use default emit options
template<class CharOwningContainer>
CharOwningContainer	emitrs_yaml (ConstNodeRef const &n, EmitOptions const &opts={})
	(3) emit+resize: YAML to a newly-created std::string/std::vector<char>-like container.
template<class CharOwningContainer>
CharOwningContainer	emitrs_json (ConstNodeRef const &n, EmitOptions const &opts={})
	(3) emit+resize: JSON to a newly-created std::string/std::vector<char>-like container.
void	emit_yaml (Tree const &t, EmitOptions const &opts, FILE *f=nullptr)
	(1) emit YAML to the given file, starting at the root node.
void	emit_yaml (Tree const &t, FILE *f=nullptr)
	(2) like (1), but use default emit options
void	emit_json (Tree const &t, EmitOptions const &opts, FILE *f=nullptr)
	(1) emit JSON to the given file.
void	emit_json (Tree const &t, FILE *f=nullptr)
	(2) like (1), but use default emit options
void	emit_yaml (Tree const &t, id_type id, EmitOptions const &opts, FILE *f)
	(1) emit YAML to the given file, starting at the given node.
void	emit_yaml (Tree const &t, id_type id, FILE *f)
	(2) like (1), but use default emit options
void	emit_json (Tree const &t, id_type id, EmitOptions const &opts, FILE *f)
	(1) emit JSON to the given file, starting at the given node.
void	emit_json (Tree const &t, id_type id, FILE *f)
	(2) like (1), but use default emit options
void	emit_yaml (ConstNodeRef const &r, EmitOptions const &opts, FILE *f=nullptr)
	(1) emit YAML to the given file.
void	emit_yaml (ConstNodeRef const &r, FILE *f=nullptr)
	(2) like (1), but use default emit options
void	emit_json (ConstNodeRef const &r, EmitOptions const &opts, FILE *f=nullptr)
	(1) emit JSON to the given file.
void	emit_json (ConstNodeRef const &r, FILE *f=nullptr)
	(2) like (1), but use default emit options
template<class OStream>
OStream &	operator<< (OStream &stream, Tree const &tree)
	emit YAML to an STL-like ostream
template<class OStream>
OStream &	operator<< (OStream &stream, ConstNodeRef const &node)
	emit YAML to an STL-like ostream This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<class OStream>
OStream &	operator<< (OStream &stream, as_json const &json_spec)
	emit JSON to an STL-like ostream
template<class OStream>
OStream &	operator<< (OStream &stream, as_yaml const &yaml_spec)
	emit YAML to an STL-like ostream
template<class DumpFn>
size_t	location_format (DumpFn &&dumpfn, Location const &loc)
	generic formatting of a location
template<class DumpFn>
void	location_format_with_context (DumpFn &&dumpfn, Location const &location, csubstr source_buffer, csubstr call="", size_t num_lines_before=3, size_t num_lines_after=0, size_t first_col_highlight=0, size_t last_col_highlight=0, size_t maxlen=80u)
	Generic formatting of a location, printing the source code buffer region around the location.
template<class DumpFn>
void	err_basic_format (DumpFn &&dumpfn, csubstr msg, ErrorDataBasic const &errdata)
	Given an error message and associated basic error data, format it fully as a basic error message.
template<class DumpFn>
void	err_parse_format (DumpFn &&dumpfn, csubstr msg, ErrorDataParse const &errdata)
	Given an error message and associated parse error data, format it fully as a parse error message.
template<class DumpFn>
void	err_visit_format (DumpFn &&dumpfn, csubstr msg, ErrorDataVisit const &errdata)
	Given an error message and associated visit error data, format it fully as a visit error message.
template<class ... Args>
void	err_basic (Callbacks const &callbacks, ErrorDataBasic const &errdata, const char *fmt, Args const &...args)
	trigger a basic error to its respective handler, with a formatted error message.
template<class ... Args>
void	err_basic (ErrorDataBasic const &errdata, const char *fmt, Args const &...args)
	trigger a basic error to its respective handler, with a formatted error message.
template<class ... Args>
void	err_parse (Callbacks const &callbacks, ErrorDataParse const &errdata, const char *fmt, Args const &...args)
	trigger a parse error to its respective handler, with a formatted error message
template<class ... Args>
void	err_parse (ErrorDataParse const &errdata, const char *fmt, Args const &...args)
	trigger a parse error to its respective handler, with a formatted error message.
template<class ... Args>
void	err_visit (Callbacks const &callbacks, ErrorDataVisit const &errdata, const char *fmt, Args const &...args)
	trigger a visit error to its respective handler, with a formatted error message
template<class ... Args>
void	err_visit (ErrorDataVisit const &errdata, const char *fmt, Args const &...args)
	trigger a visit error to its respective handler, with a formatted error message.
template<class CharContainer>
void	format_exc (CharContainer *out, ExceptionBasic const &exc)
	Format a basic exception to an existing char container.
template<class CharContainer>
void	format_exc (CharContainer *out, ExceptionParse const &exc)
	Format a parse exception to an existing char container.
template<class CharContainer>
void	format_exc (CharContainer *out, ExceptionVisit const &exc)
	Format a visit exception to an existing char container.
template<class CharContainer, class ExceptionT>
CharContainer	format_exc (ExceptionT const &exc)
	Format a parse exception, and return a newly-created char container.
template<class Fn>
void	escape_scalar_fn (Fn &&fn, csubstr scalar, bool keep_newlines=false)
	Iterate through a scalar and escape special characters in it.
size_t	adjust_pos_with_escapes (csubstr scalar, size_t pos, bool keep_newlines=false)
	Adjust a position in a scalar, increasing it to account for any escaped characters.
size_t	escape_scalar (substr buffer, csubstr scalar, bool keep_newlines=false)
	Escape a scalar to an existing buffer, using escape_scalar_fn.
size_t	to_chars (substr buf, escaped_scalar e)
	formatting implementation to escape a scalar with escape_scalar()
template<class SinkPfn>
size_t	dump (SinkPfn &&sinkfn, substr buf, escaped_scalar const &e)
	dumping implementation to escape a scalar with escape_scalar_fn()
void	file_put_contents (void const *buf, size_t sz, FILE *file, const char *filename=nullptr)
	save a contiguous buffer into a file
template<class ContiguousContainer>
void	file_put_contents (ContiguousContainer const &v, FILE *file, const char *filename=nullptr)
	save a contiguous buffer into a file
void	file_put_contents (void const *buf, size_t sz, const char *filename, const char *access="wb")
	save a contiguous buffer into a file
template<class ContiguousContainer>
void	file_put_contents (ContiguousContainer const &v, const char *filename, const char *access="wb")
	save a contiguous buffer into a file
void	file_get_contents (const char *filename, FILE *fp, size_t filesz, void *buf, size_t bufsz)
	load a file of specified size from disk into an existing contiguous buffer.
size_t	file_get_contents (const char *filename, FILE *fp, void *buf, size_t bufsz)
	load a file from disk into an existing contiguous buffer.
size_t	file_get_contents (const char *filename, void *buf, size_t bufsz, const char *access="rb")
	load a file from disk into an existing contiguous buffer.
template<class ContiguousContainer>
void	file_get_contents (ContiguousContainer *v, const char *filename, const char *access="rb")
	load a file from disk into an existing ContiguousContainer, resizing it to fit the file's contents
template<class ContiguousContainer>
ContiguousContainer	file_get_contents (const char *filename, const char *access="rb")
	load a file from disk and return a newly created ContiguousContainer with the file contents
template<class ContiguousContainer>
void	stdin_get_contents (ContiguousContainer *cont, FILE *f=stdin)
	load a file from stdin (or similar stream-like file) and return a newly created ContiguousContainer with the file contents
template<class ContiguousContainer>
ContiguousContainer	stdin_get_contents (FILE *f=stdin)
	load a file from stdin and return a newly created ContiguousContainer with the file contents
template<class T>
ReadResult	read (ConstNodeRef const &n, T *v)
template<class T>
ReadResult	read (ConstNodeRef const &n, T const &wrapper)
template<class T>
ReadResult	read_key (ConstNodeRef const &n, T *v)
template<class T>
ReadResult	read_key (ConstNodeRef const &n, T const &wrapper)
template<class T>
void	write (NodeRef *n, T const &v)
template<class T>
void	write_key (NodeRef *n, T const &v)
template<class T>
void	write (NodeRef &n, T const &v)
template<class T>
void	write_key (NodeRef &n, T const &v)
void	parse_in_place (Parser *parser, csubstr filename, substr yaml, Tree *t, id_type node_id)
	(1) parse YAML into an existing tree node.
void	parse_in_place (Parser *parser, substr yaml, Tree *t, id_type node_id)
	(2) like (1) but no filename will be reported
void	parse_in_place (Parser *parser, csubstr filename, substr yaml, Tree *t)
	(3) parse YAML into the root node of an existing tree.
void	parse_in_place (Parser *parser, substr yaml, Tree *t)
	(4) like (3) but no filename will be reported
void	parse_in_place (Parser *parser, csubstr filename, substr yaml, NodeRef node)
	(5) like (1) but the node is given as a NodeRef
void	parse_in_place (Parser *parser, substr yaml, NodeRef node)
	(6) like (5) but no filename will be reported
Tree	parse_in_place (Parser *parser, csubstr filename, substr yaml)
	(7) create a new tree, and parse YAML into its root node.
Tree	parse_in_place (Parser *parser, substr yaml)
	(8) like (7) but no filename will be reported
void	parse_in_place (csubstr filename, substr yaml, Tree *t, id_type node_id, ParserOptions const &opts={})
	(1) parse YAML into an existing tree node. The filename will be used in any error messages arising during the parse.
void	parse_in_place (substr yaml, Tree *t, id_type node_id, ParserOptions const &opts={})
	(2) like (1) but no filename will be reported
void	parse_in_place (csubstr filename, substr yaml, Tree *t, ParserOptions const &opts={})
	(3) parse YAML into an existing tree, into its root node.
void	parse_in_place (substr yaml, Tree *t, ParserOptions const &opts={})
	(4) like (3) but no filename will be reported
void	parse_in_place (csubstr filename, substr yaml, NodeRef node, ParserOptions const &opts={})
	(5) like (1) but the node is given as a NodeRef
void	parse_in_place (substr yaml, NodeRef node, ParserOptions const &opts={})
	(6) like (5) but no filename will be reported
Tree	parse_in_place (csubstr filename, substr yaml, ParserOptions const &opts={})
	(7) create a new tree, and parse YAML into its root node.
Tree	parse_in_place (substr yaml, ParserOptions const &opts={})
	(8) like (7) but no filename will be reported
void	parse_json_in_place (Parser *parser, csubstr filename, substr json, Tree *t, id_type node_id)
	(1) parse JSON into an existing tree node. The filename will be used in any error messages arising during the parse.
void	parse_json_in_place (Parser *parser, substr json, Tree *t, id_type node_id)
	(2) like (1) but no filename will be reported
void	parse_json_in_place (Parser *parser, csubstr filename, substr json, Tree *t)
	(3) parse JSON into an existing tree, into its root node.
void	parse_json_in_place (Parser *parser, substr json, Tree *t)
	(4) like (3) but no filename will be reported
void	parse_json_in_place (Parser *parser, csubstr filename, substr json, NodeRef node)
	(5) like (1) but the node is given as a NodeRef
void	parse_json_in_place (Parser *parser, substr json, NodeRef node)
	(6) like (5) but no filename will be reported
Tree	parse_json_in_place (Parser *parser, csubstr filename, substr json)
	(7) create a new tree, and parse JSON into its root node.
Tree	parse_json_in_place (Parser *parser, substr json)
	(8) like (7) but no filename will be reported
void	parse_json_in_place (csubstr filename, substr json, Tree *t, id_type node_id, ParserOptions const &opts={})
	(1) parse JSON into an existing tree node. The filename will be used in any error messages arising during the parse.
void	parse_json_in_place (substr json, Tree *t, id_type node_id, ParserOptions const &opts={})
	(2) like (1) but no filename will be reported
void	parse_json_in_place (csubstr filename, substr json, Tree *t, ParserOptions const &opts={})
	(3) parse JSON into an existing tree, into its root node.
void	parse_json_in_place (substr json, Tree *t, ParserOptions const &opts={})
	(4) like (3) but no filename will be reported
void	parse_json_in_place (csubstr filename, substr json, NodeRef node, ParserOptions const &opts={})
	(5) like (1) but the node is given as a NodeRef
void	parse_json_in_place (substr json, NodeRef node, ParserOptions const &opts={})
	(6) like (5) but no filename will be reported
Tree	parse_json_in_place (csubstr filename, substr json, ParserOptions const &opts={})
	(7) create a new tree, and parse JSON into its root node.
Tree	parse_json_in_place (substr json, ParserOptions const &opts={})
	(8) like (7) but no filename will be reported
void	parse_in_arena (Parser *parser, csubstr filename, csubstr yaml, Tree *t, id_type node_id)
	(1) parse YAML into an existing tree node. The filename will be used in any error messages arising during the parse.
void	parse_in_arena (Parser *parser, csubstr yaml, Tree *t, id_type node_id)
	(2) like (1) but no filename will be reported
void	parse_in_arena (Parser *parser, csubstr filename, csubstr yaml, Tree *t)
	(3) parse YAML into an existing tree, into its root node.
void	parse_in_arena (Parser *parser, csubstr yaml, Tree *t)
	(4) like (3) but no filename will be reported
void	parse_in_arena (Parser *parser, csubstr filename, csubstr yaml, NodeRef node)
	(5) like (1) but the node is given as a NodeRef
void	parse_in_arena (Parser *parser, csubstr yaml, NodeRef node)
	(6) like (5) but no filename will be reported
Tree	parse_in_arena (Parser *parser, csubstr filename, csubstr yaml)
	(7) create a new tree, and parse YAML into its root node.
Tree	parse_in_arena (Parser *parser, csubstr yaml)
	(8) like (7) but no filename will be reported
void	parse_in_arena (csubstr filename, csubstr yaml, Tree *t, id_type node_id, ParserOptions const &opts={})
	(1) parse YAML into an existing tree node. The filename will be used in any error messages arising during the parse.
void	parse_in_arena (csubstr yaml, Tree *t, id_type node_id, ParserOptions const &opts={})
	(2) like (1) but no filename will be reported
void	parse_in_arena (csubstr filename, csubstr yaml, Tree *t, ParserOptions const &opts={})
	(3) parse YAML into an existing tree, into its root node.
void	parse_in_arena (csubstr yaml, Tree *t, ParserOptions const &opts={})
	(4) like (3) but no filename will be reported
void	parse_in_arena (csubstr filename, csubstr yaml, NodeRef node, ParserOptions const &opts={})
	(5) like (1) but the node is given as a NodeRef
void	parse_in_arena (csubstr yaml, NodeRef node, ParserOptions const &opts={})
	(6) like (5) but no filename will be reported
Tree	parse_in_arena (csubstr filename, csubstr yaml, ParserOptions const &opts={})
	(7) create a new tree, and parse YAML into its root node.
Tree	parse_in_arena (csubstr yaml, ParserOptions const &opts={})
	(8) like (7) but no filename will be reported
void	parse_json_in_arena (Parser *parser, csubstr filename, csubstr json, Tree *t, id_type node_id)
	(1) parse JSON into an existing tree node. The filename will be used in any error messages arising during the parse.
void	parse_json_in_arena (Parser *parser, csubstr json, Tree *t, id_type node_id)
	(2) like (1) but no filename will be reported
void	parse_json_in_arena (Parser *parser, csubstr filename, csubstr json, Tree *t)
	(3) parse JSON into an existing tree, into its root node.
void	parse_json_in_arena (Parser *parser, csubstr json, Tree *t)
	(4) like (3) but no filename will be reported
void	parse_json_in_arena (Parser *parser, csubstr filename, csubstr json, NodeRef node)
	(5) like (1) but the node is given as a NodeRef
void	parse_json_in_arena (Parser *parser, csubstr json, NodeRef node)
	(6) like (5) but no filename will be reported
Tree	parse_json_in_arena (Parser *parser, csubstr filename, csubstr json)
	(7) create a new tree, and parse JSON into its root node.
Tree	parse_json_in_arena (Parser *parser, csubstr json)
	(8) like (7) but no filename will be reported
void	parse_json_in_arena (csubstr filename, csubstr json, Tree *t, id_type node_id, ParserOptions const &opts={})
	(1) parse JSON into an existing tree node. The filename will be used in any error messages arising during the parse.
void	parse_json_in_arena (csubstr json, Tree *t, id_type node_id, ParserOptions const &opts={})
	(2) like (1) but no filename will be reported
void	parse_json_in_arena (csubstr filename, csubstr json, Tree *t, ParserOptions const &opts={})
	(3) parse JSON into an existing tree, into its root node.
void	parse_json_in_arena (csubstr json, Tree *t, ParserOptions const &opts={})
	(4) like (3) but no filename will be reported
void	parse_json_in_arena (csubstr filename, csubstr json, NodeRef node, ParserOptions const &opts={})
	(5) like (1) but the node is given as a NodeRef
void	parse_json_in_arena (csubstr json, NodeRef node, ParserOptions const &opts={})
	(6) like (5) but no filename will be reported
Tree	parse_json_in_arena (csubstr filename, csubstr json, ParserOptions const &opts={})
	(7) create a new tree, and parse JSON into its root node.
Tree	parse_json_in_arena (csubstr json, ParserOptions const &opts={})
	(8) like (7) but no filename will be reported
id_type	estimate_tree_capacity (csubstr src)
	Quickly inspect the source to estimate the number of nodes the resulting tree is likely to have.
bool	scalar_is_null (csubstr s) noexcept
	YAML-sense query of nullity.
bool	scalar_is_plain_number_json (csubstr s) noexcept
	JSON-sense query of plain number.
bool	scalar_is_inf3 (const char *s) noexcept
	Query if a scalar is inf (inf, Inf, INF).
bool	scalar_is_nan3 (const char *s) noexcept
	Query if a scalar is nan (nan, NaN, Nan, NAN).
bool	scalar_is_inf_or_nan3 (const char *s) noexcept
	Same as scalar_is_inf3() || scalar_is_nan3().
bool	scalar_is_special_json (csubstr s) noexcept
	Query if a scalar is plain, eg, true, false, null, +-.inf or .nan.
template<class T>
bool	from_chars_float (csubstr scalar, T *val) RYML_NOEXCEPT
	Deserialize a floating point from string.
template<class T>
size_t	to_chars_float (substr buf, T val) RYML_NOEXCEPT
	Serialize a floating point value to a string.
template<class T>
bool	from_chars_integral (csubstr scalar, T *val) RYML_NOEXCEPT
	Deserialize an integral scalar.
template<class T>
bool	scalar_deserialize (csubstr str, T *val)
	Deserialize a scalar from its string representation, dispatching to one of from_chars(), from_chars_float() or from_chars_integral() as appropriate.
template<class T>
size_t	scalar_serialize (substr buf, T const &a)
	Serialize a scalar to the buffer, dispatching to to_chars() or to_chars_float() as appropriate.
bool	scalar_style_query_squo (csubstr scalar) noexcept
	query whether a scalar can be encoded using single quotes.
bool	scalar_style_query_plain_flow (csubstr scalar) noexcept
	query whether a scalar can be encoded using plain style while in flow mode.
bool	scalar_style_query_plain_block (csubstr scalar) noexcept
	query whether a scalar can be encoded using plain style while in block mode.
NodeType	scalar_style_choose_block (csubstr scalar) noexcept
	choose a YAML scalar style based on the scalar's contents, while in block mode.
NodeType	scalar_style_choose_json (csubstr scalar) noexcept
	choose a json scalar style based on the scalar's contents
NodeType	scalar_style_choose_flow (csubstr scalar) noexcept
	choose a YAML scalar style based on the scalar's contents, while in flow mode.
template<class K, class V, class Less, class Alloc>
void	write (c4::yml::Tree *tree, c4::yml::id_type id, std::map< K, V, Less, Alloc > const &m)
	serialize a map to a node: implementation for Tree
template<class K, class V, class Less, class Alloc>
void	write (c4::yml::NodeRef *n, std::map< K, V, Less, Alloc > const &m)
	serialize a map to a node: implementation for NodeRef
template<class K, class V, class Less, class Alloc>
ReadResult	read (c4::yml::Tree const *tree, c4::yml::id_type id, std::map< K, V, Less, Alloc > *m)
	deserialize a map from a node: implementation for Tree .
template<class K, class V, class Less, class Alloc>
ReadResult	read (c4::yml::ConstNodeRef const &n, std::map< K, V, Less, Alloc > *m)
	deserialize a map from a node: implementation for ConstNodeRef .
template<class T, class Alloc>
void	write (Tree *tree, id_type id, std::vector< T, Alloc > const &vec)
	serialize a vector to a node: implementation for Tree
template<class T, class Alloc>
void	write (NodeRef *n, std::vector< T, Alloc > const &vec)
	serialize a vector to a node: implementation for NodeRef
template<class T, class Alloc>
ReadResult	read (Tree const *tree, id_type id, std::vector< T, Alloc > *vec)
	deserialize from a Tree node, overwriting existing vector entries.
template<class T, class Alloc>
ReadResult	read (ConstNodeRef const &node, std::vector< T, Alloc > *vec)
	deserialize from a ConstNodeRef node, overwriting existing vector entries.
template<class Alloc>
ReadResult	read (Tree const *tree, id_type id, std::vector< bool, Alloc > *vec)
	deserialize from a Tree node, overwriting existing vector entries.
template<class Alloc>
ReadResult	read (ConstNodeRef const &n, std::vector< bool, Alloc > *vec)
	deserialize from a ConstNodeRef node, overwriting existing vector entries.
bool	is_custom_tag (csubstr tag)
	is a tag of the form !handle!tag?
csubstr	normalize_tag (csubstr tag)
csubstr	normalize_tag_long (csubstr tag)
csubstr	normalize_tag_long (csubstr tag, substr output)
YamlTag_e	to_tag (csubstr tag)
csubstr	from_tag_long (YamlTag_e tag)
csubstr	from_tag (YamlTag_e tag)
bool	is_valid_tag_handle (csubstr handle)
size_t	transform_tag (substr output, csubstr handle, csubstr prefix, csubstr tag, Callbacks const &callbacks, Location const &ymlloc={}, bool with_brackets=true)
	returns the length of the transformed tag, or 0 to signal that the tag is local and cannot be resolved
csubstr	serialize_to_arena_str (Tree *tree, csubstr scalar)
	Serialize a string type (as specified by c4::is_string) to a tree's arena, ensuring that there is an entry for the string in the arena even if the string is empty.
template<class T>
csubstr	serialize_to_arena_scalar (Tree *tree, T const &scalar)
	Serialize a scalar to the tree's arena.
template<class T>
csubstr	serialize_to_arena (Tree *tree, T const &scalar)
	Serialize a scalar to a tree's arena, dispatching to either serialize_to_arena_scalar() or serialize_to_arena_str() when the type is a string according to c4::is_string.
csubstr	serialize_to_arena (Tree *, std::nullptr_t) noexcept
	implementation for null values
template<class T>
type_bits	scalar_flags_val (T const &) noexcept
	Return extra style flags to use when setting a scalar as val.
template<class T>
type_bits	scalar_flags_key (T const &) noexcept
	Return extra style flags to use when setting a scalar as key.
template<class T>
void	write (Tree *tree, id_type id, T const &v)
	Serialize a variable to the tree's arena, and set it as the node's val.
template<class T>
void	write_key (Tree *tree, id_type id, T const &v)
	Serialize a variable to the tree's arena, and set it as the node's key.
template<class T>
ReadResult	read (Tree const *tree, id_type id, T *v)
	Deserialize a scalar node's val from a tree object, returning false if the conversion failed.
template<class Wrapper>
ReadResult	read (Tree const *tree, id_type id, Wrapper const &w)
	overload to enable use of wrapper tag-types like eg c4::fmt::base64()
template<class T>
ReadResult	read_key (Tree const *tree, id_type id, T *v)
	Deserialize a node's key from a tree object, returning false if the conversion failed.
template<class Wrapper>
ReadResult	read_key (Tree const *tree, id_type id, Wrapper const &w)
	overload to enable use of wrapper tag-types like eg c4::fmt::base64()
csubstr	version ()
int	version_major ()
int	version_minor ()
int	version_patch ()

Typedef Documentation

id_type

using c4::yml::id_type = RYML_ID_TYPE

The type of a node id in the YAML tree; to override the default type, define the macro RYML_ID_TYPE to a suitable integer type.

Definition at line 124 of file common.hpp.

Encoding_e

typedef enum c4::yml::Encoding_ c4::yml::Encoding_e

ParserFlag_t

using c4::yml::ParserFlag_t = int

data type for ParserState_e

Definition at line 14 of file parser_state.hpp.

Enumeration Type Documentation

anonymous enum

anonymous enum : id_type

Enumerator
NONE	an index to none

Definition at line 129 of file common.hpp.

     : id_type { // NOLINT
    /** an index to none */
    NONE = id_type(-1), // NOLINT
};

anonymous enum

anonymous enum : size_t

Enumerator
npos	a null string position

Definition at line 136 of file common.hpp.

     : size_t { // NOLINT
    /** a null string position */
    npos = size_t(-1) // NOLINT
};

Encoding_

enum c4::yml::Encoding_

Enumerator
NOBOM	No Byte Order Mark was found.
UTF8	UTF8.
UTF16LE	UTF16, Little-Endian.
UTF16BE	UTF16, Big-Endian.
UTF32LE	UTF32, Little-Endian.
UTF32BE	UTF32, Big-Endian.

Definition at line 142 of file common.hpp.

                       { // NOLINT
    NOBOM,         //!< No Byte Order Mark was found
    UTF8,          //!< UTF8
    UTF16LE,       //!< UTF16, Little-Endian
    UTF16BE,       //!< UTF16, Big-Endian
    UTF32LE,       //!< UTF32, Little-Endian
    UTF32BE,       //!< UTF32, Big-Endian
} Encoding_e;

ParserState_e

enum c4::yml::ParserState_e : ParserFlag_t

Enumeration of the state flags for the parser.

Enumerator
RTOP	reading at top level
RUNK	reading unknown state (when starting): must determine whether scalar, map or seq
RMAP	reading a map
RSEQ	reading a seq
RFLOW	reading is inside explicit flow chars: [] or {}
RBLCK	reading in block mode
QMRK	reading an explicit key (? key)
RKEY	reading a key
RVAL	reading a val
RKCL	reading the key colon (ie the : after the key in the map)
RNXT	read next sibling
SSCL	there's a stored scalar
QSCL	stored scalar was quoted
RSET	the (implicit) map being read is a !!set. See also https://yaml.org/type/set.html
RDOC	reading a document
NDOC	no document mode. a document has ended and another has not started yet.
USTY	reading in unknown style mode - must determine FLOW or BLCK reading an implicit map nested in an explicit seq. eg, {key: [key2: value2, key3: value3]} is parsed as {key: [{key2: value2}, {key3: value3}]}
RSEQIMAP

Definition at line 17 of file parser_state.hpp.

             : ParserFlag_t { // NOLINT
    RTOP = 0x01 <<  0,   ///< reading at top level
    RUNK = 0x01 <<  1,   ///< reading unknown state (when starting): must determine whether scalar, map or seq
    RMAP = 0x01 <<  2,   ///< reading a map
    RSEQ = 0x01 <<  3,   ///< reading a seq
    RFLOW = 0x01 <<  4,  ///< reading is inside explicit flow chars: [] or {}
    RBLCK = 0x01 <<  5,  ///< reading in block mode
    QMRK = 0x01 <<  6,   ///< reading an explicit key (`? key`)
    RKEY = 0x01 <<  7,   ///< reading a key
    RVAL = 0x01 <<  9,   ///< reading a val
    RKCL = 0x01 <<  8,   ///< reading the key colon (ie the : after the key in the map)
    RNXT = 0x01 << 10,   ///< read next sibling
    SSCL = 0x01 << 11,   ///< there's a stored scalar
    QSCL = 0x01 << 12,   ///< stored scalar was quoted
    RSET = 0x01 << 13,   ///< the (implicit) map being read is a !!set. @see https://yaml.org/type/set.html
    RDOC = 0x01 << 14,   ///< reading a document
    NDOC = 0x01 << 15,   ///< no document mode. a document has ended and another has not started yet.
    USTY = 0x01 << 16,   ///< reading in unknown style mode - must determine FLOW or BLCK
    //! reading an implicit map nested in an explicit seq.
    //! eg,          {key: [key2: value2, key3: value3]}
    //! is parsed as {key: [{key2: value2}, {key3: value3}]}
    RSEQIMAP = 0x01 << 17,
} ParserState_e;

Function Documentation

escape_scalar_fn()

template<class Fn>

void c4::yml::escape_scalar_fn	(	Fn &&	fn,
		csubstr	scalar,
		bool	keep_newlines = false )

Iterate through a scalar and escape special characters in it.

This function takes a callback (which accepts a single parameter of csubstr type) and, while processing, calls this callback as appropriate, passing ranges of the scalar and/or escaped characters.

Parameters

fn	a sink function receiving a csubstr
scalar	the scalar to be escaped
keep_newlines	when true, \n will be escaped as \\n\n instead of just \\n

Example usage:

// escape to stdout
void escape_scalar(FILE *file, csubstr scalar)
{
    auto print_ = [](csubstr repl){
        fwrite(repl.len, 1, repl.str, file);
    };
    escape_scalar_fn(std::ref(print_), scalar);
}
 
// escape to a different buffer and return the required buffer size
size_t escape_scalar(substr buffer, csubstr scalar)
{
    C4_ASSERT(!buffer.overlaps(scalar));
    size_t pos = 0;
    auto _append = [&](csubstr repl){
        if(repl.len && (pos + repl.len <= buffer.len))
            memcpy(buffer.str + pos, repl.str, repl.len);
        pos += repl.len;
    };
    escape_scalar_fn(std::ref(_append), scalar);
    return pos;
}

Definition at line 50 of file escape_scalar.hpp.

{
    size_t prev = 0;   // the last position that was flushed
    size_t skip = 0;   // how much to add to prev
    csubstr repl;      // replacement string
    bool newl = false; // to add a newline
    // cast to u8 to avoid having to deal with negative
    // signed chars (which are present in some platforms)
    uint8_t const* C4_RESTRICT s = reinterpret_cast<uint8_t const*>(scalar.str); // NOLINT(*-reinterpret-cast)
    // NOLINTBEGIN(*-goto,bugprone-use-after-move,hicpp-invalid-access-moved)
    for(size_t i = 0; i < scalar.len; ++i)
    {
        switch(s[i])
        {
        case UINT8_C(0x0a): // \n
            repl = "\\n";
            skip = 1;
            if(keep_newlines)
                newl = true;
            goto flush_now;
        case UINT8_C(0x5c): // '\\'
            repl = "\\\\";
            skip = 1;
            goto flush_now;
        case UINT8_C(0x09): // \t
            repl = "\\t";
            skip = 1;
            goto flush_now;
        case UINT8_C(0x0d): // \r
            repl = "\\r";
            skip = 1;
            goto flush_now;
        case UINT8_C(0x00): // \0
            repl = "\\0";
            skip = 1;
            goto flush_now;
        case UINT8_C(0x0c): // \f (form feed)
            repl = "\\f";
            skip = 1;
            goto flush_now;
        case UINT8_C(0x08): // \b (backspace)
            repl = "\\b";
            skip = 1;
            goto flush_now;
        case UINT8_C(0x07): // \a (bell)
            repl = "\\a";
            skip = 1;
            goto flush_now;
        case UINT8_C(0x0b): // \v (vertical tab)
            repl = "\\v";
            skip = 1;
            goto flush_now;
        case UINT8_C(0x1b): // \e (escape)
            repl = "\\e";
            skip = 1;
            goto flush_now;
        case UINT8_C(0xc2): // AKA -0x3e
            if(i+1 < scalar.len)
            {
                if(s[i+1] == UINT8_C(0xa0)) // AKA -0x60
                {
                    repl = "\\_";
                    skip = 2;
                    goto flush_now;
                }
                else if(s[i+1] == UINT8_C(0x85)) // AKA -0x7b
                {
                    repl = "\\N";
                    skip = 2;
                    goto flush_now;
                }
            }
            continue;
        case UINT8_C(0xe2): // AKA -0x1e
            if(i+2 < scalar.len)
            {
                if(s[i+1] == UINT8_C(0x80)) // AKA -0x80
                {
                    if(s[i+2] == UINT8_C(0xa8)) // AKA -0x58
                    {
                        repl = "\\L";
                        skip = 3;
                        goto flush_now;
                    }
                    else if(s[i+2] == UINT8_C(0xa9)) // AKA -0x57
                    {
                        repl = "\\P";
                        skip = 3;
                        goto flush_now;
                    }
                }
            }
            continue;
        default:
            continue;
        }
    flush_now:
        std::forward<Fn>(fn)(scalar.range(prev, i));
        std::forward<Fn>(fn)(repl);
        if(newl)
        {
            std::forward<Fn>(fn)("\n");
            newl = false;
        }
        prev = i + skip;
    }
    // flush the rest
    if(scalar.len > prev)
        std::forward<Fn>(fn)(scalar.sub(prev));
    // NOLINTEND(*-goto,bugprone-use-after-move,hicpp-invalid-access-moved)
}

Referenced by dump(), and escape_scalar().

adjust_pos_with_escapes()

size_t c4::yml::adjust_pos_with_escapes ( csubstr scalar, size_t pos, bool keep_newlines = false )

inline

Adjust a position in a scalar, increasing it to account for any escaped characters.

Note

This is a utility/debugging function, so it is provided in this optional header. For this reason, we inline it to obey to the One Definition Rule. But then we set the noinline attribute to ensure they are not inlined in calling code.

Definition at line 172 of file escape_scalar.hpp.

{
    // cast to u8 to avoid having to deal with negative
    // signed chars (which are present in some platforms)
    uint8_t const* C4_RESTRICT s = reinterpret_cast<uint8_t const*>(scalar.str); // NOLINT(*-reinterpret-cast)
    const size_t newbump = keep_newlines ? 2 : 1;
    size_t ret = 0;
    size_t excess = pos > scalar.len ? pos - scalar.len : 0;
    pos = pos < scalar.len ? pos : scalar.len;
    for(size_t i = 0; i < pos; ++i)
    {
        ++ret;
        switch(s[i])
        {
        case UINT8_C(0x5c): // '\\'
        case UINT8_C(0x09): // \t
        case UINT8_C(0x0d): // \r
        case UINT8_C(0x00): // \0
        case UINT8_C(0x0c): // \f (form feed)
        case UINT8_C(0x08): // \b (backspace)
        case UINT8_C(0x07): // \a (bell)
        case UINT8_C(0x0b): // \v (vertical tab)
        case UINT8_C(0x1b): // \e (escape)
            ++ret; // add the backslash
            break;
        case UINT8_C(0x0a): // \n
            ret += newbump;
            break;
        case UINT8_C(0xc2): // AKA -0x3e
            if(i+1 < scalar.len)
            {
                if(s[i+1] == UINT8_C(0xa0) // AKA -0x60 -> \_
                   ||
                   s[i+1] == UINT8_C(0x85)) // AKA -0x7b -> \N
                {
                    ++ret;
                    ++i; // skip the next entry
                }
            }
            break;
        case UINT8_C(0xe2): // AKA -0x1e
            if(i+2 < scalar.len)
            {
                if(s[i+1] == UINT8_C(0x80)) // AKA -0x80
                {
                    if(s[i+2] == UINT8_C(0xa8) // AKA -0x58 -> \L
                       ||
                       s[i+2] == UINT8_C(0xa9)) // AKA -0x57 -> \P
                    {
                        ++ret;
                        i += 2; // skip the next two entries
                    }
                }
            }
            break;
        default:
            break;
        }
    }
    return ret + excess;
}

Referenced by adjust_pos_with_escapes().

escape_scalar()

size_t c4::yml::escape_scalar ( substr buffer, csubstr scalar, bool keep_newlines = false )

inline

Escape a scalar to an existing buffer, using escape_scalar_fn.

Note

This is a utility/debugging function, so it is provided in this optional header. For this reason, we inline it to obey to the One Definition Rule. But then we set the noinline attribute to ensure they are not inlined in calling code.

Definition at line 241 of file escape_scalar.hpp.

{
    size_t pos = 0;
    C4_ASSERT(!buffer.overlaps(scalar));
    auto append_ = [&pos, &buffer](csubstr repl){
        if(repl.len && (pos + repl.len <= buffer.len))
            memcpy(buffer.str + pos, repl.str, repl.len);
        pos += repl.len;
    };
    escape_scalar_fn(append_, scalar, keep_newlines);
    return pos;
}

Referenced by c4::yml::extra::events_ints_to_testsuite(), and to_chars().

to_chars()

size_t c4::yml::to_chars ( substr buf, escaped_scalar e )

inline

formatting implementation to escape a scalar with escape_scalar()

Definition at line 264 of file escape_scalar.hpp.

{
    return escape_scalar(buf, e.scalar, e.keep_newlines);
}

Referenced by scalar_serialize(), and to_chars_float().

dump()

template<class SinkPfn>

size_t c4::yml::dump	(	SinkPfn &&	sinkfn,
		substr	buf,
		escaped_scalar const &	e )

dumping implementation to escape a scalar with escape_scalar_fn()

Definition at line 270 of file escape_scalar.hpp.

{
    (void)buf;
    C4_ASSERT(!buf.overlaps(e.scalar));
    escape_scalar_fn(std::forward<SinkPfn>(sinkfn), e.scalar, e.keep_newlines);
    return 0;
}

write() [1/4]

template<class K, class V, class Less, class Alloc>

void c4::yml::write	(	c4::yml::Tree *	tree,
		c4::yml::id_type	id,
		std::map< K, V, Less, Alloc > const &	m )

serialize a map to a node: implementation for Tree

Definition at line 18 of file map.hpp.

{
    tree->set_map(id);
    for(auto const& C4_RESTRICT p : m)
    {
        id_type child = tree->append_child(id);
        tree->set_key_serialized(child, p.first);
        tree->set_serialized(child, p.second);
    }
}

write() [2/4]

template<class K, class V, class Less, class Alloc>

void c4::yml::write ( c4::yml::NodeRef * n, std::map< K, V, Less, Alloc > const & m )

inline

serialize a map to a node: implementation for NodeRef

Definition at line 31 of file map.hpp.

{
    n->set_map();
    for(auto const& C4_RESTRICT p : m)
    {
        NodeRef ch = n->append_child();
        ch.set_key_serialized(p.first);
        ch.set_serialized(p.second);
    }
}

read() [1/6]

template<class K, class V, class Less, class Alloc>

ReadResult c4::yml::read	(	c4::yml::Tree const *	tree,
		c4::yml::id_type	id,
		std::map< K, V, Less, Alloc > *	m )

deserialize a map from a node: implementation for Tree .

Read the node members, assigning into the existing map. If a key is already present in the map, then its value will be move-assigned. The map

Definition at line 48 of file map.hpp.

{
    if C4_UNLIKELY(!tree->is_map(id))
        return ReadResult(id);
    for(id_type child = tree->first_child(id); child != NONE; child = tree->next_sibling(child))
    {
        K k{};
        ReadResult result = tree->deserialize_key(child, &k);
        if C4_UNLIKELY(!result)
            return result;
        result = tree->deserialize(child, &(*m)[std::move(k)]);
        if C4_UNLIKELY(!result)
            return result;
    }
    return ReadResult();
}

read() [2/6]

template<class K, class V, class Less, class Alloc>

ReadResult c4::yml::read	(	c4::yml::ConstNodeRef const &	n,
		std::map< K, V, Less, Alloc > *	m )

deserialize a map from a node: implementation for ConstNodeRef .

read the node members, assigning into the existing map. If a key is already present in the map, then its value will be move-assigned.

Definition at line 70 of file map.hpp.

{
    if C4_UNLIKELY(!n.is_map())
        return ReadResult(n.id());
    for(ConstNodeRef const& C4_RESTRICT ch : n)
    {
        K k{};
        ReadResult result = ch.deserialize_key(&k);
        if C4_UNLIKELY(!result)
            return result;
        result = ch.deserialize(&(*m)[std::move(k)]);
        if C4_UNLIKELY(!result)
            return result;
    }
    return ReadResult();
}

write() [3/4]

template<class T, class Alloc>

void c4::yml::write	(	Tree *	tree,
		id_type	id,
		std::vector< T, Alloc > const &	vec )

serialize a vector to a node: implementation for Tree

Definition at line 19 of file vector.hpp.

{
    tree->set_seq(id);
    for(T const& val : vec)
        tree->set_serialized(tree->append_child(id), val);
}

write() [4/4]

template<class T, class Alloc>

void c4::yml::write	(	NodeRef *	n,
		std::vector< T, Alloc > const &	vec )

serialize a vector to a node: implementation for NodeRef

Definition at line 28 of file vector.hpp.

{
    // don't defer to the tree impl here (if that were the case, we
    // wouldn't even need to implement this function, as ryml ends up
    // calling the tree impl by default). It may be the case that the
    // serialization of T uses a serialization of a nested type that
    // is not available in the tree implementation, so we need to
    // provide this as a hook for that. If that's not required, then
    // the tree implementation will get called anyway.
    n->set_seq();
    for(T const& val : vec)
    {
        NodeRef ch = n->append_child();
        // call write() directly. ch.set_serialized() would also work,
        // but does an additional check (to create the node if it is a
        // seed). That check is not needed here because we used
        // .append_child() to create the node.
        write(&ch, val);
    }
}

read() [3/6]

template<class T, class Alloc>

ReadResult c4::yml::read	(	Tree const *	tree,
		id_type	id,
		std::vector< T, Alloc > *	vec )

deserialize from a Tree node, overwriting existing vector entries.

Definition at line 52 of file vector.hpp.

{
    if C4_UNLIKELY(!tree->is_seq(id))
        return ReadResult(id);
    vec->clear();
    #if C4_CPP < 17 // prior to C++17, emplace_back() does not return a reference
    size_t pos = 0;
    #endif
    for(id_type child = tree->first_child(id); child != NONE; child = tree->next_sibling(child))
    {
        #if C4_CPP >= 17
        T &val = vec->emplace_back();
        #else
        vec->emplace_back();
        T &val = (*vec)[pos++];
        #endif
        // do not call read(tree, child, &val) here. we do not know
        // that the YAML is valid, so we need to do the checks in
        // child.deserialize()
        if(!tree->deserialize(child, &val))
            return ReadResult(id);
    }
    return ReadResult{};
}

read() [4/6]

template<class T, class Alloc>

ReadResult c4::yml::read	(	ConstNodeRef const &	node,
		std::vector< T, Alloc > *	vec )

deserialize from a ConstNodeRef node, overwriting existing vector entries.

Definition at line 79 of file vector.hpp.

{
    // don't defer to the tree impl here (if that were the case, we
    // wouldn't even need to implement this function, as ryml ends up
    // calling the tree impl by default). It may be the case that the
    // serialization of T uses a serialization of a nested type that
    // is not available in the tree implementation, so we need to
    // provide this as a hook for that. If that's not required, then
    // the tree implementation will get called anyway.
    if C4_UNLIKELY(!node.is_seq())
        return ReadResult(node.id());
    vec->clear();
    #if C4_CPP < 17 // prior to C++17, emplace_back() does not return a reference
    size_t pos = 0;
    #endif
    for(ConstNodeRef const& child : node.children())
    {
        #if C4_CPP >= 17
        T &val = vec->emplace_back();
        #else
        vec->emplace_back();
        T &val = (*vec)[pos++];
        #endif
        // do not call read(child, &val) here. we do not know that the
        // YAML is valid, so we need to do the checks in
        // child.deserialize()
        if(!child.deserialize(&val))
            return ReadResult(child.id());
    }
    return ReadResult();
}

read() [5/6]

template<class Alloc>

ReadResult c4::yml::read	(	Tree const *	tree,
		id_type	id,
		std::vector< bool, Alloc > *	vec )

deserialize from a Tree node, overwriting existing vector entries.

Definition at line 119 of file vector.hpp.

{
    if C4_UNLIKELY(!tree->is_seq(id))
        return ReadResult(id);
    vec->clear();
    bool tmp = {};
    for(id_type child = tree->first_child(id); child != NONE; child = tree->next_sibling(child))
    {
        if(!from_chars(tree->val(child), &tmp))
            return ReadResult(child);
        vec->push_back(tmp); // leave this. gcc4.8 does not have std::vector<bool>::emplace_back()
    }
    return ReadResult();
}

read() [6/6]

template<class Alloc>

ReadResult c4::yml::read	(	ConstNodeRef const &	n,
		std::vector< bool, Alloc > *	vec )

deserialize from a ConstNodeRef node, overwriting existing vector entries.

Definition at line 136 of file vector.hpp.

{
    // call the tree implementation, saving the node readability
    // checks. we can do that here because bool (the value type) is a
    // final type, so it can't be overrided.
    return read(n.tree(), n.id(), vec);
}

version()

csubstr c4::yml::version

(

)

Definition at line 6 of file version.cpp.

{
  return RYML_VERSION;
}

version_major()

int c4::yml::version_major

(

)

Definition at line 11 of file version.cpp.

{
  return RYML_VERSION_MAJOR;
}

version_minor()

int c4::yml::version_minor

(

)

Definition at line 16 of file version.cpp.

{
  return RYML_VERSION_MINOR;
}

version_patch()

int c4::yml::version_patch

(

)

Definition at line 21 of file version.cpp.

{
  return RYML_VERSION_PATCH;
}