weak_ptr.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_MEMORY_WEAK_PTR_HPP__
#define NEFORCE_CORE_MEMORY_WEAK_PTR_HPP__

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


template <typename T>
class weak_ptr {
public:
    using element_type = T; 
 
private:
    element_type* ptr_ = nullptr;                 
    inner::__smart_ptr_counter* owner_ = nullptr; 
 
    template <typename U>
    friend class weak_ptr;
 
    template <typename U>
    friend class shared_ptr;
 
    template <typename U>
    friend class inner::smart_pointer_atomic;
 
public:
    weak_ptr(nullptr_t = nullptr) noexcept {}

    template <typename U, enable_if_t<is_convertible_v<U*, T*>, int> = 0>
    weak_ptr(const shared_ptr<U>& shared) noexcept :
    ptr_(shared.get()),
    owner_(reinterpret_cast<inner::__smart_ptr_counter*>(shared.owner_)) {
        if (owner_) {
            owner_->incref_weak();
        }
    }

    weak_ptr(const weak_ptr& other) noexcept :
    ptr_(other.ptr_),
    owner_(other.owner_) {
        if (owner_) {
            owner_->incref_weak();
        }
    }

    template <typename U, enable_if_t<is_convertible_v<U*, T*>, int> = 0>
    weak_ptr(const weak_ptr<U>& other) noexcept :
    ptr_(other.ptr_),
    owner_(other.owner_) {
        if (owner_) {
            owner_->incref_weak();
        }
    }

    weak_ptr(weak_ptr&& other) noexcept :
    ptr_(other.ptr_),
    owner_(other.owner_) {
        other.ptr_ = nullptr;
        other.owner_ = nullptr;
    }

    template <typename U, enable_if_t<is_convertible_v<U*, T*>, int> = 0>
    weak_ptr(weak_ptr<U>&& other) noexcept :
    ptr_(other.ptr_),
    owner_(other.owner_) {
        other.ptr_ = nullptr;
        other.owner_ = nullptr;
    }

    ~weak_ptr() { reset(); }

    weak_ptr& operator=(const weak_ptr& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        if (owner_) {
            owner_->decref_weak();
        }
        ptr_ = other.ptr_;
        owner_ = other.owner_;
        if (owner_) {
            owner_->incref_weak();
        }
        return *this;
    }

    template <typename U, enable_if_t<is_convertible_v<U*, T*>, int> = 0>
    weak_ptr& operator=(const weak_ptr<U>& other) noexcept {
        if (owner_) {
            owner_->decref_weak();
        }
        ptr_ = other.ptr_;
        owner_ = other.owner_;
        if (owner_) {
            owner_->incref_weak();
        }
        return *this;
    }

    template <typename U, enable_if_t<is_convertible_v<U*, T*>, int> = 0>
    weak_ptr& operator=(const shared_ptr<U>& shared) noexcept {
        if (owner_) {
            owner_->decref_weak();
        }
        ptr_ = shared.get();
        owner_ = reinterpret_cast<inner::__smart_ptr_counter*>(shared.owner_);
        if (owner_) {
            owner_->incref_weak();
        }
        return *this;
    }

    weak_ptr& operator=(weak_ptr&& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return *this;
        }
        if (owner_) {
            owner_->decref_weak();
        }
        ptr_ = other.ptr_;
        owner_ = other.owner_;
        other.ptr_ = nullptr;
        other.owner_ = nullptr;
        return *this;
    }

    template <typename U, enable_if_t<is_convertible_v<U*, T*>, int> = 0>
    weak_ptr& operator=(weak_ptr<U>&& other) noexcept {
        if (owner_) {
            owner_->decref_weak();
        }
        ptr_ = other.ptr_;
        owner_ = other.owner_;
        other.ptr_ = nullptr;
        other.owner_ = nullptr;
        return *this;
    }

    void reset() noexcept {
        if (owner_) {
            owner_->decref_weak();
            owner_ = nullptr;
        }
        ptr_ = nullptr;
    }

    void swap(weak_ptr& other) noexcept {
        if (_NEFORCE addressof(other) == this) {
            return;
        }
        _NEFORCE swap(ptr_, other.ptr_);
        _NEFORCE swap(owner_, other.owner_);
    }

    NEFORCE_NODISCARD long use_count() const noexcept { return owner_ ? static_cast<long>(owner_->use_count()) : 0; }

    NEFORCE_NODISCARD bool expired() const noexcept { return use_count() == 0; }

    NEFORCE_NODISCARD shared_ptr<T> lock() const noexcept {
        if (owner_ && owner_->try_incref_strong()) {
            return shared_ptr<T>(ptr_, owner_);
        }
        return shared_ptr<T>();
    }

    template <typename U>
    NEFORCE_NODISCARD bool owner_equal(const weak_ptr<U>& rhs) const noexcept {
        return owner_ == rhs.owner_;
    }

    template <typename U>
    NEFORCE_NODISCARD bool owner_equal(const shared_ptr<U>& rhs) const noexcept {
        return owner_ == reinterpret_cast<inner::__smart_ptr_counter*>(rhs.owner_);
    }

    template <typename U>
    NEFORCE_NODISCARD bool owner_before(const weak_ptr<U>& rhs) const noexcept {
        return owner_ < rhs.owner_;
    }

    template <typename U>
    NEFORCE_NODISCARD bool owner_before(const shared_ptr<U>& rhs) const noexcept {
        return owner_ < reinterpret_cast<inner::__smart_ptr_counter*>(rhs.owner_);
    }
};
 

