...

common/adc_utils.h

@@ -282,20 +282,57 @@ static auto AdcCharRangeFromTuple(OutputR& res, const std::tuple<Ts...>& tp, Del
 }
 
 
-/*
+namespace details
- */
-template <traits::adc_output_char_range SerializedT = std::string>
-class AdcDefaultSerializer
 {
-    std::string_view _delimiter;
 
+template <typename DerivedT>
+class AdcDelimiter
+{
 public:
     template <traits::adc_input_char_range DT = std::string_view>
-    AdcDefaultSerializer(const DT& delimiter = ",") : _delimiter(delimiter.begin(), delimiter.end())
+    auto& setDelimiter(const DT& delimiter)
+    {
+        _delimiter = std::string{delimiter.begin(), delimiter.end()};
+
+        return static_cast<DerivedT&>(*this);
+    }
+
+    auto& setDelimiter(const char* delimiter)
+    {
+        _delimiter = std::string{delimiter};
+
+        return static_cast<DerivedT&>(*this);
+    }
+
+protected:
+    template <traits::adc_input_char_range DT = std::string_view>
+    AdcDelimiter(const DT& delimiter = ",") : _delimiter(delimiter.begin(), delimiter.end())
     {
     }
 
-    AdcDefaultSerializer(const char* delimiter = ",") : _delimiter(delimiter) {}
+    AdcDelimiter(const char* delimiter = ",") : _delimiter(delimiter) {}
+
+    virtual ~AdcDelimiter() = default;
+
+    std::string _delimiter;
+};
+
+}  // namespace details
+
+/*
+ */
+template <traits::adc_output_char_range SerializedT = std::string>
+class AdcDefaultSerializer : public details::AdcDelimiter<AdcDefaultSerializer<SerializedT>>
+{
+    std::string _delimiter;
+
+    using base_t = details::AdcDelimiter<AdcDefaultSerializer<SerializedT>>;
+
+public:
+    template <typename DT = std::string_view>
+    AdcDefaultSerializer(const DT& delimiter = ",") : base_t(delimiter)
+    {
+    }
 
     virtual ~AdcDefaultSerializer() = default;
 
@@ -314,20 +351,40 @@ public:
 
         return res;
     }
+};
 
-    template <traits::adc_input_char_range DT = std::string_view>
+
-    AdcDefaultSerializer& setDelimiter(const DT& delimiter)
+/*
+ */
+template <traits::adc_input_char_range SerializedT = std::string>
+class AdcDefaultDeserializer : public details::AdcDelimiter<AdcDefaultDeserializer<SerializedT>>
 {
-        _delimiter = std::string_view{delimiter.begin(), delimiter.end()};
+    std::string _delimiter;
 
-        return *this;
+    using base_t = details::AdcDelimiter<AdcDefaultSerializer<SerializedT>>;
+
+public:
+    template <typename DT = std::string_view>
+    AdcDefaultDeserializer(const DT& delimiter = ",") : base_t(delimiter)
+    {
     }
 
-    AdcDefaultSerializer& setDelimiter(const char* delimiter)
+    virtual ~AdcDefaultDeserializer() = default;
-    {
-        _delimiter = std::string_view{delimiter};
 
-        return *this;
+    template <typename T>
+    T deserialization(const SerializedT& value)
+    {
+        T res;
+
+        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);
+        } else {
+            res = AdcTrivialDeserializer<T>(value);
+        }
+
+        return res;
     }
 };
 

common/adc_value_holder.h

@@ -433,12 +433,14 @@ AdcValueHolder make_arith_valueholder(GT&& getter,
 }
 
 
-// AdcValueHolder make_arith_valueholder(std::invocable<> auto&& getter,
+/*  */
-//                                       std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter)
+
-// {
+template <typename SerializedT = std::string>
-//     return make_arith_valueholder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
+class AdcSerializingValueHolder : public AdcValueHolder
-//                                   AdcValueHolder::AdcValueHolderDummyValidator<traits::adc_retval_t<decltype(getter)>>);
+{
-// }
+public:
+    using AdcValueHolder::AdcValueHolder;
+};
 
 
 }  // namespace adc