SharedPtr.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Core/Core.h"
#include "Honey/Thread/Atomic.h"
#include "Honey/Misc/Debug.h"

namespace honey
{


namespace priv
{
    struct SharedObj_tag {};
    
    class SharedControl
    {
    public:
        SharedControl()                                 : _count(0), _weakCount(1) {}

        void ref()                                      { ++_count; }
        bool refLock()                                  { int old; do { old = _count; if (old <= 0) return false; } while (!_count.cas(old+1,old)); return true; }
        void unref()                                    { if (--_count > 0) return; finalize(); }
        int count() const                               { return _count; }
    
        void refWeak()                                  { ++_weakCount; }
        void unrefWeak()                                { if (--_weakCount > 0) return; destroy(); }
        int weakCount() const                           { return _weakCount; }
        
        virtual void finalize() = 0;
        virtual void destroy() = 0;
        
        Atomic<int> _count;
        Atomic<int> _weakCount;
    };
    
    template<class T, class Fin, class Alloc_>
    struct SharedControl_ : SharedControl
    {
        typedef typename Alloc_::template rebind<SharedControl_>::other Alloc;
        SharedControl_(T* ptr, Fin&& f, Alloc a)        : _ptr(ptr), _fin(forward<Fin>(f)), _alloc(move(a)) {}
        virtual void finalize()                         { _fin(_ptr); unrefWeak(); }
        virtual void destroy()                          { auto a = move(_alloc); delete_(this, a); }
        
        T* _ptr;
        Fin _fin;
        Alloc _alloc;
    };
    
    template<class Subclass, class T, bool isIntrusive = mt::is_base_of<SharedObj_tag, T>::value>
    struct SharedControlPtr
    {
        SharedControlPtr()                              : __control(nullptr) {}
        SharedControl* _control() const                 { return __control; }
        void _control(SharedControl* ptr)               { __control = ptr; }
        
        SharedControl* __control;
    };
    
    template<class T, class Alloc_> struct SharedControl_obj;
}
//====================================================
// SharedObj
//====================================================


template<class Subclass>
class SharedObj : public priv::SharedObj_tag, mt::NoCopy
{
    template<class, class, bool> friend struct priv::SharedControlPtr;
    template<class> friend class SharedPtr;
    
public:
    template<class Alloc = std::allocator<Subclass>>
    SharedObj(Alloc&& a = Alloc())
        debug_if(: __control(&_control()))
    {
        typedef typename mt::removeRef<Alloc>::type::template rebind<Subclass>::other Alloc_;
        new (&_controlStorage) Control(subc(), Alloc_(forward<Alloc>(a)));
    }

protected:
    void finalize()                                     { Control& control = _control(); subc().~Subclass(); control.unrefWeak(); }

private:
    struct Control : priv::SharedControl
    {
        template<class Alloc>
        Control(Subclass& obj, Alloc&& a)               : _obj(&obj), _dealloc([=](Subclass* p) mutable { a.deallocate(p,1); }) {}

        virtual void finalize()                         { _obj->finalize(); }
        
        virtual void destroy()
        {
            auto p = _obj;
            auto dealloc = move(_dealloc);
            this->~Control();
            dealloc(p);
        }

        Subclass* _obj;
        function<void (Subclass*)> _dealloc;
    };
    typedef typename std::aligned_storage<sizeof(Control), alignof(Control)>::type ControlStorage;

    Subclass& subc()                                    { return static_cast<Subclass&>(*this); }
    
    Control& _control() const                           { return reinterpret_cast<Control&>(_controlStorage); }
    
