...

common/adc_utils.h

@@ -77,12 +77,20 @@ static ValueT AdcFromChars(R&& range)
 
         std::string s(rr.begin(), rr.end());
         size_t pos;
-        if constexpr (std::is_same_v<v_t, float>) {
+        try {
-            v = std::stof(s, &pos);
+            if constexpr (std::is_same_v<v_t, float>) {
-        } else if constexpr (std::is_same_v<v_t, double>) {
+                v = std::stof(s, &pos);
-            v = std::stod(s, &pos);
+            } else if constexpr (std::is_same_v<v_t, double>) {
-        } else if constexpr (std::is_same_v<v_t, long double>) {
+                v = std::stod(s, &pos);
-            v = std::stold(s, &pos);
+            } else if constexpr (std::is_same_v<v_t, long double>) {
+                v = std::stold(s, &pos);
+            }
+        } catch (const std::invalid_argument&) {
+            throw std::invalid_argument(
+                "AdcFromChars: cannot convert char-range to user-type value (invalid argument)");
+        } catch (const std::out_of_range&) {
+            throw std::invalid_argument(
+                "AdcFromChars: cannot convert char-range to user-type value (result out of range)");
         }
 
         if (pos != s.size()) {
@@ -274,4 +282,53 @@ static auto AdcCharRangeFromTuple(OutputR& res, const std::tuple<Ts...>& tp, Del
 }
 
 
+/*
+ */
+template <traits::adc_output_char_range SerializedT = std::string>
+class AdcDefaultSerializer
+{
+    std::string_view _delimiter;
+
+public:
+    template <traits::adc_input_char_range DT = std::string_view>
+    AdcDefaultSerializer(const DT& delimiter = ",") : _delimiter(delimiter.begin(), delimiter.end())
+    {
+    }
+
+    AdcDefaultSerializer(const char* delimiter = ",") : _delimiter(delimiter) {}
+
+    virtual ~AdcDefaultSerializer() = default;
+
+    template <typename T>
+    SerializedT operator()(const T& value)
+    {
+        SerializedT res;
+
+        if constexpr (traits::adc_is_tuple_v<T>) {
+            AdcCharRangeFromTuple(res, value, _delimiter);
+        } else if constexpr (traits::adc_input_char_range<T>) {
+            AdcCharRangeFromValueRange(res, value, _delimiter);
+        } else {
+            res = AdcTrivialSerializer<SerializedT>(value);
+        }
+
+        return res;
+    }
+
+    template <traits::adc_input_char_range DT = std::string_view>
+    AdcDefaultSerializer& setDelimiter(const DT& delimiter)
+    {
+        _delimiter = std::string_view{delimiter.begin(), delimiter.end()};
+
+        return *this;
+    }
+
+    AdcDefaultSerializer& setDelimiter(const char* delimiter)
+    {
+        _delimiter = std::string_view{delimiter};
+
+        return *this;
+    }
+};
+
 }  // namespace adc::utils

tests/adc_valueholder_test.cpp

@@ -121,4 +121,12 @@ TEST_CASE("[ADC VALUEHOLDER]")
         std::cout << ch;
     }
     std::cout << "\n";
+
+
+    ss = ";\t";
+    // adc::utils::AdcDefaultSerializer sr{"; "};
+    adc::utils::AdcDefaultSerializer sr{ss};
+    std::cout << "SR: " << sr(std::list<float>{11.11, 22.22, 33.33}) << "\n";
+    ss = ",\t";
+    std::cout << "SR: " << sr.setDelimiter(" , ")(std::vector<float>{11.11, 22.22, 33.33}) << "\n";
 }