exception.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_CONFIG_EXCEPTION_HPP__
#define NEFORCE_CORE_CONFIG_EXCEPTION_HPP__

 
#include "NeForce/core/memory/memory.hpp"
NEFORCE_BEGIN_NAMESPACE__

 
#define __NEFORCE_ERROR_CONSTRUCTOR(THIS, BASE, INFO)                                                     \
    explicit THIS(const char* info = INFO, const char* type = static_type, const int code = 0) noexcept : \
    BASE(info, type, code) {}                                                                             \
                                                                                                          \
    explicit THIS(const exception& e) :                                                                   \
    BASE(e) {}
 
#define __NEFORCE_ERROR_DERIVED_DESTRUCTOR(CLASS) virtual ~CLASS() = default;
 
#define __NEFORCE_ERROR_FINAL_DESTRUCTOR(CLASS) ~CLASS() override = default;
 
#define __NEFORCE_ERROR_TYPE(CLASS) static constexpr auto static_type = #CLASS;

#define NEFORCE_ERROR_BUILD_DERIVED_CLASS(THIS, BASE, INFO) \
    struct THIS : BASE {                                    \
        __NEFORCE_ERROR_CONSTRUCTOR(THIS, BASE, INFO)       \
        __NEFORCE_ERROR_DERIVED_DESTRUCTOR(THIS)            \
        __NEFORCE_ERROR_TYPE(THIS)                          \
    };

#define NEFORCE_ERROR_BUILD_FINAL_CLASS(THIS, BASE, INFO) \
    struct THIS final : BASE {                            \
        __NEFORCE_ERROR_CONSTRUCTOR(THIS, BASE, INFO)     \
        __NEFORCE_ERROR_FINAL_DESTRUCTOR(THIS)            \
        __NEFORCE_ERROR_TYPE(THIS)                        \
    };


struct exception {
private:
    static constexpr size_t INFO_SIZE = 256; // 异常信息长度
    static constexpr size_t TYPE_SIZE = 48;  // 类型名称长度
 
    char info_[INFO_SIZE]; // 异常信息
    char type_[TYPE_SIZE]; // 异常类型
    int code_{0};
 
public:
    explicit exception(const char* info = static_type, const char* type = static_type, const int code = 0) :
    code_(code) {
        string_copy(info_, info, INFO_SIZE - 1);
        string_copy(type_, type, TYPE_SIZE - 1);
        info_[INFO_SIZE - 1] = '\0';
        type_[TYPE_SIZE - 1] = '\0';
    }

    exception(const exception& other) noexcept {
        memory_copy(info_, other.info_, INFO_SIZE);
        memory_copy(type_, other.type_, TYPE_SIZE);
        code_ = other.code_;
    }

    exception& operator=(const exception& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
 
        memory_copy(info_, other.info_, INFO_SIZE);
        memory_copy(type_, other.type_, TYPE_SIZE);
        code_ = other.code_;
 
        return *this;
    }

    exception(exception&& other) noexcept {
        memory_copy(this, &other);
        other.info_[0] = '\0';
        other.type_[0] = '\0';
        other.code_ = 0;
    }

    exception& operator=(exception&& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
 
        memory_copy(info_, other.info_, INFO_SIZE);
        memory_copy(type_, other.type_, TYPE_SIZE);
        other.info_[0] = '\0';
        other.type_[0] = '\0';
        other.code_ = 0;
 
        return *this;
    }

    template <typename Error>
    explicit exception(const Error& error) :
    exception(error.what(), error.type(), error.code()) {}

    virtual ~exception() = default;

    NEFORCE_NODISCARD const char* what() const noexcept { return info_; }

    NEFORCE_NODISCARD const char* type() const noexcept { return type_; }

    NEFORCE_NODISCARD int code() const noexcept { return code_; }
 
    static constexpr auto static_type = "exception"; 
};

NEFORCE_ERROR_BUILD_DERIVED_CLASS(memory_exception, exception, "Memory Operation Failed.")
 

NEFORCE_ERROR_BUILD_DERIVED_CLASS(system_exception, exception, "System Access Failed.")

NEFORCE_ERROR_BUILD_FINAL_CLASS(iterator_exception, memory_exception, "Iterator or Pointer Access Invalid.")

NEFORCE_ERROR_BUILD_DERIVED_CLASS(typecast_exception, memory_exception, "Type Cast Mismatch.")

NEFORCE_ERROR_BUILD_DERIVED_CLASS(value_exception, exception, "Variable Operation Invalid.")

NEFORCE_ERROR_BUILD_DERIVED_CLASS(device_exception, system_exception, "Device Operation Failed.")

NEFORCE_ERROR_BUILD_FINAL_CLASS(file_exception, system_exception, "File Operation Failed.")

NEFORCE_ERROR_BUILD_FINAL_CLASS(math_exception, value_exception, "Math Calculation Invalid.")

NEFORCE_ERROR_BUILD_DERIVED_CLASS(thirdparty_exception, exception, "ThirdParty Operation Invalid.")

NEFORCE_ERROR_BUILD_DERIVED_CLASS(database_exception, thirdparty_exception, "Database Operation Failed.")

NEFORCE_ERROR_BUILD_DERIVED_CLASS(network_exception, exception, "Network Operation or Action Failed.")
 // Exceptions

int NEFORCE_API uncaught_exceptions() noexcept NEFORCE_PURE_FUNCTION;

void NEFORCE_API throw_with_stack(const exception& err);
 
#if defined(NEFORCE_STATE_DEBUG) || !defined(NDEBUG)
#    define NEFORCE_THROW_EXCEPTION(err) throw_with_stack(err)
#else
#    define NEFORCE_THROW_EXCEPTION(err) throw err
#endif
 
#define NEFORCE_ASSERTION(COND) \
    if (!(COND)) {              \
        _NEFORCE terminate();   \
    }
 // ExceptionHandling
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_CONFIG_EXCEPTION_HPP__