573 lines
21 KiB
C++
573 lines
21 KiB
C++
#pragma once
|
|
|
|
/*
|
|
|
|
ABSTRACT DEVICE COMPONENTS LIBRARY
|
|
|
|
*/
|
|
|
|
|
|
#include <functional>
|
|
#include <system_error>
|
|
|
|
#include "adc_traits.h"
|
|
#include "adc_utils.h"
|
|
|
|
namespace adc
|
|
{
|
|
|
|
// error codes
|
|
enum class AdcValueHolderErrorCode : int {
|
|
ERROR_OK,
|
|
ERROR_NO_CONV_FUNC,
|
|
ERROR_INTERNAL_TYPE_MISMATCH,
|
|
ERROR_VALUE_IS_NOT_VALID
|
|
};
|
|
|
|
} // namespace adc
|
|
|
|
|
|
namespace std
|
|
{
|
|
|
|
template <>
|
|
class is_error_code_enum<adc::AdcValueHolderErrorCode> : public true_type
|
|
{
|
|
};
|
|
|
|
} // namespace std
|
|
|
|
|
|
namespace adc
|
|
{
|
|
|
|
|
|
|
|
// error category
|
|
struct AdcValueHolderErrorCategory : public std::error_category {
|
|
AdcValueHolderErrorCategory() : std::error_category() {}
|
|
|
|
const char* name() const noexcept { return "DEVA_DEVICE_ATTRIBUTE"; }
|
|
|
|
std::string message(int ec) const
|
|
{
|
|
AdcValueHolderErrorCode err = static_cast<AdcValueHolderErrorCode>(ec);
|
|
|
|
switch (err) {
|
|
case AdcValueHolderErrorCode::ERROR_OK:
|
|
return "OK";
|
|
case AdcValueHolderErrorCode::ERROR_NO_CONV_FUNC:
|
|
return "conversion function is not defined";
|
|
case AdcValueHolderErrorCode::ERROR_INTERNAL_TYPE_MISMATCH:
|
|
return "try to setup default conversion function for invalid type (internal type mismatch)";
|
|
case AdcValueHolderErrorCode::ERROR_VALUE_IS_NOT_VALID:
|
|
return "user value is not valid";
|
|
default:
|
|
return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
static const AdcValueHolderErrorCategory& get()
|
|
{
|
|
static const AdcValueHolderErrorCategory constInst;
|
|
return constInst;
|
|
}
|
|
};
|
|
|
|
|
|
inline std::error_code make_error_code(AdcValueHolderErrorCode ec)
|
|
{
|
|
return std::error_code(static_cast<int>(ec), AdcValueHolderErrorCategory::get());
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
GENERAL-PURPOSE VALUE HOLDER CLASS WITH OPTIONAL VALIDATOR
|
|
|
|
*/
|
|
|
|
|
|
class AdcValueHolder
|
|
{
|
|
protected:
|
|
template <typename T>
|
|
using ret_value_t = std::decay_t<traits::adc_retval_t<T>>;
|
|
|
|
template <typename VT>
|
|
inline static std::unordered_map<const AdcValueHolder*, std::function<VT()>> _getterFunc{};
|
|
|
|
template <typename VT>
|
|
inline static std::unordered_map<const AdcValueHolder*, std::function<void(const VT&)>> _setterFunc{};
|
|
|
|
std::function<void()> _clearFunc;
|
|
|
|
void init(std::invocable<> auto&& getter,
|
|
std::invocable<const ret_value_t<decltype(getter)>&> auto&& setter,
|
|
std::predicate<const ret_value_t<decltype(getter)>&> auto&& validator)
|
|
{
|
|
using value_t = ret_value_t<decltype(getter)>;
|
|
|
|
static_assert(!std::is_same_v<value_t, void>, "THE getter MUST NOT RETURN void TYPE!!!");
|
|
|
|
using g_t = decltype(getter);
|
|
using s_t = decltype(setter);
|
|
using vld_t = decltype(validator);
|
|
|
|
_getterFunc<value_t>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<g_t>(getter))]() {
|
|
return std::get<0>(wrapper)();
|
|
};
|
|
|
|
|
|
_setterFunc<value_t>[this] = [wrapper =
|
|
traits::adc_pf_wrapper(std::forward<s_t>(setter),
|
|
std::forward<vld_t>(validator))](const value_t& val) {
|
|
if (std::get<1>(wrapper)(val)) {
|
|
std::get<0>(wrapper)(val);
|
|
} else {
|
|
throw std::system_error(AdcValueHolderErrorCode::ERROR_VALUE_IS_NOT_VALID);
|
|
}
|
|
};
|
|
|
|
_clearFunc = [this]() {
|
|
_getterFunc<value_t>.erase(this);
|
|
_setterFunc<value_t>.erase(this);
|
|
};
|
|
}
|
|
|
|
public:
|
|
// default trivial types (just arithmetic ones)
|
|
constexpr static std::tuple<bool,
|
|
char,
|
|
short,
|
|
int,
|
|
long,
|
|
long long,
|
|
unsigned char,
|
|
unsigned short,
|
|
unsigned int,
|
|
unsigned long,
|
|
unsigned long long,
|
|
float,
|
|
double,
|
|
long double>
|
|
_defaultTrivialConvTypes{};
|
|
|
|
// always-true validator
|
|
// constexpr static auto AdcValueHolderDummyValidator = [](const auto&) { return true; };
|
|
template <typename VT>
|
|
constexpr static bool AdcValueHolderDummyValidator(const VT&)
|
|
{
|
|
return true;
|
|
};
|
|
|
|
/* CONSTRUCTORS AND DESTRUCTOR */
|
|
|
|
template <typename GT,
|
|
typename VALT = ret_value_t<GT>,
|
|
typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
|
|
AdcValueHolder(GT&& getter,
|
|
std::invocable<const VALT&> auto&& setter,
|
|
VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
|
|
requires std::invocable<GT> && std::predicate<VT, const VALT&>
|
|
{
|
|
init(std::forward<GT>(getter), std::forward<decltype(setter)>(setter),
|
|
std::forward<decltype(validator)>(validator));
|
|
}
|
|
|
|
|
|
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),
|
|
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...>>();
|
|
}
|
|
|
|
|
|
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;
|
|
|
|
virtual ~AdcValueHolder() { _clearFunc(); };
|
|
|
|
|
|
/* PUBLIC METHODS */
|
|
|
|
|
|
template <typename GT, typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<ret_value_t<GT>>)>
|
|
AdcValueHolder& resetValueHolder(GT&& getter,
|
|
std::invocable<const ret_value_t<GT>&> auto&& setter,
|
|
VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<ret_value_t<GT>>)
|
|
requires std::invocable<GT> && std::predicate<VT, const ret_value_t<GT>&>
|
|
{
|
|
_clearFunc();
|
|
|
|
init(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
|
|
std::forward<decltype(validator)>(validator));
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
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 */)
|
|
{
|
|
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...>>();
|
|
|
|
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);
|
|
}
|
|
|
|
|
|
template <typename FromFuncT, typename ToFuncT>
|
|
AdcValueHolder& 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 from_sig_t = typename traits::adc_func_traits<FromFuncT>;
|
|
// using to_sig_t = typename traits::adc_func_traits<ToFuncT>;
|
|
// using value_t = std::decay_t<typename to_sig_t::ret_t>; // internal value type
|
|
// using user_t = std::decay_t<typename from_sig_t::ret_t>;
|
|
|
|
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
|
|
throw std::system_error(AdcValueHolderErrorCode::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(AdcValueHolderErrorCode::ERROR_INTERNAL_TYPE_MISMATCH);
|
|
}
|
|
};
|
|
|
|
_clearFunc = [prev_clear = _clearFunc, this]() {
|
|
_getterFunc<user_t>.erase(this);
|
|
_setterFunc<user_t>.erase(this);
|
|
prev_clear();
|
|
};
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <typename UT>
|
|
operator UT()
|
|
{
|
|
// using v_t = std::remove_reference_t<UT>;
|
|
// using val_t = std::conditional_t<std::is_array_v<v_t>, std::add_pointer_t<std::remove_extent_t<v_t>>, v_t>;
|
|
using val_t = std::decay_t<UT>;
|
|
|
|
auto getter = _getterFunc<val_t>[this];
|
|
if (getter) {
|
|
return getter();
|
|
}
|
|
|
|
throw std::system_error(AdcValueHolderErrorCode::ERROR_NO_CONV_FUNC);
|
|
}
|
|
|
|
template <typename UT>
|
|
AdcValueHolder& operator=(UT&& value)
|
|
{
|
|
using val_t = std::decay_t<UT>;
|
|
|
|
auto setter = _setterFunc<val_t>[this];
|
|
if (setter) {
|
|
setter(std::forward<UT>(value));
|
|
// setter(value);
|
|
} else {
|
|
throw std::system_error(AdcValueHolderErrorCode::ERROR_NO_CONV_FUNC);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
AdcValueHolder& operator=(AdcValueHolder&& other) = default;
|
|
AdcValueHolder& operator=(const AdcValueHolder& other) = default;
|
|
|
|
|
|
protected:
|
|
template <typename VT, size_t I, typename TupleT>
|
|
void setupTrivialConvertFuncImpl()
|
|
{
|
|
if constexpr (I < std::tuple_size_v<TupleT>) {
|
|
using elem_t = std::tuple_element_t<I, TupleT>;
|
|
|
|
if constexpr (!std::is_same_v<VT, elem_t>) {
|
|
addConvertFunc([](const VT& v) { return static_cast<elem_t>(v); },
|
|
[](const elem_t& v) { return static_cast<VT>(v); });
|
|
}
|
|
|
|
setupTrivialConvertFuncImpl<VT, I + 1, TupleT>();
|
|
}
|
|
}
|
|
|
|
template <typename VT, typename TupleT>
|
|
void setupTrivialConvertFunc()
|
|
{
|
|
setupTrivialConvertFuncImpl<VT, 0, TupleT>();
|
|
}
|
|
};
|
|
|
|
|
|
|
|
/* */
|
|
|
|
template <typename SerializedT = std::string>
|
|
class AdcSerializingValueHolder : public AdcValueHolder
|
|
{
|
|
protected:
|
|
std::function<SerializedT()> _serializerWrapper;
|
|
|
|
std::function<void(const SerializedT&)> _deserializerWrapper;
|
|
|
|
template <typename ValueT, typename SRT, typename DSRT>
|
|
void initWrappers(SRT&& serializer, DSRT&& deserializer)
|
|
requires std::invocable<SRT, const ValueT&> && std::invocable<DSRT, const SerializedT&>
|
|
|
|
{
|
|
static_assert(std::is_convertible_v<traits::adc_retval_t<SRT>, SerializedT>,
|
|
"INVALID RETURNED TYPE OF SERIALIZING CALLABLE!!!");
|
|
|
|
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);
|
|
};
|
|
|
|
|
|
_deserializerWrapper = [wrapper = traits::adc_pf_wrapper(std::forward<DSRT>(deserializer)),
|
|
this](const SerializedT& sval) {
|
|
auto& deserializer = std::get<0>(wrapper);
|
|
|
|
ValueT val = deserializer(sval);
|
|
|
|
_setterFunc<ValueT>[this](val);
|
|
};
|
|
}
|
|
|
|
public:
|
|
/* CONSTRUCTORS AND DESTRUCTOR */
|
|
|
|
template <typename GT,
|
|
typename ST,
|
|
typename VALT = ret_value_t<GT>,
|
|
typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>),
|
|
typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>),
|
|
typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>)>
|
|
AdcSerializingValueHolder(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&>
|
|
: AdcValueHolder(std::forward<GT>(getter), std::forward<ST>(setter), std::forward<VT>(validator))
|
|
{
|
|
initWrappers<VALT>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
|
|
}
|
|
|
|
|
|
template <typename GT,
|
|
typename ST,
|
|
typename VALT = ret_value_t<GT>,
|
|
typename VT,
|
|
typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, VALT>),
|
|
typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<VALT, SerializedT>),
|
|
typename... Ts>
|
|
AdcSerializingValueHolder(GT&& getter,
|
|
ST&& setter,
|
|
VT&& validator,
|
|
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),
|
|
std::forward<VT>(validator),
|
|
std::tuple<Ts...>{})
|
|
{
|
|
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));
|
|
}
|
|
|
|
|
|
virtual ~AdcSerializingValueHolder() = default;
|
|
|
|
|
|
/* PUBLIC METHODS */
|
|
|
|
template <typename GT,
|
|
typename ST,
|
|
typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<ret_value_t<GT>>),
|
|
typename SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<SerializedT, ret_value_t<GT>>),
|
|
typename DSRT = decltype(utils::AdcDefaultValueConverter<>::deserialize<ret_value_t<GT>, SerializedT>)>
|
|
AdcSerializingValueHolder& resetValueHolder(
|
|
GT&& getter,
|
|
ST&& setter,
|
|
VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<ret_value_t<GT>>,
|
|
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));
|
|
initWrappers<ret_value_t<GT>>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <typename GT,
|
|
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>
|
|
AdcSerializingValueHolder& resetValueHolder(
|
|
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...>{});
|
|
|
|
initWrappers<ret_value_t<GT>>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
|
|
|
|
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); }
|
|
|
|
using AdcValueHolder::operator=;
|
|
};
|
|
|
|
|
|
/*
|
|
factory functions
|
|
|
|
*/
|
|
|
|
template <typename GT,
|
|
typename VALT = traits::adc_retval_t<GT>,
|
|
typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
|
|
AdcValueHolder make_arith_valueholder(GT&& getter,
|
|
std::invocable<const VALT&> auto&& setter,
|
|
VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
|
|
requires std::invocable<GT> && std::predicate<VT, const VALT&>
|
|
{
|
|
using val_t = traits::adc_retval_t<GT>;
|
|
|
|
// static_assert(std::predicate<decltype(validator), const traits::adc_retval_t<decltype(getter)>&>,
|
|
// "INVALID VALIDATOR TYPE!!!");
|
|
|
|
static_assert(std::is_arithmetic_v<val_t>, "GETTER MUST RETURN AN ARITHMETIC TYPE VALUE!!!");
|
|
|
|
return AdcValueHolder(std::forward<GT>(getter), std::forward<decltype(setter)>(setter),
|
|
std::forward<decltype(validator)>(validator), AdcValueHolder::_defaultTrivialConvTypes);
|
|
}
|
|
|
|
|
|
|
|
} // namespace adc
|