488 lines
16 KiB
C++
488 lines
16 KiB
C++
#pragma once
|
|
|
|
/*
|
|
|
|
ABSTRACT DEVICE COMPONENTS LIBRARY
|
|
|
|
*/
|
|
|
|
|
|
#include <any>
|
|
#include <concepts>
|
|
#include <functional>
|
|
#include <map>
|
|
#include <ranges>
|
|
#include <system_error>
|
|
#include <typeindex>
|
|
|
|
#include "adc_traits.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 arg_t = typename traits::adc_func_traits<std::remove_reference_t<T>>::ret_t;
|
|
|
|
std::function<void(std::any&)> _getterWrapper;
|
|
std::function<void(const std::any&)> _setterWrapper;
|
|
|
|
std::map<std::type_index, std::function<void(std::any&)>> _convertToInternal;
|
|
std::map<std::type_index, std::function<void(std::any&)>> _convertFromInternal;
|
|
|
|
std::type_index _internalTypeIndex;
|
|
|
|
void init(std::invocable<> auto&& getter,
|
|
std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
|
|
std::predicate<const traits::adc_retval_t<decltype(getter)>&> auto&& validator)
|
|
{
|
|
using value_t = traits::adc_retval_t<decltype(getter)>;
|
|
|
|
static_assert(!std::is_same_v<value_t, void>, "THE getter MUST NOT RETURN void TYPE!!!");
|
|
|
|
using g_t = decltype(getter);
|
|
_getterWrapper = [wrapper = traits::adc_pf_wrapper(std::forward<g_t>(getter))](std::any& val) {
|
|
auto& getter = std::get<0>(wrapper);
|
|
val = getter();
|
|
};
|
|
|
|
|
|
using vld_t = decltype(validator);
|
|
using s_t = decltype(setter);
|
|
|
|
if constexpr (std::is_same_v<vld_t, decltype(AdcValueHolderDummyValidator<value_t>)>) { // no validation
|
|
_setterWrapper = [wrapper = traits::adc_pf_wrapper(std::forward<s_t>(setter)), this](const std::any& val) {
|
|
auto& setter = std::get<0>(wrapper);
|
|
|
|
setter(std::any_cast<value_t>(val));
|
|
};
|
|
} else {
|
|
_setterWrapper = [wrapper =
|
|
traits::adc_pf_wrapper(std::forward<s_t>(setter), std::forward<vld_t>(validator)),
|
|
this](const std::any& val) {
|
|
auto& setter = std::get<0>(wrapper);
|
|
auto& validator = std::get<1>(wrapper);
|
|
|
|
auto v = std::any_cast<value_t>(val);
|
|
|
|
if (validator(v)) {
|
|
setter(v);
|
|
} else {
|
|
throw std::system_error(AdcValueHolderErrorCode::ERROR_VALUE_IS_NOT_VALID);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
// By default no conversion will be made if user value of internal type is given.
|
|
// But such a conversion may be defined explicitly by calling addConvertFunc method
|
|
_convertFromInternal[_internalTypeIndex] = [](auto) {};
|
|
_convertToInternal[_internalTypeIndex] = [](auto) {};
|
|
}
|
|
|
|
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 = traits::adc_retval_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&>
|
|
: _internalTypeIndex(std::type_index(typeid(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 traits::adc_retval_t<decltype(getter)>&> auto&& setter,
|
|
std::predicate<const traits::adc_retval_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<traits::adc_retval_t<decltype(getter)>, std::tuple<Ts...>>(this);
|
|
}
|
|
|
|
|
|
template <typename... Ts>
|
|
AdcValueHolder(std::invocable<> auto&& getter,
|
|
std::invocable<const traits::adc_retval_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() = default;
|
|
|
|
|
|
/* PUBLIC METHODS */
|
|
|
|
|
|
std::type_index valueTypeIndex() const { return _internalTypeIndex; }
|
|
|
|
|
|
std::vector<std::type_index> convTypeIndices()
|
|
{
|
|
auto kv = std::views::keys(_convertFromInternal);
|
|
return {kv.begin(), kv.end()};
|
|
}
|
|
|
|
|
|
template <typename GT,
|
|
typename VALT = traits::adc_retval_t<GT>,
|
|
typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
|
|
AdcValueHolder& resetValueHolder(GT&& getter,
|
|
std::invocable<const VALT&> auto&& setter,
|
|
VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
|
|
requires std::invocable<GT> && std::predicate<VT, const VALT&>
|
|
{
|
|
_convertFromInternal.clear();
|
|
_convertToInternal.clear();
|
|
|
|
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 traits::adc_retval_t<decltype(getter)>&> auto&& setter,
|
|
std::predicate<const traits::adc_retval_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
|
|
AdcValueHolder::setupTrivialConvertFunc<traits::adc_retval_t<decltype(getter)>, std::tuple<Ts...>>(this);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <typename... Ts>
|
|
AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
|
|
std::invocable<const traits::adc_retval_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<traits::adc_retval_t<decltype(getter)>>,
|
|
t);
|
|
}
|
|
|
|
|
|
template <typename UT>
|
|
AdcValueHolder& addConvertFunc(std::invocable<std::any&> auto&& func_to_internal,
|
|
std::invocable<std::any&> auto&& func_from_internal)
|
|
{
|
|
static_assert(!std::is_same_v<UT, void>, "void IS NOT VALID TYPE!!!");
|
|
|
|
auto t_index = std::type_index(typeid(UT));
|
|
|
|
_convertToInternal[t_index] = std::forward<decltype(func_to_internal)>(func_to_internal);
|
|
_convertFromInternal[t_index] = std::forward<decltype(func_from_internal)>(func_from_internal);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <typename UT = void>
|
|
AdcValueHolder& delConvertFunc()
|
|
{
|
|
if constexpr (std::is_same_v<UT, void>) { // delete all conversion functions
|
|
_convertFromInternal.clear();
|
|
_convertToInternal.clear();
|
|
|
|
// restore conversion functions for internal type
|
|
_convertFromInternal[_internalTypeIndex] = [](auto) {};
|
|
_convertToInternal[_internalTypeIndex] = [](auto) {};
|
|
} else {
|
|
auto t_index = std::type_index(typeid(UT));
|
|
|
|
_convertFromInternal.erase(t_index);
|
|
_convertToInternal.erase(t_index);
|
|
}
|
|
|
|
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>;
|
|
|
|
std::any val;
|
|
|
|
// auto t_index = std::type_index(typeid(UT));
|
|
auto t_index = std::type_index(typeid(val_t));
|
|
auto it = _convertFromInternal.find(t_index);
|
|
|
|
if (it == _convertFromInternal.end()) {
|
|
throw std::system_error(AdcValueHolderErrorCode::ERROR_NO_CONV_FUNC);
|
|
}
|
|
|
|
_getterWrapper(val);
|
|
it->second(val); // call conversion function
|
|
|
|
// return std::any_cast<UT>(val);
|
|
return std::any_cast<val_t>(val);
|
|
}
|
|
|
|
template <typename UT>
|
|
AdcValueHolder& operator=(UT&& value)
|
|
{
|
|
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>;
|
|
|
|
// std::any val = std::make_any<UT>(value);
|
|
std::any val = std::make_any<val_t>(value);
|
|
|
|
// auto t_index = std::type_index(typeid(UT));
|
|
auto t_index = std::type_index(typeid(val_t));
|
|
auto it = _convertToInternal.find(t_index);
|
|
|
|
if (it == _convertToInternal.end()) {
|
|
throw std::system_error(AdcValueHolderErrorCode::ERROR_NO_CONV_FUNC);
|
|
}
|
|
|
|
it->second(val); // call conversion function
|
|
|
|
_setterWrapper(val);
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
AdcValueHolder& operator=(AdcValueHolder&& other) = default;
|
|
AdcValueHolder& operator=(const AdcValueHolder& other) = default;
|
|
|
|
|
|
protected:
|
|
/* STATIC HELPER METHODS */
|
|
|
|
template <typename VT, size_t I, typename TupleT>
|
|
static void setupTrivialConvertFuncImpl(AdcValueHolder* holder)
|
|
{
|
|
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>) {
|
|
auto t_index = std::type_index(typeid(elem_t));
|
|
|
|
holder->_convertToInternal[t_index] = [](std::any& val) {
|
|
val = std::make_any<VT>(std::any_cast<elem_t>(val));
|
|
};
|
|
|
|
holder->_convertFromInternal[t_index] = [](std::any& val) {
|
|
val = std::make_any<elem_t>(std::any_cast<VT>(val));
|
|
};
|
|
}
|
|
|
|
AdcValueHolder::setupTrivialConvertFuncImpl<VT, I + 1, TupleT>(holder);
|
|
}
|
|
}
|
|
|
|
template <typename VT, typename TupleT>
|
|
static void setupTrivialConvertFunc(AdcValueHolder* holder)
|
|
{
|
|
setupTrivialConvertFuncImpl<VT, 0, TupleT>(holder);
|
|
}
|
|
};
|
|
|
|
|
|
/*
|
|
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);
|
|
}
|
|
|
|
|
|
/* */
|
|
|
|
template <typename SerializedT = std::string>
|
|
class AdcSerializingValueHolder : public AdcValueHolder
|
|
{
|
|
protected:
|
|
std::function<SerializedT()> _serializerWrapper = []() {
|
|
|
|
};
|
|
|
|
std::function<void(const SerializedT&)> _deserializerWrapper;
|
|
|
|
template <typename GT, typename ST, typename VT, typename SRT, typename DSRT>
|
|
void init(GT&& getter, ST&& setter, VT&& validator, SRT&& serializer, DSRT&& deserializer)
|
|
{
|
|
_serializerWrapper = [wrapper =
|
|
traits::adc_pf_wrapper(std::forward<GT>(getter), std::forward<SRT>(serializer))]() {
|
|
auto& getter = std::get<0>(wrapper);
|
|
auto& serializer = std::get<1>(wrapper);
|
|
|
|
auto val = getter();
|
|
return serializer(val);
|
|
};
|
|
|
|
|
|
using v_t = traits::adc_retval_t<GT>;
|
|
|
|
_serializerWrapper = [wrapper =
|
|
traits::adc_pf_wrapper(std::forward<ST>(setter), std::forward<VT>(validator),
|
|
std::forward<DSRT>(deserializer))](const SerializedT& sval) {
|
|
auto& setter = std::get<0>(wrapper);
|
|
auto& validator = std::get<1>(wrapper);
|
|
auto& deserializer = std::get<2>(wrapper);
|
|
|
|
v_t val = deserializer(sval);
|
|
|
|
if (validator(val)) {
|
|
setter(val);
|
|
} else {
|
|
throw std::system_error(AdcValueHolderErrorCode::ERROR_VALUE_IS_NOT_VALID);
|
|
}
|
|
};
|
|
}
|
|
|
|
public:
|
|
using AdcValueHolder::AdcValueHolder;
|
|
|
|
virtual ~AdcSerializingValueHolder() = default;
|
|
};
|
|
|
|
|
|
} // namespace adc
|