exception.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_CONFIG_EXCEPTION_HPP__
#define MSTL_CORE_CONFIG_EXCEPTION_HPP__

 
#include "MSTL/core/memory/memory.hpp"
MSTL_BEGIN_NAMESPACE__

 
#define __MSTL_ERROR_CONSTRUCTOR(THIS, BASE, INFO) \
    explicit THIS(const char* info = INFO, const char* type = static_type) noexcept \
        : BASE(info, type) {} \
    explicit THIS(const exception& e) : BASE(e) {}
 
#define __MSTL_ERROR_DERIVED_DESTRUCTOR(CLASS) \
    virtual ~CLASS() = default;
 
#define __MSTL_ERROR_FINAL_DESTRUCTOR(CLASS) \
    ~CLASS() override = default;
 
#define __MSTL_ERROR_TYPE(CLASS) \
    static constexpr auto static_type = #CLASS;

#define MSTL_ERROR_BUILD_DERIVED_CLASS(THIS, BASE, INFO) \
    struct MSTL_API THIS : BASE { \
        __MSTL_ERROR_CONSTRUCTOR(THIS, BASE, INFO) \
        __MSTL_ERROR_DERIVED_DESTRUCTOR(THIS) \
        __MSTL_ERROR_TYPE(THIS) \
    };

#define MSTL_ERROR_BUILD_FINAL_CLASS(THIS, BASE, INFO) \
    struct MSTL_API THIS final : BASE { \
        __MSTL_ERROR_CONSTRUCTOR(THIS, BASE, INFO) \
        __MSTL_ERROR_FINAL_DESTRUCTOR(THIS) \
        __MSTL_ERROR_TYPE(THIS) \
    };


struct MSTL_API 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 (_MSTL 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 (_MSTL 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;

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

    MSTL_NODISCARD const char* type() const noexcept { return type_; }
    
    MSTL_NODISCARD int code() const noexcept { return code_; }
 
    __MSTL_ERROR_TYPE(exception)  
};

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

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

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

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

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

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

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

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

MSTL_ERROR_BUILD_DERIVED_CLASS(database_exception, system_exception, "Database Operation Failed.")
 // Exceptions

void MSTL_API throw_with_stack(const exception& err);
 
#if defined(MSTL_STATE_DEBUG__) || !defined(NDEBUG)
#define throw_exception(err) throw_with_stack(err)
#else
#define throw_exception(err) throw err
#endif
 // ExceptionHandling
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_CONFIG_EXCEPTION_HPP__