sharedptr.h

Go to the documentation of this file.

 
#pragma once
 
#include <assert.h>
 
class SharedPtrDeletionInternal {
public:
    virtual ~SharedPtrDeletionInternal ()
    {
    }
};
 
template<class T>
class SharedPtrDeletionImpl: public SharedPtrDeletionInternal {
public:
    SharedPtrDeletionImpl (T *ptr) :
            _ptr(ptr)
    {
    }
    ~SharedPtrDeletionImpl ()
    {
        // Checks if the supplied type is not just a plain
        // forward definition, taken from boost::checked_delete
        // This makes the user really aware what he tries to do
        // when using this with an incomplete type.
        typedef char completeCheck[sizeof(T) ? 1 : -1];(void)sizeof(completeCheck);
        delete _ptr;
    }
private:
    T *_ptr;
};
 
template<class T, class D>
class SharedPtrDeletionDeleterImpl: public SharedPtrDeletionInternal {
public:
    SharedPtrDeletionDeleterImpl (T *ptr, D d) :
            _ptr(ptr), _deleter(d)
    {
    }
    ~SharedPtrDeletionDeleterImpl ()
    {
        _deleter(_ptr);
    }
private:
    T *_ptr;
    D _deleter;
};

template<class T>
class SharedPtr {
#if !((__GNUC__ == 2) && (__GNUC_MINOR__ >= 95))
    template<class T2> friend class SharedPtr;
#endif
public:
    typedef int RefValue;
    typedef T ValueType;
    typedef T *PointerType;
    typedef const T *ConstPointerType;
    typedef T &ReferenceType;
    typedef const T &ConstReferenceType;
 
    SharedPtr () :
            _refCount(0), _deletion(0), _pointer(0)
    {
    }
 
    template<class T2>
    explicit SharedPtr (T2 *p) :
            _refCount(new RefValue(1)), _deletion(new SharedPtrDeletionImpl<T2>(p)), _pointer(p)
    {
    }
 
    template<class T2, class D>
    SharedPtr (T2 *p, D d) :
            _refCount(new RefValue(1)), _deletion(new SharedPtrDeletionDeleterImpl<T2, D>(p, d)), _pointer(p)
    {
    }
 
    SharedPtr (const SharedPtr &r) :
            _refCount(r._refCount), _deletion(r._deletion), _pointer(r._pointer)
    {
        if (_refCount)
            ++(*_refCount);
    }
    template<class T2>
    SharedPtr (const SharedPtr<T2> &r) :
            _refCount(r._refCount), _deletion(r._deletion), _pointer(r._pointer)
    {
        if (_refCount)
            ++(*_refCount);
    }
 
    ~SharedPtr ()
    {
        decRef();
    }
 
    SharedPtr &operator= (const SharedPtr &r)
    {
        if (r._refCount)
            ++(*r._refCount);
        decRef();
 
        _refCount = r._refCount;
        _deletion = r._deletion;
        _pointer = r._pointer;
 
        return *this;
    }
 
    template<class T2>
    SharedPtr &operator= (const SharedPtr<T2> &r)
    {
        if (r._refCount)
            ++(*r._refCount);
        decRef();
 
        _refCount = r._refCount;
        _deletion = r._deletion;
        _pointer = r._pointer;
 
        return *this;
    }
 
    inline ReferenceType operator* () const
    {
        assert(_pointer);
        return *_pointer;
    }
    inline PointerType operator-> () const
    {
        assert(_pointer);
        return _pointer;
    }
 
    inline bool operator< (ConstPointerType other) const
    {
        return *_pointer < *other;
    }
 
    inline bool operator< (ConstReferenceType other) const
    {
        return *_pointer < other;
    }

    inline PointerType get () const
    {
        return _pointer;
    }

    inline operator bool () const
    {
        return _pointer != 0;
    }

    inline bool unique () const
    {
        return refCount() == 1;
    }

    void reset ()
    {
        decRef();
        _deletion = 0;
        _refCount = 0;
        _pointer = 0;
    }
 
    template<class T2>
    bool operator== (const SharedPtr<T2> &r) const
    {
        return _pointer == r.get();
    }
 
    template<class T2>
    bool operator!= (const SharedPtr<T2> &r) const
    {
        return _pointer != r.get();
    }

    RefValue refCount () const
    {
        return _refCount ? *_refCount : 0;
    }
#if !((__GNUC__ == 2) && (__GNUC_MINOR__ >= 95))
private:
#endif
    void decRef ()
    {
        if (_refCount) {
            --(*_refCount);
            if (!*_refCount) {
                delete _refCount;
                delete _deletion;
                _deletion = 0;
                _refCount = 0;
                _pointer = 0;
            }
        }
    }
 
    RefValue *_refCount;
    SharedPtrDeletionInternal *_deletion;
    PointerType _pointer;
};