solve problem with adc_func_traits

add and use concept adc_is_callable
rewrite value holder and device attribute classes
with new constructor's arguments resolution scheme

common/adc_traits.h

@@ -67,10 +67,16 @@ struct adc_func_traits_helper_t<R, Arg, Args...> {
 };
 
 
-// callable traits
+// callable concept and its signature traits
 
-template <typename F, typename = void>
+template <typename T>
-struct adc_func_traits;
+concept adc_is_callable =
+    std::is_function_v<T> || (std::is_object_v<T> && requires(T) { std::is_function_v<decltype(&T::operator())>; });
+
+template <typename F>
+struct adc_func_traits {
+    // use of an empty struct here to match std::invoke_result behaivior (at least of GCC)
+};
 
 template <typename R, typename... Args>
 struct adc_func_traits<R (*)(Args...)> : adc_func_traits_helper_t<R, Args...> {
@@ -89,8 +95,8 @@ struct adc_func_traits<R (C::*)(Args...) const> : adc_func_traits_helper_t<R, Ar
 };
 
 template <typename F>
-// struct adc_func_traits : adc_func_traits<decltype(&std::remove_reference_t<F>::operator())> {
+    requires adc_is_callable<F>
-struct adc_func_traits<F, std::enable_if_t<std::is_class_v<F>>> : adc_func_traits<decltype(&F::operator())> {
+struct adc_func_traits<F> : adc_func_traits<decltype(&F::operator())> {
 };
 
 template <typename F>
@@ -138,13 +144,32 @@ template <typename T>
 struct adc_is_tuple : std::false_type {
 };
 
+template <typename T>
+struct adc_is_tuple<T&> : adc_is_tuple<T> {
+};
+
+template <typename T>
+struct adc_is_tuple<const T&> : adc_is_tuple<T> {
+};
+
+template <typename T>
+struct adc_is_tuple<T&&> : adc_is_tuple<T> {
+};
+
 
 template <typename... Ts>
 struct adc_is_tuple<std::tuple<Ts...>> : std::true_type {
 };
 
+template <typename T1, typename T2>
+struct adc_is_tuple<std::pair<T1, T2>> : std::true_type {
+};
 
 template <typename T>
 static inline constexpr bool adc_is_tuple_v = adc_is_tuple<T>::value;
 
+template <typename T>
+concept adc_tuple_like = adc_is_tuple_v<T> == true;
+
+
 }  // namespace adc::traits

common/adc_value.h

@@ -177,32 +177,21 @@ public:
     }
 
 
-    template <typename... Ts>
+    template <typename GT,
-    AdcValueHolder(std::invocable<> auto&& getter,
+              typename VALT = ret_value_t<GT>,
-                   std::invocable<const ret_value_t<decltype(getter)>&> auto&& setter,
+              typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
-                   std::predicate<const ret_value_t<decltype(getter)>&> auto&& validator,
+    AdcValueHolder(traits::adc_tuple_like<> auto&& tpl,
-                   const std::tuple<Ts...>& /* tuple-of-trivially-converting-types */)
+                   GT&& getter,
-        : AdcValueHolder(std::forward<decltype(getter)>(getter),
+                   std::invocable<const VALT&> auto&& setter,
+                   VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
+        : AdcValueHolder(std::forward<GT>(getter),
                          std::forward<decltype(setter)>(setter),
                          std::forward<decltype(validator)>(validator))
     {
         // setup trivially-defined conversion function
-        AdcValueHolder::setupTrivialConvertFunc<ret_value_t<decltype(getter)>, std::tuple<Ts...>>();
+        AdcValueHolder::setupTrivialConvertFunc<VALT, std::decay_t<decltype(tpl)>>();
     }
 
-
-    template <typename... Ts>
-    AdcValueHolder(std::invocable<> auto&& getter,
-                   std::invocable<const ret_value_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;
 
@@ -227,29 +216,17 @@ public:
     }
 
 
-    template <typename... Ts>
+    template <typename GT, typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<ret_value_t<GT>>)>
-    AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
+    AdcValueHolder& resetValueHolder(traits::adc_tuple_like<> auto&& tpl,
-                                     std::invocable<const ret_value_t<decltype(getter)>&> auto&& setter,
+                                     GT&& getter,
-                                     std::predicate<const ret_value_t<decltype(getter)>&> auto&& validator,
+                                     std::invocable<const ret_value_t<GT>&> auto&& setter,
-                                     const std::tuple<Ts...>& /* tuple-of-trivially-converting-types */)
+                                     VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<ret_value_t<GT>>)
     {
-        resetValueHolder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
-                         std::forward<decltype(validator)>(validator));
-
         // setup trivially-defined conversion function
-        setupTrivialConvertFunc<ret_value_t<decltype(getter)>, std::tuple<Ts...>>();
+        AdcValueHolder::setupTrivialConvertFunc<ret_value_t<GT>, std::decay_t<decltype(tpl)>>();
 
-        return *this;
-    }
-
-
-    template <typename... Ts>
-    AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
-                                     std::invocable<const ret_value_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<ret_value_t<decltype(getter)>>, t);
+                                std::forward<decltype(validator)>(validator));
     }
 
 
