AdcDeviceCommand is now parameter-less

rewrite AdcDeviceAttribute class, basic tests of AdcDeviceAttribute passed

common/adc_traits.h

@@ -78,6 +78,15 @@ struct adc_func_traits {
     // use of an empty struct here to match std::invoke_result behaivior (at least of GCC)
 };
 
+// special case
+template <>
+struct adc_func_traits<std::nullptr_t> {
+    using ret_t = std::nullptr_t;
+    using args_t = std::tuple<>;
+    using arg1_t = std::nullptr_t;
+    static constexpr size_t arity = 0;
+};
+
 template <typename R, typename... Args>
 struct adc_func_traits<R (*)(Args...)> : adc_func_traits_helper_t<R, Args...> {
 };

common/adc_utils.h

@@ -148,6 +148,8 @@ static VT AdcTrivialDeserializer(SerializedT&& s_value)
     } else {
         static_assert(false, "TRIVIAL DESERIALIZER: UNSUPPORTED SERIALIZING TYPE!!!");
     }
+
+    return VT();
 }
 
 

device/adc_device_attribute.h

@@ -63,52 +63,47 @@ concept adc_attr_convfunc_c = std::is_null_pointer_v<T> ||
 
 // deduce attribute type from getter and setter functions signatures
 template <adc_attr_getter_c GT, adc_attr_setter_c ST>
-using attr_value_t =
+using attr_value_t = std::decay_t<
     std::conditional_t<std::is_null_pointer_v<GT>,
                        std::conditional_t<std::is_null_pointer_v<ST>, std::nullptr_t, traits::adc_func_arg1_t<ST>>,
-                       traits::adc_retval_t<GT>>;
+                       traits::adc_retval_t<GT>>>;
 
 
 
 // deduce attribute internal type from conversional functions signatures
 template <adc_attr_convfunc_c FromFuncT, adc_attr_convfunc_c ToFuncT>
-using attr_internal_t = std::conditional_t<
+using attr_internal_t = std::decay_t<std::conditional_t<
     std::is_null_pointer_v<ToFuncT>,
     std::conditional_t<std::is_null_pointer_v<FromFuncT>, std::nullptr_t, traits::adc_retval_t<FromFuncT>>,
-    traits::adc_retval_t<ToFuncT>>;
+    traits::adc_retval_t<ToFuncT>>>;
 
 
 // deduce user-defined type from conversional functions signatures
 template <adc_attr_convfunc_c FromFuncT, adc_attr_convfunc_c ToFuncT>
-using attr_user_t = std::conditional_t<
+using attr_user_t = std::decay_t<std::conditional_t<
     std::is_null_pointer_v<FromFuncT>,
     std::conditional_t<std::is_null_pointer_v<ToFuncT>, std::nullptr_t, traits::adc_retval_t<ToFuncT>>,
-    traits::adc_retval_t<FromFuncT>>;
+    traits::adc_retval_t<FromFuncT>>>;
 
 
 // attribute serializer function concept
 template <typename T, typename VT>
-concept adc_serializer_c = std::invocable<T, const VT&> && !std::same_as<void, traits::adc_retval_t<T>>;
+concept adc_serializer_c =
+    std::is_null_pointer_v<T> || (std::invocable<T, const VT&> && !std::same_as<void, traits::adc_retval_t<T>>);
 
 
 // attribute deserializer function concept
-template <typename T, typename ST>
-concept adc_deserializer_c = std::invocable<T, const ST&> && !std::same_as<void, traits::adc_retval_t<T>>;
-
-
-// a callable and it has exactly one argument
-template <typename T>
-concept adc_is_setter = adc_func_traits<T>::arity == 1;
-
-// a callable with exactly one argument of type VT
 template <typename T, typename VT>