    mutable ControlStorage _controlStorage;
    debug_if(Control* __control;) //make control visible in debugger
};
    
namespace priv
{
    template<class Subclass, class T>
    struct SharedControlPtr<Subclass, T, true>
    {
        SharedControl* _control() const                 { return subc()._ptr ? &subc()._ptr->SharedObj::_control() : nullptr; }
        void _control(SharedControl*) {}
    private:
        const Subclass& subc() const                    { return static_cast<const Subclass&>(*this); }
    };
}
//====================================================
// SharedPtr
//====================================================

template<class T, class Fin> class UniquePtr;
template<class T> class WeakPtr;
    

template<class T>
class SharedPtr : priv::SharedControlPtr<SharedPtr<T>, T>
{
    typedef priv::SharedControlPtr<SharedPtr<T>, T> ControlPtr;
    friend ControlPtr;
    template<class> friend class SharedPtr;
    template<class> friend class WeakPtr;
    template<class, class> friend struct priv::SharedControl_obj;
    template<class T_, class U> friend SharedPtr<T_> static_pointer_cast(const SharedPtr<U>&);
    template<class T_, class U> friend SharedPtr<T_> dynamic_pointer_cast(const SharedPtr<U>&);
    template<class T_, class U> friend SharedPtr<T_> const_pointer_cast(const SharedPtr<U>&);
    
    static const bool isIntrusive                                   = mt::is_base_of<priv::SharedObj_tag, T>::value;
    
    template<class T_, bool = std::is_void<T_>::value> struct Ref_  { typedef T_& type; static type deref(T_* p) { return *p; } };
    template<class T_> struct Ref_<T_, true>                        { typedef T_ type;  static type deref(T_* p) {} };
    
public:
    typedef T Elem;
    typedef typename Ref_<Elem>::type Ref;
    
    SharedPtr()                                                     : _ptr(nullptr) {}
    SharedPtr(nullptr_t)                                            : _ptr(nullptr) {}
    
    template<class U, typename std::enable_if<mt::True<U>::value && isIntrusive, int>::type=0>
    SharedPtr(U* ptr)                                               : _ptr(nullptr) { set(ptr); }

    template<class U, class Fin = finalize<U>, class Alloc = typename DefaultAllocator<U>::type, typename mt::disable_if<mt::True<U>::value && isIntrusive, int>::type=0>
    explicit SharedPtr(U* ptr, Fin&& f = Fin(), Alloc&& a = Alloc())    : _ptr(nullptr) { set(ptr, forward<Fin>(f), forward<Alloc>(a)); }
    
    SharedPtr(const SharedPtr& ptr)                                 : _ptr(nullptr) { set(ptr); }
    template<class U>
    SharedPtr(const SharedPtr<U>& ptr)                              : _ptr(nullptr) { set(ptr); }
    SharedPtr(SharedPtr&& ptr)                                      : _ptr(nullptr) { set(move(ptr)); }
    template<class U>
    SharedPtr(SharedPtr<U>&& ptr)                                   : _ptr(nullptr) { set(move(ptr)); }

    template<class U>
    explicit SharedPtr(const WeakPtr<U>& ptr)                       : _ptr(ptr._ptr) { this->_control(ptr._control()); if (_ptr && !getControl().refLock()) _ptr = nullptr; }
    
    template<class U, class Fin>
    SharedPtr(UniquePtr<U,Fin>&& ptr)                               : _ptr(nullptr) { operator=(move(ptr)); }

    ~SharedPtr()                                                    { set(nullptr); }

    SharedPtr& operator=(const SharedPtr& rhs)                      { set(rhs); return *this; }
    template<class U>
    SharedPtr& operator=(const SharedPtr<U>& rhs)                   { set(rhs); return *this; }
    SharedPtr& operator=(SharedPtr&& rhs)                           { set(move(rhs)); return *this; }
    template<class U>
    SharedPtr& operator=(SharedPtr<U>&& rhs)                        { set(move(rhs)); return *this; }
    
    template<class U, class Fin, typename std::enable_if<mt::True<U>::value && isIntrusive, int>::type=0>
    SharedPtr& operator=(UniquePtr<U,Fin>&& rhs)                    { set(rhs.release()); return *this; }
    template<class U, class Fin, typename mt::disable_if<mt::True<U>::value && isIntrusive, int>::type=0> 
    SharedPtr& operator=(UniquePtr<U,Fin>&& rhs)                    { set(rhs.release(), move(rhs.finalizer())); return *this; }
    
