parse_result.h

Go to the documentation of this file.

#ifndef OOKII_PARSE_RESULT_H_
#define OOKII_PARSE_RESULT_H_
 
#pragma once
 
#include "format_helper.h"
 
namespace ookii
{
    namespace details
    {
        template<typename CharType>
        struct error_formats
        {
            static constexpr auto invalid_value = literal_cast<CharType>("The value provided for the argument '{}' was invalid.");
            static constexpr auto unknown_argument = literal_cast<CharType>("Unknown argument name '{}'.");
            static constexpr auto missing_value = literal_cast<CharType>("No value was supplied for the argument '{}'.");
            static constexpr auto duplicate_argument = literal_cast<CharType>("The argument '{}' was supplied more than once.");
            static constexpr auto too_many_arguments = literal_cast<CharType>("Too many arguments were supplied.");
            static constexpr auto missing_required_argument = literal_cast<CharType>("The required argument '{}' was not supplied.");
            static constexpr auto unknown = literal_cast<CharType>("An unknown error has occurred.");
        };
    }
 
    enum class parse_error
    {
        none,
 
        parsing_cancelled,
 
        invalid_value,
 
        unknown_argument,
 
        missing_value,
 
        duplicate_argument,
 
        too_many_arguments,
 
        missing_required_argument
    };
 
    template<typename CharType, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    struct [[nodiscard]] parse_result
    {
        using string_type = std::basic_string<CharType, Traits, Alloc>;
 
        parse_result(parse_error error = parse_error::none, string_type error_arg_name = {})
            : error{error},
              error_arg_name{error_arg_name}
        {
        }
 
        parse_error error;
 
        string_type error_arg_name;
 
        operator bool() const noexcept
        {
            return error == parse_error::none;
        }
 
        string_type get_error_message(const std::locale &loc = {}) const
        {
            switch (error)
            {
            case parse_error::none:
            case parse_error::parsing_cancelled:
                return {};
 
            case parse_error::invalid_value:
                return OOKII_FMT_NS format(loc, details::error_formats<CharType>::invalid_value.data(), error_arg_name);
 
            case parse_error::unknown_argument:
                return OOKII_FMT_NS format(loc, details::error_formats<CharType>::unknown_argument.data(), error_arg_name);
 
            case parse_error::missing_value:
                return OOKII_FMT_NS format(loc, details::error_formats<CharType>::missing_value.data(), error_arg_name);
 
            case parse_error::duplicate_argument:
                return OOKII_FMT_NS format(loc, details::error_formats<CharType>::duplicate_argument.data(), error_arg_name);
 
            case parse_error::too_many_arguments:
                return OOKII_FMT_NS format(loc, details::error_formats<CharType>::too_many_arguments.data(), error_arg_name);
 
            case parse_error::missing_required_argument:
                return OOKII_FMT_NS format(loc, details::error_formats<CharType>::missing_required_argument.data(), error_arg_name);
 
            default:
                return OOKII_FMT_NS format(loc, details::error_formats<CharType>::unknown.data(), error_arg_name);
            }
        }
    };
}
 
#endif