-concept adc_is_setter_arg = (adc_func_traits<T>::arity == 1) && std::same_as<VT, adc_func_arg1_t<T>>;
+concept adc_deserializer_c = std::is_null_pointer_v<T> || (traits::adc_func_traits<T>::arity == 1 &&
+                                                           std::convertible_to<traits::adc_retval_t<T>, VT>);
 
 
-// a callable with exactly one argument of type VT and it returns a value of type ST
+template <typename SRT, typename DSRT>
-template <typename T, typename ST, typename VT>
+using adc_attr_serialized_t = std::decay_t<
-concept adc_is_serializer =
+    std::conditional_t<std::is_null_pointer_v<SRT>,
-    (adc_func_traits<T>::arity == 1) && std::same_as<VT, adc_func_arg1_t<T>> && std::same_as<ST, adc_retval_t<T>>;
+                       std::conditional_t<std::is_null_pointer_v<DSRT>, std::nullptr_t, traits::adc_func_arg1_t<DSRT>>,
+                       traits::adc_retval_t<SRT>>>;
+
 
 }  // namespace traits
 
@@ -119,7 +114,9 @@ enum class AdcDeviceAttributeErrorCode : int {
     ERROR_INTERNAL_TYPE_MISMATCH,
     ERROR_READ_ONLY,
     ERROR_WRITE_ONLY,
-    ERROR_INVALID_SERIALIZED_TYPE
+    ERROR_INVALID_SERIALIZED_TYPE,
+    ERROR_NO_SERIALIZER,
+    ERROR_NO_DESERIALIZER
 };
 
 }  // namespace adc
@@ -163,6 +160,10 @@ struct AdcDeviceAttributeErrorCategory : public std::error_category {
                 return "device attribute is write-only";
             case AdcDeviceAttributeErrorCode::ERROR_INVALID_SERIALIZED_TYPE:
                 return "invalid user-passed serialized type";
+            case AdcDeviceAttributeErrorCode::ERROR_NO_SERIALIZER:
+                return "serializing function was not defined";
+            case AdcDeviceAttributeErrorCode::ERROR_NO_DESERIALIZER:
+                return "deserializing function was not defined";
             default:
                 return "UNKNOWN";
         }
@@ -216,68 +217,63 @@ public:
 
     enum AccessType { ReadOnly, WriteOnly, ReadWrite };
 
-    template <typename T>
-    constexpr static T DummyGetter()
-    {
-        return T();
-    }
-
-
-    template <typename T>
-    constexpr static void DummySetter(const T&)
-    {
-    }
-
-    template <typename T, typename SerializedT = default_serialized_t>
-    constexpr static SerializedT DummySerializer(const T&)
-    {
-        return SerializedT();
-    }
-
-    template <typename T, typename SerializedT = default_serialized_t>
-    constexpr static T DummyDeserializer(const SerializedT&)
-    {
-        return T();
-    }
-
 
     /*  CONSTRUCTORS AND DESTRUCTOR  */
 
-    template <std::invocable<> GT,
+    template <traits::adc_attr_getter_c GT,
-              typename ValueT = ret_value_t<GT>,
+              traits::adc_attr_setter_c ST,
-              std::invocable<const ValueT&> ST,
+              typename ValueT = traits::attr_value_t<GT, ST>,
-              std::invocable<const ValueT&> SRT =
+              traits::adc_serializer_c<ValueT> SRT =
                   decltype(utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>),
