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

solve problem with adc_func_traits

Browse Source 
add and use concept adc_is_callable
rewrite value holder and device attribute classes
with new constructor's arguments resolution scheme
This commit is contained in:
Timur A. Fatkhullin 2024-05-04 22:29:10 +03:00
parent 2412b59b7a
commit ba60fadb79
5 changed files with 119 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
common/adc_traits.h
View File

@ -67,10 +67,16 @@ struct adc_func_traits_helper_t<R, Arg, Args...> {
};
// callable traits
// callable concept and its signature traits
template <typename F, typename = void>
struct adc_func_traits;
template <typename T>
concept adc_is_callable =
std::is_function_v<T> || (std::is_object_v<T> && requires(T) { std::is_function_v<decltype(&T::operator())>; });
template <typename F>
struct adc_func_traits {
// use of an empty struct here to match std::invoke_result behaivior (at least of GCC)
};
template <typename R, typename... Args>
struct adc_func_traits<R (*)(Args...)> : adc_func_traits_helper_t<R, Args...> {
@ -89,8 +95,8 @@ struct adc_func_traits<R (C::*)(Args...) const> : adc_func_traits_helper_t<R, Ar
};
template <typename F>
// struct adc_func_traits : adc_func_traits<decltype(&std::remove_reference_t<F>::operator())> {
struct adc_func_traits<F, std::enable_if_t<std::is_class_v<F>>> : adc_func_traits<decltype(&F::operator())> {
requires adc_is_callable<F>
struct adc_func_traits<F> : adc_func_traits<decltype(&F::operator())> {
};
template <typename F>
@ -138,13 +144,32 @@ template <typename T>
struct adc_is_tuple : std::false_type {
};
template <typename T>
struct adc_is_tuple<T&> : adc_is_tuple<T> {
};
template <typename T>
struct adc_is_tuple<const T&> : adc_is_tuple<T> {
};
template <typename T>
struct adc_is_tuple<T&&> : adc_is_tuple<T> {
};
template <typename... Ts>
struct adc_is_tuple<std::tuple<Ts...>> : std::true_type {
};
template <typename T1, typename T2>
struct adc_is_tuple<std::pair<T1, T2>> : std::true_type {
};
template <typename T>
static inline constexpr bool adc_is_tuple_v = adc_is_tuple<T>::value;
template <typename T>
concept adc_tuple_like = adc_is_tuple_v<T> == true;
} // namespace adc::traits

132
common/adc_value.h
View File

