timur/ADC
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

...

Browse Source
This commit is contained in:
Timur A. Fatkhullin 2024-05-03 21:55:49 +03:00
parent 6de9127e58
commit 3ea9aa9c4d
2 changed files with 13 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
device/adc_device_attribute.h
View File

@ -30,7 +30,7 @@ public:
template <typename T> template <typename T>
constexpr static T DummyGetter() constexpr static T DummyGetter()
{ {
return std::declval<T>(); return T();
} }
@ -42,41 +42,22 @@ public:
template <typename T> template <typename T>
constexpr static SerializedT DummySerializer(const T&) constexpr static SerializedT DummySerializer(const T&)
{ {
return std::declval<SerializedT>(); return SerializedT();
} }
template <typename T> template <typename T>
constexpr static T DummyDeserializer(const SerializedT&) constexpr static T DummyDeserializer(const SerializedT&)
{ {
return std::declval<T>(); return T();
} }
/* CONSTRUCTORS AND DESTRUCTOR */ /* CONSTRUCTORS AND DESTRUCTOR */
// general read-write attribute constructor // general read-write attribute constructor
template <typename GT, template <typename... SerValHolderTs>
typename ST, AdcDeviceAttribute(const IdentT& ident, SerValHolderTs&&... ctor_args)
typename VALT = ret_value_t<GT>, : base_t(std::forward<SerValHolderTs>(ctor_args)...), _ident(ident), _accessType(ReadWrite)
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)
{ {
} }
@ -90,13 +71,13 @@ public:
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>) SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>)
requires std::invocable<GT> && std::invocable<SRT, const VALT&> requires std::invocable<GT> && std::invocable<SRT, const VALT&>
: AdcDeviceAttribute(ident, : AdcDeviceAttribute(ident,
ReadOnly,
std::forward<GT>(getter), std::forward<GT>(getter),
AdcDeviceAttribute::DummySetter<VALT>, AdcDeviceAttribute::DummySetter<VALT>,
AdcValueHolder::AdcValueHolderDummyValidator<VALT>, AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
std::forward<SRT>(serializer), std::forward<SRT>(serializer),
AdcDeviceAttribute::DummyDeserializer<VALT>) AdcDeviceAttribute::DummyDeserializer<VALT>)
{ {
_accessType = ReadOnly;
} }
@ -110,22 +91,16 @@ public:
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>) DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
requires std::invocable<DSRT, const SerializedT&> requires std::invocable<DSRT, const SerializedT&>
: AdcDeviceAttribute(ident, : AdcDeviceAttribute(ident,
WriteOnly,
AdcDeviceAttribute::DummyGetter<VALT>, AdcDeviceAttribute::DummyGetter<VALT>,
std::forward<ST>(setter), std::forward<ST>(setter),
std::forward<decltype(validator)>(validator), std::forward<decltype(validator)>(validator),
AdcDeviceAttribute::DummySerializer<VALT>, AdcDeviceAttribute::DummySerializer<VALT>,
std::forward<DSRT>(deserializer)) std::forward<DSRT>(deserializer))
{ {
_accessType = WriteOnly;
} }
// 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; virtual ~AdcDeviceAttribute() = default;

10
tests/adc_devattr_test.cpp
View File

@ -34,11 +34,11 @@ TEST_CASE("[ADC DEVICE ATTRIBUTE]")
// attr_t attr(AdcValueHolder::_defaultTrivialConvTypes, "ATTR_A", attr_t::ReadWrite, vv::getter, vv::setter, // attr_t attr(AdcValueHolder::_defaultTrivialConvTypes, "ATTR_A", attr_t::ReadWrite, vv::getter, vv::setter,
// vv::validator); // vv::validator);
attr_t attr("ATTR_A", attr_t::ReadWrite, vv::getter, vv::setter, vv::validator); attr_t attr("ATTR_A", vv::getter, vv::setter, vv::validator, AdcValueHolder::_defaultTrivialConvTypes);
// attr = 10.7; attr = 10.7;
// av = attr; av = attr;
// std::cout << "ATTR = " << av << "\n"; std::cout << "ATTR = " << av << "\n";
std::cout << "ATTR = " << (unsigned)attr << "\n"; // std::cout << "ATTR = " << (unsigned)attr << "\n";
} }