File Coverage

src/panda/refcnt.h

Criterion	Covered	Total	%
statement	20	20	100.0
branch	12	14	85.7
condition			n/a
subroutine			n/a
pod			n/a
total	32	34	94.1

#pragma once
#include "cast.h"
#include "traits.h"
#include
#include
#include
#include

namespace panda {

using std::nullptr_t;

template
struct iptr {
    template  friend struct iptr;
    typedef T element_type;

    iptr ()                : ptr(NULL)    {}
    iptr (T* pointer)      : ptr(pointer) { if (ptr) refcnt_inc(ptr); }
    iptr (const iptr& oth) : ptr(oth.ptr) { if (ptr) refcnt_inc(ptr); }

    template >
    iptr (const iptr& oth) : ptr(oth.ptr) { if (ptr) refcnt_inc(ptr); }

    iptr (iptr&& oth) {
        ptr = oth.ptr;
        oth.ptr = NULL;
    }

    template >
    iptr (iptr&& oth) {
        ptr = oth.ptr;
        oth.ptr = NULL;
    }

    ~iptr () { if (ptr) refcnt_dec(ptr); }

    iptr& operator= (T* pointer) {
        if (pointer) refcnt_inc(pointer);
        if (ptr) refcnt_dec(ptr);
        ptr = pointer;
        return *this;
    }

    iptr& operator= (const iptr& oth) { return operator=(oth.ptr); }

    template >
    iptr& operator= (const iptr& oth) { return operator=(oth.ptr); }

    iptr& operator= (iptr&& oth) {
        std::swap(ptr, oth.ptr);
        return *this;
    }

    template >
    iptr& operator= (iptr&& oth) {
        if (ptr) {
            if (ptr == oth.ptr) return *this;
            refcnt_dec(ptr);
        }
        ptr = oth.ptr;
        oth.ptr = NULL;
        return *this;
    }

    void reset () {
        if (ptr) refcnt_dec(ptr);
        ptr = NULL;
    }

    void reset (T* p) { operator=(p); }

    T* operator-> () const noexcept { return ptr; }
    T& operator*  () const noexcept { return *ptr; }
    operator T*   () const noexcept { return ptr; }

    explicit
    operator bool () const noexcept { return ptr; }

    T* get () const noexcept { return ptr; }

    uint32_t use_count () const noexcept { return refcnt_get(ptr); }

    T* detach () noexcept {
        auto ret = ptr;
        ptr = nullptr;
        return ret;
    }

    void swap (iptr& oth) noexcept {
        std::swap(ptr, oth.ptr);
    }

private:
    T* ptr;
};

template  inline bool operator== (const iptr& x, const iptr& y) { return x.get() == y.get(); }
template  inline bool operator!= (const iptr& x, const iptr& y) { return x.get() != y.get(); }
template  inline bool operator<  (const iptr& x, const iptr& y) { return x.get() < y.get(); }
template  inline bool operator<= (const iptr& x, const iptr& y) { return x.get() <= y.get(); }
template  inline bool operator>  (const iptr& x, const iptr& y) { return x.get() > y.get(); }
template  inline bool operator>= (const iptr& x, const iptr& y) { return x.get() >= y.get(); }

template  inline bool operator== (const iptr& x, nullptr_t) noexcept { return !x.get(); }
template  inline bool operator== (nullptr_t, const iptr& x) noexcept { return !x.get(); }
template  inline bool operator!= (const iptr& x, nullptr_t) noexcept { return x.get(); }
template  inline bool operator!= (nullptr_t, const iptr& x) noexcept { return x.get(); }
template  inline bool operator<  (const iptr& x, nullptr_t) noexcept { return x.get() < nullptr; }
template  inline bool operator<  (nullptr_t, const iptr& x) noexcept { return nullptr < x.get(); }
template  inline bool operator<= (const iptr& x, nullptr_t) noexcept { return x.get() <= nullptr; }
template  inline bool operator<= (nullptr_t, const iptr& x) noexcept { return nullptr <= x.get(); }
template  inline bool operator>  (const iptr& x, nullptr_t) noexcept { return x.get() > nullptr; }
template  inline bool operator>  (nullptr_t, const iptr& x) noexcept { return nullptr > x.get(); }
template  inline bool operator>= (const iptr& x, nullptr_t) noexcept { return x.get() >= nullptr; }
template  inline bool operator>= (nullptr_t, const iptr& x) noexcept { return nullptr >= x.get(); }

template
iptr make_iptr (Args&&... args) {
    return iptr(new T(std::forward(args)...));
}

template
void swap (iptr& a, iptr& b) noexcept { a.swap(b); }

struct weak_storage;

struct Refcnt {
    void retain  () const { ++_refcnt; }
    void release () const {
        if (_refcnt > 1) --_refcnt;
        else delete this;
    }
    uint32_t refcnt () const noexcept { return _refcnt; }

protected:
    Refcnt () : _refcnt(0) {}
    virtual ~Refcnt ();

private:
    friend iptr refcnt_weak (const Refcnt*);

