error.hh

Go to the documentation of this file.

#pragma once
 
#include <string>
 
namespace cli {

enum class ErrorCode {
  unknown_option,       
  unknown_command,      
  unexpected_argument,  
  missing_value,        
  invalid_value,  
  duplicate_argument,  
 
  conversion_error,  
  out_of_range,  
  missing_required,    
  mutually_exclusive,  
  dependency_missing,  
  invalid_choice,      
  validation_failed,   
  help_requested,  
  exit_success,    
  unknown_error,   
};

enum class ErrorKind {
  parse,
  conversion,
  validation,
};

[[nodiscard]] constexpr auto to_string(ErrorCode code) noexcept
    -> std::string_view {
  switch (code) {
    case ErrorCode::unknown_option:
      return "unknown option";
    case ErrorCode::unknown_command:
      return "unknown command";
    case ErrorCode::unexpected_argument:
      return "unexpected argument";
    case ErrorCode::missing_value:
      return "missing value";
    case ErrorCode::invalid_value:
      return "invalid value";
    case ErrorCode::duplicate_argument:
      return "duplicate argument";
    case ErrorCode::conversion_error:
      return "conversion error";
    case ErrorCode::out_of_range:
      return "out of range";
    case ErrorCode::missing_required:
      return "missing required argument";
    case ErrorCode::mutually_exclusive:
      return "mutually exclusive argument";
    case ErrorCode::dependency_missing:
      return "dependency missing";
    case ErrorCode::invalid_choice:
      return "invalid choice";
    case ErrorCode::validation_failed:
      return "validation failed";
    case ErrorCode::help_requested:
      return "help requested";
    case ErrorCode::exit_success:
      return "exit success";
    case ErrorCode::unknown_error:
      return "unknown error";
  }
 
  return "unknown error";
}

struct ParseError {
  ErrorCode code = ErrorCode::unknown_error;

  ErrorKind kind = ErrorKind::parse;

  int position = -1;

  std::string subject{};

  std::string detail{};

  [[nodiscard]] constexpr auto has_position() const noexcept -> bool {
    return position >= 0;
  }

  [[nodiscard]] constexpr auto exit_code() const noexcept -> int {
    return code == ErrorCode::help_requested || code == ErrorCode::exit_success
               ? 0
               : 1;
  }

  [[nodiscard]] constexpr auto use_stdout() const noexcept -> bool {
    return code == ErrorCode::help_requested || code == ErrorCode::exit_success;
  }

  [[nodiscard]] constexpr auto message() const -> std::string {
    if (code == ErrorCode::help_requested) {
      return detail;
    }
 
    if (code == ErrorCode::exit_success) {
      return detail;
    }
 
    std::string out{to_string(code)};
    if (!subject.empty()) {
      out += ": ";
      out += subject;
    }
 
    if (!detail.empty()) {
      out += " (";
      out += detail;
      out += ")";
    }
 
    if (has_position()) {
      out += " at argv[";
      out += std::to_string(position);
      out += "]";
    }
 
    return out;
  }

  [[nodiscard]] constexpr auto has_error() const noexcept -> bool {
    return code != ErrorCode::unknown_error;
  }
};
 
}  // namespace cli