timur/ADC
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

...

Browse Source
This commit is contained in:
Timur A. Fatkhullin 2024-04-30 15:28:24 +03:00
parent b6edadee03
commit b4a4722583
2 changed files with 118 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
common/adc_utils.h
View File

@ -388,4 +388,49 @@ public:
}
};
namespace constants
{
static constexpr char DEFAULT_CONVERTER_DELIMITER[] = " ";
} // namespace constants
template <const char* DELIMITER = constants::DEFAULT_CONVERTER_DELIMITER>
class AdcDefaultValueConverter
{
public:
template <typename SerializedT, typename ValueT>
static SerializedT serialize(const ValueT& value)
{
SerializedT res;
if constexpr (traits::adc_is_tuple_v<ValueT>) {
AdcCharRangeFromTuple(res, value, DELIMITER);
} else if constexpr (traits::adc_input_char_range<ValueT>) {
AdcCharRangeFromValueRange(res, value, DELIMITER);
} else {
res = AdcTrivialSerializer<SerializedT>(value);
}
return res;
}
template <typename ValueT, typename SerializedT>
static ValueT deserialize(const SerializedT& svalue)
{
ValueT res;
if constexpr (traits::adc_is_tuple_v<ValueT>) {
AdcTupleFromCharRange(res, svalue, DELIMITER);
} else if constexpr (traits::adc_output_char_range<ValueT>) {
AdcValueRangeFromCharRange(res, svalue, DELIMITER);
} else {
res = AdcTrivialDeserializer<ValueT>(svalue);
}
return res;
}
};
} // namespace adc::utils

83
common/adc_value.h
View File

@ -11,6 +11,7 @@
#include <system_error>
#include "adc_traits.h"
#include "adc_utils.h"
namespace adc
{
@ -391,13 +392,19 @@ protected:
std::function<void(const SerializedT&)> _deserializerWrapper;
template <typename VALUET, typename SRT, typename DSRT>
template <typename ValueT, typename SRT, typename DSRT>
void initWrappers(SRT&& serializer, DSRT&& deserializer)
{
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]();
auto val = _getterFunc<ValueT>[this]();
return serializer(val);
};
@ -407,28 +414,84 @@ protected:
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);
};
}
public:
/* CONSTRUCTORS AND DESTRUCTOR */
template <typename GT,
typename ST,
typename VALT = std::decay_t<traits::adc_retval_t<GT>>,
typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>),
typename SRT,
typename DSRT>
AdcSerializingValueHolder(GT&& getter, ST&& setter, VT&& validator, SRT&& serializer, DSRT&& deserializer)
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<SRT, VALT> && std::invocable<DSRT, SerializedT>
: AdcValueHolder(std::forward<GT>(getter), std::forward<ST>(setter), std::forward<VT>(validator))
{
using value_t = std::decay_t<traits::adc_retval_t<GT>>;
initWrappers<value_t>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
initWrappers<VALT>(std::forward<SRT>(serializer), std::forward<DSRT>(deserializer));
}
template <typename GT,
typename ST,
typename VALT = std::decay_t<traits::adc_retval_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 = std::decay_t<traits::adc_retval_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 */
SerializedT serialize() { return _serializerWrapper(); }
void deserialize(const SerializedT& sval) { _deserializerWrapper(sval); }
};