Serialize container types

Serialization definitions used in sample_user_container_types(). 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 user types. More...

Functions
template<class T>
void	write (ryml::Tree *tree, ryml::id_type id, my_seq_type< T > const &seq)
void	write (ryml::Tree *tree, ryml::id_type id, my_seq_type< std::string > const &seq)
template<class K, class V>
void	write (ryml::Tree *tree, ryml::id_type id, my_map_type< K, V > const &map)
void	write (ryml::Tree *tree, ryml::id_type id, my_type const &val)
template<class T>
ryml::ReadResult	read (ryml::Tree const *tree, ryml::id_type id, my_seq_type< T > *seq)
template<class K, class V>
ryml::ReadResult	read (ryml::Tree const *tree, ryml::id_type id, my_map_type< K, V > *map)
ryml::ReadResult	read (ryml::ConstNodeRef const &n, my_type *val)
ryml::ReadResult	read (ryml::Tree const *tree, ryml::id_type id, my_type *val)

Detailed Description

Serialization definitions used in sample_user_container_types().

Function Documentation

write() [1/4]

template<class T>

void write	(	ryml::Tree *	tree,
		ryml::id_type	id,
		my_seq_type< T > const &	seq )

Definition at line 4245 of file quickstart.cpp.

{
    tree->set_seq(id);
    for(T const& v : seq.seq_member)
    {
        // inside write(), prefer using .set_serialized() instead of .save()
        tree->set_serialized(tree->append_child(id), v);
    }
}

write() [2/4]

void write	(	ryml::Tree *	tree,
		ryml::id_type	id,
		my_seq_type< std::string > const &	seq )

Definition at line 4257 of file quickstart.cpp.

{
    tree->set_seq(id);
    for(std::string const& v : seq.seq_member)
    {
        // now the tree is pointing at seq's strings. using .set_val()
        // does not serialize, and this avoids the string copy to the
        // tree's arena
        tree->set_val(tree->append_child(id), ryml::to_csubstr(v));
    }
}

write() [3/4]

template<class K, class V>

void write	(	ryml::Tree *	tree,
		ryml::id_type	id,
		my_map_type< K, V > const &	map )

Definition at line 4271 of file quickstart.cpp.

{
    tree->set_map(id);
    for(auto const& v : map.map_member)
    {
        // inside write(), prefer using .set_serialized() instead of .save()
        ryml::id_type child_id = tree->append_child(id);
        tree->set_key_serialized(child_id, v.first); // we're serializing the key!
        tree->set_serialized(child_id, v.second);
    }
}

write() [4/4]

void write	(	ryml::Tree *	tree,
		ryml::id_type	id,
		my_type const &	val )

Definition at line 4283 of file quickstart.cpp.

{
    tree->set_map(id);
    // inside write(), prefer using .set_serialized() instead of .save()
    //
    ryml::id_type ch;
    // these are leaf nodes:
    ch = tree->append_child(id); tree->set_key(ch, "v2"); tree->set_serialized(ch, val.v2);
    ch = tree->append_child(id); tree->set_key(ch, "v3"); tree->set_serialized(ch, val.v3);
    ch = tree->append_child(id); tree->set_key(ch, "v4"); tree->set_serialized(ch, val.v4);
    // these are container nodes (note how the call is equal):
    ch = tree->append_child(id); tree->set_key(ch, "seq"); tree->set_serialized(ch, val.seq);
    ch = tree->append_child(id); tree->set_key(ch, "map"); tree->set_serialized(ch, val.map);
    // Note above that we're NOT serializing the keys. That works and
    // is correct here because the keys themselves are fixed, and are
    // static strings located in the executable. But if the keys came
    // from the data, they too would have to be serialized with
    // .set_key_serialized().
}

read() [1/4]

template<class T>

ryml::ReadResult read	(	ryml::Tree const *	tree,
		ryml::id_type	id,
		my_seq_type< T > *	seq )

Definition at line 4313 of file quickstart.cpp.

{
    if(!tree->is_seq(id)) return ryml::ReadResult(id); // id must be a seq
    seq->seq_member.clear(); // we'll overwrite the vector
    for(ryml::id_type child = tree->first_child(id);
        child != ryml::NONE;
        child = tree->next_sibling(child))
    {
        // create a new entry
        seq->seq_member.emplace_back();
        // inside read() you SHOULD NOT use .load() because of its
        // exceptional flow. Instead, you should use .deserialize() to
        // play nice with .deserialize() callers calling this function.
        // Read more at the doxygen page linked above.
        ryml::ReadResult r = tree->deserialize(child, &seq->seq_member.back());
        if(!r) return r; // return the inner-most result
    }
    return ryml::ReadResult(); // all good
}

read() [2/4]

template<class K, class V>

ryml::ReadResult read	(	ryml::Tree const *	tree,
		ryml::id_type	id,
		my_map_type< K, V > *	map )

Definition at line 4334 of file quickstart.cpp.

{
    if(!tree->is_map(id)) return ryml::ReadResult(id); // id must be a seq
    for(ryml::id_type child = tree->first_child(id);
        child != ryml::NONE;
        child = tree->next_sibling(child))
    {
        K k{};
        // again, we're using .deserialize() instead of .load()
        // because (1) we should gracefully return a ReadResult and
        // anyway (2) we're certain the node is readable (because
        // we're inside the loop).
        ryml::ReadResult r = tree->deserialize_key(child, &k);
        if(r) r = tree->deserialize(child, &map->map_member[std::move(k)]);
        if(!r) return r; // return the inner-most result
    }
    return ryml::ReadResult(); // all good.
}

read() [3/4]

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

Definition at line 4369 of file quickstart.cpp.

{
    ryml::ReadResult r(n.is_map(), n.id()); // node must be a map
    if(r) r = n.deserialize_child("v2", &val->v2);
    if(r) r = n.deserialize_child("v3", &val->v3);
    if(r) r = n.deserialize_child("v4", &val->v4);
    if(r) r = n.deserialize_child("seq", &val->seq);
    if(r) r = n.deserialize_child("map", &val->map);
    // hint: you can also add a default argument for when no such child exists
    // hint: you can also use indices instead of keys
    return r;
}

read() [4/4]

ryml::ReadResult read	(	ryml::Tree const *	tree,
		ryml::id_type	id,
		my_type *	val )

Definition at line 4387 of file quickstart.cpp.

{
    ryml::ReadResult r(tree->is_map(id), id); // node must be a map
    if(r) r = tree->deserialize_child(id, "v2", &val->v2);
    if(r) r = tree->deserialize_child(id, "v3", &val->v3);
    if(r) r = tree->deserialize_child(id, "v4", &val->v4);
    if(r) r = tree->deserialize_child(id, "seq", &val->seq);
    if(r) r = tree->deserialize_child(id, "map", &val->map);
    // hint: you can also add a default argument for when no such child exists
    // hint: you can also use indices instead of keys
    return r;
}