wip

Author: biojppm

CMakeLists.txt

@@ -56,7 +56,6 @@ c4_add_library(ryml
         c4/yml/fwd.hpp
         c4/yml/export.hpp
         c4/yml/node.hpp
-        c4/yml/node.cpp
         c4/yml/node_type.hpp
         c4/yml/node_type.cpp
         c4/yml/parser_state.hpp

src/c4/yml/common.hpp

@@ -4,9 +4,16 @@
 /** @file common.hpp Common utilities and infrastructure used by ryml. */
 
 #include <cstddef>
+
+#ifndef _C4_SUBSTR_HPP_
 #include <c4/substr.hpp>
+#endif
+#ifndef _C4_CHARCONV_HPP_
 #include <c4/charconv.hpp>
+#endif
+#ifndef _C4_YML_CHARCONV_HPP_
 #include <c4/yml/export.hpp>
+#endif
 
 
 //-----------------------------------------------------------------------------
@@ -150,6 +157,10 @@ static_assert(RYML_LOGBUF_SIZE < RYML_ERRMSG_SIZE, "invalid size");
  *
  */
 
+/** @defgroup doc_serialization_helpers Serialization helpers
+ *
+ */
+
 /** @defgroup doc_ref_utils Anchor/Reference utilities
  *
  * @see sample::sample_anchors_and_aliases
@@ -602,6 +613,30 @@ struct RYML_EXPORT Callbacks
 /** @} */
 
 
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+
+/** @addtogroup doc_serialization_helpers
+ *
+ * @{
+ */
+
+/** A tag type to select the key when serializing with operator<< or operator== */
+template<class K>
+struct Key
+{
+    K &&k; // NOLINT
+};
+template<class K>
+C4_ALWAYS_INLINE Key<K> key(K && k)
+{
+    return Key<K>{std::forward<K>(k)};
+}
+
+/** @} */
+
+
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

src/c4/yml/node.cpp

@@ -4,27 +4,5 @@ namespace c4 {
 namespace yml {
 
 
-
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-
-size_t NodeRef::set_key_serialized(c4::fmt::const_base64_wrapper w)
-{
-    _apply_seed();
-    csubstr encoded = this->to_arena(w);
-    this->set_key(encoded);
-    return encoded.len;
-}
-
-size_t NodeRef::set_val_serialized(c4::fmt::const_base64_wrapper w)
-{
-    _apply_seed();
-    csubstr encoded = this->to_arena(w);
-    this->set_val(encoded);
-    return encoded.len;
-}
-
 } // namespace yml
 } // namespace c4

src/c4/yml/node.hpp

@@ -461,17 +461,23 @@ void ParseEngine<EventHandler>::_relocate_arena(csubstr prev_arena, substr next_
     }
     _ryml_relocate(m_evt_handler->m_src);
     for(size_t i = 0; i < m_pending_tags.num_entries; ++i)
-        _ryml_relocate(m_pending_tags.annotations[i].str); // LCOV_EXCL_LINE
+    {
+        _ryml_relocate(m_pending_tags.annotations[i].str);
+    }
     for(size_t i = 0; i < m_pending_anchors.num_entries; ++i)
-        _ryml_relocate(m_pending_anchors.annotations[i].str); // LCOV_EXCL_LINE
+    {
+        _ryml_relocate(m_pending_anchors.annotations[i].str);
+    }
     TagDirectives &tds = m_evt_handler->tag_directives();
     for(size_t i = 0, sz = tds.size(); i < sz; ++i)
     {
-        _ryml_relocate(tds.m_directives[i].handle); // LCOV_EXCL_LINE
-        _ryml_relocate(tds.m_directives[i].prefix); // LCOV_EXCL_LINE
+        _ryml_relocate(tds.m_directives[i].handle);
+        _ryml_relocate(tds.m_directives[i].prefix);
     }
     if(other)
-        _ryml_relocate(*other); // LCOV_EXCL_LINE
+    {
+        _ryml_relocate(*other);
+    }
     #undef _ryml_relocate
 }
 

src/c4/yml/parse.cpp

