Arena utils

Implementation utils for serializing scalars in a tree's arena. More...

Functions
template<class T>
csubstr	c4::yml::serialize_to_arena_scalar (Tree *tree, T const &scalar)
	Serialize a scalar to the tree's arena.
csubstr	c4::yml::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	c4::yml::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	c4::yml::serialize_to_arena (Tree *, std::nullptr_t) noexcept
	implementation for null values

Detailed Description

Implementation utils for serializing scalars in a tree's arena.

These functions are implementation helpers used by Tree::to_arena() and NodeRef::to_arena() to grow the tree arena as needed and serialize scalars in it. There should be no reason to call these functions directly.

They can be overriden by the user to customize behavior for a user type, but generally there should be no reason to do so – if you think there is, please open an issue in github.

Function Documentation

serialize_to_arena_scalar()

template<class T>

csubstr c4::yml::serialize_to_arena_scalar	(	Tree *	tree,
		T const &	scalar )

Serialize a scalar to the tree's arena.

Forward to scalar_serialize(), giving it the tree's arena and resizing the arena as needed to fit the result.

This is an implementation helper for serialize_to_arena(), serializing through scalar_serialize().

Definition at line 1754 of file tree.hpp.

{
    substr buf = tree->arena_rem(); // buffer: the free part of the tree's arenra.
 again:
    size_t num = scalar_serialize(buf, a); // try to write into it
    if C4_LIKELY(num <= buf.len) // was it enough?
    {
        buf = buf.first(num); // fit the payload
    }
    else
    {
        buf = tree->_grow_arena(num); // does not advance pos
        goto again; // NOLINT
    }
    tree->m_arena_pos += num;
    return buf;
}

Referenced by serialize_to_arena(), serialize_to_arena_scalar(), and serialize_to_arena_str().

serialize_to_arena_str()

csubstr c4::yml::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.

This is an implementation helper for serialize_to_arena(), serializing through scalar_serialize() and then ensuring that the serialized string will be placed in the arena, even if the string is zero-length.

Definition at line 27 of file tree.cpp.

{
    if(scalar.len > 0)
    {
        return serialize_to_arena_scalar<csubstr>(tree, scalar);
    }
    else
    {
        if(scalar.str == nullptr)
        {
            return csubstr{};
        }
        else if(tree->m_arena.str == nullptr)
        {
            // Arena is empty and we want to store a non-null
            // zero-length string.
            // Even though the string has zero length, we need
            // some "memory" to store a non-nullptr string
            tree->_grow_arena(1);
        }
        return tree->_request_span(0);
    }
}

Referenced by serialize_to_arena(), and serialize_to_arena_str().

serialize_to_arena() [1/2]

template<class T>

csubstr c4::yml::serialize_to_arena ( Tree * tree, T const & scalar )

inline

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.

This is the entry point for customizing how a scalar is serialized to a tree's arena. It is never needed for the user to call this function, and generally there is no reason for overriding this function for user types, unless it has specific requirements for the tree's arena, as happens for example with string types. For user string types, defining c4::is_string is enough. For example:

Note

When using a standard older than C++17, if constexpr is not available, and the implementation reverts to SFINAE to achieve the compile-time dispatch.

namespace foo {
class MyStringType {...}; // an example of a user-defined string type
// define conversion to/from substrings
c4::yml::csubstr to_csubstr(MyStringType const& s) { return ...; }
c4::yml::substr to_substr(MyStringType & s) { return ...; }
} // namespace foo
// tell ryml to treat this type as a string
template<> struct c4::is_string<foo::MyStringType> : std::true_type {};

Definition at line 109 of file tree.hpp.

{
    if constexpr (_is_string_nocvref<T>::value)
        return serialize_to_arena_str(tree, to_csubstr(scalar));
    else
        return serialize_to_arena_scalar<T>(tree, scalar);
}

Referenced by serialize_to_arena(), serialize_to_arena(), c4::yml::Tree::to_arena(), write(), and write_key().

serialize_to_arena() [2/2]

csubstr c4::yml::serialize_to_arena ( Tree * , std::nullptr_t  )

inlinenoexcept

implementation for null values

Definition at line 136 of file tree.hpp.

{
    return csubstr{};
}