...

device/adc_device_attribute.h

@@ -1 +1,143 @@
 #pragma once
+
+/*
+
+ ABSTRACT DEVICE COMPONENTS LIBRARY
+
+ */
+
+
+#include "../common/adc_value.h"
+
+
+namespace adc
+{
+
+template <typename IdentT, typename SerializedT = std::string>
+class AdcDeviceAttribute : public AdcSerializingValueHolder<SerializedT>
+{
+    using base_t = AdcSerializingValueHolder<SerializedT>;
+
+    template <typename T>
+    using ret_value_t = base_t::template ret_value_t<T>;
+
+public:
+    typedef IdentT ident_t;
+    typedef SerializedT serialized_t;
+
+    enum AccessType { ReadOnly, WriteOnly, ReadWrite };
+
+    template <typename T>
+    constexpr static T DummyGetter()
+    {
+        return std::declval<T>();
+    }
+
+
+    template <typename T>
+    constexpr static void DummySetter(const T&)
+    {
+    }
+
+    template <typename T>
+    constexpr static SerializedT DummySerializer(const T&)
+    {
+        return std::declval<SerializedT>();
+    }
+
+    template <typename T>
+    constexpr static T DummyDeserializer(const SerializedT&)
+    {
+        return std::declval<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)
+    {
+    }
+
+
+    // read-only attribute constructor
+    template <typename GT,
+              typename VALT = ret_value_t<GT>,
+              typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>)>
+    AdcDeviceAttribute(const IdentT& ident,
+                       GT&& getter,
+                       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>)
+    {
+    }
+
+
+    // write-only attribute constructor
+    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,
+                       ST&& setter,
+                       std::predicate<const VALT&> auto&& validator,
+                       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))
+    {
+    }
+
+
+    // 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;
+
+    IdentT ident() const { return _ident; }
+
+    AccessType accessType() const { return _accessType; }
+
+    using base_t::operator=;
+
+protected:
+    IdentT _ident;
+    AccessType _accessType;
+};
+
+}  // namespace adc