From 53779d2f13220f9ca3517da41dafda13fdce0dda Mon Sep 17 00:00:00 2001
From: "Timur A. Fatkhullin" <timur@sao.ru>
Date: Thu, 11 Apr 2024 22:11:24 +0300
Subject: [PATCH] add new AdcValueHolder implementation in adc_value.h

---
 CMakeLists.txt                 |   4 +-
 common/adc_value.h             | 430 +++++++++++++++++++++++++++++++++
 tests/adc_valueholder_test.cpp |  19 +-
 3 files changed, 444 insertions(+), 9 deletions(-)
 create mode 100644 common/adc_value.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f9527ec..8625575 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,8 +8,8 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(ADC_COMMON_HEADERS
     common/adc_traits.h
-    common/adc_value_holder.h
-)
+    common/adc_value_holder.h    
+    common/adc_value.h)
 
 set(ADC_DEVICE_HEADERS
     device/adc_device_attribute.h
diff --git a/common/adc_value.h b/common/adc_value.h
new file mode 100644
index 0000000..b293e57
--- /dev/null
+++ b/common/adc_value.h
@@ -0,0 +1,430 @@
+#pragma once
+
+/*
+
+ ABSTRACT DEVICE COMPONENTS LIBRARY
+
+ */
+
+
+#include <functional>
+#include <map>
+#include <system_error>
+
+#include "adc_traits.h"
+
+namespace adc
+{
+
+// error codes
+enum class AdcValueHolderErrorCode : int {
+    ERROR_OK,
+    ERROR_NO_CONV_FUNC,
+    ERROR_INTERNAL_TYPE_MISMATCH,
+    ERROR_VALUE_IS_NOT_VALID
+};
+
+}  // namespace adc
+
+
+namespace std
+{
+
+template <>
+class is_error_code_enum<adc::AdcValueHolderErrorCode> : public true_type
+{
+};
+
+}  // namespace std
+
+
+namespace adc
+{
+
+
+
+// error category
+struct AdcValueHolderErrorCategory : public std::error_category {
+    AdcValueHolderErrorCategory() : std::error_category() {}
+
+    const char* name() const noexcept { return "DEVA_DEVICE_ATTRIBUTE"; }
+
+    std::string message(int ec) const
+    {
+        AdcValueHolderErrorCode err = static_cast<AdcValueHolderErrorCode>(ec);
+
+        switch (err) {
+            case AdcValueHolderErrorCode::ERROR_OK:
+                return "OK";
+            case AdcValueHolderErrorCode::ERROR_NO_CONV_FUNC:
+                return "conversion function is not defined";
+            case AdcValueHolderErrorCode::ERROR_INTERNAL_TYPE_MISMATCH:
+                return "try to setup default conversion function for invalid type (internal type mismatch)";
+            case AdcValueHolderErrorCode::ERROR_VALUE_IS_NOT_VALID:
+                return "user value is not valid";
+            default:
+                return "UNKNOWN";
+        }
+    }
+
+    static const AdcValueHolderErrorCategory& get()
+    {
+        static const AdcValueHolderErrorCategory constInst;
+        return constInst;
+    }
+};
+
+
+inline std::error_code make_error_code(AdcValueHolderErrorCode ec)
+{
+    return std::error_code(static_cast<int>(ec), AdcValueHolderErrorCategory::get());
+}
+
+
+
+/*
+
+                         GENERAL-PURPOSE VALUE HOLDER CLASS WITH OPTIONAL VALIDATOR
+
+ */
+
+
+class AdcValueHolder
+{
+protected:
+    template <typename VT>
+    inline static std::unordered_map<const AdcValueHolder*, std::function<VT()>> _getterFunc{};
+
+    template <typename VT>
+    inline static std::unordered_map<const AdcValueHolder*, std::function<void(const VT&)>> _setterFunc{};
+
+    void init(std::invocable<> auto&& getter,
+              std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
+              std::predicate<const traits::adc_retval_t<decltype(getter)>&> auto&& validator)
+    {
+        using value_t = traits::adc_retval_t<decltype(getter)>;
+
+        static_assert(!std::is_same_v<value_t, void>, "THE getter MUST NOT RETURN void TYPE!!!");
+
+        using g_t = decltype(getter);
+        using s_t = decltype(setter);
+        using vld_t = decltype(validator);
+
+        _getterFunc<value_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<g_t>(getter))]() {
+            return std::get<0>(wrapper)();
+        };
+
+
+        _setterFunc<value_t>[this] = [wrapper =
+                                          traits::adc_pf_wrapper(std::forward<s_t>(setter),
+                                                                 std::forward<vld_t>(validator))](const value_t& val) {
+            if (std::get<1>(wrapper)(val)) {
+                std::get<0>(wrapper)(val);
+            } else {
+                throw std::system_error(AdcValueHolderErrorCode::ERROR_VALUE_IS_NOT_VALID);
+            }
+        };
+    }
+
+public:
+    // default trivial types (just arithmetic ones)
+    constexpr static std::tuple<bool,
+                                char,
+                                short,
+                                int,
+                                long,
+                                long long,
+                                unsigned char,
+                                unsigned short,
+                                unsigned int,
+                                unsigned long,
+                                unsigned long long,
+                                float,
+                                double,
+                                long double>
+        _defaultTrivialConvTypes{};
+
+    // always-true validator
+    // constexpr static auto AdcValueHolderDummyValidator = [](const auto&) { return true; };
+    template <typename VT>
+    constexpr static bool AdcValueHolderDummyValidator(const VT&)
+    {
+        return true;
+    };
+
+    /*  CONSTRUCTORS AND DESTRUCTOR  */
+
+    template <typename GT,
+              typename VALT = traits::adc_retval_t<GT>,
+              typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
+    AdcValueHolder(GT&& getter,
+                   std::invocable<const VALT&> auto&& setter,
+                   VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
+        requires std::invocable<GT> && std::predicate<VT, const VALT&>
+    {
+        init(std::forward<GT>(getter), std::forward<decltype(setter)>(setter),
+             std::forward<decltype(validator)>(validator));
+    }
+
+
+    template <typename... Ts>
+    AdcValueHolder(std::invocable<> auto&& getter,
+                   std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
+                   std::predicate<const traits::adc_retval_t<decltype(getter)>&> auto&& validator,
+                   const std::tuple<Ts...>& /* tuple-of-trivially-converting-types */)
+        : AdcValueHolder(std::forward<decltype(getter)>(getter),
+                         std::forward<decltype(setter)>(setter),
+                         std::forward<decltype(validator)>(validator))
+    {
+        // setup trivially-defined conversion function
+        AdcValueHolder::setupTrivialConvertFunc<traits::adc_retval_t<decltype(getter)>, std::tuple<Ts...>>();
+    }
+
+
+    template <typename... Ts>
+    AdcValueHolder(std::invocable<> auto&& getter,
+                   std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
+                   const std::tuple<Ts...>& t /* tuple-of-trivially-converting-types */)
+        : AdcValueHolder(std::forward<decltype(getter)>(getter),
+                         std::forward<decltype(setter)>(setter),
+                         AdcValueHolder::AdcValueHolderDummyValidator<traits::adc_retval_t<decltype(getter)>>,
+                         t)
+    {
+    }
+
+
+    AdcValueHolder(const AdcValueHolder&) = default;
+    AdcValueHolder(AdcValueHolder&&) = default;
+
+    virtual ~AdcValueHolder() = default;
+
+
+    /*  PUBLIC METHODS  */
+
+
+    template <typename GT,
+              typename VALT = traits::adc_retval_t<GT>,
+              typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
+    AdcValueHolder& resetValueHolder(GT&& getter,
+                                     std::invocable<const VALT&> auto&& setter,
+                                     VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
+        requires std::invocable<GT> && std::predicate<VT, const VALT&>
+    {
+        init(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
+             std::forward<decltype(validator)>(validator));
+
+        return *this;
+    }
+
+
+    template <typename... Ts>
+    AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
+                                     std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
+                                     std::predicate<const traits::adc_retval_t<decltype(getter)>&> auto&& validator,
+                                     const std::tuple<Ts...>& /* tuple-of-trivially-converting-types */)
+    {
+        resetValueHolder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
+                         std::forward<decltype(validator)>(validator));
+
+        // setup trivially-defined conversion function
+        AdcValueHolder::setupTrivialConvertFunc<traits::adc_retval_t<decltype(getter)>, std::tuple<Ts...>>();
+
+        return *this;
+    }
+
+
+    template <typename... Ts>
+    AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
+                                     std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
+                                     const std::tuple<Ts...>& t /* tuple-of-trivially-converting-types */)
+    {
+        return resetValueHolder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
+                                AdcValueHolder::AdcValueHolderDummyValidator<traits::adc_retval_t<decltype(getter)>>,
+                                t);
+    }
+
+
+    template <typename FromFuncT, typename ToFuncT>
+    AdcValueHolder& addConvertFunc(FromFuncT&& func_from_internal, ToFuncT&& func_to_internal)
+    // requires std::invocable<FromFuncT, std::remove_cvref_t<traits::adc_retval_t<ToFuncT>>> &&
+    //          std::invocable<ToFuncT, std::remove_cvref_t<traits::adc_retval_t<FromFuncT>>>
+    {
+        using from_sig_t = typename traits::adc_func_traits<FromFuncT>;
+        using to_sig_t = typename traits::adc_func_traits<ToFuncT>;
+        using value_t = typename to_sig_t::ret_t;  // internal value type
+        using user_t = typename from_sig_t::ret_t;
+
+        // static_assert(!std::is_same_v<value_t, void>, "void IS NOT VALID TYPE!!!");
+
+        // static_assert(!std::is_void_v<typename traits::adc_func_traits<FromFuncT>::arg1_t>,
+        //               "INVALID CONVERSIONAL FUNCTION!!!");
+
+        // static_assert(std::is_same_v<std::remove_cvref_t<typename traits::adc_func_traits<FromFuncT>::arg1_t>,
+        // value_t>,
+        //               "INVALID CONVERSIONAL FUNCTION!!!");
+
+        _getterFunc<user_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<FromFuncT>(func_from_internal)),
+                                     this]() {
+            if (_getterFunc<value_t>[this]) {
+                auto val = _getterFunc<value_t>[this]();
+                return std::get<0>(wrapper)(val);  // convert from internal type
+            }
+            // invalid conversion function signature
+            throw std::system_error(AdcValueHolderErrorCode::ERROR_INTERNAL_TYPE_MISMATCH);
+        };
+
+
+        _setterFunc<user_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<ToFuncT>(func_to_internal)),
+                                     this](const user_t& val) {
+            value_t value = std::get<0>(wrapper)(val);  // convert to internal type
+            if (_setterFunc<value_t>[this]) {
+                _setterFunc<value_t>[this](value);
+            } else {
+                // invalid conversion function signature
+                throw std::system_error(AdcValueHolderErrorCode::ERROR_INTERNAL_TYPE_MISMATCH);
+            }
+        };
+
+        return *this;
+    }
+
+
+    template <typename UT>
+    operator UT()
+    {
+        using v_t = std::remove_reference_t<UT>;
+        using val_t = std::conditional_t<std::is_array_v<v_t>, std::add_pointer_t<std::remove_extent_t<v_t>>, v_t>;
+
+        auto getter = _getterFunc<val_t>[this];
+        if (getter) {
+            return getter();
+        }
+
+        throw std::system_error(AdcValueHolderErrorCode::ERROR_NO_CONV_FUNC);
+    }
+
+    template <typename UT>
+    AdcValueHolder& operator=(UT&& value)
+    {
+        // using v_t = std::remove_reference_t<UT>;
+        using v_t = std::remove_cvref_t<UT>;
+        using val_t = std::conditional_t<std::is_array_v<v_t>, std::add_pointer_t<std::remove_extent_t<v_t>>, v_t>;
+
+        auto setter = _setterFunc<val_t>[this];
+        if (setter) {
+            setter(std::forward<UT>(value));
+        } else {
+            throw std::system_error(AdcValueHolderErrorCode::ERROR_NO_CONV_FUNC);
+        }
+
+        return *this;
+    }
+
+
+    AdcValueHolder& operator=(AdcValueHolder&& other) = default;
+    AdcValueHolder& operator=(const AdcValueHolder& other) = default;
+
+
+protected:
+    /*  STATIC HELPER METHODS   */
+
+    template <typename VT, size_t I, typename TupleT>
+    void setupTrivialConvertFuncImpl()
+    {
+        if constexpr (I < std::tuple_size_v<TupleT>) {
+            using elem_t = std::tuple_element_t<I, TupleT>;
+
+            if constexpr (!std::is_same_v<VT, elem_t>) {
+                addConvertFunc([](const VT& v) { return static_cast<elem_t>(v); },
+                               [](const elem_t& v) { return static_cast<VT>(v); });
+            }
+
+            AdcValueHolder::setupTrivialConvertFuncImpl<VT, I + 1, TupleT>();
+        }
+    }
+
+    template <typename VT, typename TupleT>
+    void setupTrivialConvertFunc()
+    {
+        setupTrivialConvertFuncImpl<VT, 0, TupleT>();
+    }
+};
+
+
+/*
+    factory functions
+
+ */
+
+template <typename GT,
+          typename VALT = traits::adc_retval_t<GT>,
+          typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
+AdcValueHolder make_arith_valueholder(GT&& getter,
+                                      std::invocable<const VALT&> auto&& setter,
+                                      VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
+    requires std::invocable<GT> && std::predicate<VT, const VALT&>
+{
+    using val_t = traits::adc_retval_t<GT>;
+
+    // static_assert(std::predicate<decltype(validator), const traits::adc_retval_t<decltype(getter)>&>,
+    //               "INVALID VALIDATOR TYPE!!!");
+
+    static_assert(std::is_arithmetic_v<val_t>, "GETTER MUST RETURN AN ARITHMETIC TYPE VALUE!!!");
+
+    return AdcValueHolder(std::forward<GT>(getter), std::forward<decltype(setter)>(setter),
+                          std::forward<decltype(validator)>(validator), AdcValueHolder::_defaultTrivialConvTypes);
+}
+
+
+/*  */
+
+template <typename SerializedT = std::string>
+class AdcSerializingValueHolder : public AdcValueHolder
+{
+protected:
+    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)
+    {
+        _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);
+
+            auto val = getter();
+            return serializer(val);
+        };
+
+
+        using v_t = traits::adc_retval_t<GT>;
+
+        _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);
+
+            v_t val = deserializer(sval);
+
+            if (validator(val)) {
+                setter(val);
+            } else {
+                throw std::system_error(AdcValueHolderErrorCode::ERROR_VALUE_IS_NOT_VALID);
+            }
+        };
+    }
+
+public:
+    using AdcValueHolder::AdcValueHolder;
+
+    virtual ~AdcSerializingValueHolder() = default;
+};
+
+
+}  // namespace adc
diff --git a/tests/adc_valueholder_test.cpp b/tests/adc_valueholder_test.cpp
index 07b7f0e..af0bc7b 100644
--- a/tests/adc_valueholder_test.cpp
+++ b/tests/adc_valueholder_test.cpp
@@ -4,7 +4,8 @@
 #include <iostream>
 
 #include "../common/adc_utils.h"
