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

...

Browse Source
This commit is contained in:
Timur A. Fatkhullin
2026-02-02 12:15:07 +03:00
parent ae91e7320c
commit b871b9dd46
4 changed files with 352 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

330
mcc_deserializer.h
View File

@@ -10,8 +10,13 @@
* *
****************************************************************************************/
#include <algorithm>
#include <atomic>
#include <string_view>
#include "mcc_concepts.h"
#include "mcc_constants.h"
#include "mcc_coordinate.h"
#include "mcc_epoch.h"
#include "mcc_error.h"
namespace mcc::impl
@@ -20,7 +25,7 @@ namespace mcc::impl
enum class MccDeserializerErrorCode : int {
ERROR_OK,
ERROR_UNDERLYING_DESERIALIZER,
ERROR_INVALID_SERIAL_VALUE,
ERROR_INVALID_SERIALIZED_VALUE,
ERROR_COORD_TRANSFORM
};
@@ -61,7 +66,7 @@ struct MccDeserializerCategory : public std::error_category {
return "OK";
case MccDeserializerErrorCode::ERROR_UNDERLYING_DESERIALIZER:
return "error returned by underlying deserializer";
case MccDeserializerErrorCode::ERROR_INVALID_SERIAL_VALUE:
case MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE:
return "invalid serialized value";
case MccDeserializerErrorCode::ERROR_COORD_TRANSFORM:
return "coordinates transformation error";
@@ -90,8 +95,11 @@ struct mcc_deserializer_interface_t {
typedef RetT error_t;
template <std::derived_from<mcc_deserializer_interface_t> SelfT, traits::mcc_input_char_range R, typename ValueT>
RetT operator()(this SelfT&& self, R const& input, ValueT& value)
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);
}
@@ -107,89 +115,46 @@ concept mcc_deserializer_c = std::derived_from<T, mcc_deserializer_interface_t<t
namespace details
{
struct MccDeserializerBase : mcc_deserializer_interface_t<impl::MccError> {
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;
// set delimiter for elements of the range-type serialized value
template <traits::mcc_input_char_range R>
void setSeqDelimiter(R const& delim)
{
if constexpr (std::is_array_v<std::decay_t<R>>) {
setSeqDelimiter(std::string_view{delim});
} else {
_seqDelimiter.clear();
std::ranges::copy(delim, std::back_inserter(_seqDelimiter));
}
}
template <traits::mcc_view_or_output_char_range R>
R getSeqDelimiter() const
{
if constexpr (std::same_as<R, decltype(_seqDelimiter)>) {
return _seqDelimiter;
} else if constexpr (std::ranges::view<R>) {
return R{_seqDelimiter.begin(), _seqDelimiter.end()};
} else {
R r;
std::ranges::copy(_seqDelimiter, std::back_inserter(r));
return r;
}
}
std::string getSeqDelimiter() const
{
return getSeqDelimiter<std::string>();
}
template <traits::mcc_input_char_range R>
void setElemDelimiter(R const& delim)
{
if constexpr (std::is_array_v<std::decay_t<R>>) {
setElemDelimiter(std::string_view{delim});
} else {
_elementDelimiter.clear();
std::ranges::copy(delim, std::back_inserter(_seqDelimiter));
}
}
template <traits::mcc_view_or_output_char_range R>
R getElemDelimiter() const
{
if constexpr (std::same_as<R, decltype(_seqDelimiter)>) {
return _elementDelimiter;
} else if constexpr (std::ranges::view<R>) {
return R{_elementDelimiter.begin(), _elementDelimiter.end()};
} else {
R r;
std::ranges::copy(_elementDelimiter, std::back_inserter(r));
return r;
}
}
std::string getElemDelimiter() const
{
return getElemDelimiter<std::string>();
}
protected:
MccDeserializerBase() = default;
// delimiter for sequence of serialized values
std::string _seqDelimiter{MCC_DEFAULT_SEQ_DELIMITER};
// delimiter for aggregative (multi-element) serialized value
std::string _elementDelimiter{MCC_DEFAULT_ELEM_DELIMITER};
template <typename VT, typename R>
requires(std::ranges::input_range<R> && std::same_as<VT, std::ranges::range_value_t<R>>)
error_t deserializingRange(mcc_deserializer_c auto& dsr, traits::mcc_input_char_range auto const& input, R& r) const
//
// 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
{
if (std::ranges::size(input) == 0) { // ignore empy input
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;
}
@@ -198,7 +163,7 @@ protected:
auto it = r.begin();
for (auto const& el : r_str) {
auto err = dsr(el, val);
auto err = dsr(el, val, std::forward<DeserParamsT>(params)...);
if (err) {
return mcc_deduced_err(err, MccDeserializerErrorCode::ERROR_UNDERLYING_DESERIALIZER);
}
@@ -219,7 +184,8 @@ protected:
} // namespace details
//
/* fallback template: basic deserializer */
template <typename VT>
class MccDeserializer : public details::MccDeserializerBase
{
@@ -234,7 +200,7 @@ public:
if constexpr (std::is_arithmetic_v<VT>) {
auto v = mcc::utils::numFromStr<VT>(trimSpaces(input));
if (!v.has_value()) {
return MccDeserializerErrorCode::ERROR_INVALID_SERIAL_VALUE;
return MccDeserializerErrorCode::ERROR_INVALID_SERIALIZED_VALUE;
}
value = v.value();
@@ -267,6 +233,17 @@ public:
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!!!");
}
@@ -276,4 +253,193 @@ public:
}
};
/* 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) {
value = res.value();
} 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