add common/adc_valholder.h header:
new conception: 1) no validator
2) AdcSerializingValueHolder is now non-templated
class
This commit is contained in:
Timur A. Fatkhullin
548
common/adc_valholder.h
Normal file
548
common/adc_valholder.h
Normal file
@@ -0,0 +1,548 @@
|
||||
#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 };
|
||||
|
||||
enum class AdcSerializingValueHolderErrorCode : int { ERROR_OK, ERROR_INVALID_SERIALIZED_TYPE };
|
||||
|
||||
} // namespace adc
|
||||
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
template <>
|
||||
class is_error_code_enum<adc::AdcValueHolderErrorCode> : public true_type
|
||||
{
|
||||
};
|
||||
|
||||
template <>
|
||||
class is_error_code_enum<adc::AdcSerializingValueHolderErrorCode> : 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 "ADC_VALUE_HOLDER_CATEGORY"; }
|
||||
|
||||
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)";
|
||||
default:
|
||||
return "UNKNOWN";
|
||||
}
|
||||
}
|
||||
|
||||
static const AdcValueHolderErrorCategory& get()
|
||||
{
|
||||
static const AdcValueHolderErrorCategory constInst;
|
||||
return constInst;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
struct AdcSerializingValueHolderErrorCategory : public std::error_category {
|
||||
AdcSerializingValueHolderErrorCategory() : std::error_category() {}
|
||||
|
||||
const char* name() const noexcept { return "ADC_SERIALIZING_VALUE_HOLDER_CATEGORY"; }
|
||||
|
||||
std::string message(int ec) const
|
||||
{
|
||||
AdcSerializingValueHolderErrorCode err = static_cast<AdcSerializingValueHolderErrorCode>(ec);
|
||||
|
||||
switch (err) {
|
||||
case AdcSerializingValueHolderErrorCode::ERROR_OK:
|
||||
return "OK";
|
||||
case AdcSerializingValueHolderErrorCode::ERROR_INVALID_SERIALIZED_TYPE:
|
||||
return "invalid user-passed serialized type";
|
||||
default:
|
||||
return "UNKNOWN";
|
||||
}
|
||||
}
|
||||
|
||||
static const AdcSerializingValueHolderErrorCategory& get()
|
||||
{
|
||||
static const AdcSerializingValueHolderErrorCategory constInst;
|
||||
return constInst;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
inline std::error_code make_error_code(AdcValueHolderErrorCode ec)
|
||||
{
|
||||
return std::error_code(static_cast<int>(ec), AdcValueHolderErrorCategory::get());
|
||||
}
|
||||
|
||||
|
||||
inline std::error_code make_error_code(AdcSerializingValueHolderErrorCode ec)
|
||||
{
|
||||
return std::error_code(static_cast<int>(ec), AdcSerializingValueHolderErrorCategory::get());
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
|
||||
GENERAL-PURPOSE VALUE HOLDER CLASS
|
||||
|
||||
*/
|
||||
|
||||
|
||||
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;
|
||||
|
||||
std::function<void(AdcValueHolder*)> _copyFunc;
|
||||
std::function<void(AdcValueHolder*)> _moveFunc;
|
||||
|
||||
|
||||
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{};
|
||||
|
||||
|
||||
/* CONSTRUCTORS AND DESTRUCTOR */
|
||||
|
||||
template <std::invocable<> GT, typename ValueT = ret_value_t<GT>, std::invocable<const ValueT&> ST>
|
||||
AdcValueHolder(GT&& getter, ST&& setter)
|
||||
{
|
||||
_getterFunc<ValueT>.emplace(this, std::forward<GT>(getter));
|
||||
_setterFunc<ValueT>.emplace(this, std::forward<ST>(setter));
|
||||
|
||||
_clearFunc = [this]() {
|
||||
_getterFunc<ValueT>.erase(this);
|
||||
_setterFunc<ValueT>.erase(this);
|
||||
};
|
||||
|
||||
// copy TO other
|
||||
_copyFunc = [this](AdcValueHolder* other) {
|
||||
_getterFunc<ValueT>.emplace(other, _getterFunc<ValueT>[this]);
|
||||
_setterFunc<ValueT>.emplace(other, _setterFunc<ValueT>[this]);
|
||||
};
|
||||
|
||||
// move TO other
|
||||
_moveFunc = [this](AdcValueHolder* other) {
|
||||
_getterFunc<ValueT>.emplace(other, std::move(_getterFunc<ValueT>[this]));
|
||||
_setterFunc<ValueT>.emplace(other, std::move(_setterFunc<ValueT>[this]));
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
template <traits::adc_tuple_like<> TupleT,
|
||||
std::invocable<> GT,
|
||||
typename ValueT = ret_value_t<GT>,
|
||||
std::invocable<const ValueT&> ST>
|
||||
AdcValueHolder(TupleT&&, GT&& getter, ST&& setter)
|
||||
: AdcValueHolder(std::forward<GT>(getter), std::forward<ST>(setter))
|
||||
{
|
||||
// setup trivially-defined conversion function
|
||||
AdcValueHolder::setupTrivialConvertFunc<ValueT, std::decay_t<TupleT>>();
|
||||
}
|
||||
|
||||
AdcValueHolder(const AdcValueHolder& other)
|
||||
{
|
||||
_clearFunc();
|
||||
|
||||
other._copyFunc(this);
|
||||
|
||||
_clearFunc = other._clearFunc;
|
||||
_copyFunc = other._copyFunc;
|
||||
_moveFunc = other._moveFunc;
|
||||
};
|
||||
|
||||
|
||||
AdcValueHolder(AdcValueHolder&& other)
|
||||
{
|
||||
_clearFunc();
|
||||
|
||||
other._moveFunc(this);
|
||||
|
||||
_clearFunc = std::move(other._clearFunc);
|
||||
_copyFunc = std::move(other._copyFunc);
|
||||
_moveFunc = std::move(other._moveFunc);
|
||||
};
|
||||
|
||||
virtual ~AdcValueHolder() { _clearFunc(); };
|
||||
|
||||
|
||||
/* PUBLIC METHODS */
|
||||
|
||||
|
||||
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 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]() {
|
||||
prev_clear();
|
||||
|
||||
_getterFunc<user_t>.erase(this);
|
||||
_setterFunc<user_t>.erase(this);
|
||||
};
|
||||
|
||||
|
||||
_copyFunc = [prev_copy = _copyFunc, this](AdcValueHolder* other) {
|
||||
prev_copy(other);
|
||||
|
||||
_getterFunc<user_t>.emplace(other, _getterFunc<user_t>[this]);
|
||||
_setterFunc<user_t>.emplace(other, _setterFunc<user_t>[this]);
|
||||
};
|
||||
|
||||
// move TO other
|
||||
_moveFunc = [prev_move = _moveFunc, this](AdcValueHolder* other) {
|
||||
prev_move(other);
|
||||
|
||||
_getterFunc<user_t>.emplace(other, std::move(_getterFunc<user_t>[this]));
|
||||
_setterFunc<user_t>.emplace(other, std::move(_setterFunc<user_t>[this]));
|
||||
};
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
template <typename UT>
|
||||
operator UT() const
|
||||
{
|
||||
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)
|
||||
{
|
||||
if (&other != this) {
|
||||
_clearFunc();
|
||||
|
||||
other._moveFunc(this);
|
||||
|
||||
_clearFunc = std::move(other._clearFunc);
|
||||
_copyFunc = std::move(other._copyFunc);
|
||||
_moveFunc = std::move(other._moveFunc);
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
AdcValueHolder& operator=(const AdcValueHolder& other)
|
||||
{
|
||||
if (&other != this) {
|
||||
_clearFunc();
|
||||
|
||||
other._copyFunc(this);
|
||||
|
||||
_clearFunc = other._clearFunc;
|
||||
_copyFunc = other._copyFunc;
|
||||
_moveFunc = other._moveFunc;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
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>();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
class AdcSerializingValueHolder : public AdcValueHolder
|
||||
{
|
||||
protected:
|
||||
template <typename SerializedT>
|
||||
inline static std::unordered_map<const AdcSerializingValueHolder*, std::function<SerializedT()>> _serializerFunc{};
|
||||
|
||||
template <typename SerializedT>
|
||||
inline static std::unordered_map<const AdcSerializingValueHolder*, std::function<void(const SerializedT&)>>
|
||||
_deserializerFunc{};
|
||||
|
||||
// shadow base class's members
|
||||
std::function<void()> _clearFunc;
|
||||
std::function<void(AdcSerializingValueHolder*)> _copyFunc;
|
||||
std::function<void(AdcSerializingValueHolder*)> _moveFunc;
|
||||
|
||||
public:
|
||||
template <
|
||||
std::invocable<> GT,
|
||||
typename ValueT = ret_value_t<GT>,
|
||||
std::invocable<const ValueT&> ST,
|
||||
std::invocable<const ValueT&> SRT = decltype(utils::AdcDefaultValueConverter<>::serialize<std::string, ValueT>),
|
||||
typename SerializedT = ret_value_t<SRT>,
|
||||
std::invocable<const SerializedT&> DSRT =
|
||||
decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)>
|
||||
AdcSerializingValueHolder(GT&& getter,
|
||||
ST&& setter,
|
||||
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<std::string, ValueT>,
|
||||
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
|
||||
: AdcValueHolder(std::forward<GT>(getter), std::forward<ST>(setter))
|
||||
{
|
||||
_serializerFunc<SerializedT>[this] = [wrapper = traits::adc_pf_wrapper(std::forward<SRT>(serializer)), this]() {
|
||||
auto& serializer = std::get<0>(wrapper);
|
||||
|
||||
|
||||
auto val = _getterFunc<ValueT>[this]();
|
||||
|
||||
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);
|
||||
|
||||
ValueT val = deserializer(sval);
|
||||
|
||||
_setterFunc<ValueT>[this](val);
|
||||
};
|
||||
|
||||
_clearFunc = [this]() {
|
||||
_serializerFunc<SerializedT>.erase(this);
|
||||
_deserializerFunc<SerializedT>.erase(this);
|
||||
};
|
||||
|
||||
_copyFunc = [this](AdcSerializingValueHolder* other) {
|
||||
_serializerFunc<SerializedT>.emplace(other, _serializerFunc<SerializedT>[this]);
|
||||
_deserializerFunc<SerializedT>.emplace(other, _deserializerFunc<SerializedT>[this]);
|
||||
};
|
||||
|
||||
_moveFunc = [this](AdcSerializingValueHolder* other) {
|
||||
_serializerFunc<SerializedT>.emplace(other, std::move(_serializerFunc<SerializedT>[this]));
|
||||
_deserializerFunc<SerializedT>.emplace(other, std::move(_deserializerFunc<SerializedT>[this]));
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
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 = decltype(utils::AdcDefaultValueConverter<>::serialize<std::string, ValueT>),
|
||||
typename SerializedT = ret_value_t<SRT>,
|
||||
std::invocable<const SerializedT&> DSRT =
|
||||
decltype(utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)>
|
||||
AdcSerializingValueHolder(TupleT&&,
|
||||
GT&& getter,
|
||||
ST&& setter,
|
||||
SRT&& serializer = utils::AdcDefaultValueConverter<>::serialize<std::string, ValueT>,
|
||||
DSRT&& deserializer = utils::AdcDefaultValueConverter<>::deserialize<ValueT, SerializedT>)
|
||||
: AdcSerializingValueHolder(std::forward<GT>(getter),
|
||||
std::forward<ST>(setter),
|
||||
std::forward<SRT>(serializer),
|
||||
std::forward<DSRT>(deserializer))
|
||||
{
|
||||
AdcValueHolder::setupTrivialConvertFunc<ValueT, std::decay_t<TupleT>>();
|
||||
}
|
||||
|
||||
|
||||
virtual ~AdcSerializingValueHolder() { _clearFunc(); };
|
||||
|
||||
AdcSerializingValueHolder(const AdcSerializingValueHolder& other) : AdcValueHolder(other)
|
||||
{
|
||||
_clearFunc();
|
||||
|
||||
_copyFunc(other);
|
||||
}
|
||||
|
||||
|
||||
AdcSerializingValueHolder(AdcSerializingValueHolder&& other) : AdcValueHolder(std::move(other))
|
||||
{
|
||||
_clearFunc();
|
||||
|
||||
_moveFunc(other);
|
||||
}
|
||||
|
||||
AdcSerializingValueHolder& operator=(const AdcSerializingValueHolder& other)
|
||||
{
|
||||
AdcValueHolder::operator=(other);
|
||||
_copyFunc(other);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
AdcSerializingValueHolder& operator=(AdcSerializingValueHolder&& other)
|
||||
{
|
||||
AdcValueHolder::operator=(std::move(other));
|
||||
_moveFunc(other);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
using AdcValueHolder::operator=;
|
||||
|
||||
|
||||
template <typename SerializedT>
|
||||
SerializedT serialize()
|
||||
{
|
||||
using s_t = std::decay_t<SerializedT>;
|
||||
|
||||
auto& serializer = _serializerFunc<s_t>[this];
|
||||
|
||||
if (serializer) {
|
||||
return serializer();
|
||||
}
|
||||
|
||||
throw std::system_error(AdcSerializingValueHolderErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
|
||||
}
|
||||
|
||||
template <typename SerializedT>
|
||||
void deserialize(const SerializedT& sval)
|
||||
{
|
||||
using s_t = std::decay_t<SerializedT>;
|
||||
|
||||
auto& deserializer = _deserializerFunc<s_t>[this];
|
||||
if (deserializer) {
|
||||
deserializer(sval);
|
||||
} else {
|
||||
throw std::system_error(AdcSerializingValueHolderErrorCode::ERROR_INVALID_SERIALIZED_TYPE);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
factory functions
|
||||
|
||||
*/
|
||||
|
||||
template <typename HolderT,
|
||||
std::invocable<> GT,
|
||||
typename VALT = traits::adc_retval_t<GT>,
|
||||
std::invocable<const VALT&> ST,
|
||||
typename... Ts>
|
||||
HolderT makeArithmValue(GT&& getter, ST&& setter, Ts&&... other_ctor_args)
|
||||
{
|
||||
using val_t = traits::adc_retval_t<GT>;
|
||||
|
||||
static_assert(std::is_arithmetic_v<val_t>, "GETTER MUST RETURN AN ARITHMETIC TYPE VALUE!!!");
|
||||
|
||||
return HolderT(AdcValueHolder::defaultTrivialConvTypes, std::forward<GT>(getter), std::forward<ST>(setter),
|
||||
std::forward<Ts>(other_ctor_args)...);
|
||||
}
|
||||
|
||||
} // namespace adc
|
||||
Reference in New Issue
Block a user