...

common/adc_utils.h

@@ -388,4 +388,49 @@ public:
     }
 };
 
+namespace constants
+{
+
+static constexpr char DEFAULT_CONVERTER_DELIMITER[] = " ";
+
+}  // namespace constants
+
+template <const char* DELIMITER = constants::DEFAULT_CONVERTER_DELIMITER>
+class AdcDefaultValueConverter
+{
+public:
+    template <typename SerializedT, typename ValueT>
+    static SerializedT serialize(const ValueT& value)
+    {
+        SerializedT res;
+
+        if constexpr (traits::adc_is_tuple_v<ValueT>) {
+            AdcCharRangeFromTuple(res, value, DELIMITER);
+        } else if constexpr (traits::adc_input_char_range<ValueT>) {
+            AdcCharRangeFromValueRange(res, value, DELIMITER);
+        } else {
+            res = AdcTrivialSerializer<SerializedT>(value);
+        }
+
+        return res;
+    }
+
+
+    template <typename ValueT, typename SerializedT>
+    static ValueT deserialize(const SerializedT& svalue)
+    {
+        ValueT res;
+
+        if constexpr (traits::adc_is_tuple_v<ValueT>) {
+            AdcTupleFromCharRange(res, svalue, DELIMITER);
+        } else if constexpr (traits::adc_output_char_range<ValueT>) {
+            AdcValueRangeFromCharRange(res, svalue, DELIMITER);
+        } else {
+            res = AdcTrivialDeserializer<ValueT>(svalue);
+        }
+
+        return res;
+    }
+};
+
 }  // namespace adc::utils

common/adc_value.h

@@ -11,6 +11,7 @@
 #include <system_error>
 
 #include "adc_traits.h"
+#include "adc_utils.h"
 
 namespace adc
 {
@@ -391,13 +392,19 @@ protected:
 
     std::function<void(const SerializedT&)> _deserializerWrapper;
 
-    template <typename VALUET, typename SRT, typename DSRT>
+    template <typename ValueT, typename SRT, typename DSRT>
     void initWrappers(SRT&& serializer, DSRT&& deserializer)
     {
+        static_assert(std::is_convertible_v<traits::adc_retval_t<SRT>, SerializedT>,
+                      "INVALID RETURNED TYPE OF SERIALIZING CALLABLE!!!");
+
+        static_assert(std::is_convertible_v<traits::adc_retval_t<DSRT>, ValueT>,
+                      "INVALID RETURNED TYPE OF DESERIALIZING CALLABLE!!!");
+
         _serializerWrapper = [wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer)), this]() {
             auto& serializer = std::get<0>(wrapper);
 
-            auto val = _getterFunc<VALUET>[this]();
+            auto val = _getterFunc<ValueT>[this]();
 
             return serializer(val);
         };
@@ -407,28 +414,84 @@ protected:
                               this](const SerializedT& sval) {
             auto& deserializer = std::get<0>(wrapper);
 
-            VALUET val = deserializer(sval);
+            ValueT val = deserializer(sval);
 
-            _setterFunc<VALUET>[this](val);
+            _setterFunc<ValueT>[this](val);
         };
     }
 
 public:
+    /*  CONSTRUCTORS AND DESTRUCTOR  */
+
     template <typename GT,
               typename ST,
               typename VALT = std::decay_t<traits::adc_retval_t<GT>>,
               typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>),
-              typename SRT,
+              typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>),
-              typename DSRT>
+              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)>
-    AdcSerializingValueHolder(GT&& getter, ST&& setter, VT&& validator, SRT&& serializer, DSRT&& deserializer)
+    AdcSerializingValueHolder(GT&& getter,
+                              ST&& setter,
+                              VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
+                              SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>,
+                              DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
+        requires std::invocable<GT> && std::invocable<SRT, VALT> && std::invocable<DSRT, SerializedT>
         : AdcValueHolder(std::forward<GT>(getter), std::forward<ST>(setter), std::forward<VT>(validator))
     {
-        using value_t = std::decay_t<traits::adc_retval_t<GT>>;
+        initWrappers<VALT>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
-
-        initWrappers<value_t>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
     }
 
+
+    template <typename GT,
+              typename ST,
+              typename VALT = std::decay_t<traits::adc_retval_t<GT>>,
+              typename VT,
+              typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>),
+              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>),
+              typename... Ts>
+    AdcSerializingValueHolder(GT&& getter,
+                              ST&& setter,
+                              VT&& validator,
+                              const std::tuple<Ts...>&,
+                              SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>,
+                              DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
+        : AdcValueHolder(std::forward<GT>(getter),
+                         std::forward<ST>(setter),
+                         std::forward<VT>(validator),
+                         std::tuple<Ts...>{})
+    {
+        initWrappers<VALT>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
+    }
+
+
+
+    template <typename GT,
+              typename ST,
+              typename VALT = std::decay_t<traits::adc_retval_t<GT>>,
+              typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>),
+              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>),
+              typename... Ts>
+    AdcSerializingValueHolder(GT&& getter,
+                              ST&& setter,
+                              const std::tuple<Ts...>&,
+                              SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>,
+                              DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
+        : AdcValueHolder(std::forward<GT>(getter),
+                         std::forward<ST>(setter),
+                         AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
+                         std::tuple<Ts...>{})
+    {
+        initWrappers<VALT>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
+    }
+
+
     virtual ~AdcSerializingValueHolder() = default;
+
+
+    /*  PUBLIC METHODS  */
+
+    SerializedT serialize() { return _serializerWrapper(); }
+
+    void deserialize(const SerializedT& sval) { _deserializerWrapper(sval); }
 };