    template<class U>
    bool operator==(const SharedPtr<U>& rhs) const                  { return get() == rhs.get(); }
    template<class U>
    bool operator!=(const SharedPtr<U>& rhs) const                  { return !operator==(rhs); }
    template<class U>
    bool operator< (const SharedPtr<U>& rhs) const                  { return std::less<typename std::common_type<T*,U*>::type>()(get(), rhs.get()); }
    template<class U>
    bool operator> (const SharedPtr<U>& rhs) const                  { return rhs.operator<(*this); }
    template<class U>
    bool operator<=(const SharedPtr<U>& rhs) const                  { return !operator>(rhs); }
    template<class U>
    bool operator>=(const SharedPtr<U>& rhs) const                  { return !operator<(rhs); }

    bool operator==(nullptr_t) const                                { return !get(); }
    bool operator!=(nullptr_t) const                                { return get(); }
    friend bool operator==(nullptr_t, const SharedPtr& rhs)         { return !rhs.get(); }
    friend bool operator!=(nullptr_t, const SharedPtr& rhs)         { return rhs.get(); }

    T* operator->() const                                           { assert(_ptr); return _ptr; }
    Ref operator*() const                                           { assert(_ptr); return Ref_<Elem>::deref(_ptr); }
    operator T*() const                                             { return _ptr; }

    T* get() const                                                  { return _ptr; }

    template<class U, typename std::enable_if<mt::True<U>::value && isIntrusive, int>::type=0>
    void set(U* ptr)                                                { setControl(ptr, ptr ? &ptr->SharedObj::_control() : nullptr); }
    template<class U, class Fin = finalize<U>, class Alloc = typename DefaultAllocator<U>::type, typename mt::disable_if<mt::True<U>::value && isIntrusive, int>::type=0>
    void set(U* ptr, Fin&& f = Fin(), Alloc&& a = Alloc())
    {
        typedef priv::SharedControl_<U,Fin,Alloc> Control;
        typedef typename Alloc::template rebind<Control>::other Alloc_;
        Alloc_ a_ = forward<Alloc>(a);
        setControl(ptr, ptr ? new (a_.allocate(1)) Control(ptr, forward<Fin>(f), move(a_)) : nullptr);
    }
    void set(nullptr_t)                                             { set((T*)nullptr); }

    int refCount() const                                            { if (_ptr) return getControl().count(); return 0; }
    bool unique() const                                             { return refCount() == 1; }

private:
    template<class U> void set(const SharedPtr<U>& rhs)             { setControl(rhs._ptr, rhs._control()); }
    template<class U> void set(SharedPtr<U>&& rhs)                  { moveControl(rhs._ptr, rhs._control()); rhs._ptr = nullptr; rhs._control(nullptr); }
    
    template<class U>
    void setControl(U* ptr, priv::SharedControl* control)
    {
        if (ptr) control->ref();
        T* oldPtr = _ptr; priv::SharedControl* oldControl = this->_control();
        _ptr = ptr; this->_control(control);
        if (oldPtr) oldControl->unref();
    }
    
    template<class U>
    void moveControl(U* ptr, priv::SharedControl* control)
    {
        if (_ptr && this->_control() != control)
            this->_control()->unref();
        _ptr = ptr; this->_control(control);
    }
    
    priv::SharedControl& getControl() const                         { assert(this->_control()); return *this->_control(); }

    T* _ptr;
};

namespace priv
{    
    template<class T, class Alloc_>
    struct SharedControl_obj : SharedControl
    {
        typedef typename mt::removeRef<Alloc_>::type::template rebind<SharedControl_obj>::other Alloc;
        typedef typename std::aligned_storage<sizeof(T), alignof(T)>::type Storage;
        
        template<class... Args>
        static SharedPtr<T> create(Alloc a, Args&&... args)
        {
            auto* control = new (a.allocate(1)) SharedControl_obj(move(a), forward<Args>(args)...);
            SharedPtr<T> ptr;
            ptr.setControl(&control->_obj(), control);
            return ptr;
        }
        
        template<class... Args>
        SharedControl_obj(Alloc&& a, Args&&... args)                : _alloc(move(a)) { new (&_storage) T(forward<Args>(args)...); }
        virtual void finalize()                                     { _obj().~T(); unrefWeak(); }
        virtual void destroy()                                      { auto a = move(_alloc); delete_(this, a); }
        T& _obj()                                                   { return reinterpret_cast<T&>(_storage); }

