144 lines
4.8 KiB
C++
144 lines
4.8 KiB
C++
#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
|