exception.hpp

// Copyright (C) 2022-2023 by Camden Mannett.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "arg_router/basic_types.hpp"
#include "arg_router/traits.hpp"
#include "arg_router/utility/exception_formatter.hpp"
 
#include <exception>
 
namespace arg_router
{
enum class error_code : std::size_t {
    // Common
    unknown_argument = 0,  
    unhandled_arguments,   
    argument_has_already_been_set,  
    failed_to_parse,                
    no_arguments_passed,        
    minimum_value_not_reached,  
    maximum_value_exceeded,     
    minimum_count_not_reached,  
    maximum_count_exceeded,     
    unknown_argument_with_suggestion,  
 
    // Builtin node specific
    mode_requires_arguments = 100,  
    missing_required_argument,      
    too_few_values_for_alias,       
    dependent_argument_missing,     
    one_of_selected_type_mismatch,  
    missing_value_separator,        
};
 
struct default_error_code_translations {
    using error_code_translations = std::tuple<
        std::pair<traits::integral_constant<error_code::unknown_argument>,
                  AR_STRING("Unknown argument")>,
        std::pair<traits::integral_constant<error_code::unhandled_arguments>,
                  AR_STRING("Unhandled arguments")>,
        std::pair<traits::integral_constant<error_code::argument_has_already_been_set>,
                  AR_STRING("Argument has already been set")>,
        std::pair<traits::integral_constant<error_code::failed_to_parse>,
                  AR_STRING("Failed to parse")>,
        std::pair<traits::integral_constant<error_code::no_arguments_passed>,
                  AR_STRING("No arguments passed")>,
        std::pair<traits::integral_constant<error_code::minimum_value_not_reached>,
                  AR_STRING("Minimum value not reached")>,
        std::pair<traits::integral_constant<error_code::maximum_value_exceeded>,
                  AR_STRING("Maximum value exceeded")>,
        std::pair<traits::integral_constant<error_code::minimum_count_not_reached>,
                  AR_STRING("Minimum count not reached")>,
        std::pair<traits::integral_constant<error_code::maximum_count_exceeded>,
                  AR_STRING("Maximum count exceeded")>,
        std::pair<traits::integral_constant<error_code::unknown_argument_with_suggestion>,
                  AR_STRING("Unknown argument: {}. Did you mean { }?")>,
        std::pair<traits::integral_constant<error_code::mode_requires_arguments>,
                  AR_STRING("Mode requires arguments")>,
        std::pair<traits::integral_constant<error_code::missing_required_argument>,
                  AR_STRING("Missing required argument")>,
        std::pair<traits::integral_constant<error_code::too_few_values_for_alias>,
                  AR_STRING("Too few values for alias")>,
        std::pair<traits::integral_constant<error_code::dependent_argument_missing>,
                  AR_STRING("Dependent argument missing (needs to be before the "
                            "requiring token on the command line)")>,
        std::pair<traits::integral_constant<error_code::one_of_selected_type_mismatch>,
                  AR_STRING("Only one argument from a \"One Of\" can be used at once")>,
        std::pair<traits::integral_constant<error_code::missing_value_separator>,
                  AR_STRING("Expected a value separator")>>;
};
 
class multi_lang_exception : public std::exception
{
public:
    explicit multi_lang_exception(error_code ec) noexcept : ec_{ec} {}
 
    multi_lang_exception(error_code ec, const parsing::token_type& token) : ec_{ec}, tokens_{token}
    {
    }
 
    multi_lang_exception(error_code ec, vector<parsing::token_type> tokens) noexcept :
        ec_{ec}, tokens_(std::move(tokens))
    {
    }
 
    [[nodiscard]] error_code ec() const noexcept { return ec_; }
 
    [[nodiscard]] const vector<parsing::token_type>& tokens() const noexcept { return tokens_; }
 
private:
    error_code ec_;
    vector<parsing::token_type> tokens_;
};
 
class parse_exception : public std::exception
{
public:
    explicit parse_exception(const string& message,
                             const vector<parsing::token_type>& tokens = {}) :
        message_{message + (tokens.empty() ? "" : ": " + parsing::to_string(tokens))}
    {
    }
 
    parse_exception(const string& message, const parsing::token_type& token) :
        message_{message + ": " + parsing::to_string(token)}
    {
    }
 
    template <typename S>
    parse_exception(utility::exception_formatter<S> cts,
                    const vector<parsing::token_type>& tokens = {}) :
        message_{cts.format(tokens)}
    {
    }
 
    [[nodiscard]] const char* what() const noexcept override { return message_.data(); }
 
private:
    string message_;
};
}  // namespace arg_router