exception_ptr.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_EXCEPTION_EXCEPTION_PTR_HPP__
#define NEFORCE_CORE_EXCEPTION_EXCEPTION_PTR_HPP__

 
#include <typeinfo>
#include "NeForce/core/async/atomic.hpp"
#include "NeForce/core/memory/unique_ptr.hpp"
NEFORCE_BEGIN_NAMESPACE__


class exception_wrapper {
public:
    virtual ~exception_wrapper() = default;

    virtual void rethrow() const = 0;

    virtual const std::type_info& type() const noexcept = 0;

    virtual unique_ptr<exception_wrapper> clone() const = 0;
};

template <typename Ex>
class typed_exception_wrapper final : public exception_wrapper {
    Ex exception_; 
 
public:
    typed_exception_wrapper(const Ex& ex) :
    exception_(ex) {}

    typed_exception_wrapper(Ex&& ex) noexcept :
    exception_(_NEFORCE move(ex)) {}

    NEFORCE_ALWAYS_INLINE void rethrow() const override { throw exception_; }

    NEFORCE_ALWAYS_INLINE const std::type_info& type() const noexcept override { return typeid(Ex); }

    NEFORCE_ALWAYS_INLINE unique_ptr<exception_wrapper> clone() const override {
        return _NEFORCE make_unique<typed_exception_wrapper>(exception_);
    }
};
 

class exception_ptr {
public:
    struct ecb {
        unique_ptr<exception_wrapper> wrapper; 
        atomic<int> ref_count{1};              

        explicit ecb(unique_ptr<exception_wrapper> wrapper) :
        wrapper(_NEFORCE move(wrapper)) {}

        NEFORCE_ALWAYS_INLINE void add_ref() noexcept { ref_count.fetch_add(1, memory_order_relaxed); }

        NEFORCE_ALWAYS_INLINE void release() noexcept {
            if (ref_count.load(memory_order_acquire) == 1 || ref_count.fetch_sub(1, memory_order_acq_rel) == 1) {
                delete this;
            }
        }
    };
 
private:
    ecb* ecb_{nullptr}; 

    explicit exception_ptr(ecb* cb) noexcept :
    ecb_(cb) {}
 
    template <typename Ex>
    friend exception_ptr make_exception_ptr(Ex) noexcept;
 
    friend exception_ptr NEFORCE_API current_exception() noexcept;
 
    friend void NEFORCE_API rethrow_exception(const exception_ptr&);
 
    template <typename Ex>
    friend exception_ptr make_exception_ptr(Ex ex) noexcept;
 
public:
    exception_ptr(nullptr_t np = nullptr) noexcept {}

    exception_ptr(const exception_ptr& other) noexcept :
    ecb_(other.ecb_) {
        if (ecb_) {
            ecb_->add_ref();
        }
    }

    exception_ptr(exception_ptr&& other) noexcept :
    ecb_(other.ecb_) {
        other.ecb_ = nullptr;
    }

    ~exception_ptr() noexcept {
        if (ecb_) {
            ecb_->release();
        }
    }

    exception_ptr& operator=(const exception_ptr& other) noexcept {
        if (addressof(other) == this) {
            return *this;
        }
        exception_ptr temp(other);
        swap(temp);
        return *this;
    }

    exception_ptr& operator=(exception_ptr&& other) noexcept {
        if (addressof(other) == this) {
            return *this;
        }
        exception_ptr temp(_NEFORCE move(other));
        swap(temp);
        return *this;
    }

    void swap(exception_ptr& other) noexcept { _NEFORCE swap(ecb_, other.ecb_); }

    explicit operator bool() const noexcept { return ecb_ != nullptr; }

    bool operator==(const exception_ptr& rhs) const noexcept { return ecb_ == rhs.ecb_; }

    bool operator!=(const exception_ptr& rhs) const noexcept { return !(*this == rhs); }

    bool operator==(nullptr_t) const noexcept { return !static_cast<bool>(*this); }

    friend bool operator==(nullptr_t, const exception_ptr& ptr) noexcept { return !ptr; }

    bool operator!=(nullptr_t) const noexcept { return static_cast<bool>(*this); }

    friend bool operator!=(nullptr_t, const exception_ptr& ptr) noexcept { return static_cast<bool>(ptr); }

    NEFORCE_NODISCARD const std::type_info& exception_type() const noexcept {
        if (!ecb_ || !ecb_->wrapper) {
            return typeid(void);
        }
        return ecb_->wrapper->type();
    }
};
 

template <typename Ex>
exception_ptr make_exception_ptr(Ex ex) noexcept {
    try {
        auto wrapper = _NEFORCE make_unique<typed_exception_wrapper<decay_t<Ex>>>(_NEFORCE forward<Ex>(ex));
        unique_ptr<exception_ptr::ecb> control_block(new exception_ptr::ecb(_NEFORCE move(wrapper)));
        exception_ptr result;
        result.ecb_ = control_block.release();
        return result;
    } catch (...) {
        return exception_ptr();
    }
}

exception_ptr NEFORCE_API current_exception() noexcept;

void NEFORCE_API rethrow_exception(const exception_ptr& p);
 // ExceptionHandling
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_EXCEPTION_EXCEPTION_PTR_HPP__