Serialize/deserialize container types

To serialize/deserialize container types to a tree, implement the appropriate functions: More...

Classes
struct	my_seq_type< T >
	example user container type: seq-like More...
struct	my_map_type< K, V >
	example user container type: map-like More...
struct	my_type
	example user container type with nested container members. More...

Functions
template<class T>
void	write (ryml::NodeRef *n, my_seq_type< T > const &seq)
template<class K, class V>
void	write (ryml::NodeRef *n, my_map_type< K, V > const &map)
void	write (ryml::NodeRef *n, my_type const &val)
template<class T>
bool	read (ryml::ConstNodeRef const &n, my_seq_type< T > *seq)
template<class K, class V>
bool	read (ryml::ConstNodeRef const &n, my_map_type< K, V > *map)
bool	read (ryml::ConstNodeRef const &n, my_type *val)

Detailed Description

To serialize/deserialize container types to a tree, implement the appropriate functions:

void write(ryml::NodeRef *n, T const& seq);
bool read(ryml::ConstNodeRef const& n, T *seq);

Warning

Because of C++'s ADL rules, it is required to overload these functions in the namespace of the type you're serializing (or in the c4 namespace, or in the c4::yml namespace). [Here's an example of an issue where failing to do this was causing problems in some platforms](https://github.com/biojppm/rapidyaml/issues/424)

Note

Please take note of the following pitfall when using serialization functions: you may have to include the header with your write() or read() implementation before any other headers that use functions from it. See the include order at the top of this source file. This constraint also applies to the conversion functions for your types; just like with the STL's headers, they should be included prior to ryml's headers. Lately, some effort was directed to provide forward declarations to alleviate this problem, but it may still occur.

See also

sample_container_types

sample_std_types

Function Documentation

write() [1/3]

template<class T>

void write	(	ryml::NodeRef *	n,
		my_seq_type< T > const &	seq )

Definition at line 3707 of file quickstart.cpp.

{
    *n |= ryml::SEQ;
    for(auto const& v : seq.seq_member)
        n->append_child() << v;
}

write() [2/3]

template<class K, class V>

void write	(	ryml::NodeRef *	n,
		my_map_type< K, V > const &	map )

Definition at line 3714 of file quickstart.cpp.

{
    *n |= ryml::MAP;
    for(auto const& v : map.map_member)
        n->append_child() << ryml::key(v.first) << v.second;
}

write() [3/3]

void write	(	ryml::NodeRef *	n,
		my_type const &	val )

Definition at line 3720 of file quickstart.cpp.

{
    *n |= ryml::MAP;
    // these are leaf nodes:
    n->append_child() << ryml::key("v2") << val.v2;
    n->append_child() << ryml::key("v3") << val.v3;
    n->append_child() << ryml::key("v4") << val.v4;
    // these are container nodes:
    n->append_child() << ryml::key("seq") << val.seq;
    n->append_child() << ryml::key("map") << val.map;
}

read() [1/3]

template<class T>

bool read	(	ryml::ConstNodeRef const &	n,
		my_seq_type< T > *	seq )

Definition at line 3733 of file quickstart.cpp.

{
    seq->seq_member.resize(static_cast<size_t>(n.num_children())); // num_children() is O(N)
    size_t pos = 0;
    for(auto const ch : n.children())
        ch >> seq->seq_member[pos++];
    return true;
}

read() [2/3]

template<class K, class V>

bool read	(	ryml::ConstNodeRef const &	n,
		my_map_type< K, V > *	map )

Definition at line 3742 of file quickstart.cpp.

{
    K k{};
    V v{};
    for(auto const ch : n)
    {
        ch >> c4::yml::key(k) >> v;
        map->map_member.emplace(std::make_pair(std::move(k), std::move(v)));
    }
    return true;
}

read() [3/3]

bool read	(	ryml::ConstNodeRef const &	n,
		my_type *	val )

Definition at line 3753 of file quickstart.cpp.

{
    // these are leaf nodes:
    n["v2"] >> val->v2;
    n["v3"] >> val->v3;
    n["v4"] >> val->v4;
    // these are container nodes:
    n["seq"] >> val->seq;
    n["map"] >> val->map;
    return true;
}