    mutable uint32_t _refcnt;
    mutable iptr _weak;

    iptr get_weak () const;
};

struct Refcntd : Refcnt {
    void release () const {
        if (refcnt() <= 1) const_cast(this)->on_delete();
        Refcnt::release();
    }

protected:
    virtual void on_delete () noexcept {}
};

struct weak_storage : public Refcnt {
    weak_storage () : valid(true) {}
    bool valid;
};

inline void               refcnt_inc  (const Refcnt*  o) { o->retain(); }
inline void               refcnt_dec  (const Refcntd* o) { o->release(); }
inline void               refcnt_dec  (const Refcnt*  o) { o->release(); }
inline uint32_t           refcnt_get  (const Refcnt*  o) { return o->refcnt(); }
inline iptr refcnt_weak (const Refcnt*  o) { return o->get_weak(); }

template  inline iptr static_pointer_cast  (const iptr& ptr) { return iptr(static_cast(ptr.get())); }
template  inline iptr const_pointer_cast   (const iptr& ptr) { return iptr(const_cast(ptr.get())); }
template  inline iptr dynamic_pointer_cast (const iptr& ptr) { return iptr(dyn_cast(ptr.get())); }

template  inline std::shared_ptr static_pointer_cast  (const std::shared_ptr& shptr) { return std::static_pointer_cast(shptr); }
template  inline std::shared_ptr const_pointer_cast   (const std::shared_ptr& shptr) { return std::const_pointer_cast(shptr); }
template  inline std::shared_ptr dynamic_pointer_cast (const std::shared_ptr& shptr) { return std::dynamic_pointer_cast(shptr); }

template
struct weak_iptr {
    template  friend struct weak_iptr;
    typedef T element_type;

    weak_iptr() : storage(nullptr), object(nullptr) {}
    weak_iptr(const weak_iptr&) = default;
    weak_iptr& operator=(const weak_iptr& o) = default;

    weak_iptr(weak_iptr&&) = default;
    weak_iptr& operator=(weak_iptr&& o) = default;

    template >
    weak_iptr(const iptr& src) : storage(src ? refcnt_weak(src.get()) : nullptr), object(src ? src.get() : nullptr) {}

    template >
    weak_iptr(const weak_iptr& src) : storage(src.storage), object(src.object) {}

    template
    weak_iptr& operator=(const weak_iptr& o) {
        storage = o.storage;
        object = o.object;
        return *this;
    }

    template
    weak_iptr& operator=(const iptr& src) {
        storage = src ? refcnt_weak(src.get()) : nullptr;
        object  = src ? src.get() : nullptr;
        return *this;
    }

    template
    weak_iptr& operator=(weak_iptr&& o) {
        storage = std::move(o.storage);
        object = std::move(o.object);
        return *this;
    }

    iptr lock() const {
        return expired() ? nullptr : object;
    }

    bool expired() const {
        return !operator bool();
    }

    explicit operator bool() const {
        return storage && storage->valid;
    }

    size_t use_count() const {
        return *this ? refcnt_get(object) : 0;
    }

    size_t weak_count() const {
        if (!storage) return 0;
        if (storage->valid) return storage.use_count() - 1; // object itself refers to weak storage, ignore this reference in count
        return storage.use_count();
    }

    void reset() noexcept {
        storage.reset();
        object = nullptr;
    }

    void swap(weak_iptr& oth) noexcept {
        storage.swap(oth.storage);
        std::swap(object, oth.object);
    }

private:
    iptr storage;
    T* object; // it is cache, it never invalidates itself, use storage->object to check validity
};

template
void swap(weak_iptr& a, weak_iptr& b) noexcept { a.swap(b); }

template  struct _weak_t;
template  struct _weak_t> {
    using type = weak_iptr;
};

template
using weak = typename _weak_t::type;

}