-              typename SerializedT = ret_value_t<SRT>,
+              traits::adc_deserializer_c<ValueT> DSRT =
-              std::invocable<const SerializedT&> DSRT =
+                  decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, default_serialized_t>)>
-                  decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)>
+    AdcDeviceAttribute(
-    AdcDeviceAttribute(GT&& getter,
+        const IdentT& ident,
-                       ST&& setter,
+        GT&& getter,
-                       SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>,
+        ST&& setter,
-                       DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
+        SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>,
+        DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, default_serialized_t>)
+        : _ident(ident), _accessType(AdcDeviceAttribute::ReadWrite)
     {
+        static_assert(!std::is_null_pointer_v<ValueT>, "Getter and Setter can not be nullptr simultaneously!!!");
+
+        using SerializedT = traits::adc_attr_serialized_t<SRT, DSRT>;
+        static_assert(!std::is_null_pointer_v<SerializedT>, "Deduced serialized type must not be std::nullptr_t!!!");
+
         _getterFunc<ValueT>.emplace(this, std::forward<GT>(getter));
         _setterFunc<ValueT>.emplace(this, std::forward<ST>(setter));
 
+        if constexpr (std::is_null_pointer_v<GT>) {
+            _accessType = AdcDeviceAttribute::WriteOnly;
+        }
 
-        _serializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer)), this]() {
+        if constexpr (std::is_null_pointer_v<ST>) {
-            auto& serializer = std::get<0>(wrapper);
+            _accessType = AdcDeviceAttribute::ReadOnly;
+        }
+
+        if constexpr (!std::is_null_pointer_v<GT> && !std::is_null_pointer_v<SRT>) {
+            _serializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer)),
+                                                  this]() {
+                auto& serializer = std::get<0>(wrapper);
 
 
-            auto val = _getterFunc<ValueT>[this]();
+                auto val = _getterFunc<ValueT>[this]();
 
-            return serializer(val);
+                return serializer(val);
-        };
+            };
+        }
 
 
-        _deserializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<DSRT>(deserializer)),
+        if constexpr (!std::is_null_pointer_v<ST> && !std::is_null_pointer_v<DSRT>) {
-                                                this](const SerializedT& sval) {
+            _deserializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<DSRT>(deserializer)),
-            auto& deserializer = std::get<0>(wrapper);
+                                                    this](const SerializedT& sval) {
+                auto& deserializer = std::get<0>(wrapper);
 
-            ValueT val = deserializer(sval);
+                ValueT val = deserializer(sval);
 
-            _setterFunc<ValueT>[this](val);
+                _setterFunc<ValueT>[this](val);
-        };
+            };
+        }
 
         _clearFunc = [this]() {
             _getterFunc<ValueT>.erase(this);
@@ -309,90 +305,77 @@ public:
     }
 
 
-    template <traits::adc_tuple_like<> TupleT,
+    template <traits::adc_tuple_like TupleT,
-              std::invocable<> GT,
+              traits::adc_attr_getter_c GT,
-              typename ValueT = ret_value_t<GT>,
+              traits::adc_attr_setter_c ST,
-              std::invocable<const ValueT&> ST,
+              typename ValueT = traits::attr_value_t<GT, ST>,
-              std::invocable<const ValueT&> SRT =
+              traits::adc_serializer_c<ValueT> SRT =
                   decltype(utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>),
