error.hpp

//
// error.hpp
// *********
//
// Copyright (c) 2019 Sharon W (sharon at aegis dot gg)
//
// Distributed under the MIT License. (See accompanying file LICENSE)
//

#pragma once

#include "aegis/config.hpp"
#include <exception>
#include <string>
#include <utility>
#include <system_error>

namespace aegis
{
using err_str_pair = std::pair<std::error_code, std::string>;

using error_code = std::error_code;

enum error
{
    general = 1,

    invalid_token,

    invalid_state,

    get_gateway,

    no_gateway,

    no_permission,

    not_implemented,

    member_not_found,

    channel_not_found,

    guild_not_found,

    rate_limited,

    global_rate_limited,

    member_error,

    channel_error,

    guild_error,

    shard_error,

    bad_request,

    bad_redis_request,

    bulk_delete_out_of_range,

    invalid_intents,

    disallowed_intents,

    max_errors
};

class category : public std::error_category
{
public:
    category() = default;

    char const * name() const noexcept override
    {
        return "aegis";
    }

    std::string message(int val) const override
    {
        switch (val)
        {
            case error::general:
                return "Generic error";
            case error::invalid_token:
                return "Token invalid";
            case error::invalid_state:
                return "Invalid state";
            case error::get_gateway:
                return "Unable to retrieve gateway data";
            case error::no_gateway:
                return "No gateway url set";
            case error::no_permission:
                return "No permission for this action";
            case error::not_implemented:
                return "Feature not yet implemented";
            case error::member_not_found:
                return "Member not found";
            case error::channel_not_found:
                return "Channel not found";
            case error::guild_not_found:
                return "Guild not found";
            case error::rate_limited:
                return "Rate limited";
            case error::global_rate_limited:
                return "Globally rate limited";
            case error::member_error:
                return "Member related error";
            case error::channel_error:
                return "Channel related error";
            case error::guild_error:
                return "Guild related error";
            case error::shard_error:
                return "Shard related error";
            case error::bad_request:
                return "Bad request";
            case error::bad_redis_request:
                return "Bad Redis request";
            case error::bulk_delete_out_of_range:
                return "Bulk delete invalid message amount";
            case error::invalid_intents:
                return "Invalid intents";
            case error::disallowed_intents:
                return "Disallowed intents";
            default:
                return "Unknown";
        }
    }
};

inline const std::error_category & get_category()
{
    static category instance;
    return instance;
}

inline std::error_code make_error_code(error e)
{
    return std::error_code(static_cast<int>(e), get_category());
}

class exception : public std::exception
{
public:
    exception(std::string const & msg, std::error_code ec = make_error_code(error::general))
        : _msg(msg.empty() ? ec.message() : msg)
        , _code(ec)
    {
    }

    explicit exception(std::error_code ec)
        : _msg(ec.message())
        , _code(ec)
    {
    }

    ~exception() = default;

    virtual char const * what() const noexcept override
    {
        return _msg.c_str();
    }

    std::error_code code() const noexcept
    {
        return _code;
    }

    const std::string _msg;
    std::error_code _code;
};

}

namespace std
{

template<> struct is_error_code_enum<aegis::error>
{
    static const bool value = true;
};

}