Referenced.hpp

浏览该文件的文档.

 
 
#pragma once
 
#include "AstGlobal.h"
#include <atomic>       // for std::atomic
#include <cstdint>      // for uint32_t
#include <cstdio>       // for printf
#include <cassert>      // for assert
 
AST_NAMESPACE_BEGIN
 
struct initial_strong_ref_t {};                      
constexpr initial_strong_ref_t initial_strong_ref{}; 
 
 
class AST_UTIL_API Referenced
{
public:
    Referenced()
        : refcnt_{0}
        , weakrefcnt_{1}
    {}
    explicit Referenced(initial_strong_ref_t)
        : refcnt_{1}
        , weakrefcnt_{1}
    {}
    virtual ~Referenced()
    {
        setDestructed();
    }
public: // 引用计数
    uint32_t refCount() const{return refcnt_;}
 
    uint32_t weakRefCount() const{return weakrefcnt_;}
 
    bool     isDestructed() const{return aObject_IsDestructed(this);}
 
    void     destruct()
    {
        #ifndef NDEBUG
        if(refcnt_ != 0)
        {
            std::printf("object ref count is not 0, can not destruct");
        }
        #endif
        assert(refcnt_ == 0);  // 只能直接删除不采用共享引用计数管理的对象
        this->_destruct();
    }
 
    uint32_t incWeakRef()
    {
        return aObject_IncWeakRef(this);
    }
 
    uint32_t decWeakRef()
    {
        return aObject_DecWeakRef(this);
    }
 
    uint32_t incRef()
    {
        return aObject_IncRef(this);
    }
 
    uint32_t decRef()
    {
        return aObject_DecRef(this);
    }
 
    uint32_t decRefNoDelete()
    {
        return --refcnt_;
    }
 
public: // 实参依赖查找（ADL）
    A_ALWAYS_INLINE 
    friend uint32_t aObject_IncRef(Referenced* obj)
    {
        return ++(obj->refcnt_);
    }
    A_ALWAYS_INLINE 
    friend uint32_t aObject_DecRef(Referenced* obj)
    {
        if (obj->refcnt_ == 1) {
            obj->_destruct();
            return 0;
        }
        return --(obj->refcnt_);
    }
    A_ALWAYS_INLINE 
    friend uint32_t aObject_IncWeakRef(Referenced* obj)
    {
        return ++(obj->weakrefcnt_);
    }
    A_ALWAYS_INLINE 
    friend uint32_t aObject_DecWeakRef(Referenced* obj)
    {
        if (obj->weakrefcnt_ == 1) {
            operator delete(obj);
            return 0;
        }
        else {
            return --(obj->weakrefcnt_);
        }
    }
    A_ALWAYS_INLINE 
    friend bool aObject_IsDestructed(const Referenced *obj)
    {
        return obj->refcnt_ == static_cast<uint32_t>(-1);
    }
protected:
    void setDestructed()
    {
        this->refcnt_ = static_cast<uint32_t>(-1); // 标识对象是否被析构. bit mask indicate whether object is destructed.
    }
private:
    void    _destruct()
    {
        this->~Referenced();
        this->decWeakRef();
    }
private:
    std::atomic<uint32_t>    refcnt_{0};                                
    std::atomic<uint32_t>    weakrefcnt_{1};                            
};
 
 
 
AST_NAMESPACE_END