add common/adc_valholder.h header:

new conception: 1) no validator
                  2) AdcSerializingValueHolder is now non-templated
                     class

CMakeLists.txt

@@ -10,7 +10,8 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(ADC_COMMON_HEADERS
     common/adc_traits.h
     common/adc_value_holder.h    
-    common/adc_value.h)
+    common/adc_value.h
+    common/adc_valholder.h)
 
 set(ADC_DEVICE_HEADERS
     device/adc_device_attribute.h
@@ -26,7 +27,7 @@ if (BUILD_TESTS)
     add_executable(${VALUEHOLDER_TEST_APP} tests/adc_valueholder_test.cpp)
 
     set(DEVATTR_TEST_APP adc_devattr_test)
-    add_executable(${DEVATTR_TEST_APP} tests/adc_devattr_test.cpp)
+    # add_executable(${DEVATTR_TEST_APP} tests/adc_devattr_test.cpp)
 
     if (NOT doctest_FOUND)
         include(FetchContent)

common/adc_valholder.h

@@ -0,0 +1,548 @@
+#pragma once
+
+
+/*
+
+ABSTRACT DEVICE COMPONENTS LIBRARY
+
+ */
+
+
+#include <functional>
+#include <system_error>
+
+#include "adc_traits.h"
+#include "adc_utils.h"
+
+
+namespace adc
+{
+
+// error codes
+enum class AdcValueHolderErrorCode : int { ERROR_OK, ERROR_NO_CONV_FUNC, ERROR_INTERNAL_TYPE_MISMATCH };
+
+enum class AdcSerializingValueHolderErrorCode : int { ERROR_OK, ERROR_INVALID_SERIALIZED_TYPE };
+
+}  // namespace adc
+
+
+namespace std
+{
+
+template <>
+class is_error_code_enum<adc::AdcValueHolderErrorCode> : public true_type
+{
+};
+
+template <>
+class is_error_code_enum<adc::AdcSerializingValueHolderErrorCode> : 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 "ADC_VALUE_HOLDER_CATEGORY"; }
+
+    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)";
+            default:
+                return "UNKNOWN";
+        }
+    }
+
+    static const AdcValueHolderErrorCategory& get()
+    {
+        static const AdcValueHolderErrorCategory constInst;
+        return constInst;
+    }
+};
+
+
+struct AdcSerializingValueHolderErrorCategory : public std::error_category {
+    AdcSerializingValueHolderErrorCategory() : std::error_category() {}
+
+    const char* name() const noexcept { return "ADC_SERIALIZING_VALUE_HOLDER_CATEGORY"; }
+
+    std::string message(int ec) const
+    {
+        AdcSerializingValueHolderErrorCode err = static_cast<AdcSerializingValueHolderErrorCode>(ec);
+
+        switch (err) {
+            case AdcSerializingValueHolderErrorCode::ERROR_OK:
+                return "OK";
+            case AdcSerializingValueHolderErrorCode::ERROR_INVALID_SERIALIZED_TYPE:
+                return "invalid user-passed serialized type";
+            default:
+                return "UNKNOWN";
+        }
+    }
+
+    static const AdcSerializingValueHolderErrorCategory& get()
+    {
+        static const AdcSerializingValueHolderErrorCategory constInst;
+        return constInst;
+    }
+};
+
+
+inline std::error_code make_error_code(AdcValueHolderErrorCode ec)
+{
+    return std::error_code(static_cast<int>(ec), AdcValueHolderErrorCategory::get());
+}
+
+
+inline std::error_code make_error_code(AdcSerializingValueHolderErrorCode ec)
+{
+    return std::error_code(static_cast<int>(ec), AdcSerializingValueHolderErrorCategory::get());
+}
+
+
+/*
+
+                      GENERAL-PURPOSE VALUE HOLDER CLASS
+
+ */
+
+
+class AdcValueHolder
+{
+protected:
+    template <typename T>
+    using ret_value_t = std::decay_t<traits::adc_retval_t<T>>;
+
+    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{};
+
+    std::function<void()> _clearFunc;
+
+    std::function<void(AdcValueHolder*)> _copyFunc;
+    std::function<void(AdcValueHolder*)> _moveFunc;
+
+
+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{};
+
+
+    /*  CONSTRUCTORS AND DESTRUCTOR  */
+
+    template <std::invocable<> GT, typename ValueT = ret_value_t<GT>, std::invocable<const ValueT&> ST>
+    AdcValueHolder(GT&& getter, ST&& setter)
+    {
+        _getterFunc<ValueT>.emplace(this, std::forward<GT>(getter));
+        _setterFunc<ValueT>.emplace(this, std::forward<ST>(setter));
+
+        _clearFunc = [this]() {
+            _getterFunc<ValueT>.erase(this);
+            _setterFunc<ValueT>.erase(this);
+        };
+
+        // copy TO other
+        _copyFunc = [this](AdcValueHolder* other) {
+            _getterFunc<ValueT>.emplace(other, _getterFunc<ValueT>[this]);
+            _setterFunc<ValueT>.emplace(other, _setterFunc<ValueT>[this]);
+        };
+
+        // move TO other
+        _moveFunc = [this](AdcValueHolder* other) {
+            _getterFunc<ValueT>.emplace(other, std::move(_getterFunc<ValueT>[this]));
+            _setterFunc<ValueT>.emplace(other, std::move(_setterFunc<ValueT>[this]));
+        };
+    }
+
+
+    template <traits::adc_tuple_like<> TupleT,
+              std::invocable<> GT,
+              typename ValueT = ret_value_t<GT>,
+              std::invocable<const ValueT&> ST>
+    AdcValueHolder(TupleT&&, GT&& getter, ST&& setter)
+        : AdcValueHolder(std::forward<GT>(getter), std::forward<ST>(setter))
+    {
+        // setup trivially-defined conversion function
+        AdcValueHolder::setupTrivialConvertFunc<ValueT, std::decay_t<TupleT>>();
+    }
+
+    AdcValueHolder(const AdcValueHolder& other)
+    {
+        _clearFunc();
+
+        other._copyFunc(this);
+
+        _clearFunc = other._clearFunc;
+        _copyFunc = other._copyFunc;
+        _moveFunc = other._moveFunc;
+    };
+
+
+    AdcValueHolder(AdcValueHolder&& other)
+    {
+        _clearFunc();
+
+        other._moveFunc(this);
+
+        _clearFunc = std::move(other._clearFunc);
+        _copyFunc = std::move(other._copyFunc);
+        _moveFunc = std::move(other._moveFunc);
+    };
+
+    virtual ~AdcValueHolder() { _clearFunc(); };
+
+
+    /*  PUBLIC METHODS  */
+
+
+    template <typename FromFuncT, typename ToFuncT>
+    AdcValueHolder& addConvertFunc(FromFuncT&& func_from_internal, ToFuncT&& func_to_internal)
+        requires std::invocable<FromFuncT, const ret_value_t<ToFuncT>&> &&
+                 std::invocable<ToFuncT, const ret_value_t<FromFuncT>&>
+    {
+        using value_t = ret_value_t<ToFuncT>;  // it must be internal value type
+        using user_t = ret_value_t<FromFuncT>;
+
+        _getterFunc<user_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<FromFuncT>(func_from_internal)),
+                                     this]() {
+            auto& getter = _getterFunc<value_t>[this];
+            if (getter) {
+                auto val = getter();
+                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
+            auto& setter = _setterFunc<value_t>[this];
+            if (setter) {
+                setter(value);
+            } else {
+                // invalid conversion function signature
+                throw std::system_error(AdcValueHolderErrorCode::ERROR_INTERNAL_TYPE_MISMATCH);
+            }
+        };
+
+        _clearFunc = [prev_clear = _clearFunc, this]() {
+            prev_clear();
+
+            _getterFunc<user_t>.erase(this);
+            _setterFunc<user_t>.erase(this);
+        };
+
+
+        _copyFunc = [prev_copy = _copyFunc, this](AdcValueHolder* other) {
+            prev_copy(other);
+
+            _getterFunc<user_t>.emplace(other, _getterFunc<user_t>[this]);
+            _setterFunc<user_t>.emplace(other, _setterFunc<user_t>[this]);
+        };
+
+        // move TO other
+        _moveFunc = [prev_move = _moveFunc, this](AdcValueHolder* other) {
+            prev_move(other);
+
+            _getterFunc<user_t>.emplace(other, std::move(_getterFunc<user_t>[this]));
+            _setterFunc<user_t>.emplace(other, std::move(_setterFunc<user_t>[this]));
+        };
+
+        return *this;
+    }
+
+
+    template <typename UT>
+    operator UT() const
+    {
+        using val_t = std::decay_t<UT>;
+
+        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 val_t = std::decay_t<UT>;
+
+        auto setter = _setterFunc<val_t>[this];
+        if (setter) {
+            setter(std::forward<UT>(value));
+            // setter(value);
+        } else {
+            throw std::system_error(AdcValueHolderErrorCode::ERROR_NO_CONV_FUNC);
+        }
+
+        return *this;
+    }
+
+
+    AdcValueHolder& operator=(AdcValueHolder&& other)
+    {
+        if (&other != this) {
+            _clearFunc();
+
+            other._moveFunc(this);
+
+            _clearFunc = std::move(other._clearFunc);
+            _copyFunc = std::move(other._copyFunc);
+            _moveFunc = std::move(other._moveFunc);
+        }
+
+        return *this;
+    }
+
+    AdcValueHolder& operator=(const AdcValueHolder& other)
+    {
+        if (&other != this) {
+            _clearFunc();
+
+            other._copyFunc(this);
+
+            _clearFunc = other._clearFunc;
+            _copyFunc = other._copyFunc;
+            _moveFunc = other._moveFunc;
+        }
+
+        return *this;
+    }
+
+
+protected:
+    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); });
+            }
+
+            setupTrivialConvertFuncImpl<VT, I + 1, TupleT>();
+        }
+    }
+
+    template <typename VT, typename TupleT>
+    void setupTrivialConvertFunc()
+    {
+        setupTrivialConvertFuncImpl<VT, 0, TupleT>();
+    }
+};
+
+
+
+class AdcSerializingValueHolder : public AdcValueHolder
+{
+protected:
+    template <typename SerializedT>
+    inline static std::unordered_map<const AdcSerializingValueHolder*, std::function<SerializedT()>> _serializerFunc{};
+
+    template <typename SerializedT>
+    inline static std::unordered_map<const AdcSerializingValueHolder*, std::function<void(const SerializedT&)>>
+        _deserializerFunc{};
+
+    // shadow base class's members
+    std::function<void()> _clearFunc;
+    std::function<void(AdcSerializingValueHolder*)> _copyFunc;
+    std::function<void(AdcSerializingValueHolder*)> _moveFunc;
+
+public:
+    template <
+        std::invocable<> GT,
+        typename ValueT = ret_value_t<GT>,
+        std::invocable<const ValueT&> ST,
+        std::invocable<const ValueT&> SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<std::string, ValueT>),
+        typename SerializedT = ret_value_t<SRT>,
+        std::invocable<const SerializedT&> DSRT =
+            decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)>
+    AdcSerializingValueHolder(GT&& getter,
+                              ST&& setter,
+                              SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<std::string, ValueT>,
+                              DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
+        : AdcValueHolder(std::forward<GT>(getter), std::forward<ST>(setter))
+    {
+        _serializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer)), this]() {
+            auto& serializer = std::get<0>(wrapper);
+
+
+            auto val = _getterFunc<ValueT>[this]();
+
+            return serializer(val);
+        };
+
+
+        _deserializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<DSRT>(deserializer)),
+                                                this](const SerializedT& sval) {
+            auto& deserializer = std::get<0>(wrapper);
+
+            ValueT val = deserializer(sval);
+
+            _setterFunc<ValueT>[this](val);
+        };
+
+        _clearFunc = [this]() {
+            _serializerFunc<SerializedT>.erase(this);
+            _deserializerFunc<SerializedT>.erase(this);
+        };
+
+        _copyFunc = [this](AdcSerializingValueHolder* other) {
+            _serializerFunc<SerializedT>.emplace(other, _serializerFunc<SerializedT>[this]);
+            _deserializerFunc<SerializedT>.emplace(other, _deserializerFunc<SerializedT>[this]);
+        };
+
+        _moveFunc = [this](AdcSerializingValueHolder* other) {
+            _serializerFunc<SerializedT>.emplace(other, std::move(_serializerFunc<SerializedT>[this]));
+            _deserializerFunc<SerializedT>.emplace(other, std::move(_deserializerFunc<SerializedT>[this]));
+        };
+    }
+
+
+    template <
+        traits::adc_tuple_like<> TupleT,
+        std::invocable<> GT,
+        typename ValueT = ret_value_t<GT>,
+        std::invocable<const ValueT&> ST,
+        std::invocable<const ValueT&> SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<std::string, ValueT>),
+        typename SerializedT = ret_value_t<SRT>,
+        std::invocable<const SerializedT&> DSRT =
+            decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)>
+    AdcSerializingValueHolder(TupleT&&,
+                              GT&& getter,
+                              ST&& setter,
+                              SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<std::string, ValueT>,
+                              DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
+        : AdcSerializingValueHolder(std::forward<GT>(getter),
+                                    std::forward<ST>(setter),
+                                    std::forward<SRT>(serializer),
+                                    std::forward<DSRT>(deserializer))
+    {
+        AdcValueHolder::setupTrivialConvertFunc<ValueT, std::decay_t<TupleT>>();
+    }
+
+
+    virtual ~AdcSerializingValueHolder() { _clearFunc(); };
+
+    AdcSerializingValueHolder(const AdcSerializingValueHolder& other) : AdcValueHolder(other)
+    {
+        _clearFunc();
+
+        _copyFunc(other);
+    }
+
+
+    AdcSerializingValueHolder(AdcSerializingValueHolder&& other) : AdcValueHolder(std::move(other))
+    {
+        _clearFunc();
+
+        _moveFunc(other);
+    }
+
+    AdcSerializingValueHolder& operator=(const AdcSerializingValueHolder& other)
+    {
+        AdcValueHolder::operator=(other);
+        _copyFunc(other);
+
+        return *this;
+    }
+
+    AdcSerializingValueHolder& operator=(AdcSerializingValueHolder&& other)
+    {
+        AdcValueHolder::operator=(std::move(other));
+        _moveFunc(other);
+
+        return *this;
+    }
+
+
+    using AdcValueHolder::operator=;
+
+
+    template <typename SerializedT>
+    SerializedT serialize()
+    {
+        using s_t = std::decay_t<SerializedT>;
+
+        auto& serializer = _serializerFunc<s_t>[this];
+
+        if (serializer) {
+            return serializer();
+        }
+
+        throw std::system_error(AdcSerializingValueHolderErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
+    }
+
+    template <typename SerializedT>
+    void deserialize(const SerializedT& sval)
+    {
+        using s_t = std::decay_t<SerializedT>;
+
+        auto& deserializer = _deserializerFunc<s_t>[this];
+        if (deserializer) {
+            deserializer(sval);
+        } else {
+            throw std::system_error(AdcSerializingValueHolderErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
+        }
+    }
+};
+
+
+/*
+    factory functions
+
+ */
+
+template <typename HolderT,
+          std::invocable<> GT,
+          typename VALT = traits::adc_retval_t<GT>,
+          std::invocable<const VALT&> ST,
+          typename... Ts>
+HolderT makeArithmValue(GT&& getter, ST&& setter, Ts&&... other_ctor_args)
+{
+    using val_t = traits::adc_retval_t<GT>;
+
+    static_assert(std::is_arithmetic_v<val_t>, "GETTER MUST RETURN AN ARITHMETIC TYPE VALUE!!!");
+
+    return HolderT(AdcValueHolder::defaultTrivialConvTypes, std::forward<GT>(getter), std::forward<ST>(setter),
+                   std::forward<Ts>(other_ctor_args)...);
+}
+
+}  // namespace adc

tests/adc_valueholder_test.cpp

@@ -1,12 +1,15 @@
-#include <list>
+// #include <list>
 #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
 #include <doctest/doctest.h>
-#include <chrono>
+// #include <chrono>
 #include <iostream>
 
-#include "../common/adc_utils.h"
+// #include "../common/adc_utils.h"
+
+
 // #include "../common/adc_value_holder.h"
-#include "../common/adc_value.h"
+// #include "../common/adc_value.h"
+#include "../common/adc_valholder.h"
 
 
 static double dbl_val = 99.99;
@@ -33,6 +36,96 @@ bool vdbl(const double& v)
 }
 
 
