constraint.hh

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <optional>
#include <string>
#include <string_view>
 
#include "cli/error.hh"
 
namespace cli {

struct ConstraintResult {
  std::optional<ParseError> error;
 
  [[nodiscard]] auto ok() const noexcept -> bool { return !error.has_value(); }
  [[nodiscard]] explicit operator bool() const noexcept { return ok(); }
 
  static auto pass() -> ConstraintResult { return {}; }
  static auto fail(ParseError e) -> ConstraintResult { return {std::move(e)}; }
 
  friend auto operator&&(ConstraintResult a, ConstraintResult b)
      -> ConstraintResult {
    return a.ok() ? std::move(b) : std::move(a);
  }
 
  friend auto operator||(ConstraintResult a, ConstraintResult b)
      -> ConstraintResult {
    return a.ok() ? std::move(a) : std::move(b);
  }
};
 
namespace detail {
 
template <class T>
concept NamedProviderArg = requires(const T& t) {
  { t.provided() } -> std::convertible_to<bool>;
  {
    std::remove_cvref_t<T>::name.view()
  } -> std::convertible_to<std::string_view>;
};
 
template <NamedProviderArg... Args>
auto names_list(const Args&...) -> std::string {
  std::string s;
  bool first = true;
  (..., (s += (first ? std::string{} : std::string{", "}) + "--" +
              std::string(std::remove_cvref_t<Args>::name.view()),
         first = false));
  return s;
}
 
}  // namespace detail

namespace constraint {

template <detail::NamedProviderArg... Args>
auto one_of(const Args&... args) -> ConstraintResult {
  int count = (0 + ... + (args.provided() ? 1 : 0));
  if (count == 1) return ConstraintResult::pass();
  auto subject = detail::names_list(args...);
  if (count == 0) {
    return ConstraintResult::fail(ParseError{
        .code = ErrorCode::missing_required,
        .kind = ErrorKind::validation,
        .subject = subject,
        .detail = "exactly one of these options must be provided",
    });
  }
  return ConstraintResult::fail(ParseError{
      .code = ErrorCode::mutually_exclusive,
      .kind = ErrorKind::validation,
      .subject = subject,
      .detail = "exactly one of these options must be provided, but multiple "
                "were given",
  });
}

template <detail::NamedProviderArg... Args>
auto at_most_one_of(const Args&... args) -> ConstraintResult {
  int count = (0 + ... + (args.provided() ? 1 : 0));
  if (count <= 1) return ConstraintResult::pass();
  return ConstraintResult::fail(ParseError{
      .code = ErrorCode::mutually_exclusive,
      .kind = ErrorKind::validation,
      .subject = detail::names_list(args...),
      .detail = "at most one of these options may be provided",
  });
}

template <detail::NamedProviderArg... Args>
auto all_of(const Args&... args) -> ConstraintResult {
  bool all = (... && args.provided());
  if (all) return ConstraintResult::pass();
  return ConstraintResult::fail(ParseError{
      .code = ErrorCode::missing_required,
      .kind = ErrorKind::validation,
      .subject = detail::names_list(args...),
      .detail = "all of these options must be provided",
  });
}

template <detail::NamedProviderArg... Args>
auto all_or_none(const Args&... args) -> ConstraintResult {
  int count = (0 + ... + (args.provided() ? 1 : 0));
  constexpr int total = static_cast<int>(sizeof...(Args));
  if (count == 0 || count == total) return ConstraintResult::pass();
  return ConstraintResult::fail(ParseError{
      .code = ErrorCode::dependency_missing,
      .kind = ErrorKind::validation,
      .subject = detail::names_list(args...),
      .detail = "either all of these options must be provided, or none",
  });
}

template <detail::NamedProviderArg Cond, detail::NamedProviderArg Req>
auto requires_if(const Cond& condition, const Req& required)
    -> ConstraintResult {
  if (!condition.provided() || required.provided())
    return ConstraintResult::pass();
  return ConstraintResult::fail(ParseError{
      .code = ErrorCode::dependency_missing,
      .kind = ErrorKind::validation,
      .subject = "--" + std::string(std::remove_cvref_t<Req>::name.view()),
      .detail = "required when --" +
                std::string(std::remove_cvref_t<Cond>::name.view()) +
                " is provided",
  });
}
 
}  // namespace constraint
 
}  // namespace cli