dep: Add rapidyaml

dep/rapidyaml/include/c4/yml/std/map.hpp

@@ -0,0 +1,45 @@
+#ifndef _C4_YML_STD_MAP_HPP_
+#define _C4_YML_STD_MAP_HPP_
+
+/** @file map.hpp write/read std::map to/from a YAML tree. */
+
+#include "c4/yml/node.hpp"
+#include <map>
+
+namespace c4 {
+namespace yml {
+
+// std::map requires child nodes in the data
+// tree hierarchy (a MAP node in ryml parlance).
+// So it should be serialized via write()/read().
+
+template<class K, class V, class Less, class Alloc>
+void write(c4::yml::NodeRef *n, std::map<K, V, Less, Alloc> const& m)
+{
+    *n |= c4::yml::MAP;
+    for(auto const& C4_RESTRICT p : m)
+    {
+        auto ch = n->append_child();
+        ch << c4::yml::key(p.first);
+        ch << p.second;
+    }
+}
+
+template<class K, class V, class Less, class Alloc>
+bool read(c4::yml::ConstNodeRef const& n, std::map<K, V, Less, Alloc> * m)
+{
+    K k{};
+    V v{};
+    for(auto const& C4_RESTRICT ch : n)
+    {
+        ch >> c4::yml::key(k);
+        ch >> v;
+        m->emplace(std::make_pair(std::move(k), std::move(v)));
+    }
+    return true;
+}
+
+} // namespace yml
+} // namespace c4
+
+#endif // _C4_YML_STD_MAP_HPP_

dep/rapidyaml/include/c4/yml/std/std.hpp

@@ -0,0 +1,8 @@
+#ifndef _C4_YML_STD_STD_HPP_
+#define _C4_YML_STD_STD_HPP_
+
+#include "c4/yml/std/string.hpp"
+#include "c4/yml/std/vector.hpp"
+#include "c4/yml/std/map.hpp"
+
+#endif // _C4_YML_STD_STD_HPP_

dep/rapidyaml/include/c4/yml/std/string.hpp

@@ -0,0 +1,9 @@
+#ifndef C4_YML_STD_STRING_HPP_
+#define C4_YML_STD_STRING_HPP_
+
+/** @file string.hpp substring conversions for/from std::string */
+
+// everything we need is implemented here:
+#include <c4/std/string.hpp>
+
+#endif // C4_YML_STD_STRING_HPP_

dep/rapidyaml/include/c4/yml/std/vector.hpp

@@ -0,0 +1,53 @@
+#ifndef _C4_YML_STD_VECTOR_HPP_
+#define _C4_YML_STD_VECTOR_HPP_
+
+#include "c4/yml/node.hpp"
+#include <c4/std/vector.hpp>
+#include <vector>
+
+namespace c4 {
+namespace yml {
+
+// vector is a sequence-like type, and it requires child nodes
+// in the data tree hierarchy (a SEQ node in ryml parlance).
+// So it should be serialized via write()/read().
+
+
+template<class V, class Alloc>
+void write(c4::yml::NodeRef *n, std::vector<V, Alloc> const& vec)
+{
+    *n |= c4::yml::SEQ;
+    for(auto const& v : vec)
+        n->append_child() << v;
+}
+
+template<class V, class Alloc>
+bool read(c4::yml::ConstNodeRef const& n, std::vector<V, Alloc> *vec)
+{
+    vec->resize(n.num_children());
+    size_t pos = 0;
+    for(auto const ch : n)
+        ch >> (*vec)[pos++];
+    return true;
+}
+
+/** specialization: std::vector<bool> uses std::vector<bool>::reference as
+ * the return value of its operator[]. */
+template<class Alloc>
+bool read(c4::yml::ConstNodeRef const& n, std::vector<bool, Alloc> *vec)
+{
+    vec->resize(n.num_children());
+    size_t pos = 0;
+    bool tmp;
+    for(auto const ch : n)
+    {
+        ch >> tmp;
+        (*vec)[pos++] = tmp;
+    }
+    return true;
+}
+
+} // namespace yml
+} // namespace c4
+
+#endif // _C4_YML_STD_VECTOR_HPP_