125 lines
3.8 KiB
C++
125 lines
3.8 KiB
C++
#pragma once
|
|
|
|
|
|
/*
|
|
|
|
ABSTRACT DEVICE COMPONENTS LIBRARY
|
|
|
|
*/
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
// #include "../common/adc_value_holder.h"
|
|
#include "../common/adc_value.h"
|
|
|
|
/*
|
|
|
|
*/
|
|
|
|
namespace adc
|
|
{
|
|
|
|
template <typename IdentT, typename SerializedT = std::string>
|
|
class AdcDeviceCommand
|
|
{
|
|
protected:
|
|
IdentT _ident;
|
|
|
|
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 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 = utils::AdcDefaultValueConverter<>::deserialize<ARGT, SerializedT>,
|
|
ValidatorT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<ARGT>)
|
|
: _ident(ident), _commandArgUptr()
|
|
{
|
|
using sign_t = traits::adc_func_traits<ExecFuncT>;
|
|
|
|
static_assert(sign_t::arity > 1, "COMMAND EXECUTION FUNCTION MUST ACCEPT 0 OR EXACTLY 1 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");
|
|
|
|
static_assert(std::invocable<DeserializerT, const SerializedT&>, "INVALID TYPE OF DESERIALIZER");
|
|
static_assert(std::is_convertible_v<std::invoke_result_t<DeserializerT, const SerializedT&>, value_t>,
|
|
"INVALID RETURN TYPE OF DESERIALIZER");
|
|
|
|
|
|
auto command_arg = std::shared_ptr<value_t>(value_t());
|
|
|
|
_commandArgUptr = std::make_unique<AdcSerializingValueHolder<SerializedT>>(
|
|
[command_arg]() { return *command_arg; }, [command_arg](const value_t& value) { *command_arg = value; },
|
|
std::forward<ValidatorT>(validator));
|
|
|
|
_execFuncWrapper = [wrapper = traits::adc_pf_wrapper(std::forward<ExecFuncT>(exec_func)), this]() {
|
|
auto& exec_func = std::get<0>(wrapper);
|
|
value_t val = std::any_cast<value_t>(*_commandArgUptr);
|
|
exec_func(val);
|
|
};
|
|
|
|
|
|
_deserializerWrapper =
|
|
[wrapper = traits::adc_pf_wrapper(std::forward<DeserializerT>(deserializer))](std::any& val) {
|
|
auto& deserializer = std::get<0>(wrapper);
|
|
val = std::make_any<value_t>(deserializer(std::any_cast<SerializedT>(val)));
|
|
};
|
|
|
|
// setup only convert-to-native-value function (deserializer)
|
|
_commandArgUptr->addConvertFunc<SerializedT>(std::forward<DeserializerT>(deserializer), []() {});
|
|
} else { // command without argument (ignore deserializer and validator)
|
|
_execFuncWrapper = std::forward<ExecFuncT>(exec_func);
|
|
}
|
|
}
|
|
|
|
|
|
virtual ~AdcDeviceCommand() = default;
|
|
|
|
|
|
/* PUBLIC METHODS */
|
|
|
|
IdentT ident() const { return ident; }
|
|
|
|
|
|
template <typename ValueT>
|
|
void operator()(const ValueT& value)
|
|
{
|
|
if (_commandArgUptr) { // command with argument
|
|
*_commandArgUptr = value;
|
|
}
|
|
_execFuncWrapper();
|
|
}
|
|
|
|
|
|
void operator()()
|
|
{
|
|
if (_commandArgUptr) { // command with argument
|
|
throw 1;
|
|
}
|
|
|
|
_execFuncWrapper();
|
|
}
|
|
};
|
|
|
|
|
|
} // namespace adc
|