@@ -16,7 +16,7 @@ namespace yml {
 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;
+    n->set_map();
     for(auto const& C4_RESTRICT p : m)
     {
         auto ch = n->append_child();

src/c4/yml/parse_engine.def.hpp

@@ -16,7 +16,7 @@ namespace yml {
 template<class V, class Alloc>
 void write(c4::yml::NodeRef *n, std::vector<V, Alloc> const& vec)
 {
-    *n |= c4::yml::SEQ;
+    n->set_seq();
     for(V const& v : vec)
         n->append_child() << v;
 }

src/c4/yml/std/map.hpp

@@ -16,19 +16,11 @@ namespace c4 {
 namespace yml {
 
 
-csubstr serialize_to_arena(Tree * C4_RESTRICT tree, csubstr a)
+csubstr serialize_to_arena_str(Tree * C4_RESTRICT tree, csubstr a)
 {
     if(a.len > 0)
     {
-        substr rem(tree->m_arena.sub(tree->m_arena_pos));
-        size_t num = to_chars(rem, a);
-        if(num > rem.len)
-        {
-            rem = tree->_grow_arena(num);
-            num = to_chars(rem, a);
-            _RYML_ASSERT_VISIT_(tree->m_callbacks, num <= rem.len, tree, NONE);
-        }
-        return tree->_request_span(num);
+        return serialize_to_arena_scalar<csubstr>(tree, a);
     }
     else
     {
@@ -89,7 +81,7 @@ NodeRef Tree::operator[] (csubstr key)
 }
 ConstNodeRef Tree::operator[] (csubstr key) const
 {
-    return rootref()[key];
+    return crootref()[key];
 }
 
 NodeRef Tree::operator[] (id_type i)
@@ -98,7 +90,7 @@ NodeRef Tree::operator[] (id_type i)
 }
 ConstNodeRef Tree::operator[] (id_type i) const
 {
-    return rootref()[i];
+    return crootref()[i];
 }
 
 NodeRef Tree::docref(id_type i)
@@ -107,11 +99,11 @@ NodeRef Tree::docref(id_type i)
 }
 ConstNodeRef Tree::docref(id_type i) const
 {
-    return cref(doc(i));
+    return ConstNodeRef(this, doc(i));
 }
 ConstNodeRef Tree::cdocref(id_type i) const
 {
-    return cref(doc(i));
+    return ConstNodeRef(this, doc(i));
 }
 
 
@@ -937,6 +929,7 @@ void Tree::remove_children(id_type node)
     }
 }
 
+//-----------------------------------------------------------------------------
 bool Tree::change_type(id_type node, NodeType type)
 {
     _RYML_ASSERT_VISIT_(m_callbacks, type.is_val() || type.is_map() || type.is_seq(), this, node);
@@ -1150,9 +1143,8 @@ void Tree::merge_with(Tree const *src, id_type src_node, id_type dst_node)
                 remove_children(dst_node);
             _clear_type(dst_node);
             if(src->has_key(src_node))
-                to_seq(dst_node, src->key(src_node));
-            else
-                to_seq(dst_node);
+                set_key(dst_node, src->key(src_node));
+            set_seq(dst_node);
             _p(dst_node)->m_type = src->_p(src_node)->m_type;
         }
         for(id_type sch = src->first_child(src_node); sch != NONE; sch = src->next_sibling(sch))
@@ -1171,9 +1163,8 @@ void Tree::merge_with(Tree const *src, id_type src_node, id_type dst_node)
                 remove_children(dst_node);
             _clear_type(dst_node);
             if(src->has_key(src_node))
-                to_map(dst_node, src->key(src_node));
-            else
-                to_map(dst_node);
+                set_key(dst_node, src->key(src_node));
+            set_map(dst_node);
             _p(dst_node)->m_type = src->_p(src_node)->m_type;
         }
         for(id_type sch = src->first_child(src_node); sch != NONE; sch = src->next_sibling(sch))
@@ -1259,7 +1250,7 @@ id_type Tree::find_child(id_type node, csubstr const& name) const
 {
     _RYML_ASSERT_VISIT_(m_callbacks, node != NONE, this, node);
     _RYML_ASSERT_VISIT_(m_callbacks, is_map(node), this, node);
-    if(get(node)->m_first_child == NONE)
+    if(_p(node)->m_first_child == NONE)
     {
         _RYML_ASSERT_VISIT_(m_callbacks, _p(node)->m_last_child == NONE, this, node);
         return NONE;
@@ -1335,6 +1326,7 @@ void Tree::to_val(id_type node, csubstr val, type_bits more_flags)
 {
     _RYML_ASSERT_VISIT_(m_callbacks,  ! has_children(node), this, node);
     _RYML_ASSERT_VISIT_(m_callbacks, parent(node) == NONE || ! parent_is_map(node), this, node);
+    _RYML_ASSERT_VISIT_(m_callbacks, !is_seq(node) && !is_map(node), this, node);
     _set_flags(node, VAL|more_flags);
     _p(node)->m_key.clear();
     _p(node)->m_val = val;
@@ -1344,6 +1336,7 @@ void Tree::to_keyval(id_type node, csubstr key, csubstr val, type_bits more_flag
 {
     _RYML_ASSERT_VISIT_(m_callbacks,  ! has_children(node), this, node);
     _RYML_ASSERT_VISIT_(m_callbacks, parent(node) == NONE || parent_is_map(node), this, node);
+    _RYML_ASSERT_VISIT_(m_callbacks, !is_seq(node) && !is_map(node), this, node);
     _set_flags(node, KEYVAL|more_flags);
     _p(node)->m_key = key;
     _p(node)->m_val = val;
@@ -1352,7 +1345,6 @@ void Tree::to_keyval(id_type node, csubstr key, csubstr val, type_bits more_flag
 void Tree::to_map(id_type node, type_bits more_flags)
 {
     _RYML_ASSERT_VISIT_(m_callbacks,  ! has_children(node), this, node);
-    _RYML_ASSERT_VISIT_(m_callbacks, parent(node) == NONE || ! parent_is_map(node), this, node); // parent must not have children with keys
     _set_flags(node, MAP|more_flags);
     _p(node)->m_key.clear();
     _p(node)->m_val.clear();
@@ -1605,10 +1597,7 @@ Tree::lookup_result Tree::lookup_path(csubstr path, id_type start) const
 id_type Tree::lookup_path_or_modify(csubstr default_value, csubstr path, id_type start)
 {
     id_type target = _lookup_path_or_create(path, start);
-    if(parent_is_map(target))
-        to_keyval(target, key(target), default_value);
-    else
-        to_val(target, default_value);
+    set_val(target, default_value);
     return target;
 }
 
@@ -1732,10 +1721,7 @@ id_type Tree::_next_node_modify(lookup_result * r, _lookup_path_token *parent)
         //_RYML_ASSERT_VISIT_(m_callbacks, is_container(r->closest) || r->closest == NONE);
         if( ! is_container(r->closest))
         {
-            if(has_key(r->closest))
-                to_map(r->closest, key(r->closest));
-            else
-                to_map(r->closest);
+            set_map(r->closest);
         }
         else
         {
@@ -1789,17 +1775,7 @@ id_type Tree::_next_node_modify(lookup_result * r, _lookup_path_token *parent)
              return NONE;
         if( ! is_container(r->closest))
         {
-            if(has_key(r->closest))
-            {
-                csubstr k = key(r->closest);
-                _clear_type(r->closest);
-                to_seq(r->closest, k);
-            }
-            else
-            {
-                _clear_type(r->closest);
-                to_seq(r->closest);
-            }
+            set_seq(r->closest);
         }
         _RYML_ASSERT_VISIT_(m_callbacks, is_container(r->closest), this, r->closest);
         node = child(r->closest, idx);
@@ -1812,9 +1788,16 @@ id_type Tree::_next_node_modify(lookup_result * r, _lookup_path_token *parent)
                 if(i < idx)
                 {
                     if(is_map(r->closest))
-                        to_keyval(node, /*"~"*/{}, /*"~"*/{});
+                    {
+                        _clear_type(node);
+                        set_key(node, {});
+                        set_val(node, {});
+                    }
                     else if(is_seq(r->closest))
-                        to_val(node, /*"~"*/{});
+                    {
+                        _clear_type(node);
+                        set_val(node, {});
+                    }
                 }
             }
         }