119 lines
3.3 KiB
C++
119 lines
3.3 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 T();
|
|
}
|
|
|
|
|
|
template <typename T>
|
|
constexpr static void DummySetter(const T&)
|
|
{
|
|
}
|
|
|
|
template <typename T>
|
|
constexpr static SerializedT DummySerializer(const T&)
|
|
{
|
|
return SerializedT();
|
|
}
|
|
|
|
template <typename T>
|
|
constexpr static T DummyDeserializer(const SerializedT&)
|
|
{
|
|
return T();
|
|
}
|
|
|
|
|
|
/* CONSTRUCTORS AND DESTRUCTOR */
|
|
|
|
// general read-write attribute constructor
|
|
template <typename... SerValHolderTs>
|
|
AdcDeviceAttribute(const IdentT& ident, SerValHolderTs&&... ctor_args)
|
|
: base_t(std::forward<SerValHolderTs>(ctor_args)...), _ident(ident), _accessType(ReadWrite)
|
|
{
|
|
}
|
|
|
|
|
|
// 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,
|
|
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>>,
|
|
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,
|
|
AdcDeviceAttribute::DummyGetter<VALT>,
|
|
std::forward<ST>(setter),
|
|
std::forward<decltype(validator)>(validator),
|
|
AdcDeviceAttribute::DummySerializer<VALT>,
|
|
std::forward<DSRT>(deserializer))
|
|
{
|
|
_accessType = WriteOnly;
|
|
}
|
|
|
|
|
|
|
|
virtual ~AdcDeviceAttribute() = default;
|
|
|
|
IdentT ident() const { return _ident; }
|
|
|
|
AccessType accessType() const { return _accessType; }
|
|
|
|
using base_t::operator=;
|
|
|
|
protected:
|
|
IdentT _ident;
|
|
AccessType _accessType;
|
|
};
|
|
|
|
} // namespace adc
|