template <typename T>
struct owner_less;

template <typename T>
struct owner_less<shared_ptr<T>> {
    using is_transparent = void; 

    NEFORCE_NODISCARD bool operator()(const shared_ptr<T>& lhs, const shared_ptr<T>& rhs) const noexcept {
        return lhs.owner_before(rhs);
    }

    NEFORCE_NODISCARD bool operator()(const shared_ptr<T>& lhs, const weak_ptr<T>& rhs) const noexcept {
        return lhs.owner_before(rhs);
    }

    NEFORCE_NODISCARD bool operator()(const weak_ptr<T>& lhs, const shared_ptr<T>& rhs) const noexcept {
        return lhs.owner_before(rhs);
    }
};

template <typename T>
struct owner_less<weak_ptr<T>> {
    using is_transparent = void; 

    NEFORCE_NODISCARD bool operator()(const weak_ptr<T>& lhs, const weak_ptr<T>& rhs) const noexcept {
        return lhs.owner_before(rhs);
    }

    NEFORCE_NODISCARD bool operator()(const weak_ptr<T>& lhs, const shared_ptr<T>& rhs) const noexcept {
        return lhs.owner_before(rhs);
    }

    NEFORCE_NODISCARD bool operator()(const shared_ptr<T>& lhs, const weak_ptr<T>& rhs) const noexcept {
        return lhs.owner_before(rhs);
    }
};

template <>
struct owner_less<void> {
    using is_transparent = void; 

    template <typename T, typename U>
    NEFORCE_NODISCARD bool operator()(const shared_ptr<T>& lhs, const shared_ptr<U>& rhs) const noexcept {
        return lhs.owner_before(rhs);
    }

    template <typename T, typename U>
    NEFORCE_NODISCARD bool operator()(const shared_ptr<T>& lhs, const weak_ptr<U>& rhs) const noexcept {
        return lhs.owner_before(rhs);
    }

    template <typename T, typename U>
    NEFORCE_NODISCARD bool operator()(const weak_ptr<T>& lhs, const shared_ptr<U>& rhs) const noexcept {
        return lhs.owner_before(rhs);
    }

    template <typename T, typename U>
    NEFORCE_NODISCARD bool operator()(const weak_ptr<T>& lhs, const weak_ptr<U>& rhs) const noexcept {
        return lhs.owner_before(rhs);
    }
};
 // WeakPointer


template <typename T>
struct atomic<weak_ptr<T>> {
public:
    using value_type = weak_ptr<T>;
 
    static constexpr bool is_always_lock_free = false;
 
private:
    inner::smart_pointer_atomic<value_type> atomic_;
 
public:
    bool is_lock_free() const noexcept { return false; }
 
    constexpr atomic() noexcept = default;

    atomic(value_type value) noexcept :
    atomic_(move(value)) {}
 
    atomic(const atomic&) = delete;
    void operator=(const atomic&) = delete;

    value_type load(memory_order mo = memory_order_seq_cst) const noexcept { return atomic_.load(mo); }

    operator value_type() const noexcept { return atomic_.load(memory_order_seq_cst); }

    void store(value_type desired, memory_order mo = memory_order_seq_cst) noexcept { atomic_.swap(desired, mo); }

    void operator=(value_type desired) noexcept { atomic_.swap(desired, memory_order_seq_cst); }

    value_type exchange(value_type desired, memory_order mo = memory_order_seq_cst) noexcept {
        atomic_.swap(desired, mo);
        return desired;
    }

    bool compare_exchange_strong(value_type& expected, value_type desired, memory_order mo, memory_order mo2) noexcept {
        return atomic_.compare_exchange_strong(expected, desired, mo, mo2);
    }

    bool compare_exchange_strong(value_type& expected, value_type desired,
                                 memory_order mo = memory_order_seq_cst) noexcept {
        return compare_exchange_strong(expected, move(desired), mo, cmpexch_failure_order(mo));
    }

    bool compare_exchange_weak(value_type& expected, value_type desired, memory_order mo, memory_order mo2) noexcept {
        return compare_exchange_strong(expected, move(desired), mo, mo2);
    }

    bool compare_exchange_weak(value_type& expected, value_type desired,
                               memory_order mo = memory_order_seq_cst) noexcept {
        return compare_exchange_strong(expected, move(desired), mo);
    }

    void wait(value_type mold, memory_order mo = memory_order_seq_cst) const noexcept { atomic_.wait(move(mold), mo); }

    void notify_one() noexcept { atomic_.notify_one(); }

    void notify_all() noexcept { atomic_.notify_all(); }
};
 // AtomicOperations
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_MEMORY_WEAK_PTR_HPP__