@@ -425,43 +402,24 @@ public:
     template <typename GT,
               typename ST,
               typename VALT = ret_value_t<GT>,
-              typename VT,
+              typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>),
               typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>),
-              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>),
+              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)>
-              typename... Ts>
+    AdcSerializingValueHolder(traits::adc_tuple_like<> auto&& tpl,
-    AdcSerializingValueHolder(GT&& getter,
+                              GT&& getter,
                               ST&& setter,
-                              VT&& validator,
+                              VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
-                              const std::tuple<Ts...>&,
                               SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>,
                               DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
-        : AdcValueHolder(std::forward<GT>(getter),
+        requires std::invocable<GT> && std::invocable<ST, const VALT&> && std::predicate<VT, const VALT&> &&
+                 std::invocable<SRT, const VALT&> && std::invocable<DSRT, const SerializedT&>
+        : AdcSerializingValueHolder(std::forward<GT>(getter),
                                     std::forward<ST>(setter),
                                     std::forward<VT>(validator),
-                         std::tuple<Ts...>{})
+                                    std::forward<SRT>(serializer),
+                                    std::forward<DSRT>(deserializer))
     {
-        initWrappers<VALT>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
+        AdcValueHolder::setupTrivialConvertFunc<VALT, std::decay_t<decltype(tpl)>>();
-    }
-
-
-
-    template <typename GT,
-              typename ST,
-              typename VALT = ret_value_t<GT>,
-              typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>),
-              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>),
-              typename... Ts>
-    AdcSerializingValueHolder(GT&& getter,
-                              ST&& setter,
-                              const std::tuple<Ts...>&,
-                              SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>,
-                              DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
-        : AdcValueHolder(std::forward<GT>(getter),
-                         std::forward<ST>(setter),
-                         AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
-                         std::tuple<Ts...>{})
-    {
-        initWrappers<VALT>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
     }
 
 
@@ -494,44 +452,24 @@ public:
               typename ST,
               typename VT,
               typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, ret_value_t<GT>>),
-              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ret_value_t<GT>, SerializedT>),
+              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ret_value_t<GT>, SerializedT>)>
-              typename... Ts>
     AdcSerializingValueHolder& resetValueHolder(
+        traits::adc_tuple_like<> auto&& tpl,
         GT&& getter,
         ST&& setter,
         VT&& validator,
-        const std::tuple<Ts...>&,
         SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, ret_value_t<GT>>,
         DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ret_value_t<GT>, SerializedT>)
     {
-        AdcValueHolder::resetValueHolder(std::forward<GT>(getter), std::forward<ST>(setter),
+        AdcSerializingValueHolder::resetValueHolder(std::forward<GT>(getter), std::forward<ST>(setter),
-                                         std::forward<VT>(validator), std::tuple<Ts...>{});
+                                                    std::forward<VT>(validator), std::forward<SRT>(serializer),
+                                                    std::forward<DSRT>(deserializer));
 
-        initWrappers<ret_value_t<GT>>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
+        AdcValueHolder::setupTrivialConvertFunc<ret_value_t<GT>, std::decay_t<decltype(tpl)>>();
 
         return *this;
     }
 
-    template <typename GT,
-              typename ST,
-              typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, ret_value_t<GT>>),
-              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ret_value_t<GT>, SerializedT>),
-              typename... Ts>
-    AdcSerializingValueHolder& resetValueHolder(
-        GT&& getter,
-        ST&& setter,
-        const std::tuple<Ts...>&,
-        SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, ret_value_t<GT>>,
-        DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ret_value_t<GT>, SerializedT>)
-    {
-        AdcValueHolder::resetValueHolder(std::forward<GT>(getter), std::forward<ST>(setter), std::tuple<Ts...>{});
-
-        initWrappers<ret_value_t<GT>>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
-
-        return *this;
-    }
-
-
     SerializedT serialize() { return _serializerWrapper(); }
 
     void deserialize(const SerializedT& sval) { _deserializerWrapper(sval); }
@@ -560,8 +498,8 @@ HolderT makeArithmValue(GT&& getter,
 
     static_assert(std::is_arithmetic_v<val_t>, "GETTER MUST RETURN AN ARITHMETIC TYPE VALUE!!!");
 
-    return HolderT(std::forward<GT>(getter), std::forward<decltype(setter)>(setter),
+    return HolderT(AdcValueHolder::_defaultTrivialConvTypes, std::forward<GT>(getter),
-                   std::forward<decltype(validator)>(validator), AdcValueHolder::_defaultTrivialConvTypes,
+                   std::forward<decltype(setter)>(setter), std::forward<decltype(validator)>(validator),
                    std::forward<Ts>(other_ctor_args)...);
 }
 

device/adc_device_attribute.h

@@ -81,6 +81,26 @@ public:
     }
 
 