-              typename SerializedT = ret_value_t<SRT>,
+              traits::adc_deserializer_c<ValueT> DSRT =
-              std::invocable<const SerializedT&> DSRT =
+                  decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, default_serialized_t>)>
-                  decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)>
+    AdcDeviceAttribute(
-    AdcDeviceAttribute(TupleT&&,
+        const IdentT& ident,
-                       GT&& getter,
+        TupleT&&,
-                       ST&& setter,
+        GT&& getter,
-                       SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>,
+        ST&& setter,
-                       DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
+        SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>,
-        : AdcDeviceAttribute(std::forward<GT>(getter),
+        DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, default_serialized_t>)
+        : AdcDeviceAttribute(ident,
+                             std::forward<GT>(getter),
                              std::forward<ST>(setter),
                              std::forward<SRT>(serializer),
                              std::forward<DSRT>(deserializer))
     {
+        static_assert(!std::is_null_pointer_v<ValueT>, "Getter and Setter can not be nullptr simultaneously!!!");
+
         AdcDeviceAttribute::setupTrivialConvertFunc<ValueT, std::decay_t<TupleT>>();
     }
 
 
-
     // read-only attribute constructor
-    template <std::invocable<> GT,
+    template <std::invocable GT,
               typename ValueT = ret_value_t<GT>,
-              std::invocable<const ValueT&> SRT =
+              traits::adc_serializer_c<ValueT> SRT =
                   decltype(utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>),
               typename SerializedT = ret_value_t<SRT>>
     AdcDeviceAttribute(const IdentT& ident,
                        GT&& getter,
                        SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>)
-        : AdcDeviceAttribute(ident,
+        : AdcDeviceAttribute(ident, std::forward<GT>(getter), nullptr, std::forward<SRT>(serializer), nullptr)
-                             std::forward<GT>(getter),
-                             AdcDeviceAttribute::DummySetter<ValueT>,
-                             std::forward<SRT>(serializer),
-                             AdcDeviceAttribute::DummyDeserializer<ValueT, SerializedT>)
     {
-        _accessType = ReadOnly;
     }
 
 
-    template <traits::adc_tuple_like<> TupleT,
+    template <traits::adc_tuple_like TupleT,
-              std::invocable<> GT,
+              std::invocable GT,
               typename ValueT = ret_value_t<GT>,
-              std::invocable<const ValueT&> SRT =
+              traits::adc_serializer_c<ValueT> SRT =
                   decltype(utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>),
               typename SerializedT = ret_value_t<SRT>>
     AdcDeviceAttribute(const IdentT& ident,
                        TupleT&&,
                        GT&& getter,
                        SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>)
-        : AdcDeviceAttribute(ident,
+        : AdcDeviceAttribute(ident, TupleT{}, std::forward<GT>(getter), nullptr, std::forward<SRT>(serializer), nullptr)
-                             TupleT{},
-                             std::forward<GT>(getter),
-                             AdcDeviceAttribute::DummySetter<ValueT>,
-                             std::forward<SRT>(serializer),
-                             AdcDeviceAttribute::DummyDeserializer<ValueT, SerializedT>)
     {
-        _accessType = ReadOnly;
     }
 
 
     // write-only attribute constructor
-    template <traits::adc_is_setter<> ST,
+    template <traits::adc_attr_setter_c ST,
               typename ValueT = std::decay_t<traits::adc_func_arg1_t<ST>>,
               typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, default_serialized_t>),
               typename SerializedT = std::decay_t<traits::adc_func_arg1_t<DSRT>>>
     AdcDeviceAttribute(const IdentT& ident,
                        ST&& setter,
                        DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
-        : AdcDeviceAttribute(ident,
+        : AdcDeviceAttribute(ident, nullptr, std::forward<ST>(setter), nullptr, std::forward<DSRT>(deserializer))
-                             AdcDeviceAttribute::DummyGetter<ValueT>,
-                             std::forward<ST>(setter),
-                             AdcDeviceAttribute::DummySerializer<ValueT>,
-                             std::forward<DSRT>(deserializer))
     {
-        _accessType = WriteOnly;
     }
 
 
-    template <traits::adc_tuple_like<> TupleT,
+    template <traits::adc_tuple_like TupleT,
-              traits::adc_is_setter<> ST,
+              traits::adc_attr_setter_c ST,
               typename ValueT = std::decay_t<traits::adc_func_arg1_t<ST>>,
               typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, default_serialized_t>),
               typename SerializedT = std::decay_t<traits::adc_func_arg1_t<DSRT>>>
@@ -402,16 +385,14 @@ public:
                        DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
         : AdcDeviceAttribute(ident,
                              TupleT{},
-                             AdcDeviceAttribute::DummyGetter<ValueT>,
+                             nullptr,
                              std::forward<ST>(setter),
-                             AdcDeviceAttribute::DummySerializer<ValueT>,
+                             nullptr,
                              std::forward<DSRT>(deserializer))
     {
-        _accessType = WriteOnly;
     }
 
 
-
     AdcDeviceAttribute(const AdcDeviceAttribute& other)
     {
         _clearFunc();
@@ -447,37 +428,45 @@ public:
     AccessType accessType() const { return _accessType; }
 
 
-    template <typename FromFuncT, typename ToFuncT>
+    template <traits::adc_attr_convfunc_c FromFuncT, traits::adc_attr_convfunc_c ToFuncT>
     AdcDeviceAttribute& 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 value_t = ret_value_t<ToFuncT>;  // it must be internal value type
-        using user_t = ret_value_t<FromFuncT>;
+        // using user_t = ret_value_t<FromFuncT>;
 
-        _getterFunc<user_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<FromFuncT>(func_from_internal)),
+        using value_t = traits::attr_internal_t<FromFuncT, ToFuncT>;
-                                     this]() {
+        using user_t = traits::attr_user_t<FromFuncT, ToFuncT>;
-            auto& getter = _getterFunc<value_t>[this];
+
-            if (getter) {
+        static_assert(!std::is_null_pointer_v<value_t>,
-                auto val = getter();
+                      "Deduced attribute internal type must not be std::nullptr_t!!!");
-                return std::get<0>(wrapper)(val);  // convert from internal type
+        static_assert(!std::is_null_pointer_v<user_t>, "Deduced user-defined type must not be std::nullptr_t!!!");
-            }
+
-            // invalid conversion function signature
+        try {
+            if (_accessType != AdcDeviceAttribute::WriteOnly) {
+                auto& getter = _getterFunc<value_t>.at(this);  // throw out_of_range if value_t is invalid
+
+                _getterFunc<user_t>[this] =
+                    [&getter, wrapper = traits::adc_pf_wrapper(std::forward<FromFuncT>(func_from_internal)), this]() {
+                        auto val = getter();
+                        return std::get<0>(wrapper)(val);  // convert from internal type
+                    };
+            }  // ignore "from_internal" conversional function for write-only attribute
+
+
+
+            if (_accessType != AdcDeviceAttribute::ReadOnly) {
+                auto& setter = _setterFunc<value_t>.at(this);  // throw out_of_range if value_t is invalid
+
+                _setterFunc<user_t>[this] = [&setter,
+                                             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
+                    setter(value);
+                };
+            }  // ignore "to_internal" conversional function for read-only attribute
+        } catch (const std::out_of_range&) {
             throw std::system_error(AdcDeviceAttributeErrorCode::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(AdcDeviceAttributeErrorCode::ERROR_INTERNAL_TYPE_MISMATCH);
-            }
-        };
 
         _clearFunc = [prev_clear = _clearFunc, this]() {
             prev_clear();
@@ -515,16 +504,22 @@ public:
 
         using val_t = std::decay_t<UT>;
 
-        auto getter = _getterFunc<val_t>[this];
+        try {
-        if (getter) {
+            return _getterFunc<val_t>.at(this)();
-            return getter();
+        } catch (const std::out_of_range&) {
+            throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_CONV_FUNC);
         }
 
-        throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_CONV_FUNC);
+        // auto& getter = _getterFunc<val_t>[this];
+        // if (getter) {
+        //     return getter();
+        // }
+
+        // throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_CONV_FUNC);
     }
 
     template <typename UT>
