...

common/adc_traits.h

@@ -55,6 +55,7 @@ struct adc_func_traits_helper_t<R> {
     using ret_t = R;
     using args_t = std::tuple<>;
     using arg1_t = void;
+    static constexpr size_t arity = 0;
 };
 
 template <typename R, typename Arg, typename... Args>
@@ -62,6 +63,7 @@ struct adc_func_traits_helper_t<R, Arg, Args...> {
     using ret_t = R;
     using args_t = std::tuple<Arg, Args...>;
     using arg1_t = Arg;
+    static constexpr size_t arity = sizeof...(Args) + 1;
 };
 
 
@@ -109,7 +111,7 @@ using adc_func_arg1_t = typename adc_func_traits<T>::arg1_t;
 template <typename T>
 using adc_deduced_type =
     std::conditional_t<std::is_lvalue_reference_v<T> && !std::is_const_v<std::remove_reference_t<T>>,
-                       T,
+                       T&,
                        std::remove_cvref_t<T>>;
 
 

common/adc_utils.h

@@ -419,6 +419,10 @@ public:
     template <typename ValueT, typename SerializedT>
     static ValueT deserialize(const SerializedT& svalue)
     {
+        if constexpr (std::is_void_v<ValueT>) {
+            return;
+        }
+
         ValueT res;
 
         if constexpr (traits::adc_is_tuple_v<ValueT>) {

common/adc_value.h

@@ -382,9 +382,11 @@ protected:
         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]();
 
             return serializer(val);
@@ -486,6 +488,8 @@ public:
         AdcValueHolder::resetValueHolder(std::forward<GT>(getter), std::forward<ST>(setter),
                                          std::forward<VT>(validator));
         initWrappers<ret_value_t<GT>>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
+
+        return *this;
     }
 
 
@@ -507,6 +511,8 @@ public:
                                          std::forward<VT>(validator), std::tuple<Ts...>{});
 
         initWrappers<ret_value_t<GT>>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
+
+        return *this;
     }
 
     template <typename GT,
@@ -524,6 +530,8 @@ public:
         AdcValueHolder::resetValueHolder(std::forward<GT>(getter), std::forward<ST>(setter), std::tuple<Ts...>{});
 
         initWrappers<ret_value_t<GT>>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
+
+        return *this;
     }
 
 

device/adc_device_command.h

@@ -9,7 +9,8 @@
 
 #include <memory>
 #include <string>
-#include "../common/adc_value_holder.h"
+// #include "../common/adc_value_holder.h"
+#include "../common/adc_value.h"
 
 /*
 
@@ -24,31 +25,37 @@ class AdcDeviceCommand
 protected:
     IdentT _ident;
 
-    std::unique_ptr<AdcValueHolder> _commandArgUptr;
+    std::unique_ptr<AdcSerializingValueHolder<SerializedT>> _commandArgUptr;
 
     std::function<void()> _execFuncWrapper;
     std::function<void(std::any&)> _deserializerWrapper;
 
+    template <typename T>
+    constexpr static SerializedT AdcDeviceCommandDummySerializer(const T&)
+    {
+        return SerializedT();
+    }
+
 public:
     typedef IdentT ident_t;
     typedef SerializedT serialized_t;
 
 
     template <typename ExecFuncT,
-              typename DeserializerT,
+              typename ARGT = traits::adc_func_arg1_t<ExecFuncT>,
-              typename ValidatorT = decltype(AdcValueHolder::AdcValueHolderDummyValidator)>
+              typename DeserializerT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ARGT, SerializedT>),
+              typename ValidatorT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<ARGT>)>
     AdcDeviceCommand(const IdentT& ident,
                      ExecFuncT&& exec_func,
-                     DeserializerT&& deserializer,
+                     DeserializerT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ARGT, SerializedT>,
-                     ValidatorT&& validator = AdcValueHolder::AdcValueHolderDummyValidator)
+                     ValidatorT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<ARGT>)
         : _ident(ident), _commandArgUptr()
     {
         using sign_t = traits::adc_func_traits<ExecFuncT>;
 
-        static_assert(std::tuple_size_v<typename sign_t::args_t> > 1,
+        static_assert(sign_t::arity > 1, "COMMAND EXECUTION FUNCTION MUST ACCEPT 0 OR EXACTLY 1 ARGUMENT!!!");
-                      "COMMAND EXECUTION FUNCTION MUST ACCEPT 0 OR EXACTLY 1 ARGUMENT!!!");
 
-        if constexpr (std::tuple_size_v<typename sign_t::args_t>) {  // command with argument
+        if constexpr (sign_t::arity) {  // command with argument
             using value_t = typename sign_t::arg1_t;
 
             static_assert(std::predicate<ValidatorT, const value_t&>, "INVALID TYPE OF VALIDATOR");
@@ -60,7 +67,7 @@ public:
 
             auto command_arg = std::shared_ptr<value_t>(value_t());
 
-            _commandArgUptr = std::make_unique<AdcValueHolder>(
+            _commandArgUptr = std::make_unique<AdcSerializingValueHolder<SerializedT>>(
                 [command_arg]() { return *command_arg; }, [command_arg](const value_t& value) { *command_arg = value; },
                 std::forward<ValidatorT>(validator));
 

tests/adc_valueholder_test.cpp

@@ -192,9 +192,9 @@ TEST_CASE("[ADC VALUEHOLDER]")
     // fl = vsh;
     // std::cout << "VSH: " << fl << "\n";
 
-    // svh.resetValueHolder(gdbl, sdbl, vdbl, adc::AdcValueHolder::_defaultTrivialConvTypes);
+    svh.resetValueHolder(gdbl, sdbl, vdbl, adc::AdcValueHolder::_defaultTrivialConvTypes);
-    svh.resetValueHolder([]() { return dbl_val; }, [](const double& v) { dbl_val = v; },
+    // svh.resetValueHolder([]() { return dbl_val; }, [](const double& v) { dbl_val = v; },
-                         [](const double&) { return true; }, adc::AdcValueHolder::_defaultTrivialConvTypes);
+    //                      [](const double&) { return true; }, adc::AdcValueHolder::_defaultTrivialConvTypes);
     std::cout << "SERIALIZED: " << svh.serialize() << "\n";
     svh.deserialize("123.123");
     res = svh;