+TEST_CASE("[ADC VALUEHOLDER]")
+{
+    int int_val = 10;
+
+    auto getter = [&int_val]() { return int_val; };
+    auto setter = [&int_val](const int& v) { int_val = v; };
+
+
+    adc::AdcValueHolder vh(getter, setter);
+    auto vah = adc::makeArithmValue<adc::AdcValueHolder>(getter, setter);
+
+    vh = 77;
+
+    REQUIRE_EQ(int_val, 77);
+
+    vh = 100;
+
+    int res = vh;
+
+    REQUIRE_EQ(res, 100);
+
+    CHECK_THROWS_WITH_AS(vh = 1.1, "conversion function is not defined", std::system_error);
+
+    std::cout << "int_val = " << int_val << "\n";
+
+    const double dv = 33.33;
+    vah = dv;
+
+    REQUIRE_EQ(int_val, 33);
+
+    vah = 100;
+    auto res_long = static_cast<unsigned long>(vah);
+
+    REQUIRE_EQ(res_long, 100ul);
+
+    vah = -10.1234;
+    REQUIRE_EQ(int_val, -10);
+
+
+
+    std::string str = "THIS IS A STRING";
+
+    auto sget = [&str]() { return str; };
+    auto sset = [&str](const std::string& s) { str = s; };
+
+
+    adc::AdcValueHolder vsh(sget, sset);
+
+    auto lls = [](const char* v) { return std::string(v); };
+    vsh.addConvertFunc([&str](const std::string&) { return str.c_str(); }, lls);
+
+    vsh = "NEW VALUE";
+
+    REQUIRE_EQ(str, "NEW VALUE");
+
+    const char* sptr = vsh;
+
+    std::cout << "SPTR: " << sptr << "\n";
+
+    REQUIRE_EQ(std::strcmp(sptr, "NEW VALUE"), 0);
+
+    // vah = vsh;
+
+
+    // vah = 10;
+
+
+    // adc::AdcSerializingValueHolder svh(adc::AdcValueHolder::defaultTrivialConvTypes, getter, setter);
+    auto svh = adc::makeArithmValue<adc::AdcSerializingValueHolder>(getter, setter);
+
+    svh = 77.65412;
+
+    std::cout << "SERIALIZED: " << svh.serialize<std::string>() << "\n";
+
+    std::string sval = "123";
+    svh.deserialize(sval);
+    float fl = svh;
+    std::cout << "DESERIALIZED: " << fl << "\n";
+
+
+    // adc::AdcSerializingValueHolder svhs(
+    //     sget, sset, [](const std::string& s) { return s; }, [](const std::string& s) { return s; });
+
+    // svh = svhs;
+
+    // svh = 10;
+}
+
+/*
+
 TEST_CASE("[ADC VALUEHOLDER]")
 {
     int int_val = 10;
@@ -81,7 +174,6 @@ TEST_CASE("[ADC VALUEHOLDER]")
     REQUIRE_EQ(int_val, -10);
 
 
-    /*  std::string holder  */
 
     std::string str = "THIS IS A STRING";
 
@@ -204,3 +296,5 @@ TEST_CASE("[ADC VALUEHOLDER]")
     res = svh;
     std::cout << "DESERIALIZED: " << res << "\n";
 }
+
+*/