@ -177,32 +177,21 @@ public:
}
template <typename... Ts>
AdcValueHolder(std::invocable<> auto&& getter,
std::invocable<const ret_value_t<decltype(getter)>&> auto&& setter,
std::predicate<const ret_value_t<decltype(getter)>&> auto&& validator,
const std::tuple<Ts...>& /* tuple-of-trivially-converting-types */)
: AdcValueHolder(std::forward<decltype(getter)>(getter),
template <typename GT,
typename VALT = ret_value_t<GT>,
typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
AdcValueHolder(traits::adc_tuple_like<> auto&& tpl,
GT&& getter,
std::invocable<const VALT&> auto&& setter,
VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
: AdcValueHolder(std::forward<GT>(getter),
std::forward<decltype(setter)>(setter),
std::forward<decltype(validator)>(validator))
{
// setup trivially-defined conversion function
AdcValueHolder::setupTrivialConvertFunc<ret_value_t<decltype(getter)>, std::tuple<Ts...>>();
AdcValueHolder::setupTrivialConvertFunc<VALT, std::decay_t<decltype(tpl)>>();
}
template <typename... Ts>
AdcValueHolder(std::invocable<> auto&& getter,
std::invocable<const ret_value_t<decltype(getter)>&> auto&& setter,
const std::tuple<Ts...>& t /* tuple-of-trivially-converting-types */)
: AdcValueHolder(std::forward<decltype(getter)>(getter),
std::forward<decltype(setter)>(setter),
AdcValueHolder::AdcValueHolderDummyValidator<traits::adc_retval_t<decltype(getter)>>,
t)
{
}
AdcValueHolder(const AdcValueHolder&) = default;
AdcValueHolder(AdcValueHolder&&) = default;
@ -227,29 +216,17 @@ public:
}
template <typename... Ts>
AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
std::invocable<const ret_value_t<decltype(getter)>&> auto&& setter,
std::predicate<const ret_value_t<decltype(getter)>&> auto&& validator,
const std::tuple<Ts...>& /* tuple-of-trivially-converting-types */)
template <typename GT, typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<ret_value_t<GT>>)>
AdcValueHolder& resetValueHolder(traits::adc_tuple_like<> auto&& tpl,
GT&& getter,
std::invocable<const ret_value_t<GT>&> auto&& setter,
VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<ret_value_t<GT>>)
{
resetValueHolder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
std::forward<decltype(validator)>(validator));
// setup trivially-defined conversion function
setupTrivialConvertFunc<ret_value_t<decltype(getter)>, std::tuple<Ts...>>();
AdcValueHolder::setupTrivialConvertFunc<ret_value_t<GT>, std::decay_t<decltype(tpl)>>();
return *this;
}
template <typename... Ts>
AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
std::invocable<const ret_value_t<decltype(getter)>&> auto&& setter,
const std::tuple<Ts...>& t /* tuple-of-trivially-converting-types */)
{
return resetValueHolder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
AdcValueHolder::AdcValueHolderDummyValidator<ret_value_t<decltype(getter)>>, t);
std::forward<decltype(validator)>(validator));
}
@ -425,43 +402,24 @@ public:
template <typename GT,
typename ST,
typename VALT = ret_value_t<GT>,
typename VT,
typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>),
typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>),
typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>),
typename... Ts>
AdcSerializingValueHolder(GT&& getter,
typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)>
AdcSerializingValueHolder(traits::adc_tuple_like<> auto&& tpl,
GT&& getter,
ST&& setter,
VT&& validator,
const std::tuple<Ts...>&,
VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>,
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
: AdcValueHolder(std::forward<GT>(getter),
requires std::invocable<GT> && std::invocable<ST, const VALT&> && std::predicate<VT, const VALT&> &&
std::invocable<SRT, const VALT&> && std::invocable<DSRT, const SerializedT&>
: AdcSerializingValueHolder(std::forward<GT>(getter),
std::forward<ST>(setter),
std::forward<VT>(validator),
std::tuple<Ts...>{})
std::forward<SRT>(serializer),
std::forward<DSRT>(deserializer))
{
initWrappers<VALT>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
}
template <typename GT,
typename ST,
typename VALT = ret_value_t<GT>,
typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>),
typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>),
typename... Ts>
AdcSerializingValueHolder(GT&& getter,
ST&& setter,
const std::tuple<Ts...>&,
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>,
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
: AdcValueHolder(std::forward<GT>(getter),
std::forward<ST>(setter),
AdcValueHolder::AdcValueHolderDummyValidator<VALT>,
std::tuple<Ts...>{})
{
initWrappers<VALT>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
AdcValueHolder::setupTrivialConvertFunc<VALT, std::decay_t<decltype(tpl)>>();
}
@ -494,44 +452,24 @@ public:
typename ST,
typename VT,
typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, ret_value_t<GT>>),
typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ret_value_t<GT>, SerializedT>),
typename... Ts>
typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ret_value_t<GT>, SerializedT>)>
AdcSerializingValueHolder& resetValueHolder(
traits::adc_tuple_like<> auto&& tpl,
GT&& getter,
ST&& setter,
VT&& validator,
const std::tuple<Ts...>&,
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, ret_value_t<GT>>,
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ret_value_t<GT>, SerializedT>)
{
AdcValueHolder::resetValueHolder(std::forward<GT>(getter), std::forward<ST>(setter),
std::forward<VT>(validator), std::tuple<Ts...>{});
AdcSerializingValueHolder::resetValueHolder(std::forward<GT>(getter), std::forward<ST>(setter),
std::forward<VT>(validator), std::forward<SRT>(serializer),
std::forward<DSRT>(deserializer));
initWrappers<ret_value_t<GT>>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
AdcValueHolder::setupTrivialConvertFunc<ret_value_t<GT>, std::decay_t<decltype(tpl)>>();
return *this;
}
template <typename GT,
typename ST,
typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, ret_value_t<GT>>),
typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ret_value_t<GT>, SerializedT>),
typename... Ts>
AdcSerializingValueHolder& resetValueHolder(
GT&& getter,
ST&& setter,
const std::tuple<Ts...>&,
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, ret_value_t<GT>>,
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ret_value_t<GT>, SerializedT>)
{
AdcValueHolder::resetValueHolder(std::forward<GT>(getter), std::forward<ST>(setter), std::tuple<Ts...>{});
initWrappers<ret_value_t<GT>>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
return *this;
}
SerializedT serialize() { return _serializerWrapper(); }
void deserialize(const SerializedT& sval) { _deserializerWrapper(sval); }
@ -560,8 +498,8 @@ HolderT makeArithmValue(GT&& getter,
static_assert(std::is_arithmetic_v<val_t>, "GETTER MUST RETURN AN ARITHMETIC TYPE VALUE!!!");
return HolderT(std::forward<GT>(getter), std::forward<decltype(setter)>(setter),
std::forward<decltype(validator)>(validator), AdcValueHolder::_defaultTrivialConvTypes,
return HolderT(AdcValueHolder::_defaultTrivialConvTypes, std::forward<GT>(getter),
std::forward<decltype(setter)>(setter), std::forward<decltype(validator)>(validator),
std::forward<Ts>(other_ctor_args)...);
}

41
device/adc_device_attribute.h
View File

@ -81,6 +81,26 @@ public:
}
template <typename GT,
typename VALT = ret_value_t<GT>,
typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>)>
AdcDeviceAttribute(const IdentT& ident,
traits::adc_tuple_like<> auto&& tpl,
GT&& getter,
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>)
requires std::invocable<GT> && std::invocable<SRT, const VALT&>
: AdcDeviceAttribute(ident,
std::forward<decltype(tpl)>(tpl),
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>>,
@ -101,6 +121,27 @@ public:
}
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,
traits::adc_tuple_like<> auto&& tpl,
ST&& setter,
std::predicate<const VALT&> auto&& validator,
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)
requires std::invocable<DSRT, const SerializedT&>
: AdcDeviceAttribute(ident,
std::forward<decltype(tpl)>(tpl),
AdcDeviceAttribute::DummyGetter<VALT>,
std::forward<ST>(setter),
std::forward<decltype(validator)>(validator),
AdcDeviceAttribute::DummySerializer<VALT>,
std::forward<DSRT>(deserializer))
{
_accessType = WriteOnly;
}
virtual ~AdcDeviceAttribute() = default;

