1226 lines
37 KiB
C++
1226 lines
37 KiB
C++
#pragma once
|
|
|
|
/* MOUNT CONTROL COMPONENTS LIBRARY */
|
|
|
|
|
|
/* MCC LIBRARY DEFAULT IMPLEMENTATION OF SOME CLASSES */
|
|
|
|
// #include <compare>
|
|
|
|
#include "mcc_generics.h"
|
|
|
|
namespace mcc
|
|
{
|
|
|
|
|
|
/* DEFAULT TIME-RELATED CLASSES */
|
|
|
|
typedef std::chrono::system_clock::time_point MccTimePoint;
|
|
|
|
|
|
typedef std::chrono::duration<double> MccTimeDuration; // seconds as floating-point value
|
|
|
|
template <traits::mcc_time_duration_c DT>
|
|
static constexpr DT mcc_infinite_duration_v =
|
|
std::floating_point<typename DT::rep> ? DT{std::numeric_limits<typename DT::rep>::infinity()}
|
|
: DT{std::numeric_limits<typename DT::rep>::max()};
|
|
|
|
|
|
/* DEFAULT JULIAN DAY CLASS */
|
|
|
|
struct MccJulianDay {
|
|
static constexpr double MJD0 = 2400000.5;
|
|
|
|
MccJulianDay() = default;
|
|
|
|
MccJulianDay(double jd) : mjd(jd - MJD0) {}
|
|
|
|
constexpr operator double() const
|
|
{
|
|
return MccJulianDay::MJD0 + mjd;
|
|
}
|
|
|
|
MccJulianDay& operator=(double jd)
|
|
{
|
|
mjd = jd - MJD0;
|
|
|
|
return *this;
|
|
}
|
|
|
|
double MJD() const
|
|
{
|
|
return mjd;
|
|
}
|
|
|
|
constexpr auto operator<=>(const MccJulianDay&) const = default;
|
|
|
|
constexpr auto operator<=>(double v) const
|
|
{
|
|
return v <=> (MccJulianDay::MJD0 + mjd);
|
|
};
|
|
|
|
protected:
|
|
double mjd{51544.5}; // J2000.0
|
|
};
|
|
|
|
|
|
/* DEFAULT CELESTIAL COORDINATES EPOCH CLASS */
|
|
|
|
class MccCelestialCoordEpoch : public mcc_coord_epoch_interface_t
|
|
{
|
|
inline static const std::regex dateTimeISO8601Rx{
|
|
" *[0-9]{4}-[0,1][0-9]-[0-2][0-9]T[0-2][0-9]:[0-6][0-9]:[0-6][0-9](\\.[0-9]+)? *"};
|
|
|
|
inline static const std::regex dateTimeJEpochRx{" *J[0-9]{4}(\\.[0-9]{1,})+ *"};
|
|
inline static const std::regex dateTimeBEpochRx{" *B[0-9]{4}(\\.[0-9]{1,})+ *"};
|
|
inline static const std::regex dateTimeMJDRx{" *([0-9]*[.])?[0-9]+([eE][-+]?[0-9]+)? *"};
|
|
|
|
|
|
typedef std::chrono::duration<double, std::ratio<31556952>> year_fp_t;
|
|
typedef std::chrono::duration<double, std::ratio<86400>> day_fp_t;
|
|
|
|
public:
|
|
static constexpr auto J2000_UTC =
|
|
std::chrono::sys_days(
|
|
std::chrono::year_month_day(std::chrono::January / std::chrono::day(1) / std::chrono::year(2000))) +
|
|
std::chrono::hours(11) + std::chrono::minutes(58) + std::chrono::milliseconds(55816);
|
|
|
|
static constexpr double J2000_MJD = 51544.5;
|
|
|
|
|
|
static MccCelestialCoordEpoch now()
|
|
{
|
|
MccCelestialCoordEpoch ep;
|
|
ep.fromTimePoint(std::chrono::system_clock::now());
|
|
|
|
return ep;
|
|
}
|
|
|
|
MccCelestialCoordEpoch() : _UTC(J2000_UTC), _MJD(J2000_MJD), _JEpoch(2000.0) {}
|
|
|
|
template <traits::mcc_input_char_range IR>
|
|
bool fromCharRange(IR&& str)
|
|
{
|
|
if constexpr (std::is_pointer_v<std::decay_t<IR>>) {
|
|
return fromCharRange(std::string_view{str});
|
|
}
|
|
|
|
bool ret = false;
|
|
|
|
std::string_view sv = utils::trimSpaces(std::forward<IR>(str));
|
|
std::istringstream ist{std::string(sv)};
|
|
|
|
// try ISO8601 date ...
|
|
std::chrono::from_stream(ist, "%FT%T", _UTC);
|
|
if (ist.fail()) { // not ISO8601 date
|
|
// try MJD (floating-point number) ...
|
|
std::optional<double> mjd = utils::numFromStr<double>(sv);
|
|
if (mjd) {
|
|
_MJD = mjd.value();
|
|
ret = fromMJD();
|
|
} else { // not MJD
|
|
// try epoch (e.g. J2010.32)
|
|
if (sv[0] == 'J') {
|
|
auto jep = utils::numFromStr<double>(sv.substr(1));
|
|
if (jep) {
|
|
_JEpoch = jep.value();
|
|
ret = fromJEpoch();
|
|
} else { // ERROR!!!
|
|
ret = false;
|
|
}
|
|
} else { // ERROR!!!
|
|
ret = false;
|
|
}
|
|
}
|
|
} else {
|
|
ret = fromUTC();
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
template <typename ClockT, typename DurT>
|
|
bool fromTimePoint(std::chrono::time_point<ClockT, DurT>&& tp)
|
|
{
|
|
if constexpr (std::same_as<ClockT, std::chrono::system_clock>) {
|
|
_UTC = std::chrono::time_point_cast<decltype(_UTC)::duration>(std::forward<decltype(tp)>(tp));
|
|
} else if constexpr (std::same_as<ClockT, std::chrono::utc_clock>) {
|
|
auto stp = std::chrono::utc_clock::to_sys(std::forward<decltype(tp)>(tp));
|
|
_UTC = std::chrono::time_point_cast<decltype(_UTC)::duration>(std::forward<decltype(tp)>(stp));
|
|
} else if constexpr (std::same_as<ClockT, std::chrono::tai_clock>) {
|
|
return fromTimePoint(ClockT::to_utc(std::forward<decltype(tp)>(tp)));
|
|
} else if constexpr (std::same_as<ClockT, std::chrono::gps_clock>) {
|
|
return fromTimePoint(ClockT::to_utc(std::forward<decltype(tp)>(tp)));
|
|
} else {
|
|
static_assert(false, "UNSUPPORTED CLOCK!!!");
|
|
}
|
|
|
|
|
|
return fromUTC();
|
|
}
|
|
|
|
template <typename VT>
|
|
bool fromMJD(VT&& mjd)
|
|
requires std::is_arithmetic_v<VT>
|
|
{
|
|
_MJD = static_cast<double>(std::forward<VT>(mjd));
|
|
|
|
return fromMJD();
|
|
}
|
|
|
|
template <traits::mcc_time_duration_c DT>
|
|
MccCelestialCoordEpoch& operator+=(DT&& dt)
|
|
{
|
|
_UTC += std::chrono::duration_cast<decltype(_UTC)::duration>(std::forward<DT>(dt));
|
|
|
|
_MJD += std::chrono::duration_cast<day_fp_t>(std::forward<DT>(dt)).count();
|
|
|
|
_JEpoch += std::chrono::duration_cast<year_fp_t>(std::forward<DT>(dt)).count();
|
|
|
|
return *this;
|
|
}
|
|
|
|
template <traits::mcc_time_duration_c DT>
|
|
MccCelestialCoordEpoch& operator-=(DT&& dt)
|
|
{
|
|
_UTC -= std::chrono::duration_cast<decltype(_UTC)::duration>(std::forward<DT>(dt));
|
|
|
|
_MJD -= std::chrono::duration_cast<day_fp_t>(std::forward<DT>(dt)).count();
|
|
|
|
_JEpoch -= std::chrono::duration_cast<year_fp_t>(std::forward<DT>(dt)).count();
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <traits::mcc_time_duration_c DT>
|
|
friend MccCelestialCoordEpoch operator+(const MccCelestialCoordEpoch& lhs, const DT& dt)
|
|
{
|
|
MccCelestialCoordEpoch ep = lhs;
|
|
ep += dt;
|
|
|
|
return ep;
|
|
}
|
|
template <traits::mcc_time_duration_c DT>
|
|
friend MccCelestialCoordEpoch operator+(const DT& dt, const MccCelestialCoordEpoch& rhs)
|
|
{
|
|
return rhs + dt;
|
|
}
|
|
|
|
template <traits::mcc_time_duration_c DT>
|
|
friend MccCelestialCoordEpoch operator-(const MccCelestialCoordEpoch& lhs, const DT& dt)
|
|
{
|
|
MccCelestialCoordEpoch ep = lhs;
|
|
ep -= dt;
|
|
|
|
return ep;
|
|
}
|
|
|
|
friend auto operator-(const MccCelestialCoordEpoch& lhs, const MccCelestialCoordEpoch& rhs)
|
|
{
|
|
return lhs._UTC - rhs._UTC;
|
|
}
|
|
|
|
|
|
template <typename VT>
|
|
requires std::is_arithmetic_v<VT>
|
|
VT MJD() const
|
|
{
|
|
return _MJD;
|
|
}
|
|
|
|
double MJD() const
|
|
{
|
|
return _MJD;
|
|
}
|
|
|
|
template <typename DT>
|
|
std::chrono::sys_time<DT> UTC() const
|
|
{
|
|
return std::chrono::time_point_cast<DT>(_UTC);
|
|
}
|
|
|
|
std::chrono::system_clock::time_point UTC() const
|
|
{
|
|
return _UTC;
|
|
}
|
|
|
|
|
|
template <traits::mcc_output_char_range R>
|
|
R JEpoch(uint8_t prec = 0) const
|
|
{
|
|
std::string prec_str{"J{:"};
|
|
if (prec > 0) {
|
|
prec_str += ".";
|
|
prec_str += std::to_string(prec);
|
|
}
|
|
prec_str += "f}";
|
|
|
|
std::string res = std::vformat(std::string_view{prec_str}, std::make_format_args(_JEpoch));
|
|
|
|
if constexpr (std::same_as<R, std::string>) {
|
|
return res;
|
|
}
|
|
|
|
R r;
|
|
std::ranges::copy(res, std::back_inserter(r));
|
|
|
|
return r;
|
|
}
|
|
|
|
std::string JEpoch(uint8_t prec = 0) const
|
|
{
|
|
return JEpoch<std::string>(prec);
|
|
}
|
|
|
|
auto operator<=>(const MccCelestialCoordEpoch& rhs) const
|
|
{
|
|
return _UTC <=> rhs._UTC;
|
|
}
|
|
|
|
auto operator==(const MccCelestialCoordEpoch& rhs) const
|
|
{
|
|
return _UTC == rhs._UTC;
|
|
}
|
|
|
|
protected:
|
|
std::chrono::system_clock::time_point _UTC;
|
|
double _MJD;
|
|
double _JEpoch;
|
|
|
|
bool fromUTC()
|
|
{
|
|
// modified Julian date (based on ERFA eraCal2jd)
|
|
auto dd = std::chrono::floor<std::chrono::days>(_UTC);
|
|
std::chrono::year_month_day ymd{dd};
|
|
|
|
static constexpr std::chrono::year MIN_YEAR{-4799};
|
|
|
|
if (ymd.year() < MIN_YEAR) {
|
|
return false;
|
|
}
|
|
if (!ymd.month().ok()) {
|
|
return false;
|
|
}
|
|
|
|
int64_t im = (unsigned)ymd.month();
|
|
int64_t id = (unsigned)ymd.day();
|
|
int64_t iy = (int)ymd.year();
|
|
|
|
int64_t my = (im - 14LL) / 12LL;
|
|
int64_t iypmy = iy + my;
|
|
|
|
// integer part of result MJD
|
|
int64_t mjd_int = (1461LL * (iypmy + 4800LL)) / 4LL + (367LL * (im - 2LL - 12LL * my)) / 12LL -
|
|
(3LL * ((iypmy + 4900LL) / 100LL)) / 4LL + id - 2432076LL;
|
|
|
|
_MJD = static_cast<double>(mjd_int) + std::chrono::duration_cast<day_fp_t>(_UTC - dd).count();
|
|
|
|
_JEpoch = std::chrono::duration_cast<year_fp_t>(_UTC - J2000_UTC).count() + 2000.0;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool fromMJD(bool only_time_point = false)
|
|
{
|
|
// Gregorian date from modified Julian date (based on ERFS eraJd2cal)
|
|
double f1 = -0.5;
|
|
long jd = std::round(_MJD);
|
|
double f2 = _MJD - jd;
|
|
jd += 2400001.0;
|
|
|
|
double s = 0.5, cs = 0.0;
|
|
// double v[] = {f1, f2};
|
|
|
|
auto lmd = [&](double v) {
|
|
// double x = v;
|
|
// double t = s + x;
|
|
// cs += std::fabs(s) >= std::fabs(x) ? (s - t) + x : (x - t) + s;
|
|
double t = s + v;
|
|
cs += std::fabs(s) >= std::fabs(v) ? (s - t) + v : (v - t) + s;
|
|
s = t;
|
|
if (s >= 1.0) {
|
|
jd++;
|
|
s -= 1.0;
|
|
}
|
|
};
|
|
|
|
lmd(f1);
|
|
lmd(f2);
|
|
|
|
double f = s + cs;
|
|
cs = f - s;
|
|
|
|
if (f < 0.0) {
|
|
f = s + 1.0;
|
|
cs += (1.0 - f) + s;
|
|
s = f;
|
|
f = s + cs;
|
|
cs = f - s;
|
|
jd--;
|
|
}
|
|
|
|
|
|
if ((f - 1.0) >= -std::numeric_limits<double>::epsilon() / 4.0) {
|
|
/* Compensated summation: assume that |s| <= 1.0. */
|
|
double t = s - 1.0;
|
|
cs += (s - t) - 1.0;
|
|
s = t;
|
|
f = s + cs;
|
|
if (-std::numeric_limits<double>::epsilon() / 2.0 < f) {
|
|
jd++;
|
|
f = std::max(f, 0.0);
|
|
}
|
|
}
|
|
|
|
long l = jd + 68569L;
|
|
long n = (4L * l) / 146097L;
|
|
l -= (146097L * n + 3L) / 4L;
|
|
long i = (4000L * (l + 1L)) / 1461001L;
|
|
l -= (1461L * i) / 4L - 31L;
|
|
long k = (80L * l) / 2447L;
|
|
|
|
auto day = std::chrono::day(l - (2447L * k) / 80L);
|
|
l = k / 11L;
|
|
auto month = std::chrono::month(k + 2L - 12L * l);
|
|
auto year = std::chrono::year(100L * (n - 49L) + i + l);
|
|
|
|
auto day_frac = day_fp_t(f);
|
|
|
|
// _UTC = years + month + days + day_frac;
|
|
_UTC = std::chrono::sys_days(std::chrono::year_month_day(month / day / year));
|
|
_UTC += std::chrono::duration_cast<decltype(_UTC)::duration>(day_frac);
|
|
|
|
if (!only_time_point) {
|
|
_JEpoch = 2000.0 + (_MJD - J2000_MJD) / 365.25;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool fromJEpoch()
|
|
{
|
|
_MJD = J2000_MJD + (_JEpoch - 2000.0) * 365.25;
|
|
|
|
return fromMJD(true);
|
|
}
|
|
};
|
|
|
|
|
|
static_assert(mcc_coord_epoch_c<MccCelestialCoordEpoch>, "!!!");
|
|
|
|
|
|
/* DEFAULT CELESTIAL POINT CLASS */
|
|
|
|
|
|
template <mcc_angle_c CoordT>
|
|
struct MccGenericCelestialPoint {
|
|
typedef CoordT coord_t;
|
|
|
|
MccCoordPairKind pair_kind{MccCoordPairKind::COORDS_KIND_RADEC_ICRS};
|
|
|
|
// MccTimePoint time_point{std::chrono::sys_days(std::chrono::year_month_day{std::chrono::January / 1 / 2000}) +
|
|
// std::chrono::hours(12)}; // J2000.0
|
|
|
|
MccTimePoint time_point{std::chrono::sys_days(std::chrono::year_month_day(
|
|
std::chrono::January / std::chrono::day(1) / std::chrono::year(2000))) +
|
|
std::chrono::hours(11) + std::chrono::minutes(58) +
|
|
std::chrono::milliseconds(55816)}; // J2000.0 UTC
|
|
|
|
|
|
coord_t X{}, Y{};
|
|
};
|
|
|
|
|
|
typedef MccGenericCelestialPoint<double> MccCelestialPoint;
|
|
|
|
|
|
template <mcc_angle_c CoordT>
|
|
struct MccGenericEqtHrzCoords : MccGenericCelestialPoint<CoordT> {
|
|
using typename MccGenericCelestialPoint<CoordT>::coord_t;
|
|
|
|
using MccGenericCelestialPoint<CoordT>::time_point;
|
|
|
|
coord_t RA_APP{}, DEC_APP{}, HA{}, AZ{}, ZD{}, ALT{};
|
|
};
|
|
|
|
typedef MccGenericEqtHrzCoords<MccCelestialPoint::coord_t> MccEqtHrzCoords;
|
|
|
|
|
|
template <mcc_angle_c CoordT>
|
|
struct MccGenericPointingTarget : MccGenericEqtHrzCoords<CoordT> {
|
|
using typename MccGenericEqtHrzCoords<CoordT>::coord_t;
|
|
|
|
coord_t RA_ICRS{}, DEC_ICRS{};
|
|
};
|
|
|
|
|
|
typedef MccGenericPointingTarget<MccCelestialPoint::coord_t> MccPointingTarget;
|
|
|
|
|
|
|
|
template <mcc_angle_c CoordT>
|
|
struct MccGenericPCMResult {
|
|
CoordT pcmX, pcmY;
|
|
};
|
|
|
|
|
|
typedef MccGenericPCMResult<double> MccPCMResult;
|
|
|
|
|
|
/* DEFAULT TELEMETRY DATA CLASS */
|
|
|
|
template <mcc_angle_c CoordT>
|
|
struct MccGenericTelemetryData : MccGenericEqtHrzCoords<CoordT> {
|
|
using typename MccGenericEqtHrzCoords<CoordT>::coord_t;
|
|
|
|
MccJulianDay JD;
|
|
coord_t LST; // local apparent sideral time
|
|
|
|
MccGenericPointingTarget<coord_t> target{};
|
|
|
|
coord_t speedX, speedY;
|
|
|
|
coord_t pcmX, pcmY;
|
|
|
|
coord_t refCorr;
|
|
|
|
coord_t EO;
|
|
};
|
|
|
|
|
|
typedef MccGenericTelemetryData<MccCelestialPoint::coord_t> MccTelemetryData;
|
|
|
|
|
|
|
|
template <mcc_ccte_c CCTE_T, mcc_hardware_c HARDWARE_T, mcc_PCM_c PCM_T>
|
|
struct MccPositionControls : CCTE_T, HARDWARE_T, PCM_T {
|
|
virtual ~MccPositionControls() = default;
|
|
};
|
|
|
|
|
|
/* JUST CHECK FOR CONCEPT CONSISTENCY */
|
|
|
|
static_assert(mcc_julday_c<MccJulianDay>, "");
|
|
static_assert(mcc_celestial_point_c<MccCelestialPoint>, "");
|
|
static_assert(mcc_pointing_target_coord_c<MccGenericPointingTarget<double>>, "");
|
|
static_assert(mcc_telemetry_data_c<MccTelemetryData>, "");
|
|
|
|
|
|
|
|
/* DEFAULT SERIALIZER/DESERIALIZER FOR COORDINATE-RELATED CLASSES */
|
|
|
|
|
|
enum class MccCoordinateConvErrorCode : int {
|
|
ERROR_OK,
|
|
ERROR_ARG_LEN,
|
|
ERROR_NONNUM_ARG,
|
|
ERROR_NONSGM_ARG,
|
|
ERROR_INVALID_CPAIR,
|
|
ERROR_TIMEPOINT,
|
|
ERROR_INVALID_COORD_FMT,
|
|
ERROR_INVALID_COORD_PREC
|
|
};
|
|
|
|
class MccCoordinateConvErrorCategory : public std::error_category
|
|
{
|
|
public:
|
|
const char* name() const noexcept
|
|
{
|
|
return "MCC-COORD-CONV";
|
|
}
|
|
|
|
std::string message(int ec) const
|
|
{
|
|
MccCoordinateConvErrorCode err = static_cast<MccCoordinateConvErrorCode>(ec);
|
|
|
|
switch (err) {
|
|
case MccCoordinateConvErrorCode::ERROR_OK:
|
|
return "OK";
|
|
case MccCoordinateConvErrorCode::ERROR_ARG_LEN:
|
|
return "invalid argument length or number of argument elements";
|
|
case MccCoordinateConvErrorCode::ERROR_NONNUM_ARG:
|
|
return "non-numeric or out-of-range argument";
|
|
case MccCoordinateConvErrorCode::ERROR_NONSGM_ARG:
|
|
return "non-sexagesimal argument";
|
|
case MccCoordinateConvErrorCode::ERROR_INVALID_CPAIR:
|
|
return "invalid coordinate pair name";
|
|
case MccCoordinateConvErrorCode::ERROR_TIMEPOINT:
|
|
return "invalid time point";
|
|
case MccCoordinateConvErrorCode::ERROR_INVALID_COORD_FMT:
|
|
return "invalid coordinate formatter string";
|
|
case MccCoordinateConvErrorCode::ERROR_INVALID_COORD_PREC:
|
|
return "invalid coordinate formatter precision string";
|
|
defaut:
|
|
return "unknown";
|
|
};
|
|
|
|
return "unknown";
|
|
}
|
|
|
|
static const MccCoordinateConvErrorCategory& get()
|
|
{
|
|
static const MccCoordinateConvErrorCategory constInst;
|
|
return constInst;
|
|
}
|
|
};
|
|
|
|
} // namespace mcc
|
|
|
|
|
|
namespace std
|
|
{
|
|
|
|
template <>
|
|
class is_error_code_enum<mcc::MccCoordinateConvErrorCode> : public true_type
|
|
{
|
|
};
|
|
|
|
} // namespace std
|
|
|
|
|
|
namespace mcc
|
|
{
|
|
|
|
inline std::error_code make_error_code(mcc::MccCoordinateConvErrorCode ec)
|
|
{
|
|
return std::error_code(static_cast<int>(ec), mcc::MccCoordinateConvErrorCategory::get());
|
|
}
|
|
|
|
static constexpr std::string_view MccCoordinateDefaultDelimiter{","};
|
|
|
|
// base class
|
|
class MccCoordinateDeserializer
|
|
{
|
|
public:
|
|
MccCoordinateDeserializer() = default;
|
|
|
|
template <traits::mcc_input_char_range R>
|
|
MccCoordinateDeserializer(R&& delim) : MccCoordinateDeserializer()
|
|
{
|
|
setDelimiter(std::forward<R>(delim));
|
|
}
|
|
|
|
|
|
virtual ~MccCoordinateDeserializer() = default;
|
|
|
|
template <traits::mcc_input_char_range R>
|
|
void setDelimiter(R&& delim)
|
|
{
|
|
if constexpr (std::is_pointer_v<std::decay_t<R>>) {
|
|
setDelimiter(std::string_view(delim));
|
|
} else {
|
|
_delimiter.clear();
|
|
std::ranges::copy(std::forward<R>(delim), std::back_inserter(_delimiter));
|
|
}
|
|
}
|
|
|
|
|
|
template <std::derived_from<MccCoordinateDeserializer> SelfT, traits::mcc_input_char_range IR, typename VT>
|
|
std::error_code operator()(this SelfT&& self, IR&& bytes, VT& value)
|
|
{
|
|
if constexpr (std::same_as<std::remove_cvref_t<SelfT>, MccCoordinateDeserializer>) {
|
|
static_assert(false, "!!!!!");
|
|
} else {
|
|
return std::forward<SelfT>(self)(std::forward<IR>(bytes), value);
|
|
}
|
|
}
|
|
|
|
protected:
|
|
std::string _delimiter{MccCoordinateDefaultDelimiter};
|
|
|
|
template <traits::mcc_input_char_range IR>
|
|
std::vector<std::string_view> splitToElements(IR&& bytes)
|
|
{
|
|
std::vector<std::string_view> res;
|
|
|
|
auto els = std::views::split(std::forward<IR>(bytes), _delimiter);
|
|
|
|
for (auto const& el : els) {
|
|
std::back_inserter(res) = std::string_view(el.begin(), el.end());
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
template <traits::mcc_input_char_range IR, mcc_celestial_point_c T>
|
|
std::error_code parseTimePoint(const IR& bytes, T& cp)
|
|
{
|
|
MccCelestialCoordEpoch cep;
|
|
|
|
bool ok = cep.fromCharRange(bytes);
|
|
if (!ok) {
|
|
// return std::make_error_code(std::errc::invalid_argument);
|
|
return MccCoordinateConvErrorCode::ERROR_TIMEPOINT;
|
|
}
|
|
|
|
mcc_tp2tp(cep.UTC(), cp.time_point);
|
|
|
|
return {};
|
|
}
|
|
|
|
template <traits::mcc_input_char_range IR>
|
|
std::error_code parseHourRepr(const IR& bytes, double& ang_value)
|
|
{
|
|
std::optional<double> ang;
|
|
ang = mcc::utils::parsAngleString(bytes, true);
|
|
if (ang) {
|
|
ang_value = MccAngle(ang.value(), MccDegreeTag{});
|
|
} else {
|
|
// return std::make_error_code(std::errc::invalid_argument);
|
|
return MccCoordinateConvErrorCode::ERROR_NONNUM_ARG;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
template <traits::mcc_input_char_range IR>
|
|
std::error_code parseDegreeRepr(const IR& bytes, double& ang_value)
|
|
{
|
|
std::optional<double> ang;
|
|
ang = mcc::utils::parsAngleString(bytes);
|
|
if (ang) {
|
|
ang_value = MccAngle(ang.value(), MccDegreeTag{});
|
|
} else {
|
|
// return std::make_error_code(std::errc::invalid_argument);
|
|
return MccCoordinateConvErrorCode::ERROR_NONNUM_ARG;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
};
|
|
|
|
// base class
|
|
class MccCoordinateSerializer
|
|
{
|
|
public:
|
|
enum SerializedCoordFormat {
|
|
CFMT_DEGREES, // floating-point representation in degrees
|
|
CFMT_SGM // sexagesimal representation: HH:MM:SS.SSSSSS (hours:minutes:seconds) or DD:MM:SS.SSSSS
|
|
// (degrees:arcmins::arcsecs)
|
|
};
|
|
|
|
struct SexagesimalCoordPrec {
|
|
uint8_t hour_prec = 2; // number of decimal places in hour seconds
|
|
uint8_t deg_prec = 1; // number of decimal places in arcseconds
|
|
};
|
|
|
|
|
|
constexpr MccCoordinateSerializer() = default;
|
|
|
|
constexpr MccCoordinateSerializer(SerializedCoordFormat fmt, SexagesimalCoordPrec prec)
|
|
{
|
|
setFormat(fmt);
|
|
setPrecision(std::move(prec));
|
|
}
|
|
|
|
virtual ~MccCoordinateSerializer() = default;
|
|
|
|
void setFormat(SerializedCoordFormat fmt)
|
|
{
|
|
_currentFormat = fmt;
|
|
}
|
|
|
|
void setPrecision(SexagesimalCoordPrec prec)
|
|
{
|
|
_currentPrec = std::move(prec);
|
|
}
|
|
|
|
template <traits::mcc_input_char_range R>
|
|
void setDelimiter(R&& delim)
|
|
{
|
|
if constexpr (std::is_pointer_v<std::decay_t<R>>) {
|
|
setDelimiter(std::string_view(delim));
|
|
} else {
|
|
_delimiter.clear();
|
|
std::ranges::copy(std::forward<R>(delim), std::back_inserter(_delimiter));
|
|
}
|
|
}
|
|
|
|
template <std::derived_from<MccCoordinateSerializer> SelfT, typename T, traits::mcc_output_char_range OR>
|
|
void operator()(this SelfT&& self, const T& value, OR& bytes)
|
|
{
|
|
if constexpr (std::same_as<std::remove_cvref_t<SelfT>, MccCoordinateSerializer>) {
|
|
static_assert(false, "!!!!!");
|
|
} else {
|
|
std::forward<SelfT>(self)(value, bytes);
|
|
}
|
|
}
|
|
|
|
protected:
|
|
SerializedCoordFormat _currentFormat{CFMT_DEGREES};
|
|
SexagesimalCoordPrec _currentPrec{.hour_prec = 2, .deg_prec = 1};
|
|
|
|
std::string _delimiter{MccCoordinateDefaultDelimiter};
|
|
|
|
template <mcc_celestial_point_c T, traits::mcc_output_char_range OR>
|
|
void serializePairKindTimePoint(const T& value, OR& bytes)
|
|
{
|
|
std::format_to(std::back_inserter(bytes), "{0:}{1:}{2:%F}T{2:%T}", MccCoordPairKindToStr(value.pair_kind),
|
|
_delimiter, value.time_point);
|
|
}
|
|
|
|
template <traits::mcc_output_char_range OR, std::convertible_to<double>... Ts>
|
|
void toDegrees(OR& bytes, double angle, const Ts&... angles)
|
|
{
|
|
std::format_to(std::back_inserter(bytes), "{}", MccAngle(angle).degrees());
|
|
if constexpr (sizeof...(Ts)) {
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
toDegrees(bytes, angles...);
|
|
}
|
|
}
|
|
|
|
template <traits::mcc_output_char_range OR, std::convertible_to<double>... Ts>
|
|
void toSexagesimalHour(OR& bytes, double angle, const Ts&... angles)
|
|
{
|
|
std::format_to(std::back_inserter(bytes), "{}", MccAngle(angle).sexagesimal(true, _currentPrec.hour_prec));
|
|
if constexpr (sizeof...(Ts)) {
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
toSexagesimalHour(bytes, angles...);
|
|
}
|
|
}
|
|
|
|
template <traits::mcc_output_char_range OR, std::convertible_to<double>... Ts>
|
|
void toSexagesimalDeg(OR& bytes, double angle, const Ts&... angles)
|
|
{
|
|
std::format_to(std::back_inserter(bytes), "{}", MccAngle(angle).sexagesimal(false, _currentPrec.deg_prec));
|
|
if constexpr (sizeof...(Ts)) {
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
toSexagesimalDeg(bytes, angles...);
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
class MccCelestialPointSerializer : public MccCoordinateSerializer
|
|
{
|
|
public:
|
|
using MccCoordinateSerializer::MccCoordinateSerializer;
|
|
|
|
template <mcc_celestial_point_c T, traits::mcc_output_char_range OR>
|
|
void operator()(const T& value, OR& bytes)
|
|
{
|
|
if (_currentFormat == SerializedCoordFormat::CFMT_DEGREES) {
|
|
// std::format_to(std::back_inserter(bytes), "{}{}{}", MccAngle(value.X).degrees(), _delimiter,
|
|
// MccAngle(value.Y).degrees());
|
|
toDegrees(bytes, value.X, value.Y);
|
|
} else {
|
|
switch (value.pair_kind) {
|
|
case MccCoordPairKind::COORDS_KIND_RADEC_ICRS:
|
|
case MccCoordPairKind::COORDS_KIND_RADEC_APP:
|
|
case MccCoordPairKind::COORDS_KIND_HADEC_APP:
|
|
// std::format_to(std::back_inserter(bytes), "{}{}",
|
|
// MccAngle(value.X).sexagesimal(true, _currentPrec.hour_prec), _delimiter);
|
|
toSexagesimalHour(bytes, value.X);
|
|
break;
|
|
default:
|
|
// std::format_to(std::back_inserter(bytes), "{}{}",
|
|
// MccAngle(value.X).sexagesimal(false, _currentPrec.deg_prec), _delimiter);
|
|
toSexagesimalDeg(bytes, value.X);
|
|
}
|
|
|
|
// std::format_to(std::back_inserter(bytes), "{}",
|
|
// MccAngle(value.Y).sexagesimal(false, _currentPrec.deg_prec));
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
toSexagesimalDeg(bytes, value.Y);
|
|
}
|
|
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
serializePairKindTimePoint(value, bytes);
|
|
}
|
|
};
|
|
|
|
|
|
class MccCelestialPointDeserializer : public MccCoordinateDeserializer
|
|
{
|
|
public:
|
|
using MccCoordinateDeserializer::MccCoordinateDeserializer;
|
|
|
|
template <traits::mcc_input_char_range IR, mcc_celestial_point_c T>
|
|
std::error_code operator()(IR&& bytes, T& value)
|
|
{
|
|
auto els = splitToElements(std::forward<IR>(bytes));
|
|
|
|
if (els.size() < 2) { // at least coordinate pair must be given
|
|
// return std::make_error_code(std::errc::invalid_argument);
|
|
return MccCoordinateConvErrorCode::ERROR_ARG_LEN;
|
|
}
|
|
|
|
MccCelestialPoint pt{.pair_kind = MccCoordPairKind::COORDS_KIND_RADEC_ICRS};
|
|
|
|
if (els.size() > 2) { // pair of coordinates and the pair kind
|
|
pt.pair_kind = MccCoordStrToPairKind(els[2]);
|
|
if (pt.pair_kind == MccCoordPairKind::COORDS_KIND_UNKNOWN) {
|
|
// return std::make_error_code(std::errc::invalid_argument);
|
|
return MccCoordinateConvErrorCode::ERROR_INVALID_CPAIR;
|
|
}
|
|
}
|
|
|
|
if (pt.pair_kind == MccCoordPairKind::COORDS_KIND_RADEC_ICRS) {
|
|
// J2000.0: 11:58:55.816 1 January 2000 UTC
|
|
auto tp = std::chrono::sys_days(std::chrono::year_month_day(std::chrono::January / std::chrono::day(1) /
|
|
std::chrono::year(2000))) +
|
|
std::chrono::hours(11) + std::chrono::minutes(58) + std::chrono::milliseconds(55816);
|
|
mcc_tp2tp(tp, pt.time_point);
|
|
} else {
|
|
if (els.size() > 3) { // coordinates epoch is given
|
|
auto err = parseTimePoint(els[3], pt);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
} else { // no time point - use NOW
|
|
mcc_tp2tp(std::chrono::system_clock::now(), pt.time_point);
|
|
}
|
|
}
|
|
|
|
std::optional<double> ang1, ang2;
|
|
|
|
switch (pt.pair_kind) {
|
|
// if sexagesimal then hours:minutes:seconds form
|
|
case mcc::MccCoordPairKind::COORDS_KIND_RADEC_ICRS:
|
|
case mcc::MccCoordPairKind::COORDS_KIND_RADEC_APP:
|
|
case mcc::MccCoordPairKind::COORDS_KIND_HADEC_APP:
|
|
ang1 = mcc::utils::parsAngleString(els[0], true);
|
|
break;
|
|
default:
|
|
// if sexagesimal then degrees:arcminutes:arcseconds form
|
|
ang1 = mcc::utils::parsAngleString(els[0]);
|
|
}
|
|
if (!ang1) {
|
|
// return std::make_error_code(std::errc::invalid_argument);
|
|
return MccCoordinateConvErrorCode::ERROR_NONNUM_ARG;
|
|
}
|
|
|
|
ang2 = mcc::utils::parsAngleString(els[1]);
|
|
if (!ang2) {
|
|
// return std::make_error_code(std::errc::invalid_argument);
|
|
return MccCoordinateConvErrorCode::ERROR_NONNUM_ARG;
|
|
}
|
|
|
|
|
|
pt.X = MccAngle(ang1.value(), mcc::MccDegreeTag{});
|
|
pt.Y = MccAngle(ang2.value(), mcc::MccDegreeTag{});
|
|
|
|
mcc_copy_celestial_point(pt, &value);
|
|
|
|
return {};
|
|
}
|
|
};
|
|
|
|
|
|
class MccEqtHrzCoordsSerializer : public MccCoordinateSerializer
|
|
{
|
|
public:
|
|
using MccCoordinateSerializer::MccCoordinateSerializer;
|
|
|
|
template <mcc_eqt_hrz_coord_c T, traits::mcc_output_char_range OR>
|
|
void operator()(const T& value, OR& bytes)
|
|
{
|
|
// output format: RA, DEC, HA, AZ, ZD, ALT, X, Y, pair-kind, time-point
|
|
// in the case of sexagesimal output X,Y coordinates will be interpretated
|
|
// according to value.pair_kind field
|
|
|
|
if (_currentFormat == SerializedCoordFormat::CFMT_DEGREES) {
|
|
toDegrees(bytes, value.RA_APP, value.DEC_APP, value.HA, value.AZ, value.ZD, value.ALT, value.X, value.Y);
|
|
} else if (_currentFormat == SerializedCoordFormat::CFMT_SGM) {
|
|
toSexagesimalHour(bytes, value.RA_APP);
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
|
|
toSexagesimalDeg(bytes, value.DEC_APP);
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
|
|
toSexagesimalHour(bytes, value.HA);
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
|
|
toSexagesimalDeg(bytes, value.AZ, value.ZD, value.ALT);
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
|
|
switch (value.pair_kind) {
|
|
case MccCoordPairKind::COORDS_KIND_RADEC_ICRS:
|
|
case MccCoordPairKind::COORDS_KIND_RADEC_APP:
|
|
case MccCoordPairKind::COORDS_KIND_HADEC_APP:
|
|
toSexagesimalHour(bytes, value.X);
|
|
break;
|
|
default:
|
|
toSexagesimalDeg(bytes, value.X);
|
|
}
|
|
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
toSexagesimalDeg(bytes, value.Y);
|
|
} else {
|
|
// !!!!!
|
|
}
|
|
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
|
|
serializePairKindTimePoint(value, bytes);
|
|
}
|
|
};
|
|
|
|
class MccEqtHrzCoordsDeserializer : public MccCoordinateDeserializer
|
|
{
|
|
public:
|
|
using MccCoordinateDeserializer::MccCoordinateDeserializer;
|
|
|
|
template <traits::mcc_input_char_range IR, mcc_eqt_hrz_coord_c T>
|
|
std::error_code operator()(IR&& bytes, T& value)
|
|
{
|
|
// valid format: RA, DEC, HA, AZ, ZD, ALT, X, Y, pair-kind, time-point
|
|
// in the case of sexagesimal input the X,Y coordinates will be interpretated
|
|
// according to value.pair_kind field
|
|
|
|
auto els = splitToElements(std::forward<IR>(bytes));
|
|
if (els.size() < 10) {
|
|
// return std::make_error_code(std::errc::invalid_argument);
|
|
return MccCoordinateConvErrorCode::ERROR_ARG_LEN;
|
|
}
|
|
|
|
MccEqtHrzCoords pt;
|
|
pt.pair_kind = MccCoordStrToPairKind(els[8]);
|
|
if (pt.pair_kind == MccCoordPairKind::COORDS_KIND_UNKNOWN) {
|
|
// return std::make_error_code(std::errc::invalid_argument);
|
|
return MccCoordinateConvErrorCode::ERROR_INVALID_CPAIR;
|
|
}
|
|
|
|
auto err = parseTimePoint(els[9], pt);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseHourRepr(els[0], pt.RA_APP);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseDegreeRepr(els[1], pt.DEC_APP);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseHourRepr(els[2], pt.HA);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseDegreeRepr(els[4], pt.AZ);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseDegreeRepr(els[5], pt.ZD);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseDegreeRepr(els[6], pt.ALT);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
switch (value.pair_kind) {
|
|
case MccCoordPairKind::COORDS_KIND_RADEC_ICRS:
|
|
case MccCoordPairKind::COORDS_KIND_RADEC_APP:
|
|
case MccCoordPairKind::COORDS_KIND_HADEC_APP:
|
|
err = parseHourRepr(els[7], pt.X);
|
|
break;
|
|
default:
|
|
err = parseDegreeRepr(els[7], pt.X);
|
|
}
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseDegreeRepr(els[8], pt.Y);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
mcc_copy_eqt_hrz_coord(pt, &value);
|
|
|
|
return {};
|
|
}
|
|
};
|
|
|
|
|
|
|
|
class MccPointingTargetSerializer : public MccCoordinateSerializer
|
|
{
|
|
public:
|
|
template <mcc_pointing_target_coord_c T, traits::mcc_output_char_range OR>
|
|
void operator()(const T& value, OR& bytes)
|
|
{
|
|
static MccEqtHrzCoordsSerializer eqhrz_ser;
|
|
|
|
// output format: RA_ICRS, DEC_ICRS, RA_APP, DEC_APP, HA, AZ, ZD, ALT, X, Y, pair-kind, time-point
|
|
// in the case of sexagesimal output X,Y coordinates will be interpretated
|
|
// according to value.pair_kind field
|
|
|
|
if (_currentFormat == SerializedCoordFormat::CFMT_DEGREES) {
|
|
toDegrees(bytes, value.RA_ICRS, value.DEC_ICRS);
|
|
} else if (_currentFormat == SerializedCoordFormat::CFMT_SGM) {
|
|
toSexagesimalHour(bytes, value.RA_ICRS);
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
|
|
toSexagesimalDeg(bytes, value.DEC_ICRS);
|
|
}
|
|
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
|
|
eqhrz_ser.setFormat(_currentFormat);
|
|
eqhrz_ser.setPrecision(_currentPrec);
|
|
eqhrz_ser(value, bytes);
|
|
|
|
// MccEqtHrzCoordsSerializer{}(value, bytes);
|
|
}
|
|
};
|
|
|
|
class MccPointingTargetDeserializer : public MccCoordinateDeserializer
|
|
{
|
|
public:
|
|
template <traits::mcc_input_char_range IR, mcc_pointing_target_coord_c T>
|
|
std::error_code operator()(IR&& bytes, T& value)
|
|
{
|
|
// valid format: RA_ICRS, DEC_ICRS, RA_APP, DEC_APP, HA, AZ, ZD, ALT, X, Y, pair-kind, time-point
|
|
// in the case of sexagesimal input the X,Y coordinates will be interpretated
|
|
// according to value.pair_kind field
|
|
|
|
auto els = splitToElements(std::forward<IR>(bytes));
|
|
if (els.size() < 12) {
|
|
// return std::make_error_code(std::errc::invalid_argument);
|
|
return MccCoordinateConvErrorCode::ERROR_ARG_LEN;
|
|
}
|
|
|
|
MccPointingTarget pt;
|
|
auto err = parseHourRepr(els[0], pt.RA_ICRS);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseDegreeRepr(els[1], pt.DEC_ICRS);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = MccEqtHrzCoordsDeserializer{}(std::string_view{els[2].begin(), els[11].end()}, pt);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
mcc_copy_pointing_target_coord(pt, &value);
|
|
|
|
return {};
|
|
}
|
|
};
|
|
|
|
|
|
class MccTelemetryDataSerializer : public MccCoordinateSerializer
|
|
{
|
|
public:
|
|
template <mcc_telemetry_data_c T, traits::mcc_output_char_range OR>
|
|
void operator()(const T& value, OR& bytes)
|
|
{
|
|
static MccEqtHrzCoordsSerializer eqhrz_ser;
|
|
static MccPointingTargetSerializer pt_ser;
|
|
|
|
// output format: <mount data>, speedX, speedY, pcmX, pcmY, refCorr (in arcsecs), <target data>
|
|
// RA-APP_mnt, DEC-APP_mnt, HA_mnt, AZ_mnt, ZD_mnt, ALT_mnt, X_mnt, Y_mnt, COO-PAIR_mnt, TIME-POINT_mnt,
|
|
// LST, EO, SPEED_X_mnt, SPEED_Y_mnt, PCM_X, PCM_Y, REFCORR,
|
|
// RA-ICRS_tag, DEC-ICRS_tag, RA-APP_tag, DEC-APP_tag, HA_tag, AZ_tag, ZD_tag, ALT_tag, X_tag, Y_tag,
|
|
// COO-PAIR_tag, TIME-POINT_tag
|
|
|
|
eqhrz_ser.setFormat(_currentFormat);
|
|
eqhrz_ser.setPrecision(_currentPrec);
|
|
eqhrz_ser(value, bytes);
|
|
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
toSexagesimalHour(bytes, value.LST);
|
|
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
|
|
toSexagesimalHour(bytes, value.EO);
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
|
|
// '*3600.0' to express refraction correction in arcseconds!
|
|
// toDegrees(bytes, value.speedX, value.speedY, value.pcmX, value.pcmY, value.refCorr * 3600.0);
|
|
toSexagesimalDeg(bytes, value.speedX, value.speedY, value.pcmX, value.pcmY, value.refCorr);
|
|
std::format_to(std::back_inserter(bytes), "{}", _delimiter);
|
|
|
|
pt_ser.setFormat(_currentFormat);
|
|
pt_ser.setPrecision(_currentPrec);
|
|
pt_ser(value.target, bytes);
|
|
}
|
|
};
|
|
|
|
|
|
class MccTelemetryDataDeserializer : public MccCoordinateDeserializer
|
|
{
|
|
public:
|
|
using MccCoordinateDeserializer::MccCoordinateDeserializer;
|
|
|
|
template <traits::mcc_input_char_range IR, mcc_telemetry_data_c T>
|
|
std::error_code operator()(IR&& bytes, T& value)
|
|
{
|
|
// valid format: <mount data>, speedX, speedY, pcmX, pcmY, refCorr, <target data>
|
|
|
|
auto els = splitToElements(std::forward<IR>(bytes));
|
|
if (els.size() < 29) {
|
|
// return std::make_error_code(std::errc::invalid_argument);
|
|
return MccCoordinateConvErrorCode::ERROR_ARG_LEN;
|
|
}
|
|
|
|
MccTelemetryData tdata;
|
|
auto err = MccEqtHrzCoordsDeserializer{}(std::string_view{els[0].begin(), els[9].end()}, tdata);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
size_t idx = 10;
|
|
|
|
err = parseHourRepr(els[idx++], tdata.LST);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseHourRepr(els[idx++], tdata.EO);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseDegreeRepr(els[idx++], tdata.speedX);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseDegreeRepr(els[idx++], tdata.speedY);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseDegreeRepr(els[idx++], tdata.pcmX);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseDegreeRepr(els[idx++], tdata.pcmY);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = parseDegreeRepr(els[idx++], tdata.refCorr);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
err = MccPointingTargetDeserializer{}(std::string_view{els[idx].begin(), els.back().end()}, tdata.target);
|
|
if (err) {
|
|
return err;
|
|
}
|
|
|
|
mcc_copy_telemetry_data(tdata, &value);
|
|
|
|
return {};
|
|
}
|
|
};
|
|
|
|
} // namespace mcc
|