measure.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <dimval/core.hpp>
#include <dimval/interface.hpp>
#include <dimval/traits.hpp>
#include <dimval/unit.hpp>
 
#include <commons/color.hpp>
#include <commons/icon.hpp>
 
#include <expected>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
 
namespace dimval {
 
template <MeasureLike M, NumericValue T = double>
struct MeasureValue : public IMeasureValue {
    using measure_t = M;
    using unit_t = M::base_unit_t;
    using value_t = T;
 
    T v{};
 
    constexpr MeasureValue() = default;
    constexpr MeasureValue(T value) noexcept : v(value) {}  // NOLINT(google-explicit-constructor)
 
    [[nodiscard]] static std::shared_ptr<MeasureValue> of(T value) {
        return std::make_shared<MeasureValue>(value);
    }
 
    [[nodiscard]] static std::unique_ptr<MeasureValue> unique(T value) {
        return std::make_unique<MeasureValue>(value);
    }
 
    [[nodiscard]] static std::expected<MeasureValue, ParseError> parse(std::string_view input) {
        auto u = UnitValue<unit_t, T>::parse(input);
        if (!u)
            return std::unexpected{u.error()};
        return MeasureValue{u->v};
    }
 
    // Compile-time metadata accessors -----------------------------------------
    // Read straight off the measure / unit tag, no descriptor round-trip.
    [[nodiscard]] static constexpr std::string_view id() noexcept {
        return M::id;
    }
    [[nodiscard]] static constexpr std::string_view unit_id() noexcept {
        return unit_t::id;
    }
    [[nodiscard]] static constexpr std::string_view name() noexcept {
        return M::name;
    }
    [[nodiscard]] static constexpr std::string_view symbol() noexcept {
        return unit_t::symbol;
    }
    [[nodiscard]] static constexpr std::string_view kind() noexcept {
        return unit_t::kind;
    }
    [[nodiscard]] static constexpr std::optional<comms::Icon> icon() noexcept {
        return M::icon ? M::icon : unit_t::icon;
    }
    [[nodiscard]] static constexpr std::optional<comms::Color> color() noexcept {
        return M::color ? M::color : unit_t::color;
    }
 
    [[nodiscard]] constexpr UnitValue<unit_t, T> as_unit_value() const noexcept {
        return UnitValue<unit_t, T>{v};
    }
 
    // IMeasureValue overrides -------------------------------------------------
    // Only the descriptors stay virtual — per-field metadata is reachable via
    // `descriptor().name`, `unit_descriptor().symbol`, ... from a polymorphic
    // handle.
    [[nodiscard]] MeasureDescriptor descriptor() const noexcept override {
        return M::descriptor();
    }
    [[nodiscard]] UnitDescriptor unit_descriptor() const noexcept override {
        return unit_t::descriptor();
    }
    [[nodiscard]] double numeric_as_double() const noexcept override {
        return static_cast<double>(v);
    }
 
    [[nodiscard]] std::string to_string() const override;
    [[nodiscard]] std::string to_formatted_string() const override;
 
    [[nodiscard]] std::unique_ptr<IMeasureValue> clone() const override {
        return std::make_unique<MeasureValue>(*this);
    }
 
    [[nodiscard]] friend constexpr bool operator==(const MeasureValue& a,
                                                   const MeasureValue& b) noexcept {
        return a.v == b.v;
    }
    [[nodiscard]] friend constexpr auto operator<=>(const MeasureValue& a,
                                                    const MeasureValue& b) noexcept {
        return a.v <=> b.v;
    }
 
    constexpr MeasureValue& operator+=(const MeasureValue& rhs) noexcept {
        v += rhs.v;
        return *this;
    }
    constexpr MeasureValue& operator-=(const MeasureValue& rhs) noexcept {
        v -= rhs.v;
        return *this;
    }
    constexpr MeasureValue& operator*=(T s) noexcept {
        v *= s;
        return *this;
    }
    constexpr MeasureValue& operator/=(T s) noexcept {
        v /= s;
        return *this;
    }
};
 
template <MeasureLike M, NumericValue T>
[[nodiscard]] constexpr MeasureValue<M, T> operator+(const MeasureValue<M, T>& a,
                                                     const MeasureValue<M, T>& b) noexcept {
    return MeasureValue<M, T>{static_cast<T>(a.v + b.v)};
}
 
template <MeasureLike M, NumericValue T>
[[nodiscard]] constexpr MeasureValue<M, T> operator-(const MeasureValue<M, T>& a,
                                                     const MeasureValue<M, T>& b) noexcept {
    return MeasureValue<M, T>{static_cast<T>(a.v - b.v)};
}
 
template <MeasureLike M, NumericValue T>
[[nodiscard]] constexpr MeasureValue<M, T> operator-(const MeasureValue<M, T>& a) noexcept {
    return MeasureValue<M, T>{static_cast<T>(-a.v)};
}
 
template <MeasureLike M, NumericValue T>
[[nodiscard]] constexpr MeasureValue<M, T> operator+(const MeasureValue<M, T>& a) noexcept {
    return a;
}
 
template <MeasureLike M, NumericValue T>
[[nodiscard]] constexpr MeasureValue<M, T> operator*(const MeasureValue<M, T>& a, T s) noexcept {
    return MeasureValue<M, T>{static_cast<T>(a.v * s)};
}
 
template <MeasureLike M, NumericValue T>
[[nodiscard]] constexpr MeasureValue<M, T> operator*(T s, const MeasureValue<M, T>& a) noexcept {
    return MeasureValue<M, T>{static_cast<T>(a.v * s)};
}
 
template <MeasureLike M, NumericValue T>
[[nodiscard]] constexpr MeasureValue<M, T> operator/(const MeasureValue<M, T>& a, T s) noexcept {
    return MeasureValue<M, T>{static_cast<T>(a.v / s)};
}
 
template <MeasureLike M, NumericValue T>
[[nodiscard]] constexpr T operator/(const MeasureValue<M, T>& a,
                                    const MeasureValue<M, T>& b) noexcept {
    return static_cast<T>(a.v / b.v);
}
 
template <MeasureLike M, NumericValue T>
[[nodiscard]] constexpr MeasureValue<M, T>
from_unit_value(const UnitValue<typename M::base_unit_t, T>& u) noexcept {
    return MeasureValue<M, T>{u.v};
}
 
template <MeasureLike M, NumericValue T = double>
[[nodiscard]] constexpr MeasureValue<M, T> measure_value(T v) noexcept {
    return MeasureValue<M, T>{v};
}
 
}  // namespace dimval