...
This commit is contained in:
Timur A. Fatkhullin
445
mcc_deserializer.h.old
Normal file
445
mcc_deserializer.h.old
Normal file
@@ -0,0 +1,445 @@
|
||||
#pragma once
|
||||
|
||||
|
||||
/****************************************************************************************
|
||||
* *
|
||||
* MOUNT CONTROL COMPONENTS LIBRARY *
|
||||
* *
|
||||
* *
|
||||
* IMPLEMENTATION OF DESERIALIZER CLASSES *
|
||||
* *
|
||||
****************************************************************************************/
|
||||
|
||||
#include <algorithm>
|
||||
#include <atomic>
|
||||
#include <string_view>
|
||||
|
||||
#include "mcc_concepts.h"
|
||||
#include "mcc_coordinate.h"
|
||||
#include "mcc_epoch.h"
|
||||
#include "mcc_error.h"
|
||||
|
||||
namespace mcc::impl
|
||||
{
|
||||
|
||||
enum class MccDeserializerErrorCode : int {
|
||||
ERROR_OK,
|
||||
ERROR_UNDERLYING_DESERIALIZER,
|
||||
ERROR_INVALID_SERIALIZED_VALUE,
|
||||
ERROR_COORD_TRANSFORM
|
||||
};
|
||||
|
||||
} // namespace mcc::impl
|
||||
|
||||
|
||||
|
||||
namespace std
|
||||
{
|
||||
|
||||
template <>
|
||||
class is_error_code_enum<mcc::impl::MccDeserializerErrorCode> : public true_type
|
||||
{
|
||||
};
|
||||
|
||||
} // namespace std
|
||||
|
||||
|
||||
namespace mcc::impl
|
||||
{
|
||||
|
||||
|
||||
// error category
|
||||
struct MccDeserializerCategory : public std::error_category {
|
||||
MccDeserializerCategory() : std::error_category() {}
|
||||
|
||||
const char* name() const noexcept
|
||||
{
|
||||
return "MCC-DESERIALIZER-ERR-CATEGORY";
|
||||
}
|
||||
|
||||
std::string message(int ec) const
|
||||
{
|
||||
MccDeserializerErrorCode err = static_cast<MccDeserializerErrorCode>(ec);
|
||||
|
||||
switch (err) {
|
||||
case MccDeserializerErrorCode::ERROR_OK:
|
||||
return "OK";
|
||||
case MccDeserializerErrorCode::ERROR_UNDERLYING_DESERIALIZER:
|
||||
return "error returned by underlying deserializer";
|
||||
case MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE:
|
||||
return "invalid serialized value";
|
||||
case MccDeserializerErrorCode::ERROR_COORD_TRANSFORM:
|
||||
return "coordinates transformation error";
|
||||
default:
|
||||
return "UNKNOWN";
|
||||
}
|
||||
}
|
||||
|
||||
static const MccDeserializerCategory& get()
|
||||
{
|
||||
static const MccDeserializerCategory constInst;
|
||||
return constInst;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
inline std::error_code make_error_code(MccDeserializerErrorCode ec)
|
||||
{
|
||||
return std::error_code(static_cast<int>(ec), MccDeserializerCategory::get());
|
||||
}
|
||||
|
||||
|
||||
template <mcc_error_c RetT>
|
||||
struct mcc_deserializer_interface_t {
|
||||
virtual ~mcc_deserializer_interface_t() = default;
|
||||
|
||||
typedef RetT error_t;
|
||||
|
||||
template <std::derived_from<mcc_deserializer_interface_t> SelfT,
|
||||
traits::mcc_input_char_range R,
|
||||
typename ValueT,
|
||||
typename... DeserParamsT>
|
||||
RetT operator()(this SelfT&& self, R const& input, ValueT& value, DeserParamsT&&... params)
|
||||
{
|
||||
return std::forward<SelfT>(self)(input, value);
|
||||
}
|
||||
|
||||
protected:
|
||||
mcc_deserializer_interface_t() = default;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
concept mcc_deserializer_c = std::derived_from<T, mcc_deserializer_interface_t<typename T::error_t>>;
|
||||
|
||||
|
||||
namespace details
|
||||
{
|
||||
|
||||
struct MccDeserializerBase : mcc_deserializer_interface_t<impl::MccError>, utils::mcc_elem_sequence_with_delim_t {
|
||||
using typename mcc_deserializer_interface_t<impl::MccError>::error_t;
|
||||
|
||||
virtual ~MccDeserializerBase() = default;
|
||||
|
||||
|
||||
protected:
|
||||
MccDeserializerBase() = default;
|
||||
|
||||
//
|
||||
// empty == true, if the 'input' is empty or if all elements consist of only spaces
|
||||
//
|
||||
std::vector<std::string_view> splitAggregateValue(traits::mcc_input_char_range auto const& input, bool& empty) const
|
||||
{
|
||||
std::vector<std::string_view> res;
|
||||
|
||||
if (std::ranges::size(input)) {
|
||||
empty = true;
|
||||
|
||||
std::ranges::for_each(std::views::split(input, this->_elementDelimiter), [&res, &empty](auto const& el) {
|
||||
std::back_inserter(res) = utils::trimSpaces(std::string_view{el.begin(), el.end()});
|
||||
if (empty && res.back().size()) {
|
||||
empty = false;
|
||||
}
|
||||
});
|
||||
} else {
|
||||
empty = true;
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
template <typename VT, std::ranges::output_range<VT> R, typename... DeserParamsT>
|
||||
error_t deserializingRange(mcc_deserializer_c auto& dsr,
|
||||
traits::mcc_input_char_range auto const& input,
|
||||
R& r,
|
||||
DeserParamsT&&... params) const
|
||||
{
|
||||
if (std::ranges::size(input) == 0) { // ignore an empty input, just return empty range?!!
|
||||
r = R{};
|
||||
return MccDeserializerErrorCode::ERROR_OK;
|
||||
}
|
||||
|
||||
auto r_str = std::views::split(input, _seqDelimiter);
|
||||
VT val;
|
||||
|
||||
auto it = r.begin();
|
||||
for (auto const& el : r_str) {
|
||||
auto err = dsr(el, val, std::forward<DeserParamsT>(params)...);
|
||||
if (err) {
|
||||
return mcc_deduced_err(err, MccDeserializerErrorCode::ERROR_UNDERLYING_DESERIALIZER);
|
||||
}
|
||||
|
||||
if (it == r.end()) {
|
||||
std::back_inserter(r) = val;
|
||||
it = r.end();
|
||||
} else {
|
||||
*it = val;
|
||||
++it;
|
||||
}
|
||||
}
|
||||
|
||||
return MccDeserializerErrorCode::ERROR_OK;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace details
|
||||
|
||||
|
||||
/* fallback template: basic deserializer */
|
||||
|
||||
template <typename VT>
|
||||
class MccDeserializer : public details::MccDeserializerBase
|
||||
{
|
||||
public:
|
||||
using typename details::MccDeserializerBase::error_t;
|
||||
|
||||
virtual ~MccDeserializer() = default;
|
||||
|
||||
|
||||
error_t operator()(traits::mcc_input_char_range auto const& input, VT& value)
|
||||
{
|
||||
if constexpr (std::is_arithmetic_v<VT>) {
|
||||
auto v = mcc::utils::numFromStr<VT>(utils::trimSpaces(input));
|
||||
if (!v.has_value()) {
|
||||
return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
|
||||
}
|
||||
|
||||
value = v.value();
|
||||
} else if constexpr (mcc::traits::mcc_output_char_range<VT>) {
|
||||
VT r;
|
||||
if constexpr (traits::mcc_array_c<VT>) {
|
||||
size_t N =
|
||||
std::ranges::size(r) <= std::ranges::size(input) ? std::ranges::size(r) : std::ranges::size(input);
|
||||
|
||||
for (size_t i = 0; i < N; ++i) {
|
||||
r[i] = input[i];
|
||||
}
|
||||
if (std::ranges::size(r) > N) {
|
||||
for (size_t i = N; i < std::ranges::size(r); ++i) {
|
||||
r[i] = '\0';
|
||||
}
|
||||
}
|
||||
} else {
|
||||
std::ranges::copy(input, std::back_inserter(r));
|
||||
}
|
||||
|
||||
value = r;
|
||||
} else if constexpr (std::ranges::range<VT>) {
|
||||
using el_t = std::ranges::range_value_t<VT>;
|
||||
|
||||
static_assert(std::ranges::output_range<VT, el_t>, "INVALID RANGE TYPE!!!");
|
||||
|
||||
// no reference or constants allowed
|
||||
static_assert(std::is_reference_v<el_t> || std::is_const_v<el_t>, "INVALID RANGE ELEMENT TYPE!!!");
|
||||
|
||||
MccDeserializer<el_t> dsr;
|
||||
return deserializingRange<el_t>(dsr, input, value);
|
||||
} else if constexpr (traits::mcc_time_duration_c<VT>) {
|
||||
typename VT::rep vd;
|
||||
|
||||
MccDeserializer<typename VT::rep> dsr;
|
||||
|
||||
auto err = dsr(trimSpaces(input), vd);
|
||||
if (err) {
|
||||
return mcc_deduced_err(err, MccDeserializerErrorCode::ERROR_UNDERLYING_DESERIALIZER);
|
||||
}
|
||||
|
||||
value = VT{vd};
|
||||
} else {
|
||||
static_assert(false, "UNSUPPORTED VALUE TYPE!!!");
|
||||
}
|
||||
|
||||
|
||||
return MccDeserializerErrorCode::ERROR_OK;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
/* SPECIALIZATION FOR THE SOME CONCEPTS */
|
||||
|
||||
|
||||
template <typename VT>
|
||||
requires(mcc_coord_epoch_c<VT> || (std::ranges::output_range<VT, std::ranges::range_value_t<VT>> &&
|
||||
mcc_coord_epoch_c<std::remove_cv_t<std::ranges::range_value_t<VT>>>))
|
||||
class MccDeserializer<VT> : public details::MccDeserializerBase
|
||||
{
|
||||
public:
|
||||
using typename details::MccDeserializerBase::error_t;
|
||||
|
||||
virtual ~MccDeserializer() = default;
|
||||
|
||||
|
||||
error_t operator()(traits::mcc_input_char_range auto const& input, VT& value)
|
||||
{
|
||||
if constexpr (mcc_coord_epoch_c<VT>) { // scalar
|
||||
bool ok = value.fromCharRange(input);
|
||||
if (!ok) {
|
||||
return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
|
||||
}
|
||||
} else { // range
|
||||
using value_t = std::remove_cv_t<std::ranges::range_value_t<VT>>;
|
||||
MccDeserializer<value_t> dsr;
|
||||
|
||||
return deserializingRange(dsr, input, value);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template <typename VT>
|
||||
requires(!std::is_arithmetic_v<VT> &&
|
||||
(mcc_angle_c<VT> || (std::ranges::output_range<VT, std::ranges::range_value_t<VT>> &&
|
||||
mcc_angle_c<std::remove_cv_t<std::ranges::range_value_t<VT>>>)))
|
||||
class MccDeserializer<VT> : public details::MccDeserializerBase
|
||||
{
|
||||
public:
|
||||
using typename details::MccDeserializerBase::error_t;
|
||||
|
||||
virtual ~MccDeserializer() = default;
|
||||
|
||||
// if hms == true and the input sequence is a sexagesimal string then it interpretates angle as hours:mins:secs
|
||||
// otherwise the input sequence is interpretated as decimal or sexagesimal degrees
|
||||
error_t operator()(traits::mcc_input_char_range auto const& input, VT& value, bool hms = false)
|
||||
{
|
||||
if constexpr (mcc_angle_c<VT>) { // scalar
|
||||
auto res = utils::parsAngleString(input, hms);
|
||||
if (res) { // returned angle is in degrees!!!
|
||||
value = res.value() * MCC_DEGRESS_TO_RADS;
|
||||
} else {
|
||||
return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
|
||||
}
|
||||
|
||||
} else { // range
|
||||
using value_t = std::remove_cv_t<std::ranges::range_value_t<VT>>;
|
||||
MccDeserializer<value_t> dsr;
|
||||
|
||||
if constexpr (std::invocable<MccDeserializer<value_t>, decltype(input), VT&, bool>) {
|
||||
// it is assumed here, the angle deserializer has the same behavior as the one implemented above
|
||||
// (that is, it can interpret the third argument as a flag "false/true = only
|
||||
// degrees/hour-like")
|
||||
return deserializingRange<value_t>(dsr, input, value, hms);
|
||||
} else {
|
||||
return deserializingRange<value_t>(dsr, input, value);
|
||||
}
|
||||
}
|
||||
|
||||
return MccDeserializerErrorCode::ERROR_OK;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <typename VT>
|
||||
requires(mcc_skypoint_c<VT> || (std::ranges::output_range<VT, std::ranges::range_value_t<VT>> &&
|
||||
mcc_skypoint_c<std::remove_cv_t<std::ranges::range_value_t<VT>>>))
|
||||
class MccDeserializer<VT> : public details::MccDeserializerBase
|
||||
{
|
||||
public:
|
||||
using typename details::MccDeserializerBase::error_t;
|
||||
|
||||
virtual ~MccDeserializer() = default;
|
||||
|
||||
error_t operator()(traits::mcc_input_char_range auto const& input, VT& value)
|
||||
{
|
||||
if constexpr (mcc_skypoint_c<VT>) { // scalar: X[elem-delim]Y{[elem-delim]TIME-POINT[elem-delim]PAIR-KIND}
|
||||
bool empty; // exactly 2 or >3 elements
|
||||
auto elems = splitAggregateValue(input, empty);
|
||||
|
||||
if (empty || (elems.size() < 2) || (elems.size() == 3)) {
|
||||
return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
|
||||
}
|
||||
|
||||
MccCoordPairKind pair_kind{MccCoordPairKind::COORDS_KIND_RADEC_ICRS};
|
||||
MccCelestialCoordEpoch epoch; // J2000.0
|
||||
|
||||
MccAngle x, y;
|
||||
MccDeserializer<MccAngle> dsr_ang;
|
||||
|
||||
typename MccDeserializer<MccAngle>::error_t dsr_err;
|
||||
|
||||
if (elems.size() >= 4) { // X, Y, TIME-POINT, PAIR-KIND
|
||||
// first, get pair-kind
|
||||
pair_kind = MccCoordStrToPairKind(elems[3]);
|
||||
if (pair_kind == MccCoordPairKind::COORDS_KIND_UNKNOWN) {
|
||||
return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
|
||||
}
|
||||
|
||||
// epoch
|
||||
bool ok = epoch.fromCharRange(elems[2]);
|
||||
if (!ok) {
|
||||
return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
|
||||
}
|
||||
}
|
||||
|
||||
if (elems.size() >= 2) { // if == 2: just X and Y (if so it is interpretated as RADEC_ICRS)
|
||||
if (MccCoordinatePairToSxgmRep(pair_kind) == MccCoordinatePairRep::MCC_COORDPAIR_REP_SXGM_HOURDEG) {
|
||||
// if input X-angle is in sexagesimal from then interpretate it in hours::mins::secs format
|
||||
if constexpr (std::invocable<MccDeserializer<MccAngle>, decltype(elems[0]), MccAngle&, bool>) {
|
||||
// it is assumed here, the angle deserializer has the same behavior as the one implemented above
|
||||
// (that is, it can interpret the third argument as a flag "false/true = only
|
||||
// degrees/hour-like")
|
||||
dsr_err = dsr_ang(elems[0], x, true);
|
||||
} else {
|
||||
dsr_err = dsr_ang(elems[0], x);
|
||||
}
|
||||
} else {
|
||||
dsr_err = dsr_ang(elems[0], x);
|
||||
}
|
||||
|
||||
if (dsr_err) {
|
||||
return mcc_deduced_err(dsr_err, MccDeserializerErrorCode::ERROR_UNDERLYING_DESERIALIZER);
|
||||
}
|
||||
|
||||
dsr_err = dsr_ang(elems[1], y);
|
||||
|
||||
if (dsr_err) {
|
||||
return mcc_deduced_err(dsr_err, MccDeserializerErrorCode::ERROR_UNDERLYING_DESERIALIZER);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
switch (pair_kind) {
|
||||
case MccCoordPairKind::COORDS_KIND_RADEC_ICRS:
|
||||
value.from(MccSkyRADEC_ICRS{(double)x, (double)y});
|
||||
break;
|
||||
case MccCoordPairKind::COORDS_KIND_RADEC_OBS:
|
||||
value.from(MccSkyRADEC_OBS{(double)x, (double)y, epoch});
|
||||
break;
|
||||
case MccCoordPairKind::COORDS_KIND_RADEC_APP:
|
||||
value.from(MccSkyRADEC_APP{(double)x, (double)y, epoch});
|
||||
break;
|
||||
case MccCoordPairKind::COORDS_KIND_HADEC_OBS:
|
||||
value.from(MccSkyHADEC_OBS{(double)x, (double)y, epoch});
|
||||
break;
|
||||
case MccCoordPairKind::COORDS_KIND_HADEC_APP:
|
||||
value.from(MccSkyHADEC_APP{(double)x, (double)y, epoch});
|
||||
break;
|
||||
case MccCoordPairKind::COORDS_KIND_AZZD:
|
||||
value.from(MccSkyAZZD{(double)x, (double)y, epoch});
|
||||
break;
|
||||
case MccCoordPairKind::COORDS_KIND_AZALT:
|
||||
value.from(MccSkyAZALT{(double)x, (double)y, epoch});
|
||||
break;
|
||||
case MccCoordPairKind::COORDS_KIND_XY:
|
||||
value.from(MccGenXY{(double)x, (double)y, epoch});
|
||||
break;
|
||||
case MccCoordPairKind::COORDS_KIND_GENERIC:
|
||||
value.from(MccCoordPair{(double)x, (double)y, epoch});
|
||||
break;
|
||||
case MccCoordPairKind::COORDS_KIND_LONLAT:
|
||||
value.from(MccGeoLONLAT{(double)x, (double)y});
|
||||
break;
|
||||
default:
|
||||
return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
|
||||
}
|
||||
|
||||
} else { // range
|
||||
using value_t = std::remove_cv_t<std::ranges::range_value_t<VT>>;
|
||||
MccDeserializer<value_t> dsr;
|
||||
|
||||
return deserializingRange<value_t>(dsr, input, value);
|
||||
}
|
||||
|
||||
return MccDeserializerErrorCode::ERROR_OK;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace mcc::impl
|
||||
Reference in New Issue
Block a user