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-01 17:17:05 +03:00
parent 066cb7cf95
commit 0d64e0cf44
5 changed files with 35 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
common/adc_traits.h
View File

@ -55,6 +55,7 @@ struct adc_func_traits_helper_t<R> {
using ret_t = R;
using args_t = std::tuple<>;
using arg1_t = void;
static constexpr size_t arity = 0;
};
template <typename R, typename Arg, typename... Args>
@ -62,6 +63,7 @@ struct adc_func_traits_helper_t<R, Arg, Args...> {
using ret_t = R;
using args_t = std::tuple<Arg, Args...>;
using arg1_t = Arg;
static constexpr size_t arity = sizeof...(Args) + 1;
};
@ -109,7 +111,7 @@ using adc_func_arg1_t = typename adc_func_traits<T>::arg1_t;
template <typename T>
using adc_deduced_type =
std::conditional_t<std::is_lvalue_reference_v<T> && !std::is_const_v<std::remove_reference_t<T>>,
T,
T&,
std::remove_cvref_t<T>>;

4
common/adc_utils.h
View File

@ -419,6 +419,10 @@ public:
template <typename ValueT, typename SerializedT>
static ValueT deserialize(const SerializedT& svalue)
{
if constexpr (std::is_void_v<ValueT>) {
return;
}
ValueT res;
if constexpr (traits::adc_is_tuple_v<ValueT>) {

8
common/adc_value.h
View File

@ -382,9 +382,11 @@ protected:
static_assert(std::is_convertible_v<traits::adc_retval_t<DSRT>, ValueT>,
"INVALID RETURNED TYPE OF DESERIALIZING CALLABLE!!!");
_serializerWrapper = [wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer)), this]() {
auto& serializer = std::get<0>(wrapper);
auto val = _getterFunc<ValueT>[this]();
return serializer(val);
@ -486,6 +488,8 @@ public:
AdcValueHolder::resetValueHolder(std::forward<GT>(getter), std::forward<ST>(setter),
std::forward<VT>(validator));
initWrappers<ret_value_t<GT>>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
return *this;
}
@ -507,6 +511,8 @@ public:
std::forward<VT>(validator), std::tuple<Ts...>{});
initWrappers<ret_value_t<GT>>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
return *this;
}
template <typename GT,
@ -524,6 +530,8 @@ public:
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;
}

27
device/adc_device_command.h
View File

@ -9,7 +9,8 @@
#include <memory>
#include <string>
#include "../common/adc_value_holder.h"
// #include "../common/adc_value_holder.h"
#include "../common/adc_value.h"
/*
@ -24,31 +25,37 @@ class AdcDeviceCommand
protected:
IdentT _ident;
std::unique_ptr<AdcValueHolder> _commandArgUptr;
std::unique_ptr<AdcSerializingValueHolder<SerializedT>> _commandArgUptr;
std::function<void()> _execFuncWrapper;
std::function<void(std::any&)> _deserializerWrapper;
template <typename T>
constexpr static SerializedT AdcDeviceCommandDummySerializer(const T&)
{
return SerializedT();
}
public:
typedef IdentT ident_t;
typedef SerializedT serialized_t;
template <typename ExecFuncT,
typename DeserializerT,
typename ValidatorT = decltype(AdcValueHolder::AdcValueHolderDummyValidator)>
typename ARGT = traits::adc_func_arg1_t<ExecFuncT>,
typename DeserializerT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ARGT, SerializedT>),
typename ValidatorT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<ARGT>)>
AdcDeviceCommand(const IdentT& ident,
ExecFuncT&& exec_func,
DeserializerT&& deserializer,
ValidatorT&& validator = AdcValueHolder::AdcValueHolderDummyValidator)
DeserializerT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ARGT, SerializedT>,
ValidatorT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<ARGT>)
: _ident(ident), _commandArgUptr()
{
using sign_t = traits::adc_func_traits<ExecFuncT>;
static_assert(std::tuple_size_v<typename sign_t::args_t> > 1,
"COMMAND EXECUTION FUNCTION MUST ACCEPT 0 OR EXACTLY 1 ARGUMENT!!!");
static_assert(sign_t::arity > 1, "COMMAND EXECUTION FUNCTION MUST ACCEPT 0 OR EXACTLY 1 ARGUMENT!!!");
if constexpr (std::tuple_size_v<typename sign_t::args_t>) { // command with argument
if constexpr (sign_t::arity) { // command with argument
using value_t = typename sign_t::arg1_t;
static_assert(std::predicate<ValidatorT, const value_t&>, "INVALID TYPE OF VALIDATOR");
@ -60,7 +67,7 @@ public:
auto command_arg = std::shared_ptr<value_t>(value_t());
_commandArgUptr = std::make_unique<AdcValueHolder>(
_commandArgUptr = std::make_unique<AdcSerializingValueHolder<SerializedT>>(
[command_arg]() { return *command_arg; }, [command_arg](const value_t& value) { *command_arg = value; },
std::forward<ValidatorT>(validator));

6
tests/adc_valueholder_test.cpp
View File

@ -192,9 +192,9 @@ TEST_CASE("[ADC VALUEHOLDER]")
// fl = vsh;
// std::cout << "VSH: " << fl << "\n";
// svh.resetValueHolder(gdbl, sdbl, vdbl, adc::AdcValueHolder::_defaultTrivialConvTypes);
svh.resetValueHolder([]() { return dbl_val; }, [](const double& v) { dbl_val = v; },
[](const double&) { return true; }, adc::AdcValueHolder::_defaultTrivialConvTypes);
svh.resetValueHolder(gdbl, sdbl, vdbl, adc::AdcValueHolder::_defaultTrivialConvTypes);
// svh.resetValueHolder([]() { return dbl_val; }, [](const double& v) { dbl_val = v; },
// [](const double&) { return true; }, adc::AdcValueHolder::_defaultTrivialConvTypes);
std::cout << "SERIALIZED: " << svh.serialize() << "\n";
svh.deserialize("123.123");
res = svh;