-    AdcDeviceAttribute& operator=(UT&& other)
+    AdcDeviceAttribute& operator=(UT&& val)
     {
         if (_accessType == ReadOnly) {
             throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_READ_ONLY);
@@ -532,13 +527,19 @@ public:
 
         using val_t = std::decay_t<UT>;
 
-        auto setter = _setterFunc<val_t>[this];
+        try {
-        if (setter) {
+            _setterFunc<val_t>.at(this)(std::forward<UT>(val));
-            setter(std::forward<UT>(other));
+        } catch (const std::out_of_range&) {
-        } else {
             throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_CONV_FUNC);
         }
 
+        // auto& setter = _setterFunc<val_t>[this];
+        // if (setter) {
+        //     setter(std::forward<UT>(val));
+        // } else {
+        //     throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_CONV_FUNC);
+        // }
+
         return *this;
     }
 
@@ -577,28 +578,63 @@ public:
     template <typename SerializedT>
     SerializedT serialize()
     {
-        using s_t = std::decay_t<SerializedT>;
+        if (_accessType == AdcDeviceAttribute::WriteOnly) {
-
+            throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_WRITE_ONLY);
-        auto& serializer = _serializerFunc<s_t>[this];
-
-        if (serializer) {
-            return serializer();
         }
 
-        throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
+        using s_t = std::decay_t<SerializedT>;
+
+        try {
+            _serializerFunc<s_t>.at(this)();
+        } catch (const std::out_of_range&) {
+            throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
+        } catch (const std::bad_function_call&) {  // serializer was not defined in ctor!
+            throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_SERIALIZER);
+        }
+
+        // auto& serializer = _serializerFunc<s_t>[this];
+
+        // if (serializer) {
+        //     return serializer();
+        // }
+
+        // throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
     }
 
     template <typename SerializedT>
