WeakPtr.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include "AstUtil/Object.hpp"
 
AST_NAMESPACE_BEGIN
 
 
template<typename _Object>
class WeakPtr
{
public:
    WeakPtr()
        :object_{ nullptr }
    {
    }
    WeakPtr(std::nullptr_t)
        :object_{ nullptr }
    {
    }
    WeakPtr(_Object* obj)
        :object_{ obj }
    {
        _incWeakRef();
    }
    WeakPtr(const WeakPtr& ptr)
        :WeakPtr{ ptr.object_ }
    {
    }
    ~WeakPtr()
    {
        _decWeakRef();
    }
    WeakPtr& operator=(_Object* obj)
    {
        if (obj != object_) {
            _decWeakRef();
            object_ = obj;
            _incWeakRef();
        }
        return *this;
    }
    WeakPtr& operator=(std::nullptr_t)
    {
        reset();
        return *this;
    }
    WeakPtr& operator=(const WeakPtr& ptr)
    {
        if (this != &ptr) {
            this->operator=(ptr.object_);
        }
        return *this;
    }
    _Object* lock() const
    {
        return get();
    }
    _Object* get() const
    {
        if (expired()) {
            return nullptr;
        }
        return object_;
    }
    bool expired() const
    {
        return !object_ || aObject_IsDestructed(object_);
    }
    void reset()
    {
        _decWeakRef();
        object_ = nullptr;
    }
    _Object* operator->() const
    {
        return object_;
    }
    // operator _Object*() const
    // {
    //     return get();
    // }
    explicit operator bool() const
    {
        return !expired();
    }
    bool operator==(const WeakPtr& other) const
    {
        return object_ == other.object_;
    }
    bool operator!=(const WeakPtr& other) const
    {
        return object_ != other.object_;
    }
    bool operator<(const WeakPtr& other) const
    {
        return object_ < other.object_;
    }
private:
    void _incWeakRef()
    {
        if(object_)
            aObject_IncWeakRef(object_);
    }
    void _decWeakRef()
    {
        if(object_)
            aObject_DecWeakRef(object_);
    }
protected:
    _Object* object_{nullptr};
};
 
 
 
AST_NAMESPACE_END
 
namespace std
{
    template<typename _Object>
    struct hash<_AST WeakPtr<_Object>>
    {
        size_t operator()(const _AST WeakPtr<_Object>& ptr) const
        {
            return hash<_Object*>()(ptr.get());
        }
    };
}