+    template <typename GT,
+              typename VALT = ret_value_t<GT>,
+              typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>)>
+    AdcDeviceAttribute(const IdentT& ident,
+                       traits::adc_tuple_like<> auto&& tpl,
+                       GT&& getter,
+                       SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>)
+        requires std::invocable<GT> && std::invocable<SRT, const VALT&>
+        : AdcDeviceAttribute(ident,
+                             std::forward<decltype(tpl)>(tpl),
+                             std::forward<GT>(getter),
+                             AdcDeviceAttribute::DummySetter<VALT>,
+                             AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
+                             std::forward<SRT>(serializer),
+                             AdcDeviceAttribute::DummyDeserializer<VALT>)
+    {
+        _accessType = ReadOnly;
+    }
+
+
     // write-only attribute constructor
     template <typename ST,
               typename VALT = std::decay_t<traits::adc_func_arg1_t<ST>>,
@@ -101,6 +121,27 @@ public:
     }
 
 
+    template <typename ST,
+              typename VALT = std::decay_t<traits::adc_func_arg1_t<ST>>,
+              typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)>
+    AdcDeviceAttribute(const IdentT& ident,
+                       traits::adc_tuple_like<> auto&& tpl,
+                       ST&& setter,
+                       std::predicate<const VALT&> auto&& validator,
+                       DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
+        requires std::invocable<DSRT, const SerializedT&>
+        : AdcDeviceAttribute(ident,
+                             std::forward<decltype(tpl)>(tpl),
+                             AdcDeviceAttribute::DummyGetter<VALT>,
+                             std::forward<ST>(setter),
+                             std::forward<decltype(validator)>(validator),
+                             AdcDeviceAttribute::DummySerializer<VALT>,
+                             std::forward<DSRT>(deserializer))
+    {
+        _accessType = WriteOnly;
+    }
+
+
 
     virtual ~AdcDeviceAttribute() = default;
 

tests/adc_devattr_test.cpp

@@ -32,13 +32,15 @@ TEST_CASE("[ADC DEVICE ATTRIBUTE]")
 
     using attr_t = AdcDeviceAttribute<std::string_view>;
 
-    // attr_t attr(AdcValueHolder::_defaultTrivialConvTypes, "ATTR_A", attr_t::ReadWrite, vv::getter, vv::setter,
+    attr_t attr("ATTR_A", AdcValueHolder::_defaultTrivialConvTypes, vv::getter, vv::setter, vv::validator);
-    //             vv::validator);
-    attr_t attr("ATTR_A", vv::getter, vv::setter, vv::validator, AdcValueHolder::_defaultTrivialConvTypes);
 
     attr = 10.7;
     av = attr;
 
     std::cout << "ATTR = " << av << "\n";
     // std::cout << "ATTR = " << (unsigned)attr << "\n";
+
+    attr_t aw("ATTR_WO", AdcValueHolder::_defaultTrivialConvTypes, vv::setter, vv::validator);
+
+    std::cout << "ACC_TYPE: " << aw.accessType() << "\n";
 }

tests/adc_valueholder_test.cpp

@@ -46,7 +46,8 @@ TEST_CASE("[ADC VALUEHOLDER]")
             return true;
     };
 
-    adc::AdcValueHolder vht(getter, setter, adc::AdcValueHolder::_defaultTrivialConvTypes);
+    // adc::AdcValueHolder vht(getter, setter, adc::AdcValueHolder::_defaultTrivialConvTypes);
+    adc::AdcValueHolder vht(adc::AdcValueHolder::_defaultTrivialConvTypes, getter, setter);
     adc::AdcValueHolder vh(getter, setter, validator);
     // auto vah = adc::make_arith_valueholder(getter, setter);
     auto vah = adc::makeArithmValue<adc::AdcValueHolder>(getter, setter);
@@ -178,7 +179,8 @@ TEST_CASE("[ADC VALUEHOLDER]")
 
 
 
-    adc::AdcSerializingValueHolder svh(getter, setter, validator, adc::AdcValueHolder::_defaultTrivialConvTypes);
+    // adc::AdcSerializingValueHolder svh(getter, setter, validator, adc::AdcValueHolder::_defaultTrivialConvTypes);
+    adc::AdcSerializingValueHolder svh(adc::AdcValueHolder::_defaultTrivialConvTypes, getter, setter, validator);
 
     svh = 77.65412;
 
@@ -193,7 +195,8 @@ TEST_CASE("[ADC VALUEHOLDER]")
     // fl = vsh;
     // std::cout << "VSH: " << fl << "\n";
 
-    svh.resetValueHolder(gdbl, sdbl, vdbl, adc::AdcValueHolder::_defaultTrivialConvTypes);
+    // svh.resetValueHolder(gdbl, sdbl, vdbl, adc::AdcValueHolder::_defaultTrivialConvTypes);
+    svh.resetValueHolder(adc::AdcValueHolder::_defaultTrivialConvTypes, gdbl, sdbl, vdbl);
     // svh.resetValueHolder([]() { return dbl_val; }, [](const double& v) { dbl_val = v; },
     //                      [](const double&) { return true; }, adc::AdcValueHolder::_defaultTrivialConvTypes);
     std::cout << "SERIALIZED: " << svh.serialize() << "\n";