...

examples/str_exam.cpp

@@ -83,6 +83,12 @@ int main()
     std::println("valueSeq(4,2) = '{}'", kvl.valueSeq(4, 2));
     std::println("valueSeq = '{}'", kvl.valueSeq<std::list<std::string>>());
 
+    std::println("\nOwning 'key-value'");
+    snplib_keyvalue_expr_t<std::vector<char>> kv1;
+
+    kv1.setKeyValue("KEY", 7.7);
+    std::println("key = '{}'", kv1.key());
+    std::println("value = '{}'", kv1.value());
 
     snplib_random_string_generator_t<> rstr_gen;
 

include/snipplib/concepts/snplib_concepts.h

@@ -128,7 +128,10 @@ concept snplib_fixed_size_range_c =
 template <typename T>
 concept snplib_non_resizable_range_c = std::ranges::range<T> && !requires(T r, std::size_t n) { r.resize(n); };
 
-
+// a range with its own data life-time management
+template <typename T>
+concept snplib_owning_range_c = std::ranges::range<T> && !std::is_reference_v<T> &&
+                                !std::ranges::enable_view<std::decay_t<T>> && std::is_move_constructible_v<T>;
 
 /*                          an concept for error-type                    */
 

include/snipplib/utils/snplib_keyvalue_expr.h

@@ -32,7 +32,16 @@ public:
         std::string_view valseq_delim{DEFAULT_VALSEQ_DELIM_SEQ};
     };
 
-    constexpr snplib_keyvalue_expr_t(CharRangeT& bytes, config_t cfg = config_t{}) : _byteSeq(bytes), _config(cfg)
+    // inner char-sequence storage
+    constexpr snplib_keyvalue_expr_t(config_t cfg = config_t{})
+        requires snplib_owning_range_c<CharRangeT>
+        : _ownByteSeq(), _byteSeq(_ownByteSeq), _config(cfg), _isValid(false)
+    {
+    }
+
+    // outter char-sequence storage
+    constexpr snplib_keyvalue_expr_t(CharRangeT& bytes, config_t cfg = config_t{})
+        : _ownByteSeq(), _byteSeq(bytes), _config(cfg)
     {
         fromCharRange(bytes, cfg);
     }
@@ -181,12 +190,18 @@ public:
         requires mutableContent
     error_t setKey(KeyT&& key, SParT const& sparams = snplib_serialization_params_t{})
     {
-        _byteSeq.clear();
+        // _byteSeq.clear();
+        _byteSeq = CharRangeT();
+
         auto err = snplib_serializer_t<std::remove_cvref_t<KeyT>>{}(_byteSeq, std::forward<KeyT>(key), sparams);
         if (err) {
             return snplib_deduced_error(err, std::make_error_code(std::errc::invalid_argument));
         }
 
+        _key = {_byteSeq.begin(), _byteSeq.end()};
+        _value = {};
+        _valueSeq = {};
+
         return {};
     }
 
@@ -194,14 +209,43 @@ public:
         requires mutableContent
     error_t setValue(ValueT&& value, SParT sparams = snplib_serialization_params_t{})
     {
+        size_t key_sz = _key.size();
+        size_t keyval_delim_pos = _key.size() + _config.keyval_delim.size();
+        if constexpr (requires(CharRangeT t) { t.resize(std::declval<size_t>()); }) {
+            _byteSeq.resize(keyval_delim_pos);
+        } else {
+            auto it = _byteSeq.begin();
+            std::advance(it, keyval_delim_pos);
+            _byteSeq = {_byteSeq.begin(), it};
+        }
+
         auto err = snplib_serializer_t<std::remove_cvref_t<ValueT>>{}(_byteSeq, std::forward<ValueT>(value), sparams);
         if (err) {
             return snplib_deduced_error(err, std::make_error_code(std::errc::invalid_argument));
         }
 
+        // it can be a reallocation of the byte sequence so one needs to reinit _key and _value
+        auto it = _byteSeq.begin();
+        std::advance(it, key_sz);
+        _key = {_byteSeq.begin(), it};
+        std::advance(it, _config.keyval_delim.size());
+        _value = {it, _byteSeq.end()};
+        // _valueSeq = snplib_split_char_range<decltype(_valueSeq)>(_value, _config.valseq_delim);
+        _valueSeq.resize(1);
+        _valueSeq[0] = _value;
+
         return {};
     }
 
+    template <snplib_serializable_c ValueT, snplib_serialization_params_c SParT = snplib_serialization_params_t>
+        requires mutableContent
+    error_t appendValue(ValueT&& value, SParT sparams = snplib_serialization_params_t{})
+    {
+        if (_valueSeq.empty()) {
+            return setValue(std::forward<ValueT>(value), std::move(sparams));
+        }
+    }
+
 
     template <snplib_serializable_c KeyT,
               snplib_serializable_c ValueT,
@@ -218,10 +262,12 @@ public:
 
         sparams.elem_delim = _config.valseq_delim;
 
-        return setValue(std::forward<ValueT>(value), sparams);
+        return setValue(std::forward<ValueT>(value), std::move(sparams));
     }
 
 protected:
+    CharRangeT _ownByteSeq{};
+
     CharRangeT& _byteSeq;
 
     std::conditional_t<contiguousContent, std::string_view, std::ranges::subrange<typename CharRangeT::iterator>>