-#include "../common/adc_value_holder.h"
+// #include "../common/adc_value_holder.h"
+#include "../common/adc_value.h"
 
 TEST_CASE("[ADC VALUEHOLDER]")
 {
@@ -36,7 +37,9 @@ TEST_CASE("[ADC VALUEHOLDER]")
     CHECK_THROWS_WITH_AS(vh = 1.1, "conversion function is not defined", std::system_error);
     CHECK_THROWS_WITH_AS(vh = -3, "user value is not valid", std::system_error);
 
-    double dv = 33.33;
+    std::cout << "int_val = " << int_val << "\n";
+
+    const double dv = 33.33;
     vah = dv;
 
     REQUIRE_EQ(int_val, 33);
@@ -66,13 +69,15 @@ TEST_CASE("[ADC VALUEHOLDER]")
 
     adc::AdcValueHolder vsh(sget, sset, sval);
 
-    vsh.addConvertFunc<const char*>([](std::any& v) { v = std::string(std::any_cast<const char*>(v)); },
-                                    [](std::any& v) {
-                                        auto sval = std::any_cast<std::string>(&v);
-                                        v = sval->c_str();
-                                    });
+    // vsh.addConvertFunc<const char*>([](std::any& v) { v = std::string(std::any_cast<const char*>(v)); },
+    //                                 [](std::any& v) {
+    //                                     auto sval = std::any_cast<std::string>(&v);
+    //                                     v = sval->c_str();
+    //                                 });
 
 
+    vsh.addConvertFunc([](const std::string& v) { return v.c_str(); }, [](const char* v) { return std::string(v); });
+
     vsh = "NEW VALUE";
 
     REQUIRE_EQ(str, "NEW VALUE");