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) noexcept : \
    BASE(info) {}                                     \
                                                      \
    explicit THIS(const exception& e) :               \
    BASE(e) {}
 
#define __NEFORCE_ERROR_DERIVED_DESTRUCTOR(CLASS) ~CLASS() override = default;
 
#define __NEFORCE_ERROR_FINAL_DESTRUCTOR(CLASS) ~CLASS() override = default;
 
#define __NEFORCE_ERROR_TYPE(CLASS) \
    NEFORCE_NODISCARD const char* type() const noexcept override { return #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; // 异常信息长度
 
    char info_[INFO_SIZE]; // 异常信息
 
public:
    explicit exception(const char* info = "") {
        string_copy(info_, info, INFO_SIZE - 1);
        // NOLINTNEXTLINE(clang-analyzer-core.NullDereference)
        info_[INFO_SIZE - 1] = '\0';
    }

    exception(const exception& other) noexcept { memory_copy(info_, other.info_, INFO_SIZE); }

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

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

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

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

    virtual ~exception() = default;

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

    NEFORCE_NODISCARD virtual const char* type() const noexcept { return "exception"; }
};

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

NEFORCE_ERROR_BUILD_DERIVED_CLASS(allocate_exception, memory_exception, "Memory Allocation 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_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.")
 // Exceptions

int NEFORCE_API uncaught_exceptions() noexcept;

NEFORCE_NORETURN void NEFORCE_API throw_with_stack(const exception& err);
 
#if (defined(NEFORCE_STATE_DEBUG) || !defined(NDEBUG)) && 0 // 0 switch
#    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__