cli.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <CLI/CLI.hpp>
#include <charconv>
#include <concepts>
#include <uni20/common/display.hpp>
#include <uni20/common/half_int.hpp>
#include <uni20/common/program.hpp>
 
#if CLI11_VERSION_MAJOR < 2 || (CLI11_VERSION_MAJOR == 2 && CLI11_VERSION_MINOR < 7) ||                                \
    (CLI11_VERSION_MAJOR == 2 && CLI11_VERSION_MINOR == 7 && CLI11_VERSION_PATCH < 2)
#error "Uni20 requires CLI11 2.7.2 or newer"
#endif
 
namespace uni20::cli
{
enum class action
{
  run,
  help,
  version,
  build_info,
  error
};
enum class no_arguments
{
  help,
  run
};
 
struct parse_policy
{
    no_arguments empty = no_arguments::help;
    display::stream empty_destination = display::stream::err;
    int empty_exit_code = 1;
    int error_exit_code = 1;
};
 
struct parse_result
{
    action requested = action::run;
    display::stream destination = display::stream::out;
    int exit_code = 0;
    std::string message = {};
};
 
void configure(CLI::App& app, presentation::program_info const& program);
 
[[nodiscard]] parse_result parse(CLI::App& app, int argc, char const* const* argv, parse_policy policy = {});
 
[[nodiscard]] std::vector<presentation::help_group> help_groups(CLI::App const& app);
 
[[nodiscard]] presentation::report_builder help_report(CLI::App const& app, presentation::program_info const& program);
 
[[nodiscard]] presentation::report_builder build_info_report(presentation::program_info const& program);
 
[[nodiscard]] presentation::report_builder result_report(CLI::App const& app, presentation::program_info const& program,
                                                         parse_result const& result);
 
namespace detail
{
template <typename T, typename Converter>
CLI::Option* converted_option(CLI::App& app, std::string names, T& target, std::string description, Converter converter)
{
  auto* option = app.add_option_function<std::string>(
      names,
      [&target, converter, names](std::string const& token) {
        try
        {
          target = converter(token);
        }
        catch (std::invalid_argument const& error)
        {
          throw CLI::ValidationError(names, error.what());
        }
        catch (std::out_of_range const& error)
        {
          throw CLI::ValidationError(names, error.what());
        }
        catch (std::runtime_error const& error)
        {
          throw CLI::ValidationError(names, error.what());
        }
      },
      std::move(description));
  return option->run_callback_for_default();
}
} // namespace detail
 
template <std::unsigned_integral T>
  requires(!std::same_as<T, bool>)
CLI::Option* add_count_option(CLI::App& app, std::string names, T& value, std::string description = {})
{
  auto* option =
      detail::converted_option(app, std::move(names), value, std::move(description), [](std::string const& text) {
        T parsed{};
        auto const result = std::from_chars(text.data(), text.data() + text.size(), parsed);
        if (result.ec != std::errc{} || result.ptr != text.data() + text.size())
          throw std::invalid_argument("expected a representable nonnegative decimal integer: " + text);
        return parsed;
      });
  return option->type_name("COUNT")->default_function([&value] { return fmt::format("{}", value); });
}
 
template <std::signed_integral T>
CLI::Option* add_half_int_option(CLI::App& app, std::string names, basic_half_int<T>& value,
                                 std::string description = {})
{
  auto* option = detail::converted_option(app, std::move(names), value, std::move(description),
                                          [](std::string const& text) { return basic_half_int<T>::parse(text); });
  return option->type_name("HALF_INT")->default_function([&value] { return uni20::to_string(value); });
}
} // namespace uni20::cli