parcel.hpp

Go to the documentation of this file.

#pragma once
 
 
#if !defined(DIMVAL_WITH_PARCEL)
#if __has_include(<parcel/parcel.h>)
#define DIMVAL_WITH_PARCEL 1
#else
#define DIMVAL_WITH_PARCEL 0
#endif
#endif
 
#if DIMVAL_WITH_PARCEL
 
#include <dimval/format.hpp>
#include <dimval/json_nlohmann.hpp>
#include <dimval/measure.hpp>
#include <dimval/range.hpp>
#include <dimval/traits.hpp>
#include <dimval/unit.hpp>
 
#include <memory>
#include <string>
#include <string_view>
 
#include <parcel/parcel.h>
 
namespace dimval {
 
template <UnitLike U, NumericValue T = double>
class UnitValueCell : public ::parcel::BaseCell<UnitValueCell<U, T>, UnitValue<U, T>> {
    using base_t = ::parcel::BaseCell<UnitValueCell<U, T>, UnitValue<U, T>>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
 
    static constexpr std::string_view kind_id = "uv";
 
    [[nodiscard]] std::string to_string() const override {
        return this->value.to_string();
    }
 
    [[nodiscard]] std::string to_formatted_string() const override {
        return this->value.to_formatted_string();
    }
 
    static ::parcel::cell_t from_json(::parcel::json_t const& j, ::parcel::ParcelRegistry const&) {
        auto v = base_t::template cell_from_json<UnitValue<U, T>>(j, kind_id);
        auto cell = std::make_shared<UnitValueCell>(v);
        base_t::absorb_display_info(j, cell);
        return cell;
    }
 
    static ::parcel::cell_type_descriptor_t descriptor() {
        static const auto d = std::make_shared<::parcel::SimpleCellTypeDescriptor<UnitValueCell>>(
            ::parcel::DisplayInfo{.name = "dimval::UnitValue"});
        return d;
    }
};
 
template <MeasureLike M, NumericValue T = double>
class MeasureValueCell : public ::parcel::BaseCell<MeasureValueCell<M, T>, MeasureValue<M, T>> {
    using base_t = ::parcel::BaseCell<MeasureValueCell<M, T>, MeasureValue<M, T>>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
 
    static constexpr std::string_view kind_id = "mv";
 
    [[nodiscard]] std::string to_string() const override {
        return this->value.to_string();
    }
 
    [[nodiscard]] std::string to_formatted_string() const override {
        return this->value.to_formatted_string();
    }
 
    static ::parcel::cell_t from_json(::parcel::json_t const& j, ::parcel::ParcelRegistry const&) {
        auto v = base_t::template cell_from_json<MeasureValue<M, T>>(j, kind_id);
        auto cell = std::make_shared<MeasureValueCell>(v);
        base_t::absorb_display_info(j, cell);
        return cell;
    }
 
    static ::parcel::cell_type_descriptor_t descriptor() {
        static const auto d =
            std::make_shared<::parcel::SimpleCellTypeDescriptor<MeasureValueCell>>(
                ::parcel::DisplayInfo{.name = "dimval::MeasureValue"});
        return d;
    }
};
 
template <UnitLike U, NumericValue T = double>
class UnitRangeValueCell
    : public ::parcel::BaseCell<UnitRangeValueCell<U, T>, UnitRangeValue<U, T>> {
    using base_t = ::parcel::BaseCell<UnitRangeValueCell<U, T>, UnitRangeValue<U, T>>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
 
    static constexpr std::string_view kind_id = "urv";
 
    [[nodiscard]] std::string to_string() const override {
        return this->value.to_string();
    }
 
    [[nodiscard]] std::string to_formatted_string() const override {
        return this->value.to_formatted_string();
    }
 
    static ::parcel::cell_t from_json(::parcel::json_t const& j, ::parcel::ParcelRegistry const&) {
        auto v = base_t::template cell_from_json<UnitRangeValue<U, T>>(j, kind_id);
        auto cell = std::make_shared<UnitRangeValueCell>(v);
        base_t::absorb_display_info(j, cell);
        return cell;
    }
 
    static ::parcel::cell_type_descriptor_t descriptor() {
        static const auto d =
            std::make_shared<::parcel::SimpleCellTypeDescriptor<UnitRangeValueCell>>(
                ::parcel::DisplayInfo{.name = "dimval::UnitRangeValue"});
        return d;
    }
};
 
template <MeasureLike M, NumericValue T = double>
class MeasureRangeValueCell
    : public ::parcel::BaseCell<MeasureRangeValueCell<M, T>, MeasureRangeValue<M, T>> {
    using base_t = ::parcel::BaseCell<MeasureRangeValueCell<M, T>, MeasureRangeValue<M, T>>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
 
    static constexpr std::string_view kind_id = "mrv";
 
    [[nodiscard]] std::string to_string() const override {
        return this->value.to_string();
    }
 
    [[nodiscard]] std::string to_formatted_string() const override {
        return this->value.to_formatted_string();
    }
 
    static ::parcel::cell_t from_json(::parcel::json_t const& j, ::parcel::ParcelRegistry const&) {
        auto v = base_t::template cell_from_json<MeasureRangeValue<M, T>>(j, kind_id);
        auto cell = std::make_shared<MeasureRangeValueCell>(v);
        base_t::absorb_display_info(j, cell);
        return cell;
    }
 
    static ::parcel::cell_type_descriptor_t descriptor() {
        static const auto d =
            std::make_shared<::parcel::SimpleCellTypeDescriptor<MeasureRangeValueCell>>(
                ::parcel::DisplayInfo{.name = "dimval::MeasureRangeValue"});
        return d;
    }
};
 
}  // namespace dimval
 
#endif  // DIMVAL_WITH_PARCEL