From 3ea9aa9c4df38620049705c9cae109cb4f4479fc Mon Sep 17 00:00:00 2001
From: "Timur A. Fatkhullin" <amirych@gmail.com>
Date: Fri, 3 May 2024 21:55:49 +0300
Subject: [PATCH] ...

---
 device/adc_device_attribute.h | 41 +++++++----------------------------
 tests/adc_devattr_test.cpp    | 10 ++++-----
 2 files changed, 13 insertions(+), 38 deletions(-)

diff --git a/device/adc_device_attribute.h b/device/adc_device_attribute.h
index cc18098..1045610 100644
--- a/device/adc_device_attribute.h
+++ b/device/adc_device_attribute.h
@@ -30,7 +30,7 @@ public:
     template <typename T>
     constexpr static T DummyGetter()
     {
-        return std::declval<T>();
+        return T();
     }
 
 
@@ -42,41 +42,22 @@ public:
     template <typename T>
     constexpr static SerializedT DummySerializer(const T&)
     {
-        return std::declval<SerializedT>();
+        return SerializedT();
     }
 
     template <typename T>
     constexpr static T DummyDeserializer(const SerializedT&)
     {
-        return std::declval<T>();
+        return T();
     }
 
 
     /*  CONSTRUCTORS AND DESTRUCTOR  */
 
     // general read-write attribute constructor
-    template <typename GT,
-              typename ST,
-              typename VALT = ret_value_t<GT>,
-              typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>),
-              typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>),
-              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)>
-    AdcDeviceAttribute(const IdentT& ident,
-                       AccessType access_type,
-                       GT&& getter,
-                       ST&& setter,
-                       VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
-                       SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>,
-                       DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
-        requires std::invocable<GT> && std::invocable<ST, const VALT&> && std::predicate<VT, const VALT&> &&
-                     std::invocable<SRT, const VALT&> && std::invocable<DSRT, const SerializedT&>
-        : base_t(std::forward<GT>(getter),
-                 std::forward<ST>(setter),
-                 std::forward<VT>(validator),
-                 std::forward<SRT>(serializer),
-                 std::forward<DSRT>(deserializer)),
-          _ident(ident),
-          _accessType(access_type)
+    template <typename... SerValHolderTs>
+    AdcDeviceAttribute(const IdentT& ident, SerValHolderTs&&... ctor_args)
+        : base_t(std::forward<SerValHolderTs>(ctor_args)...), _ident(ident), _accessType(ReadWrite)
     {
     }
 
@@ -90,13 +71,13 @@ public:
                        SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>)
         requires std::invocable<GT> && std::invocable<SRT, const VALT&>
         : AdcDeviceAttribute(ident,
-                             ReadOnly,
                              std::forward<GT>(getter),
                              AdcDeviceAttribute::DummySetter<VALT>,
                              AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
                              std::forward<SRT>(serializer),
                              AdcDeviceAttribute::DummyDeserializer<VALT>)
     {
+        _accessType = ReadOnly;
     }
 
 
@@ -110,22 +91,16 @@ public:
                        DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
         requires std::invocable<DSRT, const SerializedT&>
         : AdcDeviceAttribute(ident,
-                             WriteOnly,
                              AdcDeviceAttribute::DummyGetter<VALT>,
                              std::forward<ST>(setter),
                              std::forward<decltype(validator)>(validator),
                              AdcDeviceAttribute::DummySerializer<VALT>,
                              std::forward<DSRT>(deserializer))
     {
+        _accessType = WriteOnly;
     }
 
 
-    // constructor of attribute with trivially casting type converters
-    template <typename... TrivCastTs, typename... Ts>
-    AdcDeviceAttribute(const std::tuple<TrivCastTs...>&, Ts&&... ctor_args)
-        : AdcDeviceAttribute(std::forward<Ts>(ctor_args)...)
-    {
-    }
 
     virtual ~AdcDeviceAttribute() = default;
 
diff --git a/tests/adc_devattr_test.cpp b/tests/adc_devattr_test.cpp
index 36c7a41..4497f2e 100644
--- a/tests/adc_devattr_test.cpp
+++ b/tests/adc_devattr_test.cpp
@@ -34,11 +34,11 @@ TEST_CASE("[ADC DEVICE ATTRIBUTE]")
 
     // attr_t attr(AdcValueHolder::_defaultTrivialConvTypes, "ATTR_A", attr_t::ReadWrite, vv::getter, vv::setter,
     //             vv::validator);
-    attr_t attr("ATTR_A", attr_t::ReadWrite, vv::getter, vv::setter, vv::validator);
+    attr_t attr("ATTR_A", vv::getter, vv::setter, vv::validator, AdcValueHolder::_defaultTrivialConvTypes);
 
-    // attr = 10.7;
-    // av = attr;
+    attr = 10.7;
+    av = attr;
 
-    // std::cout << "ATTR = " << av << "\n";
-    std::cout << "ATTR = " << (unsigned)attr << "\n";
+    std::cout << "ATTR = " << av << "\n";
+    // std::cout << "ATTR = " << (unsigned)attr << "\n";
 }