-    void deserialize(const SerializedT& sval)
+    AdcDeviceAttribute& deserialize(const SerializedT& sval)
     {
+        if (_accessType == AdcDeviceAttribute::ReadOnly) {
+            throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_READ_ONLY);
+        }
+
         using s_t = std::decay_t<SerializedT>;
 
-        auto& deserializer = _deserializerFunc<s_t>[this];
+        try {
-        if (deserializer) {
+            _deserializerFunc<s_t>.at(this)(sval);
-            deserializer(sval);
+        } catch (const std::out_of_range&) {
-        } else {
             throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
+        } catch (const std::bad_function_call&) {  // deserializer was not defined in ctor!
+            throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_DESERIALIZER);
         }
+
+        // auto& deserializer = _deserializerFunc<s_t>[this];
+        // if (deserializer) {
+        //     deserializer(sval);
+        // } else {
+        //     throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
+        // }
+
+        return *this;
+    }
+
+
+    /*   some usefull factory functions   */
+
+    template <typename... CtorArgTs>
+    static AdcDeviceAttribute makeArithAttr(const IdentT& ident, CtorArgTs... ctor_args)
+    {
+        return AdcDeviceAttribute{ident, constants::AdcDefaultTrivialConvTypes, std::forward<CtorArgTs>(ctor_args)...};
     }
 
 protected:
@@ -628,4 +664,5 @@ protected:
     }
 };
 
+
 }  // namespace adc

device/adc_device_command.h

@@ -7,10 +7,9 @@
 
 */
 
