AdcDeviceCommand is now parameter-less
rewrite AdcDeviceAttribute class, basic tests of AdcDeviceAttribute passed
This commit is contained in:
Timur A. Fatkhullin
parent
2661a60b47
commit
534d98994b
@ -78,6 +78,15 @@ struct adc_func_traits {
|
||||
// use of an empty struct here to match std::invoke_result behaivior (at least of GCC)
|
||||
};
|
||||
|
||||
// special case
|
||||
template <>
|
||||
struct adc_func_traits<std::nullptr_t> {
|
||||
using ret_t = std::nullptr_t;
|
||||
using args_t = std::tuple<>;
|
||||
using arg1_t = std::nullptr_t;
|
||||
static constexpr size_t arity = 0;
|
||||
};
|
||||
|
||||
template <typename R, typename... Args>
|
||||
struct adc_func_traits<R (*)(Args...)> : adc_func_traits_helper_t<R, Args...> {
|
||||
};
|
||||
|
||||
@ -148,6 +148,8 @@ static VT AdcTrivialDeserializer(SerializedT&& s_value)
|
||||
} else {
|
||||
static_assert(false, "TRIVIAL DESERIALIZER: UNSUPPORTED SERIALIZING TYPE!!!");
|
||||
}
|
||||
|
||||
return VT();
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -63,52 +63,47 @@ concept adc_attr_convfunc_c = std::is_null_pointer_v<T> ||
|
||||
|
||||
// deduce attribute type from getter and setter functions signatures
|
||||
template <adc_attr_getter_c GT, adc_attr_setter_c ST>
|
||||
using attr_value_t =
|
||||
using attr_value_t = std::decay_t<
|
||||
std::conditional_t<std::is_null_pointer_v<GT>,
|
||||
std::conditional_t<std::is_null_pointer_v<ST>, std::nullptr_t, traits::adc_func_arg1_t<ST>>,
|
||||
traits::adc_retval_t<GT>>;
|
||||
traits::adc_retval_t<GT>>>;
|
||||
|
||||
|
||||
|
||||
// deduce attribute internal type from conversional functions signatures
|
||||
template <adc_attr_convfunc_c FromFuncT, adc_attr_convfunc_c ToFuncT>
|
||||
using attr_internal_t = std::conditional_t<
|
||||
using attr_internal_t = std::decay_t<std::conditional_t<
|
||||
std::is_null_pointer_v<ToFuncT>,
|
||||
std::conditional_t<std::is_null_pointer_v<FromFuncT>, std::nullptr_t, traits::adc_retval_t<FromFuncT>>,
|
||||
traits::adc_retval_t<ToFuncT>>;
|
||||
traits::adc_retval_t<ToFuncT>>>;
|
||||
|
||||
|
||||
// deduce user-defined type from conversional functions signatures
|
||||
template <adc_attr_convfunc_c FromFuncT, adc_attr_convfunc_c ToFuncT>
|
||||
using attr_user_t = std::conditional_t<
|
||||
using attr_user_t = std::decay_t<std::conditional_t<
|
||||
std::is_null_pointer_v<FromFuncT>,
|
||||
std::conditional_t<std::is_null_pointer_v<ToFuncT>, std::nullptr_t, traits::adc_retval_t<ToFuncT>>,
|
||||
traits::adc_retval_t<FromFuncT>>;
|
||||
traits::adc_retval_t<FromFuncT>>>;
|
||||
|
||||
|
||||
// attribute serializer function concept
|
||||
template <typename T, typename VT>
|
||||
concept adc_serializer_c = std::invocable<T, const VT&> && !std::same_as<void, traits::adc_retval_t<T>>;
|
||||
concept adc_serializer_c =
|
||||
std::is_null_pointer_v<T> || (std::invocable<T, const VT&> && !std::same_as<void, traits::adc_retval_t<T>>);
|
||||
|
||||
|
||||
// attribute deserializer function concept
|
||||
template <typename T, typename ST>
|
||||
concept adc_deserializer_c = std::invocable<T, const ST&> && !std::same_as<void, traits::adc_retval_t<T>>;
|
||||
|
||||
|
||||
// a callable and it has exactly one argument
|
||||
template <typename T>
|
||||
concept adc_is_setter = adc_func_traits<T>::arity == 1;
|
||||
|
||||
// a callable with exactly one argument of type VT
|
||||
template <typename T, typename VT>
|
||||
concept adc_is_setter_arg = (adc_func_traits<T>::arity == 1) && std::same_as<VT, adc_func_arg1_t<T>>;
|
||||
concept adc_deserializer_c = std::is_null_pointer_v<T> || (traits::adc_func_traits<T>::arity == 1 &&
|
||||
std::convertible_to<traits::adc_retval_t<T>, VT>);
|
||||
|
||||
|
||||
// a callable with exactly one argument of type VT and it returns a value of type ST
|
||||
template <typename T, typename ST, typename VT>
|
||||
concept adc_is_serializer =
|
||||
(adc_func_traits<T>::arity == 1) && std::same_as<VT, adc_func_arg1_t<T>> && std::same_as<ST, adc_retval_t<T>>;
|
||||
template <typename SRT, typename DSRT>
|
||||
using adc_attr_serialized_t = std::decay_t<
|
||||
std::conditional_t<std::is_null_pointer_v<SRT>,
|
||||
std::conditional_t<std::is_null_pointer_v<DSRT>, std::nullptr_t, traits::adc_func_arg1_t<DSRT>>,
|
||||
traits::adc_retval_t<SRT>>>;
|
||||
|
||||
|
||||
} // namespace traits
|
||||
|
||||
@ -119,7 +114,9 @@ enum class AdcDeviceAttributeErrorCode : int {
|
||||
ERROR_INTERNAL_TYPE_MISMATCH,
|
||||
ERROR_READ_ONLY,
|
||||
ERROR_WRITE_ONLY,
|
||||
ERROR_INVALID_SERIALIZED_TYPE
|
||||
ERROR_INVALID_SERIALIZED_TYPE,
|
||||
ERROR_NO_SERIALIZER,
|
||||
ERROR_NO_DESERIALIZER
|
||||
};
|
||||
|
||||
} // namespace adc
|
||||
@ -163,6 +160,10 @@ struct AdcDeviceAttributeErrorCategory : public std::error_category {
|
||||
return "device attribute is write-only";
|
||||
case AdcDeviceAttributeErrorCode::ERROR_INVALID_SERIALIZED_TYPE:
|
||||
return "invalid user-passed serialized type";
|
||||
case AdcDeviceAttributeErrorCode::ERROR_NO_SERIALIZER:
|
||||
return "serializing function was not defined";
|
||||
case AdcDeviceAttributeErrorCode::ERROR_NO_DESERIALIZER:
|
||||
return "deserializing function was not defined";
|
||||
default:
|
||||
return "UNKNOWN";
|
||||
}
|
||||
@ -216,68 +217,63 @@ public:
|
||||
|
||||
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, typename SerializedT = default_serialized_t>
|
||||
constexpr static SerializedT DummySerializer(const T&)
|
||||
{
|
||||
return SerializedT();
|
||||
}
|
||||
|
||||
template <typename T, typename SerializedT = default_serialized_t>
|
||||
constexpr static T DummyDeserializer(const SerializedT&)
|
||||
{
|
||||
return T();
|
||||
}
|
||||
|
||||
|
||||
/* CONSTRUCTORS AND DESTRUCTOR */
|
||||
|
||||
template <std::invocable<> GT,
|
||||
typename ValueT = ret_value_t<GT>,
|
||||
std::invocable<const ValueT&> ST,
|
||||
std::invocable<const ValueT&> SRT =
|
||||
template <traits::adc_attr_getter_c GT,
|
||||
traits::adc_attr_setter_c ST,
|
||||
typename ValueT = traits::attr_value_t<GT, ST>,
|
||||
traits::adc_serializer_c<ValueT> SRT =
|
||||
decltype(utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>),
|
||||
typename SerializedT = ret_value_t<SRT>,
|
||||
std::invocable<const SerializedT&> DSRT =
|
||||
decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)>
|
||||
AdcDeviceAttribute(GT&& getter,
|
||||
ST&& setter,
|
||||
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>,
|
||||
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
|
||||
traits::adc_deserializer_c<ValueT> DSRT =
|
||||
decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, default_serialized_t>)>
|
||||
AdcDeviceAttribute(
|
||||
const IdentT& ident,
|
||||
GT&& getter,
|
||||
ST&& setter,
|
||||
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>,
|
||||
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, default_serialized_t>)
|
||||
: _ident(ident), _accessType(AdcDeviceAttribute::ReadWrite)
|
||||
{
|
||||
static_assert(!std::is_null_pointer_v<ValueT>, "Getter and Setter can not be nullptr simultaneously!!!");
|
||||
|
||||
using SerializedT = traits::adc_attr_serialized_t<SRT, DSRT>;
|
||||
static_assert(!std::is_null_pointer_v<SerializedT>, "Deduced serialized type must not be std::nullptr_t!!!");
|
||||
|
||||
_getterFunc<ValueT>.emplace(this, std::forward<GT>(getter));
|
||||
_setterFunc<ValueT>.emplace(this, std::forward<ST>(setter));
|
||||
|
||||
if constexpr (std::is_null_pointer_v<GT>) {
|
||||
_accessType = AdcDeviceAttribute::WriteOnly;
|
||||
}
|
||||
|
||||
_serializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer)), this]() {
|
||||
auto& serializer = std::get<0>(wrapper);
|
||||
if constexpr (std::is_null_pointer_v<ST>) {
|
||||
_accessType = AdcDeviceAttribute::ReadOnly;
|
||||
}
|
||||
|
||||
if constexpr (!std::is_null_pointer_v<GT> && !std::is_null_pointer_v<SRT>) {
|
||||
_serializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer)),
|
||||
this]() {
|
||||
auto& serializer = std::get<0>(wrapper);
|
||||
|
||||
|
||||
auto val = _getterFunc<ValueT>[this]();
|
||||
auto val = _getterFunc<ValueT>[this]();
|
||||
|
||||
return serializer(val);
|
||||
};
|
||||
return serializer(val);
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
_deserializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<DSRT>(deserializer)),
|
||||
this](const SerializedT& sval) {
|
||||
auto& deserializer = std::get<0>(wrapper);
|
||||
if constexpr (!std::is_null_pointer_v<ST> && !std::is_null_pointer_v<DSRT>) {
|
||||
_deserializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<DSRT>(deserializer)),
|
||||
this](const SerializedT& sval) {
|
||||
auto& deserializer = std::get<0>(wrapper);
|
||||
|
||||
ValueT val = deserializer(sval);
|
||||
ValueT val = deserializer(sval);
|
||||
|
||||
_setterFunc<ValueT>[this](val);
|
||||
};
|
||||
_setterFunc<ValueT>[this](val);
|
||||
};
|
||||
}
|
||||
|
||||
_clearFunc = [this]() {
|
||||
_getterFunc<ValueT>.erase(this);
|
||||
@ -309,90 +305,77 @@ public:
|
||||
}
|
||||
|
||||
|
||||
template <traits::adc_tuple_like<> TupleT,
|
||||
std::invocable<> GT,
|
||||
typename ValueT = ret_value_t<GT>,
|
||||
std::invocable<const ValueT&> ST,
|
||||
std::invocable<const ValueT&> SRT =
|
||||
template <traits::adc_tuple_like TupleT,
|
||||
traits::adc_attr_getter_c GT,
|
||||
traits::adc_attr_setter_c ST,
|
||||
typename ValueT = traits::attr_value_t<GT, ST>,
|
||||
traits::adc_serializer_c<ValueT> SRT =
|
||||
decltype(utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>),
|
||||
typename SerializedT = ret_value_t<SRT>,
|
||||
std::invocable<const SerializedT&> DSRT =
|
||||
decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)>
|
||||
AdcDeviceAttribute(TupleT&&,
|
||||
GT&& getter,
|
||||
ST&& setter,
|
||||
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>,
|
||||
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
|
||||
: AdcDeviceAttribute(std::forward<GT>(getter),
|
||||
traits::adc_deserializer_c<ValueT> DSRT =
|
||||
decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, default_serialized_t>)>
|
||||
AdcDeviceAttribute(
|
||||
const IdentT& ident,
|
||||
TupleT&&,
|
||||
GT&& getter,
|
||||
ST&& setter,
|
||||
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>,
|
||||
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, default_serialized_t>)
|
||||
: AdcDeviceAttribute(ident,
|
||||
std::forward<GT>(getter),
|
||||
std::forward<ST>(setter),
|
||||
std::forward<SRT>(serializer),
|
||||
std::forward<DSRT>(deserializer))
|
||||
{
|
||||
static_assert(!std::is_null_pointer_v<ValueT>, "Getter and Setter can not be nullptr simultaneously!!!");
|
||||
|
||||
AdcDeviceAttribute::setupTrivialConvertFunc<ValueT, std::decay_t<TupleT>>();
|
||||
}
|
||||
|
||||
|
||||
|
||||
// read-only attribute constructor
|
||||
template <std::invocable<> GT,
|
||||
template <std::invocable GT,
|
||||
typename ValueT = ret_value_t<GT>,
|
||||
std::invocable<const ValueT&> SRT =
|
||||
traits::adc_serializer_c<ValueT> SRT =
|
||||
decltype(utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>),
|
||||
typename SerializedT = ret_value_t<SRT>>
|
||||
AdcDeviceAttribute(const IdentT& ident,
|
||||
GT&& getter,
|
||||
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>)
|
||||
: AdcDeviceAttribute(ident,
|
||||
std::forward<GT>(getter),
|
||||
AdcDeviceAttribute::DummySetter<ValueT>,
|
||||
std::forward<SRT>(serializer),
|
||||
AdcDeviceAttribute::DummyDeserializer<ValueT, SerializedT>)
|
||||
: AdcDeviceAttribute(ident, std::forward<GT>(getter), nullptr, std::forward<SRT>(serializer), nullptr)
|
||||
{
|
||||
_accessType = ReadOnly;
|
||||
}
|
||||
|
||||
|
||||
template <traits::adc_tuple_like<> TupleT,
|
||||
std::invocable<> GT,
|
||||
template <traits::adc_tuple_like TupleT,
|
||||
std::invocable GT,
|
||||
typename ValueT = ret_value_t<GT>,
|
||||
std::invocable<const ValueT&> SRT =
|
||||
traits::adc_serializer_c<ValueT> SRT =
|
||||
decltype(utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>),
|
||||
typename SerializedT = ret_value_t<SRT>>
|
||||
AdcDeviceAttribute(const IdentT& ident,
|
||||
TupleT&&,
|
||||
GT&& getter,
|
||||
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<default_serialized_t, ValueT>)
|
||||
: AdcDeviceAttribute(ident,
|
||||
TupleT{},
|
||||
std::forward<GT>(getter),
|
||||
AdcDeviceAttribute::DummySetter<ValueT>,
|
||||
std::forward<SRT>(serializer),
|
||||
AdcDeviceAttribute::DummyDeserializer<ValueT, SerializedT>)
|
||||
: AdcDeviceAttribute(ident, TupleT{}, std::forward<GT>(getter), nullptr, std::forward<SRT>(serializer), nullptr)
|
||||
{
|
||||
_accessType = ReadOnly;
|
||||
}
|
||||
|
||||
|
||||
// write-only attribute constructor
|
||||
template <traits::adc_is_setter<> ST,
|
||||
template <traits::adc_attr_setter_c ST,
|
||||
typename ValueT = std::decay_t<traits::adc_func_arg1_t<ST>>,
|
||||
typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, default_serialized_t>),
|
||||
typename SerializedT = std::decay_t<traits::adc_func_arg1_t<DSRT>>>
|
||||
AdcDeviceAttribute(const IdentT& ident,
|
||||
ST&& setter,
|
||||
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
|
||||
: AdcDeviceAttribute(ident,
|
||||
AdcDeviceAttribute::DummyGetter<ValueT>,
|
||||
std::forward<ST>(setter),
|
||||
AdcDeviceAttribute::DummySerializer<ValueT>,
|
||||
std::forward<DSRT>(deserializer))
|
||||
: AdcDeviceAttribute(ident, nullptr, std::forward<ST>(setter), nullptr, std::forward<DSRT>(deserializer))
|
||||
{
|
||||
_accessType = WriteOnly;
|
||||
}
|
||||
|
||||
|
||||
template <traits::adc_tuple_like<> TupleT,
|
||||
traits::adc_is_setter<> ST,
|
||||
template <traits::adc_tuple_like TupleT,
|
||||
traits::adc_attr_setter_c ST,
|
||||
typename ValueT = std::decay_t<traits::adc_func_arg1_t<ST>>,
|
||||
typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, default_serialized_t>),
|
||||
typename SerializedT = std::decay_t<traits::adc_func_arg1_t<DSRT>>>
|
||||
@ -402,16 +385,14 @@ public:
|
||||
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
|
||||
: AdcDeviceAttribute(ident,
|
||||
TupleT{},
|
||||
AdcDeviceAttribute::DummyGetter<ValueT>,
|
||||
nullptr,
|
||||
std::forward<ST>(setter),
|
||||
AdcDeviceAttribute::DummySerializer<ValueT>,
|
||||
nullptr,
|
||||
std::forward<DSRT>(deserializer))
|
||||
{
|
||||
_accessType = WriteOnly;
|
||||
}
|
||||
|
||||
|
||||
|
||||
AdcDeviceAttribute(const AdcDeviceAttribute& other)
|
||||
{
|
||||
_clearFunc();
|
||||
@ -447,37 +428,45 @@ public:
|
||||
AccessType accessType() const { return _accessType; }
|
||||
|
||||
|
||||
template <typename FromFuncT, typename ToFuncT>
|
||||
template <traits::adc_attr_convfunc_c FromFuncT, traits::adc_attr_convfunc_c ToFuncT>
|
||||
AdcDeviceAttribute& addConvertFunc(FromFuncT&& func_from_internal, ToFuncT&& func_to_internal)
|
||||
requires std::invocable<FromFuncT, const ret_value_t<ToFuncT>&> &&
|
||||
std::invocable<ToFuncT, const ret_value_t<FromFuncT>&>
|
||||
{
|
||||
using value_t = ret_value_t<ToFuncT>; // it must be internal value type
|
||||
using user_t = ret_value_t<FromFuncT>;
|
||||
// using value_t = ret_value_t<ToFuncT>; // it must be internal value type
|
||||
// using user_t = ret_value_t<FromFuncT>;
|
||||
|
||||
_getterFunc<user_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<FromFuncT>(func_from_internal)),
|
||||
this]() {
|
||||
auto& getter = _getterFunc<value_t>[this];
|
||||
if (getter) {
|
||||
auto val = getter();
|
||||
return std::get<0>(wrapper)(val); // convert from internal type
|
||||
}
|
||||
// invalid conversion function signature
|
||||
using value_t = traits::attr_internal_t<FromFuncT, ToFuncT>;
|
||||
using user_t = traits::attr_user_t<FromFuncT, ToFuncT>;
|
||||
|
||||
static_assert(!std::is_null_pointer_v<value_t>,
|
||||
"Deduced attribute internal type must not be std::nullptr_t!!!");
|
||||
static_assert(!std::is_null_pointer_v<user_t>, "Deduced user-defined type must not be std::nullptr_t!!!");
|
||||
|
||||
try {
|
||||
if (_accessType != AdcDeviceAttribute::WriteOnly) {
|
||||
auto& getter = _getterFunc<value_t>.at(this); // throw out_of_range if value_t is invalid
|
||||
|
||||
_getterFunc<user_t>[this] =
|
||||
[&getter, wrapper = traits::adc_pf_wrapper(std::forward<FromFuncT>(func_from_internal)), this]() {
|
||||
auto val = getter();
|
||||
return std::get<0>(wrapper)(val); // convert from internal type
|
||||
};
|
||||
} // ignore "from_internal" conversional function for write-only attribute
|
||||
|
||||
|
||||
|
||||
if (_accessType != AdcDeviceAttribute::ReadOnly) {
|
||||
auto& setter = _setterFunc<value_t>.at(this); // throw out_of_range if value_t is invalid
|
||||
|
||||
_setterFunc<user_t>[this] = [&setter,
|
||||
wrapper = traits::adc_pf_wrapper(std::forward<ToFuncT>(func_to_internal)),
|
||||
this](const user_t& val) {
|
||||
value_t value = std::get<0>(wrapper)(val); // convert to internal type
|
||||
setter(value);
|
||||
};
|
||||
} // ignore "to_internal" conversional function for read-only attribute
|
||||
} catch (const std::out_of_range&) {
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INTERNAL_TYPE_MISMATCH);
|
||||
};
|
||||
|
||||
|
||||
_setterFunc<user_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<ToFuncT>(func_to_internal)),
|
||||
this](const user_t& val) {
|
||||
value_t value = std::get<0>(wrapper)(val); // convert to internal type
|
||||
auto& setter = _setterFunc<value_t>[this];
|
||||
if (setter) {
|
||||
setter(value);
|
||||
} else {
|
||||
// invalid conversion function signature
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INTERNAL_TYPE_MISMATCH);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
_clearFunc = [prev_clear = _clearFunc, this]() {
|
||||
prev_clear();
|
||||
@ -515,16 +504,22 @@ public:
|
||||
|
||||
using val_t = std::decay_t<UT>;
|
||||
|
||||
auto getter = _getterFunc<val_t>[this];
|
||||
if (getter) {
|
||||
return getter();
|
||||
try {
|
||||
return _getterFunc<val_t>.at(this)();
|
||||
} catch (const std::out_of_range&) {
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_CONV_FUNC);
|
||||
}
|
||||
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_CONV_FUNC);
|
||||
// auto& getter = _getterFunc<val_t>[this];
|
||||
// if (getter) {
|
||||
// return getter();
|
||||
// }
|
||||
|
||||
// throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_CONV_FUNC);
|
||||
}
|
||||
|
||||
template <typename UT>
|
||||
AdcDeviceAttribute& operator=(UT&& other)
|
||||
AdcDeviceAttribute& operator=(UT&& val)
|
||||
{
|
||||
if (_accessType == ReadOnly) {
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_READ_ONLY);
|
||||
@ -532,13 +527,19 @@ public:
|
||||
|
||||
using val_t = std::decay_t<UT>;
|
||||
|
||||
auto setter = _setterFunc<val_t>[this];
|
||||
if (setter) {
|
||||
setter(std::forward<UT>(other));
|
||||
} else {
|
||||
try {
|
||||
_setterFunc<val_t>.at(this)(std::forward<UT>(val));
|
||||
} catch (const std::out_of_range&) {
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_CONV_FUNC);
|
||||
}
|
||||
|
||||
// auto& setter = _setterFunc<val_t>[this];
|
||||
// if (setter) {
|
||||
// setter(std::forward<UT>(val));
|
||||
// } else {
|
||||
// throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_CONV_FUNC);
|
||||
// }
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -577,28 +578,63 @@ public:
|
||||
template <typename SerializedT>
|
||||
SerializedT serialize()
|
||||
{
|
||||
using s_t = std::decay_t<SerializedT>;
|
||||
|
||||
auto& serializer = _serializerFunc<s_t>[this];
|
||||
|
||||
if (serializer) {
|
||||
return serializer();
|
||||
if (_accessType == AdcDeviceAttribute::WriteOnly) {
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_WRITE_ONLY);
|
||||
}
|
||||
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
|
||||
using s_t = std::decay_t<SerializedT>;
|
||||
|
||||
try {
|
||||
_serializerFunc<s_t>.at(this)();
|
||||
} catch (const std::out_of_range&) {
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
|
||||
} catch (const std::bad_function_call&) { // serializer was not defined in ctor!
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_SERIALIZER);
|
||||
}
|
||||
|
||||
// auto& serializer = _serializerFunc<s_t>[this];
|
||||
|
||||
// if (serializer) {
|
||||
// return serializer();
|
||||
// }
|
||||
|
||||
// throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
|
||||
}
|
||||
|
||||
template <typename SerializedT>
|
||||
void deserialize(const SerializedT& sval)
|
||||
AdcDeviceAttribute& deserialize(const SerializedT& sval)
|
||||
{
|
||||
if (_accessType == AdcDeviceAttribute::ReadOnly) {
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_READ_ONLY);
|
||||
}
|
||||
|
||||
using s_t = std::decay_t<SerializedT>;
|
||||
|
||||
auto& deserializer = _deserializerFunc<s_t>[this];
|
||||
if (deserializer) {
|
||||
deserializer(sval);
|
||||
} else {
|
||||
try {
|
||||
_deserializerFunc<s_t>.at(this)(sval);
|
||||
} catch (const std::out_of_range&) {
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
|
||||
} catch (const std::bad_function_call&) { // deserializer was not defined in ctor!
|
||||
throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_NO_DESERIALIZER);
|
||||
}
|
||||
|
||||
// auto& deserializer = _deserializerFunc<s_t>[this];
|
||||
// if (deserializer) {
|
||||
// deserializer(sval);
|
||||
// } else {
|
||||
// throw std::system_error(AdcDeviceAttributeErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
|
||||
// }
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
/* some usefull factory functions */
|
||||
|
||||
template <typename... CtorArgTs>
|
||||
static AdcDeviceAttribute makeArithAttr(const IdentT& ident, CtorArgTs... ctor_args)
|
||||
{
|
||||
return AdcDeviceAttribute{ident, constants::AdcDefaultTrivialConvTypes, std::forward<CtorArgTs>(ctor_args)...};
|
||||
}
|
||||
|
||||
protected:
|
||||
@ -628,4 +664,5 @@ protected:
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
} // namespace adc
|
||||
|
||||
@ -7,10 +7,9 @@
|
||||
|
||||
*/
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
// #include "../common/adc_value_holder.h"
|
||||
#include "../common/adc_value.h"
|
||||
#include <functional>
|
||||
#include "../common/adc_traits.h"
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@ -19,76 +18,32 @@
|
||||
namespace adc
|
||||
{
|
||||
|
||||
template <typename IdentT, typename SerializedT = std::string>
|
||||
|
||||
namespace traits
|
||||
{
|
||||
|
||||
template <typename T>
|
||||
concept adc_cmd_exec_c = traits::adc_func_traits<T>::arity == 0 && !std::same_as<T, std::nullptr_t>;
|
||||
|
||||
} // namespace traits
|
||||
|
||||
|
||||
template <typename IdentT = std::string_view>
|
||||
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();
|
||||
}
|
||||
std::function<void()> _execFunc;
|
||||
|
||||
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()
|
||||
template <traits::adc_cmd_exec_c ExecFuncT>
|
||||
AdcDeviceCommand(const IdentT& ident, ExecFuncT&& exec_func)
|
||||
: _ident(ident), _execFunc(std::forward<ExecFuncT>(exec_func))
|
||||
{
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -100,24 +55,7 @@ public:
|
||||
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();
|
||||
}
|
||||
void operator()() { _execFunc(); }
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -32,15 +32,28 @@ TEST_CASE("[ADC DEVICE ATTRIBUTE]")
|
||||
|
||||
using attr_t = AdcDeviceAttribute<std::string_view>;
|
||||
|
||||
attr_t attr("ATTR_A", adc::constants::AdcDefaultTrivialConvTypes, vv::getter, vv::setter);
|
||||
std::string_view id{"ATTR_A"};
|
||||
|
||||
// attr_t attr(id, adc::constants::AdcDefaultTrivialConvTypes, vv::getter, vv::setter);
|
||||
attr_t attr("id", adc::constants::AdcDefaultTrivialConvTypes, vv::getter, vv::setter);
|
||||
|
||||
attr = 10.7;
|
||||
av = attr;
|
||||
|
||||
std::cout << "ATTR = " << av << "\n";
|
||||
// std::cout << "ATTR = " << (unsigned)attr << "\n";
|
||||
std::cout << "ATTR = " << (unsigned)attr << "\n";
|
||||
|
||||
// attr_t aw("ATTR_WO", nullptr, vv::setter, nullptr);
|
||||
attr_t aw("ATTR_WO", adc::constants::AdcDefaultTrivialConvTypes, vv::setter);
|
||||
// attr_t aw(id, adc::constants::AdcDefaultTrivialConvTypes, vv::setter);
|
||||
|
||||
std::cout << "ACC_TYPE: " << aw.accessType() << "\n";
|
||||
// av = aw;
|
||||
aw = 4534.6588;
|
||||
|
||||
// attr_t ar("ATTR_RO", adc::constants::AdcDefaultTrivialConvTypes, vv::getter);
|
||||
auto ar = attr_t::makeArithAttr("ATTR_RO", vv::getter);
|
||||
std::cout << "ACC_TYPE: " << ar.accessType() << "\n";
|
||||
|
||||
std::cout << "ATTR_RO = " << (double)ar << "\n";
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user