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 19:43:18 +03:00
parent b871b9dd46
commit 5b4456d6ef
4 changed files with 350 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

312
mcc_serialization_common.h Normal file
View File

@@ -0,0 +1,312 @@
#pragma once
/****************************************************************************************
* *
* MOUNT CONTROL COMPONENTS LIBRARY *
* *
* *
* COMMON DEFINITIONS FOR DATA SERIALIZATION/DESERIALIZATION *
* *
****************************************************************************************/
#include "mcc_concepts.h"
#include "mcc_error.h"
#include "mcc_traits.h"
namespace mcc
{
enum class MccSerializedCoordPairFormat {
MCC_SERIALIZED_FORMAT_DEGREES, // both angles are in degrees as floating-point number
MCC_SERIALIZED_FORMAT_SXGM_HOURDEG, // X is in hour and Y is in degree sexagesimal representation
MCC_SERIALIZED_FORMAT_SXGM_DEGDEG, // both angles are in sexagesimal degrees
MCC_SERIALIZED_FORMAT_UNKNOWN
};
static constexpr std::string_view MCC_SERIALIZED_FORMAT_DEGREES_STR = "SRCP-FORMAT-DEGREES";
static constexpr std::string_view MCC_SERIALIZED_FORMAT_SXGM_HOURDEG_STR = "SRCP-FORMAT-SXGM_HOURDEG";
static constexpr std::string_view MCC_SERIALIZED_FORMAT_SXGM_DEGDEG_STR = "SRCP-FORMAT-SXGM_DEGDEG";
static constexpr std::string_view MccSerializedCoordPairFormatToStr(MccSerializedCoordPairFormat fmt)
{
return fmt == MccSerializedCoordPairFormat::MCC_SERIALIZED_FORMAT_DEGREES ? MCC_SERIALIZED_FORMAT_DEGREES_STR
: fmt == MccSerializedCoordPairFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURDEG
? MCC_SERIALIZED_FORMAT_SXGM_HOURDEG_STR
: fmt == MccSerializedCoordPairFormat::MCC_SERIALIZED_FORMAT_SXGM_DEGDEG
? MCC_SERIALIZED_FORMAT_SXGM_DEGDEG_STR
: MCC_SERIALIZED_FORMAT_DEGREES_STR;
}
template <traits::mcc_input_char_range R>
static constexpr MccSerializedCoordPairFormat MccSerializedCoordPairFormatStrToValue(R&& str)
{
if constexpr (std::is_array_v<std::decay_t<R>>) {
return MccSerializedCoordPairFormatStrToValue(std::string_view{str});
}
const auto hash = mcc::utils::FNV1aHash(std::forward<R>(str));
return hash == mcc::utils::FNV1aHash(MCC_SERIALIZED_FORMAT_DEGREES_STR)
? MccSerializedCoordPairFormat::MCC_SERIALIZED_FORMAT_DEGREES
: hash == mcc::utils::FNV1aHash(MCC_SERIALIZED_FORMAT_SXGM_HOURDEG_STR)
? MccSerializedCoordPairFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURDEG
: hash == mcc::utils::FNV1aHash(MCC_SERIALIZED_FORMAT_SXGM_DEGDEG_STR)
? MccSerializedCoordPairFormat::MCC_SERIALIZED_FORMAT_SXGM_DEGDEG
: MccSerializedCoordPairFormat::MCC_SERIALIZED_FORMAT_UNKNOWN;
}
struct MccSerializedCoordPairFormatPrec {
uint8_t hour_prec = 2; // number of decimal places in hour seconds (sexagesimal format)
uint8_t deg_prec = 1; // number of decimal places in arcseconds (sexagesimal format)
// slightly better than 0.1 arcsecond precision
uint8_t decimals = 6; // number of decimal places in degrees (floating-point number format)
// if 0, then number of decimal places is according to formating rules of 'double' type
};
enum class MccTimePointFormat {
MCC_TIMEPOINT_FORMAT_DATE, // UTC date
MCC_TIMEPOINT_FORMAT_MJD, // MJD
MCC_TIMEPOINT_FORMAT_JD, // JD
MCC_TIMEPOINT_FORMAT_JEPOCH, // Julian epoch
MCC_TIMEPOINT_FORMAT_UNKNOWN
};
static constexpr std::string_view MCC_TIMEPOINT_FORMAT_DATE_STR = "TP-FORMAT-DATE";
static constexpr std::string_view MCC_TIMEPOINT_FORMAT_MJD_STR = "TP-FORMAT-MJD";
static constexpr std::string_view MCC_TIMEPOINT_FORMAT_JD_STR = "TP-FORMAT-JD";
static constexpr std::string_view MCC_TIMEPOINT_FORMAT_JEPOCH_STR = "TP-FORMAT-JEPOCH";
static constexpr std::string_view MccTimePointFormatToStr(MccTimePointFormat fmt)
{
return fmt == MccTimePointFormat::MCC_TIMEPOINT_FORMAT_DATE ? MCC_TIMEPOINT_FORMAT_DATE_STR
: fmt == MccTimePointFormat::MCC_TIMEPOINT_FORMAT_MJD ? MCC_TIMEPOINT_FORMAT_MJD_STR
: fmt == MccTimePointFormat::MCC_TIMEPOINT_FORMAT_JD ? MCC_TIMEPOINT_FORMAT_JD_STR
: fmt == MccTimePointFormat::MCC_TIMEPOINT_FORMAT_JEPOCH ? MCC_TIMEPOINT_FORMAT_JEPOCH_STR
: MCC_TIMEPOINT_FORMAT_MJD_STR;
}
template <traits::mcc_input_char_range R>
static constexpr MccTimePointFormat MccTimePointFormatStrToValue(R&& str)
{
if constexpr (std::is_array_v<std::decay_t<R>>) {
return MccTimePointFormatStrToValue(std::string_view{str});
}
const auto hash = mcc::utils::FNV1aHash(std::forward<R>(str));
return hash == mcc::utils::FNV1aHash(MCC_TIMEPOINT_FORMAT_DATE_STR) ? MccTimePointFormat::MCC_TIMEPOINT_FORMAT_DATE
: hash == mcc::utils::FNV1aHash(MCC_TIMEPOINT_FORMAT_MJD_STR) ? MccTimePointFormat::MCC_TIMEPOINT_FORMAT_MJD
: hash == mcc::utils::FNV1aHash(MCC_TIMEPOINT_FORMAT_JD_STR) ? MccTimePointFormat::MCC_TIMEPOINT_FORMAT_JD
: hash == mcc::utils::FNV1aHash(MCC_TIMEPOINT_FORMAT_JEPOCH_STR)
? MccTimePointFormat::MCC_TIMEPOINT_FORMAT_JEPOCH
: MccTimePointFormat::MCC_TIMEPOINT_FORMAT_UNKNOWN;
}
/* SERIALIZATION/DESERIALIZATION PROCESS TUNING PARAMETERS */
// delimiter between items of serializing values sequence
static constexpr std::string_view MCC_SERIALIZING_DEFAULT_SEQ_DELIMITER{";"};
// delimiter between items of aggregative (multi-element) serializing value
static constexpr std::string_view MCC_SERIALIZING_DEFAULT_ELEM_DELIMITER{","};
template <typename T>
concept mcc_serialization_params_c = requires(T t) {
requires traits::mcc_output_char_range<decltype(t.seq_delim)>;
requires traits::mcc_output_char_range<decltype(t.elem_delim)>;
requires std::same_as<decltype(t.coordpair_format), MccSerializedCoordPairFormat>;
requires std::same_as<decltype(t.coordpair_prec), MccSerializedCoordPairFormatPrec>;
requires std::same_as<decltype(t.timepoint_format), MccTimePointFormat>;
// if true - normalize angle in sexagesimal format (to control rounding)
// (to avoid something like "24:00:00.0" for sexagesimal 'hours:minutes:seconds' format)
requires std::convertible_to<decltype(t.norm_sxgm), bool>;
// if true - interpretate serialized angle in sexagesimal format as 'hours:minutes:seconds'
// otherwise as 'degrees:arcmins:arcsecs'
requires std::convertible_to<decltype(t.sxgm_hms), bool>;
};
/* SERIALIZER/DESERIALIZER CONCEPTS */
template <mcc_error_c RetT>
struct mcc_serializer_interface_t {
virtual ~mcc_serializer_interface_t() = default;
typedef RetT error_t;
template <std::derived_from<mcc_serializer_interface_t> SelfT, traits::mcc_output_char_range R, typename ValueT>
RetT operator()(this SelfT&& self, R& output, ValueT const& value)
{
return std::forward<SelfT>(self)(output, value);
}
protected:
mcc_serializer_interface_t() = default;
};
template <typename T>
concept mcc_serializer_c =
std::derived_from<T, mcc_serializer_interface_t<typename T::error_t>> && requires(T t, const T t_const) {
// static const variable with name of the serializer
requires std::formattable<decltype(T::serializerName), char> && std::is_const_v<decltype(T::serializerName)>;
// must define a type "params_t"
requires mcc_serialization_params_c<typename T::params_t>;
{ t.setParams(std::declval<typename T::params_t const&>()) };
{ t_const.getParams() } -> std::same_as<typename T::params_t>;
};
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>
RetT operator()(this SelfT&& self, R const& input, ValueT& value)
{
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>> && requires(T t, const T t_const) {
// static const variable with name of the deserializer
requires std::formattable<decltype(T::deserializerName), char> &&
std::is_const_v<decltype(T::deserializerName)>;
// must define a type "params_t"
requires mcc_serialization_params_c<typename T::params_t>;
{ t.setParams(std::declval<typename T::params_t const&>()) };
{ t_const.getParams() } -> std::same_as<typename T::params_t>;
};
/* BASE CLASS IMPLEMENTATION FOR SERIALIZER/DESERIALIZER */
namespace impl
{
// default definition of serialization/deserialization process parameters structure
struct mcc_serialization_params_t {
std::string seq_delim{MCC_SERIALIZING_DEFAULT_SEQ_DELIMITER};
std::string elem_delim{MCC_SERIALIZING_DEFAULT_ELEM_DELIMITER};
MccSerializedCoordPairFormat coordpair_format{MccSerializedCoordPairFormat::MCC_SERIALIZED_FORMAT_SXGM_HOURDEG};
MccSerializedCoordPairFormatPrec coordpair_prec{
MccSerializedCoordPairFormatPrec{.hour_prec = 2, .deg_prec = 1, .decimals = 6}};
MccTimePointFormat timepoint_format{MccTimePointFormat::MCC_TIMEPOINT_FORMAT_DATE};
bool norm_sxgm{false};
bool sxgm_hms{false};
};
namespace details
{
template <mcc_serialization_params_c ParamsT>
struct _params_manipulator_t {
virtual ~_params_manipulator_t() = default;
typedef ParamsT params_t;
template <mcc_serialization_params_c p_t>
void setParams(p_t const& pars)
{
if constexpr (std::same_as<p_t, params_t>) {
_params = pars;
} else {
_params.seq_delim = pars.seq_delim;
_params.elem_delim = pars.elem_delim;
_params.coordpair_format = pars.coordpair_format;
_params.coordpair_prec = pars.coordpair_prec;
_params.timepoint_format = pars.timepoint_format;
_params.norm_sxgm = pars.norm_sxgm;
_params.sxgm_hms = pars.sxgm_hms;
}
}
template <mcc_serialization_params_c p_t>
requires(!std::same_as<p_t, params_t>)
p_t getParams() const
{
p_t pars;
pars.seq_delim = _params.seq_delim;
pars.elem_delim = _params.elem_delim;
pars.coordpair_format = _params.coordpair_format;
pars.coordpair_prec = _params.coordpair_prec;
pars.timepoint_format = _params.timepoint_format;
pars.norm_sxgm = _params.norm_sxgm;
pars.sxgm_hms = _params.sxgm_hms;
return pars;
}
params_t getParams() const
{
return _params;
}
protected:
_params_manipulator_t() = default;
params_t _params;
};
} // namespace details
template <mcc_serialization_params_c ParamsT>
struct MccSerializerBase : mcc_serializer_interface_t<MccError>, details::_params_manipulator_t<ParamsT> {
virtual ~MccSerializerBase() = default;
using typename mcc_serializer_interface_t<MccError>::error_t;
using typename details::_params_manipulator_t<ParamsT>::params_t;
protected:
MccSerializerBase() = default;
};
template <mcc_serialization_params_c ParamsT>
struct MccDeserializerBase : mcc_deserializer_interface_t<MccError>, details::_params_manipulator_t<ParamsT> {
virtual ~MccDeserializerBase() = default;
using typename mcc_deserializer_interface_t<MccError>::error_t;
using typename details::_params_manipulator_t<ParamsT>::params_t;
protected:
MccDeserializerBase() = default;
};
} // namespace impl
} // namespace mcc