-#include <memory>
+#include <functional>
-#include <string>
+#include "../common/adc_traits.h"
-// #include "../common/adc_value_holder.h"
+
-#include "../common/adc_value.h"
 
 /*
 
@@ -19,76 +18,32 @@
 namespace adc
 {
 
-template <typename IdentT, typename SerializedT = std::string>
+
+namespace traits
+{
+
+template <typename T>
+concept adc_cmd_exec_c = traits::adc_func_traits<T>::arity == 0 && !std::same_as<T, std::nullptr_t>;
+
+}  // namespace traits
+
+
+template <typename IdentT = std::string_view>
 class AdcDeviceCommand
 {
 protected:
     IdentT _ident;
 
-    std::unique_ptr<AdcSerializingValueHolder<SerializedT>> _commandArgUptr;
+    std::function<void()> _execFunc;
-
-    std::function<void()> _execFuncWrapper;
-    std::function<void(std::any&)> _deserializerWrapper;
-
-    template <typename T>
-    constexpr static SerializedT AdcDeviceCommandDummySerializer(const T&)
-    {
-        return SerializedT();
-    }
 
 public:
     typedef IdentT ident_t;
-    typedef SerializedT serialized_t;
 
 
-    template <typename ExecFuncT,
+    template <traits::adc_cmd_exec_c ExecFuncT>
-              typename ARGT = traits::adc_func_arg1_t<ExecFuncT>,
+    AdcDeviceCommand(const IdentT& ident, ExecFuncT&& exec_func)
-              typename DeserializerT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ARGT, SerializedT>),
+        : _ident(ident), _execFunc(std::forward<ExecFuncT>(exec_func))
-              typename ValidatorT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<ARGT>)>
-    AdcDeviceCommand(const IdentT& ident,
-                     ExecFuncT&& exec_func,
-                     DeserializerT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ARGT, SerializedT>,
-                     ValidatorT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<ARGT>)
-        : _ident(ident), _commandArgUptr()
     {
-        using sign_t = traits::adc_func_traits<ExecFuncT>;
-
-        static_assert(sign_t::arity > 1, "COMMAND EXECUTION FUNCTION MUST ACCEPT 0 OR EXACTLY 1 ARGUMENT!!!");
-
-        if constexpr (sign_t::arity) {  // command with argument
-            using value_t = typename sign_t::arg1_t;
-
-            static_assert(std::predicate<ValidatorT, const value_t&>, "INVALID TYPE OF VALIDATOR");
-
-            static_assert(std::invocable<DeserializerT, const SerializedT&>, "INVALID TYPE OF DESERIALIZER");
-            static_assert(std::is_convertible_v<std::invoke_result_t<DeserializerT, const SerializedT&>, value_t>,
-                          "INVALID RETURN TYPE OF DESERIALIZER");
-
-
-            auto command_arg = std::shared_ptr<value_t>(value_t());
-
-            _commandArgUptr = std::make_unique<AdcSerializingValueHolder<SerializedT>>(
-                [command_arg]() { return *command_arg; }, [command_arg](const value_t& value) { *command_arg = value; },
-                std::forward<ValidatorT>(validator));
-
-            _execFuncWrapper = [wrapper = traits::adc_pf_wrapper(std::forward<ExecFuncT>(exec_func)), this]() {
-                auto& exec_func = std::get<0>(wrapper);
-                value_t val = std::any_cast<value_t>(*_commandArgUptr);
-                exec_func(val);
-            };
-
-
-            _deserializerWrapper =
-                [wrapper = traits::adc_pf_wrapper(std::forward<DeserializerT>(deserializer))](std::any& val) {
-                    auto& deserializer = std::get<0>(wrapper);
-                    val = std::make_any<value_t>(deserializer(std::any_cast<SerializedT>(val)));
-                };
-
-            // setup only convert-to-native-value function (deserializer)
-            _commandArgUptr->addConvertFunc<SerializedT>(std::forward<DeserializerT>(deserializer), []() {});
-        } else {  // command without argument (ignore deserializer and validator)
-            _execFuncWrapper = std::forward<ExecFuncT>(exec_func);
-        }
     }
 
 
@@ -100,24 +55,7 @@ public:
     IdentT ident() const { return ident; }
 
 
-    template <typename ValueT>
+    void operator()() { _execFunc(); }
-    void operator()(const ValueT& value)
-    {
-        if (_commandArgUptr) {  // command with argument
-            *_commandArgUptr = value;
-        }
-        _execFuncWrapper();
-    }
-
-
-    void operator()()
-    {
-        if (_commandArgUptr) {  // command with argument
-            throw 1;
-        }
-
-        _execFuncWrapper();
-    }
 };
 
 

tests/adc_devattr_test.cpp

@@ -32,15 +32,28 @@ TEST_CASE("[ADC DEVICE ATTRIBUTE]")
 
     using attr_t = AdcDeviceAttribute<std::string_view>;
 
-    attr_t attr("ATTR_A", adc::constants::AdcDefaultTrivialConvTypes, vv::getter, vv::setter);
+    std::string_view id{"ATTR_A"};
+
+    // attr_t attr(id, adc::constants::AdcDefaultTrivialConvTypes, vv::getter, vv::setter);
+    attr_t attr("id", adc::constants::AdcDefaultTrivialConvTypes, vv::getter, vv::setter);
 
     attr = 10.7;
     av = attr;
 
     std::cout << "ATTR = " << av << "\n";
-    // std::cout << "ATTR = " << (unsigned)attr << "\n";
+    std::cout << "ATTR = " << (unsigned)attr << "\n";
 
+    // attr_t aw("ATTR_WO", nullptr, vv::setter, nullptr);
     attr_t aw("ATTR_WO", adc::constants::AdcDefaultTrivialConvTypes, vv::setter);
+    // attr_t aw(id, adc::constants::AdcDefaultTrivialConvTypes, vv::setter);
 
     std::cout << "ACC_TYPE: " << aw.accessType() << "\n";
+    // av = aw;
+    aw = 4534.6588;
+
+    // attr_t ar("ATTR_RO", adc::constants::AdcDefaultTrivialConvTypes, vv::getter);
+    auto ar = attr_t::makeArithAttr("ATTR_RO", vv::getter);
+    std::cout << "ACC_TYPE: " << ar.accessType() << "\n";
+
+    std::cout << "ATTR_RO = " << (double)ar << "\n";
 }