From b6edadee03efb86ea7cfbd57ada29337e8535f8e Mon Sep 17 00:00:00 2001
From: "Timur A. Fatkhullin" <amirych@gmail.com>
Date: Tue, 30 Apr 2024 11:47:42 +0300
Subject: [PATCH] ...

---
 common/adc_utils.h |  2 +-
 common/adc_value.h | 50 +++++++++++++++++++++++-----------------------
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/common/adc_utils.h b/common/adc_utils.h
index 936a9e1..48b0103 100644
--- a/common/adc_utils.h
+++ b/common/adc_utils.h
@@ -379,7 +379,7 @@ public:
         if constexpr (traits::adc_is_tuple_v<T>) {
             AdcTupleFromCharRange(res, value, _delimiter);
         } else if constexpr (traits::adc_output_char_range<T>) {
-            AdcValuRangeFromCharRange(res, value, _delimiter);
+            AdcValueRangeFromCharRange(res, value, _delimiter);
         } else {
             res = AdcTrivialDeserializer<T>(value);
         }
diff --git a/common/adc_value.h b/common/adc_value.h
index 63c2d80..3e8f6ec 100644
--- a/common/adc_value.h
+++ b/common/adc_value.h
@@ -387,46 +387,46 @@ template <typename SerializedT = std::string>
 class AdcSerializingValueHolder : public AdcValueHolder
 {
 protected:
-    std::function<SerializedT()> _serializerWrapper = []() {
-
-    };
+    std::function<SerializedT()> _serializerWrapper;
 
     std::function<void(const SerializedT&)> _deserializerWrapper;
 
-    template <typename GT, typename ST, typename VT, typename SRT, typename DSRT>
-    void init(GT&& getter, ST&& setter, VT&& validator, SRT&& serializer, DSRT&& deserializer)
+    template <typename VALUET, typename SRT, typename DSRT>
+    void initWrappers(SRT&& serializer, DSRT&& deserializer)
     {
-        _serializerWrapper = [wrapper =
-                                  traits::adc_pf_wrapper(std::forward<GT>(getter), std::forward<SRT>(serializer))]() {
-            auto& getter = std::get<0>(wrapper);
-            auto& serializer = std::get<1>(wrapper);
+        _serializerWrapper = [wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer)), this]() {
+            auto& serializer = std::get<0>(wrapper);
+
+            auto val = _getterFunc<VALUET>[this]();
 
-            auto val = getter();
             return serializer(val);
         };
 
 
-        using v_t = traits::adc_retval_t<GT>;
+        _serializerWrapper = [wrapper = traits::adc_pf_wrapper(std::forward<DSRT>(deserializer)),
+                              this](const SerializedT& sval) {
+            auto& deserializer = std::get<0>(wrapper);
 
-        _serializerWrapper = [wrapper =
-                                  traits::adc_pf_wrapper(std::forward<ST>(setter), std::forward<VT>(validator),
-                                                         std::forward<DSRT>(deserializer))](const SerializedT& sval) {
-            auto& setter = std::get<0>(wrapper);
-            auto& validator = std::get<1>(wrapper);
-            auto& deserializer = std::get<2>(wrapper);
+            VALUET val = deserializer(sval);
 
-            v_t val = deserializer(sval);
-
-            if (validator(val)) {
-                setter(val);
-            } else {
-                throw std::system_error(AdcValueHolderErrorCode::ERROR_VALUE_IS_NOT_VALID);
-            }
+            _setterFunc<VALUET>[this](val);
         };
     }
 
 public:
-    using AdcValueHolder::AdcValueHolder;
+    template <typename GT,
+              typename ST,
+              typename VALT = std::decay_t<traits::adc_retval_t<GT>>,
+              typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>),
+              typename SRT,
+              typename DSRT>
+    AdcSerializingValueHolder(GT&& getter, ST&& setter, VT&& validator, SRT&& serializer, DSRT&& deserializer)
+        : 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<value_t>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
+    }
 
     virtual ~AdcSerializingValueHolder() = default;
 };