Error.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** R-Type
** File description:
** Error.hpp, Error class declaration
*/
 
/*
** MIT License
**
** Copyright (c) 2025 Robin Toillon
**
** Permission is hereby granted, free of charge, to any person obtaining
** a copy of this software and associated documentation files (the
** "Software"), to deal in the Software without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Software, and to
** permit persons to whom the Software is furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be
** included in all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
 
#ifndef RTYPE_CORE_ERROR_HPP_
    #define RTYPE_CORE_ERROR_HPP_
 
    #include "RType/LogLevel.hpp"
 
    #include <cstdint>
    #include <format>
    #include <string>
    #include <string_view>
    #include <system_error>
    #include <utility>
 
namespace rtp
{
    enum class ErrorCode : std::uint16_t {
        Success = 0,
        
        // --- Core ---
        Unknown = 1,            
        InvalidParameter,       
        InternalRuntimeError,   
        // --- Network ---
        ConnectionFailed = 100, 
        Disconnected,           
        Timeout,                
        PayloadError,           
        // --- IO
        FileNotFound = 200,     
        LibraryLoadFailed,      
        SymbolNotFound,         
        InvalidFormat,          
        // --- ECS ---
        ComponentMissing = 300, 
        RegistryFull,           
        EntityInvalid           
    };
 
    constexpr std::string_view toString(ErrorCode e) noexcept;
 
    std::error_code make_error_code(ErrorCode e) noexcept;
}
 
namespace std
{
    template <>
    struct is_error_code_enum<rtp::ErrorCode> : true_type {};
}
 
template <>
struct std::formatter<rtp::ErrorCode> : std::formatter<std::string_view> {
    auto format(rtp::ErrorCode e, std::format_context &ctx) const
    {
        return std::formatter<std::string_view>::format(rtp::toString(e), ctx);
    }
};
 
namespace rtp {
 
    const std::error_category &rtype_category(void) noexcept;
 
    class Error final {
        public:
            template <typename ...Args>
            [[nodiscard]]
            static auto failure(ErrorCode code,
                                std::format_string<Args...> fmt,
                                Args &&...args) -> Error;
            
            template <typename ...Args>
            [[nodiscard]]
            static auto warning(ErrorCode code,
                                std::format_string<Args...> fmt,
                                Args &&...args) -> Error;
            
            template <typename ...Args>
            [[nodiscard]]
            static auto fatal(ErrorCode code,
                              std::format_string<Args...> fmt,
                              Args &&...args) -> Error;
            
            [[nodiscard]]
            ErrorCode code(void) const noexcept;
 
            [[nodiscard]]
            log::Level severity(void) const noexcept;
            
            [[nodiscard]]
            std::uint8_t retryCount(void) const noexcept;
            
            [[nodiscard]]
            auto message(void) const noexcept
                -> std::string_view;
 
            std::uint8_t incrementRetryCount(void) noexcept;
 
        private:
            ErrorCode _code;             
            log::Level _severity;        
            std::uint8_t _retryCount{0}; 
            std::string _message;        
        private:
            Error(ErrorCode code, log::Level severity, std::string_view msg);
 
    };
}
 
template <>
struct std::formatter<rtp::Error> : std::formatter<std::string> {
    inline auto format(const rtp::Error &e, format_context &ctx) const
    {
        return std::format_to(ctx.out(), "[{}] {}: {}",
                              e.severity(),
                              rtp::toString(e.code()),
                              e.message());
    }
};
 
    #include "Error.inl" /* Inline/Constexpr implementations */
    #include "Error.tpp" /* Template implementations */
 
#endif /* !RTYPE_CORE_ERROR_HPP_ */