8
tests/adc_devattr_test.cpp
View File

@ -32,13 +32,15 @@ TEST_CASE("[ADC DEVICE ATTRIBUTE]")
using attr_t = AdcDeviceAttribute<std::string_view>;
// attr_t attr(AdcValueHolder::_defaultTrivialConvTypes, "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_t attr("ATTR_A", AdcValueHolder::_defaultTrivialConvTypes, vv::getter, vv::setter, vv::validator);
attr = 10.7;
av = attr;
std::cout << "ATTR = " << av << "\n";
// std::cout << "ATTR = " << (unsigned)attr << "\n";
attr_t aw("ATTR_WO", AdcValueHolder::_defaultTrivialConvTypes, vv::setter, vv::validator);
std::cout << "ACC_TYPE: " << aw.accessType() << "\n";
}

9
tests/adc_valueholder_test.cpp
View File

@ -46,7 +46,8 @@ TEST_CASE("[ADC VALUEHOLDER]")
return true;
};
adc::AdcValueHolder vht(getter, setter, adc::AdcValueHolder::_defaultTrivialConvTypes);
// adc::AdcValueHolder vht(getter, setter, adc::AdcValueHolder::_defaultTrivialConvTypes);
adc::AdcValueHolder vht(adc::AdcValueHolder::_defaultTrivialConvTypes, getter, setter);
adc::AdcValueHolder vh(getter, setter, validator);
// auto vah = adc::make_arith_valueholder(getter, setter);
auto vah = adc::makeArithmValue<adc::AdcValueHolder>(getter, setter);
@ -178,7 +179,8 @@ TEST_CASE("[ADC VALUEHOLDER]")
adc::AdcSerializingValueHolder svh(getter, setter, validator, adc::AdcValueHolder::_defaultTrivialConvTypes);
// adc::AdcSerializingValueHolder svh(getter, setter, validator, adc::AdcValueHolder::_defaultTrivialConvTypes);
adc::AdcSerializingValueHolder svh(adc::AdcValueHolder::_defaultTrivialConvTypes, getter, setter, validator);
svh = 77.65412;
@ -193,7 +195,8 @@ TEST_CASE("[ADC VALUEHOLDER]")
// fl = vsh;
// std::cout << "VSH: " << fl << "\n";
svh.resetValueHolder(gdbl, sdbl, vdbl, adc::AdcValueHolder::_defaultTrivialConvTypes);
// svh.resetValueHolder(gdbl, sdbl, vdbl, adc::AdcValueHolder::_defaultTrivialConvTypes);
svh.resetValueHolder(adc::AdcValueHolder::_defaultTrivialConvTypes, gdbl, sdbl, vdbl);
// svh.resetValueHolder([]() { return dbl_val; }, [](const double& v) { dbl_val = v; },
// [](const double&) { return true; }, adc::AdcValueHolder::_defaultTrivialConvTypes);
std::cout << "SERIALIZED: " << svh.serialize() << "\n";