parse.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <dimval/core.hpp>
#include <dimval/measure.hpp>
#include <dimval/parse_detail.hpp>
#include <dimval/registry.hpp>
#include <dimval/traits.hpp>
#include <dimval/unit.hpp>
 
#include <expected>
#include <string>
#include <string_view>
 
namespace dimval {
 
struct DynamicUnitValue {
    const UnitDescriptor* desc{};
    double value{};
};
 
template <UnitLike U, NumericValue T = double>
[[nodiscard]] std::expected<UnitValue<U, T>, ParseError> parse_unit_value(std::string_view input) {
    return UnitValue<U, T>::parse(input);
}
 
template <MeasureLike M, NumericValue T = double>
[[nodiscard]] std::expected<MeasureValue<M, T>, ParseError>
parse_measure_value(std::string_view input) {
    return MeasureValue<M, T>::parse(input);
}
 
[[nodiscard]] inline std::expected<DynamicUnitValue, ParseError>
parse_dynamic_unit_value(std::string_view input) {
    auto split = detail::split_number_and_tail(input);
    if (!split) {
        return std::unexpected{split.error()};
    }
    auto num = detail::parse_number<double>(split->number, input);
    if (!num) {
        return std::unexpected{num.error()};
    }
    if (split->tail.empty()) {
        // Interpret as dimensionless.
        const auto* d = UnitRegistry::global().find("dimensionless");
        if (d == nullptr) {
            return std::unexpected{
                ParseError{ParseErrorCode::UnknownUnit,
                           std::string{input},
                           split->number_end,
                           "no symbol given and 'dimensionless' is not registered"}};
        }
        return DynamicUnitValue{d, *num};
    }
    const auto* d = UnitRegistry::global().find(split->tail);
    if (d == nullptr) {
        return std::unexpected{
            ParseError{ParseErrorCode::UnknownUnit,
                       std::string{input},
                       split->number_end,
                       std::string{"unknown unit symbol: "} + std::string{split->tail}}};
    }
    return DynamicUnitValue{d, *num};
}
 
}  // namespace dimval