exception_ptr.hpp

浏览该文件的文档.

#ifndef MSTL_CORE_EXCEPTION_EXCEPTION_PTR_HPP__
#define MSTL_CORE_EXCEPTION_EXCEPTION_PTR_HPP__

 
#include "MSTL/core/async/atomic.hpp"
#include "MSTL/core/memory/unique_ptr.hpp"
#include <typeinfo>
MSTL_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_(_MSTL move(ex)) {}

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

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

    MSTL_ALWAYS_INLINE unique_ptr<exception_wrapper> clone() const override {
        return _MSTL 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(_MSTL move(wrapper)) {}

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

        MSTL_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 MSTL_API current_exception() noexcept;
 
    friend void MSTL_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 (this != &other) {
            exception_ptr temp(other);
            swap(temp);
        }
        return *this;
    }

    exception_ptr& operator =(exception_ptr&& other) noexcept {
        if (this != &other) {
            exception_ptr temp(_MSTL move(other));
            _MSTL swap(ecb_, other.ecb_);
        }
        return *this;
    }

    void swap(exception_ptr& other) noexcept {
        _MSTL 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);
    }

    MSTL_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 = _MSTL make_unique<typed_exception_wrapper<decay_t<Ex>>>(_MSTL forward<Ex>(ex));
        unique_ptr<exception_ptr::ecb> control_block(new exception_ptr::ecb(_MSTL move(wrapper)));
        exception_ptr result;
        result.ecb_ = control_block.release();
        return result;
    } catch (...) {
        return exception_ptr();
    }
}

exception_ptr MSTL_API current_exception() noexcept;

void MSTL_API rethrow_exception(const exception_ptr& p);
 
MSTL_END_NAMESPACE__
#endif // MSTL_CORE_EXCEPTION_EXCEPTION_PTR_HPP__