parse_value.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Klaus Reimer <k@ailis.de>
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <charconv>
#include <concepts>
#include <exception>
#include <format>
#include <string_view>
#include <system_error>
#include <type_traits>
 
#include <kaycxx/cli/parse_error.hpp>
 
namespace kaycxx::cli {
 
template <typename T>
concept from_chars_parseable = requires(std::string_view text, T& value) {
    requires std::default_initializable<T>;
    { std::from_chars(text.data(), text.data() + text.size(), value) } -> std::same_as<std::from_chars_result>;
};
 
template <typename T>
concept string_view_constructible =
    std::constructible_from<T, std::string_view>;
 
template <typename T>
concept from_string_parseable = requires(std::string_view text) {
    { from_string(text, std::type_identity<T>()) } -> std::same_as<T>;
};
 
template <typename T>
concept parseable_value =
    std::copy_constructible<T> && (
        from_chars_parseable<T> ||
        from_string_parseable<T> ||
        string_view_constructible<T>
    );
 
namespace detail {
 
template <parseable_value T>
[[nodiscard]] T parse_value(std::string_view text) {
    if constexpr (from_chars_parseable<T>) {
        auto value = T();
        auto const begin = text.data();
        auto const end = text.data() + text.size();
        auto const result = std::from_chars(begin, end, value);
 
        if (result.ec == std::errc::result_out_of_range) {
            throw parse_error(std::format("Value \"{}\" is out of range", text));
        }
        if (result.ec != std::errc() || result.ptr != end) {
            throw parse_error(std::format("Invalid value \"{}\"", text));
        }
 
        return value;
    } else {
        try {
            if constexpr (from_string_parseable<T>) {
                return from_string(text, std::type_identity<T>());
            } else {
                return T(text);
            }
        } catch (parse_error const&) {
            throw;
        } catch (std::exception const& error) {
            throw parse_error(std::format("Invalid value \"{}\" ({})", text, error.what()));
        } catch (...) {
            throw parse_error(std::format("Invalid value \"{}\"", text));
        }
    }
}
 
} // namespace detail
 
} // namespace kaycxx::cli