exceptions.hpp

#pragma once
 
#include <optional>
#include <stdexcept>
#include <source_location>
#include <stacktrace>
#include <string>
#include <type_traits>
#include <format>
 
namespace LiteFX {
 
    class Exception : public std::runtime_error {
    private:
        std::source_location m_location;
        std::stacktrace m_trace;
 
    protected:
        explicit Exception(const std::string& message, const std::source_location& location, std::stacktrace trace) :
            std::runtime_error(message), m_location(location), m_trace(std::move(trace)) { }
 
    public:
        Exception(const Exception&) = default;
        Exception(Exception&&) noexcept = default;
        ~Exception() noexcept override = default;
 
        Exception& operator=(const Exception&) = default;
        Exception& operator=(Exception&&) noexcept = default;
 
    public:
        const std::source_location& location() const noexcept {
            return m_location;
        }
 
        const std::stacktrace& trace() const noexcept {
            return m_trace;
        }
    };
 
    class InvalidArgumentException : public Exception {
    private:
        std::string m_argument;
 
    public:
        explicit InvalidArgumentException(std::string_view argument) :
            Exception(std::format("Invalid argument provided: {}.", argument), std::source_location::current(), std::stacktrace::current()), m_argument(argument) { }
 
        explicit InvalidArgumentException(std::string_view argument, std::string_view message) :
            Exception(std::format("Invalid argument provided: {}. {}", argument, message), std::source_location::current(), std::stacktrace::current()), m_argument(argument) { }
 
        template <typename ...TArgs>
        explicit InvalidArgumentException(std::string_view argument, std::format_string<TArgs...> format, TArgs&&... args) :
            Exception(std::format("Invalid argument provided: {}. {}", argument, std::format(format, std::forward<TArgs>(args)...)), std::source_location::current(), std::stacktrace::current()), m_argument(argument) { }
 
        InvalidArgumentException(const InvalidArgumentException&) = default;
        InvalidArgumentException(InvalidArgumentException&&) noexcept = default;
        ~InvalidArgumentException() noexcept override = default;
 
        InvalidArgumentException& operator=(const InvalidArgumentException&) = default;
        InvalidArgumentException& operator=(InvalidArgumentException&&) noexcept = default;
 
    public:
        const std::string& argument() const noexcept {
            return m_argument;
        }
    };
 
    class ArgumentOutOfRangeException : public Exception {
    private:
        std::string m_argument;
 
    public:
        explicit ArgumentOutOfRangeException(std::string_view argument) :
            Exception(std::format("Argument was out of range: {}.", argument), std::source_location::current(), std::stacktrace::current()), m_argument(argument) { }
 
        explicit ArgumentOutOfRangeException(std::string_view argument, std::string_view message) :
            Exception(std::format("Argument was out of range: {}. {}", argument, message), std::source_location::current(), std::stacktrace::current()), m_argument(argument) { }
 
        //template <typename T>
        //explicit ArgumentOutOfRangeException(std::string_view argument, std::pair<T, T> validRange, T value, std::string_view message) :
        //  Exception(std::format("Argument was out of range: {} (valid range is [{}, {}] but provided value was {}). {}", argument, validRange.first, validRange.second, value, message), std::source_location::current(), std::stacktrace::current()), m_argument(argument) { }
 
        template <typename ...TArgs>
        explicit ArgumentOutOfRangeException(std::string_view argument, std::format_string<TArgs...> format, TArgs&&... args) :
            Exception(std::format("Argument was out of range: {}. {}", argument, std::format(format, std::forward<TArgs>(args)...)), std::source_location::current(), std::stacktrace::current()), m_argument(argument) { }
 
        template <typename T, typename ...TArgs>
        explicit ArgumentOutOfRangeException(std::string_view argument, std::pair<T, T> validRange, T value, std::format_string<TArgs...> format, TArgs&&... args) :
            Exception(std::format("Argument was out of range: {} (valid range is [{}, {}) but actual value was {}). {}", argument, validRange.first, validRange.second, value, std::format(format, std::forward<TArgs>(args)...)), std::source_location::current(), std::stacktrace::current()), m_argument(argument) { }
 
        ArgumentOutOfRangeException(const ArgumentOutOfRangeException&) = default;
        ArgumentOutOfRangeException(ArgumentOutOfRangeException&&) noexcept = default;
        ~ArgumentOutOfRangeException() noexcept override = default;
 
        ArgumentOutOfRangeException& operator=(const ArgumentOutOfRangeException&) = default;
        ArgumentOutOfRangeException& operator=(ArgumentOutOfRangeException&&) noexcept = default;
 
    public:
        const std::string& argument() const noexcept {
            return m_argument;
        }
    };
 
    class ArgumentNotInitializedException : public Exception {
    private:
        std::string m_argument;
 
    public:
        explicit ArgumentNotInitializedException(std::string_view argument) :
            Exception(std::format("Argument was not initialized: {}.", argument), std::source_location::current(), std::stacktrace::current()), m_argument(argument) { }
 
        explicit ArgumentNotInitializedException(std::string_view argument, std::string_view message) :
            Exception(std::format("Argument was not initialized: {}. {}", argument, message), std::source_location::current(), std::stacktrace::current()), m_argument(argument) { }
 
        template <typename ...TArgs>
        explicit ArgumentNotInitializedException(std::string_view argument, std::format_string<TArgs...> format, TArgs&&... args) :
            Exception(std::format("Argument was not initialized: {}. {}", argument, std::format(format, std::forward<TArgs>(args)...)), std::source_location::current(), std::stacktrace::current()), m_argument(argument) { }
 
        ArgumentNotInitializedException(const ArgumentNotInitializedException&) = default;
        ArgumentNotInitializedException(ArgumentNotInitializedException&&) noexcept = default;
        ~ArgumentNotInitializedException() noexcept override = default;
 
        ArgumentNotInitializedException& operator=(const ArgumentNotInitializedException&) = default;
        ArgumentNotInitializedException& operator=(ArgumentNotInitializedException&&) noexcept = default;
 
    public:
        const std::string& argument() const noexcept {
            return m_argument;
        }
    };
 
    class RuntimeException : public Exception {
    public:
        explicit RuntimeException() :
            Exception("The operation could not be executed.", std::source_location::current(), std::stacktrace::current()) { }
 
        explicit RuntimeException(std::string_view message) :
            Exception(std::format("The operation could not be executed: {}", message), std::source_location::current(), std::stacktrace::current()) { }
 
        template <typename ...TArgs>
        explicit RuntimeException(std::format_string<TArgs...> format, TArgs&&... args) :
            Exception(std::format("The operation could not be executed: {}", std::format(format, std::forward<TArgs>(args)...)), std::source_location::current(), std::stacktrace::current()) { }
 
        RuntimeException(const RuntimeException&) = default;
        RuntimeException(RuntimeException&&) noexcept = default;
        ~RuntimeException() noexcept override = default;
 
        RuntimeException& operator=(const RuntimeException&) = default;
        RuntimeException& operator=(RuntimeException&&) noexcept = default;
    };
};