        Storage _storage;
        Alloc _alloc;
    };
}

template<class T, class Alloc, class... Args, typename mt::disable_if<mt::is_base_of<priv::SharedObj_tag, T>::value, int>::type=0>
SharedPtr<T> alloc_shared(Alloc&& a, Args&&... args)                { return priv::SharedControl_obj<T,Alloc>::create(forward<Alloc>(a), forward<Args>(args)...); }

template<class T, class Alloc, class... Args, typename std::enable_if<mt::is_base_of<priv::SharedObj_tag, T>::value, int>::type=0>
SharedPtr<T> alloc_shared(Alloc&& a, Args&&... args)                { return SharedPtr<T>(new (a.allocate(1)) T(forward<Args>(args)...)); }

template<class T, class... Args, class Alloc = typename DefaultAllocator<T>::type>
SharedPtr<T> make_shared(Args&&... args)                            { return alloc_shared<T>(Alloc(), forward<Args>(args)...); }

template<class T, class U>
SharedPtr<T> static_pointer_cast(const SharedPtr<U>& rhs)           { SharedPtr<T> ret; ret.setControl(static_cast<T*>(rhs._ptr), rhs._control()); return ret; }
template<class T, class U>
SharedPtr<T> dynamic_pointer_cast(const SharedPtr<U>& rhs)          { SharedPtr<T> ret; ret.setControl(dynamic_cast<T*>(rhs._ptr), rhs._control()); return ret; }
template<class T, class U>
SharedPtr<T> const_pointer_cast(const SharedPtr<U>& rhs)            { SharedPtr<T> ret; ret.setControl(const_cast<T*>(rhs._ptr), rhs._control()); return ret; }

//====================================================
// WeakPtr
//====================================================


template<class T>
class WeakPtr : priv::SharedControlPtr<WeakPtr<T>, T>
{
    typedef priv::SharedControlPtr<WeakPtr<T>, T> ControlPtr;
    friend ControlPtr;
    template<class> friend class WeakPtr;
    template<class> friend class SharedPtr;

public:
    WeakPtr()                                                       : _ptr(nullptr) {}
    WeakPtr(nullptr_t)                                              : _ptr(nullptr) {}
    template<class U>
    WeakPtr(const SharedPtr<U>& rhs)                                : _ptr(nullptr) { operator=(rhs); }
    WeakPtr(const WeakPtr& rhs)                                     : _ptr(nullptr) { operator=(rhs); }
    template<class U>
    WeakPtr(const WeakPtr<U>& rhs)                                  : _ptr(nullptr) { operator=(rhs); }

    ~WeakPtr()                                                      { if (_ptr) getControl().unrefWeak(); }

    WeakPtr& operator=(const WeakPtr& rhs)                          { setControl(rhs._ptr, rhs._control()); return *this; }
    template<class U>
    WeakPtr& operator=(const WeakPtr<U>& rhs)                       { setControl(rhs._ptr, rhs._control()); return *this; }
    template<class U>
    WeakPtr& operator=(const SharedPtr<U>& rhs)                     { setControl(rhs._ptr, rhs._control()); return *this; }

    void set(nullptr_t)                                             { setControl(static_cast<T*>(nullptr), nullptr); }

    SharedPtr<T> lock() const                                       { return SharedPtr<T>(*this); }

    int refCount() const                                            { if (_ptr) return getControl().count(); return 0; }
    bool expired() const                                            { return refCount() == 0; }

private:
    template<class U>
    void setControl(U* ptr, priv::SharedControl* control)
    {
        if (ptr) control->refWeak();
        T* oldPtr = _ptr; priv::SharedControl* oldControl = this->_control();
        _ptr = ptr; this->_control(control);
        if (oldPtr) oldControl->unrefWeak();     
    }
    
    priv::SharedControl& getControl() const                         { assert(this->_control()); return *this->_control(); }

    T* _ptr;
};


}

namespace std
{
    template<class T>
    struct hash<honey::SharedPtr<T>>
    {
        size_t operator()(const honey::SharedPtr<T>& val) const     { return reinterpret_cast<size_t>(val.get()); };
    };
}