...

include/mcc/mcc_keyvalue.h

@@ -97,6 +97,7 @@ template <typename T>
 concept mcc_keyvalue_record_c = requires(T t) {
     requires std::same_as<decltype(t.key), const std::string_view>;  // key name is immutable!!!
     requires mcc_variant_valid_type_c<decltype(t.value)>;            // value is mutable
+    requires mcc_variant_valid_type_c<decltype(t.default_value)>;    // value is mutable
     requires mcc_serialization_params_c<decltype(t.serial_pars)>;    // serialization parameters
 };
 
@@ -162,6 +163,13 @@ public:
     }
 
 
+    void setToDefaults()
+    {
+        [this]<size_t... Is>(std::index_sequence<Is...>) {
+            ((std::get<Is>(_keyValue).value = std::get<Is>(_keyValue).default_value), ...);
+        }(std::make_index_sequence<NUMBER_OF_RECORDS>{});
+    }
+
     template <typename T, std::ranges::contiguous_range R>
     std::expected<T, std::error_code> getValue(R const& key) const
     {
@@ -248,6 +256,9 @@ public:
         _inlineComment.clear();
         _changedKey.clear();
 
+        // set values to its defaults
+        setToDefaults();
+
         auto recs = std::views::split(buffer, std::move(rec_delim));
 
         for (auto const& el : recs) {
@@ -319,15 +330,23 @@ public:
 
         auto write_rec = [&output_buffer, &rec_delim, &ec, this]<size_t I = 0>(this auto& self) {
             if constexpr (I < NUMBER_OF_RECORDS) {
+                using val_t = std::remove_cvref_t<decltype(std::get<I>(_keyValue).value)>;
+                const val_t* value_cptr = &std::get<I>(_keyValue).value;
+
                 if constexpr (OPOLICY == MccKeyValueHolder::OPOLICY_CHANGED_ONLY) {
                     if (_changedKey.count(_hashes[I]) == 0) {
                         self.template operator()<I + 1>();
                         return;
                     }
+                } else if constexpr (OPOLICY == MccKeyValueHolder::OPOLICY_FULL) {
+                    if (_changedKey.count(_hashes[I]) == 0) {
+                        value_cptr = &std::get<I>(_keyValue).default_value;
+                    }
+                } else {
+                    static_assert(false, "UNKNOWN OUTPUT POLICY VALUE!");
                 }
 
                 auto key = std::get<I>(_keyValue).key;
-                using val_t = std::remove_cvref_t<decltype(std::get<I>(_keyValue).value)>;
 
                 std::string buff;
                 auto err =
@@ -415,25 +434,17 @@ protected:
     }
 
     // template <size_t I = 0,
-    //           OutputPolicy OPOLICY = MccKeyValueHolder::OPOLICY_CHANGED_ONLY,
     //           traits::mcc_output_char_range R,
     //           traits::mcc_input_char_range RecDelimT,
     //           mcc_serialization_params_c SerParamsT>
-    // std::error_code writeRecord(R& output_buffer, RecDelimT rec_delim, SerParamsT const& ser_params)
+    // std::error_code writeRecord(DESCR_T const& holder, R& output_buffer, RecDelimT rec_delim)
     // {
     //     if constexpr (I < NUMBER_OF_RECORDS) {
-    //         if constexpr (OPOLICY == MccKeyValueHolder::OPOLICY_CHANGED_ONLY) {
+    //         auto key = std::get<I>(holder).key;
-    //             if (_changedKey.count(_hashes[I]) == 0) {
+    //         using val_t = std::remove_cvref_t<decltype(std::get<I>(holder).value)>;
-    //                 return MccKeyValueHolderErrorCode::ERROR_OK;
-    //             }
-    //         }
-
-    //         auto key = std::get<I>(_keyValue).key;
-    //         auto val = std::get<I>(_keyValue).value;
-    //         using val_t = std::remove_cvref_t<decltype(val)>;
 
     //         std::string buff;
-    //         auto err = MccSerializer<val_t>{}(buff, val, ser_params);
+    //         auto err = MccSerializer<val_t>{}(buff, std::get<I>(holder).value, std::get<I>(holder).serial_pars);
     //         if (err) {
     //             return MccKeyValueHolderErrorCode::ERROR_SERIAL;
     //         } else {
@@ -468,8 +479,17 @@ protected:
 template <mcc_variant_valid_type_c T>
 struct mcc_simple_kv_record_t {
     const std::string_view key;
-    T value;
+    T value, default_value;
     mcc_serialization_params_t serial_pars;
 };
 
+template <mcc_variant_valid_type_c T>
+mcc_simple_kv_record_t<T> mcc_make_simple_kv_record(
+    std::string_view key,
+    T const& def_value,
+    mcc_serialization_params_t const& spars = mcc_serialization_params_t{})
+{
+    return mcc_simple_kv_record_t<T>{key, def_value, def_value, spars};
+}
+
 }  // namespace mcc::impl

tests/mcc_keyvalue_test.cpp

@@ -5,12 +5,13 @@
 using namespace mcc::impl;
 
 static auto kv_desc = std::make_tuple(
-    mcc_simple_kv_record_t{"bb", MccAngle{11.5_degs}, mcc_serialization_params_t{}},
+    mcc_simple_kv_record_t{"bb", MccAngle{11.5_degs}, MccAngle{11.5_degs}, mcc_serialization_params_t{}},
-    mcc_simple_kv_record_t{"aaa", std::string("AAA"), mcc_serialization_params_t{}},
+    mcc_simple_kv_record_t{"aaa", std::string("AAA"), std::string("AAA"), mcc_serialization_params_t{}},
-    mcc_simple_kv_record_t{"cc", MccCelestialCoordEpoch{}, mcc_serialization_params_t{}},
+    mcc_simple_kv_record_t{"cc", MccCelestialCoordEpoch{}, MccCelestialCoordEpoch{}, mcc_serialization_params_t{}},
     mcc_simple_kv_record_t{
-        "ddd", MccAngle{11.5_degs},
+        "ddd", MccAngle{11.5_degs}, MccAngle{11.5_degs},
-        mcc_serialization_params_t{.angle_format = mcc::MccSerializedAngleFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURS}});
+        mcc_serialization_params_t{.angle_format = mcc::MccSerializedAngleFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURS}},
+    mcc_make_simple_kv_record("eee", 1.5));
 
 
 
@@ -37,10 +38,29 @@ ddd = 01:02:33.434 # HA in hours:mins:secs
 
 int main()
 {
+    std::error_code err;
+    std::string buff;
+
     MccKeyValueHolder kv(kv_desc);
 
+    err = kv.toCharRange(buff);
+    if (err) {
+        std::println("ERR = {}", err);
+        return 1;
+    }
+    std::println("DEFAULT VALUES:");
+    std::println("--(\n{})--", buff);
+    std::println("\n\n");
+
+
+    err = kv.setValue("eee", 15.1515);
+    if (err) {
+        std::println("ERR = {}", err);
+        // return 1;
+    }
+
     // auto err = kv.fromCharRange(STR);
-    auto err = kv.fromCharRange(STR1);
+    err = kv.fromCharRange(STR1);
     if (err) {
         std::println("ERR = {}", err);
         return 1;
@@ -69,8 +89,8 @@ int main()
 
     std::println("------------------------------------");
 
-    std::string buff;
 
+    buff.clear();
     err = kv.toCharRange<decltype(kv)::OPOLICY_FULL>(buff);
     // err = kv.toCharRange(buff);
     if (err) {