refcount.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        K. Tingdahl
 Date:          13-11-2003
 Contents:      Basic functionality for reference counting
 RCS:           $Id$
________________________________________________________________________
 
-*/
 
#include "atomic.h"
#include "objectset.h"
#include "thread.h"
 
template <class T> class WeakPtr;
template <class T> class RefMan;
template <class T> class ConstRefMan;
 
 
#define mInvalidRefCount (-1)
 
namespace RefCount
{
class WeakPtrBase;
 
mExpClass(Basic) Counter
{
public:
 
    void                ref();
    bool                tryRef();
    bool                unRef();
    void                unRefDontInvalidate();
 
    od_int32            count() const { return count_.load(); }
    bool                refIfReffed();
 
    void                clearAllObservers();
    void                addObserver(WeakPtrBase* obj);
    void                removeObserver(WeakPtrBase* obj);
 
                        Counter();
                        Counter(const Counter& a);
 
    static od_int32     cInvalidRefCount();
    static od_int32     cStartRefCount();
 
private:
 
    ObjectSet<WeakPtrBase>      observers_;
    Threads::SpinLock           observerslock_;
 
    Threads::Atomic<od_int32>   count_;
};
 
mExpClass(Basic) Referenced
{
public:
 
    void                ref() const;
    void                unRef() const;
    void                unRefNoDelete() const;
 
protected:
 
                        Referenced()                    {}
                        Referenced(const Referenced&);
    Referenced&         operator =(const Referenced&);
    virtual             ~Referenced();
 
private:
 
    friend class        WeakPtrBase;
    virtual void        refNotify() const               {}
    virtual void        unRefNotify() const             {}
    virtual void        unRefNoDeleteNotify() const     {}
    virtual void        prepareForDelete()              {}
 
    mutable Counter     refcount_;
 
public:
 
    int                 nrRefs() const;
    bool                refIfReffed() const;
    bool                tryRef() const;
 
    void                addObserver(WeakPtrBase* obs);
    void                removeObserver(WeakPtrBase* obs);
    static bool         isSane(const Referenced*);
                                /*Returns true if this really is a referenced
                                  (i.e. has magicnumber set ) */
 
private:
 
    const od_uint64     magicnumber_ = 0x123456789abcdef;
 
};
 
 
template <class T>
inline void refIfObjIsReffed( const T* obj )
{
    if ( obj )
    {
        mDynamicCastGet( const RefCount::Referenced*, reffed, obj );
        if ( reffed )
            reffed->ref();
    }
}
 
template <class T>
inline void unRefIfObjIsReffed( const T* obj )
{
    if ( obj )
    {
        mDynamicCastGet( const RefCount::Referenced*, reffed, obj );
        if ( reffed )
            reffed->unRef();
    }
}
 
template <class T> inline void refIfObjIsReffed( const T& obj )
{ refIfObjIsReffed( &obj ); }
template <class T> inline void unRefIfObjIsReffed( const T& obj )
{ unRefIfObjIsReffed( &obj ); }
 
 
 
mExpClass(Basic) WeakPtrBase
{
public:
 
    typedef Threads::SpinLock   LockType;
 
                        operator bool() const;
    bool                operator!() const;
    bool                operator==( const WeakPtrBase& r ) const
                                { return ptr_==r.ptr_; }
 
protected:
 
                        WeakPtrBase();
        void            set(Referenced*);
 
    friend class        Counter;
 
    void                clearPtr();
    mutable LockType    lock_;
    Referenced*         ptr_;
 
};
 
 
mExpClass(Basic) WeakPtrSetBase
{
public:
 
    mExpClass(Basic) CleanupBlocker
    {
    public:
                        CleanupBlocker( WeakPtrSetBase& base )
                            : base_( base )     { base_.blockCleanup(); }
 
                        ~CleanupBlocker()       { base_.unblockCleanup(); }
    private:
 
        WeakPtrSetBase& base_;
 
    };
 
protected:
 
    Threads::Atomic<int> blockcleanup_  = 0;
 
private:
 
    friend class        CleanupBlocker;
    void                blockCleanup();
    void                unblockCleanup();
 
};
 
 
}; //RefCount namespace end
 
 
template <class T>
mClass(Basic) WeakPtr : public RefCount::WeakPtrBase
{
public:
 
                        WeakPtr(RefCount::Referenced* p = 0) { set(p); }
                        WeakPtr(const WeakPtr<T>& p) : WeakPtr<T>( p.ptr_ ) {}
                        WeakPtr(RefMan<T>& p) : WeakPtr<T>(p.ptr()) {}
                        ~WeakPtr() { set( 0 ); }
 
    inline WeakPtr<T>&  operator=(const WeakPtr<T>& p);
    RefMan<T>&          operator=(RefMan<T>& p)
                        { set(p.ptr()); return p; }
    T*                  operator=(T* p)
                        { set(p); return p; }
 
    RefMan<T>           get() const;
 
};
 
 
//A collection of weak pointers
 
template <class T>
mClass(Basic) WeakPtrSet : public RefCount::WeakPtrSetBase
{
public:
 
    typedef Threads::SpinLock           LockType;
    typedef TypeSet<WeakPtr<T> >        SetType;
    typedef int                         idx_type;
    typedef int                         size_type;
 
    bool                operator+=(const WeakPtr<T>&);
                        //Returns if added (i.e. not duplicate)
    bool                operator+=(RefMan<T>&);
                        //Returns if added (i.e. not duplicate)
    size_type           size() const;
    RefMan<T>           operator[](idx_type);
    ConstRefMan<T>      operator[](idx_type) const;
 
    idx_type            indexOf(T*) const;
 
 
private:
 
    mutable LockType    lock_;
    SetType             ptrs_;
 
};
 
 
 
#define mRefCountImplWithDestructor(ClassName, DestructorImpl, delfunc ) \
public: \
    void        ref() const \
                { \
                    refcount_.ref(); \
                    refNotify(); \
                } \
    bool        refIfReffed() const \
                { \
                    if ( !refcount_.refIfReffed() ) \
                        return false; \
                    \
                    refNotify(); \
                    return true; \
                } \
    void        unRef() const \
                { \
                    unRefNotify(); \
                    if ( refcount_.unRef() ) \
                        delfunc; \
                    return; \
                } \
 \
    void        unRefNoDelete() const \
                { \
                    unRefNoDeleteNotify(); \
                    refcount_.unRefDontInvalidate(); \
                } \
    int         nrRefs() const { return refcount_.count(); } \
private: \
    virtual void                refNotify() const {} \
    virtual void                unRefNotify() const {} \
    virtual void                unRefNoDeleteNotify() const {} \
    mutable ReferenceCounter    refcount_;      \
protected: \
                DestructorImpl; \
private:
 
 
#define mRefCountImpl(ClassName) \
mRefCountImplWithDestructor(ClassName, virtual ~ClassName(), delete this; )
 
#define mRefCountImplNoDestructor(ClassName) \
mRefCountImplWithDestructor(ClassName, virtual ~ClassName() {}, delete this; )
 
 
inline void refPtr( const RefCount::Referenced* ptr )
{
    if ( ptr )
        ptr->ref();
}
 
inline void unRefPtr( const RefCount::Referenced* ptr )
{
    if ( ptr )
        ptr->unRef();
}
 
inline void unRefNoDeletePtr( const RefCount::Referenced* ptr )
{
    if ( ptr )
        ptr->unRefNoDelete();
}
 
template <class T> inline
void unRefAndZeroPtr( T*& ptr )
{
    mDynamicCastGet(RefCount::Referenced*,refptr,ptr)
    if ( refptr )
        unRefPtr( refptr );
    else if ( !ptr )
        return;
    else
        ptr->unRef();
    ptr = 0;
}
 
template <class T> inline
void unRefAndZeroPtr( const T*& ptr )
{
    mDynamicCastGet(const RefCount::Referenced*,refptr,ptr)
    if ( refptr )
        unRefPtr( refptr );
    else if ( !ptr )
        return;
    else
        ptr->unRef();
    ptr = 0;
}
 
 
template <class T> inline
void unRefPtr( const T* ptr )
{
    if ( !ptr ) return;
    ptr->unRef();
}
 
 
template <class T> inline
void unRefNoDeletePtr( const T* ptr )
{
    if ( !ptr ) return;
    ptr->unRefNoDelete();
}
 
 
template <class T> inline
void refPtr( const T* ptr )
{
    if ( !ptr ) return;
    ptr->ref();
}
 
mObjectSetApplyToAllFunc( deepUnRef, unRefPtr( os[idx] ), os.plainErase() )
mObjectSetApplyToAllFunc( deepUnRefNoDelete, unRefNoDeletePtr( os[idx] ),
                          os.plainErase() )
mObjectSetApplyToAllFunc( deepRef, refPtr( os[idx] ), )
 
 
mClass(Basic) ReferenceCounter
{
public:
    inline void         ref();
    inline bool         unRef();
    inline void         unRefDontInvalidate();
 
    od_int32            count() const { return count_.load(); }
    inline bool         refIfReffed();
 
private:
 
    Threads::Atomic<od_int32>   count_;
};
 
 
#ifdef __win__
# define mDeclareCounters       od_int32 oldcount = count_.load(), newcount = 0
#else
# define mDeclareCounters       od_int32 oldcount = count_.load(), newcount;
#endif
 
inline void ReferenceCounter::ref()
{
    mDeclareCounters;
 
    do
    {
        if ( oldcount==mInvalidRefCount )
        {
            pErrMsg("Invalid ref");
#ifdef __debug__
            DBG::forceCrash(false);
            newcount = 0; //To fool unitialized code warning
#else
            newcount = 1; //Hoping for the best
#endif
        }
        else
        {
            newcount = oldcount+1;
        }
 
    } while ( !count_.setIfValueIs( oldcount, newcount, &oldcount ) );
}
 
 
inline bool ReferenceCounter::unRef()
{
    mDeclareCounters;
 
    do
    {
        if ( oldcount==mInvalidRefCount )
        {
            pErrMsg("Invalid reference.");
#ifdef __debug__
            DBG::forceCrash(false);
            newcount = 0; //To fool unitialized code warning
#else
            return false;
#endif
        }
        else if ( oldcount==1 )
            newcount = mInvalidRefCount;
        else
            newcount = oldcount-1;
 
    } while ( !count_.setIfValueIs(oldcount,newcount, &oldcount ) );
 
    return newcount==mInvalidRefCount;
}
 
 
inline bool ReferenceCounter::refIfReffed()
{
    mDeclareCounters;
 
    do
    {
        if ( oldcount==mInvalidRefCount )
        {
            pErrMsg("Invalid ref");
#ifdef __debug__
            DBG::forceCrash(false);
#else
            return false; //Hoping for the best
#endif
        }
        else if ( !oldcount )
            return false;
 
        newcount = oldcount+1;
 
    } while ( !count_.setIfValueIs( oldcount, newcount, &oldcount ) );
 
    return true;
}
 
 
inline void ReferenceCounter::unRefDontInvalidate()
{
    mDeclareCounters;
 
    do
    {
        if ( oldcount==mInvalidRefCount )
        {
            pErrMsg("Invalid reference.");
#ifdef __debug__
            DBG::forceCrash(false);
            newcount = 0; //Fool the unitialized warning
#else
            newcount = 0; //Hope for the best
#endif
        }
        else
            newcount = oldcount-1;
 
    } while ( !count_.setIfValueIs( oldcount, newcount, &oldcount ) );
}
 
#undef mDeclareCounters
 
 
//Implementations and legacy stuff below
 
template <class T>
WeakPtr<T>& WeakPtr<T>::operator=( const WeakPtr<T>& wp )
{
    RefMan<T> ptr = wp.get();
    ptr.setNoDelete( true );
    set( ptr.ptr() );
    return *this;
}
 
 
template <class T>
RefMan<T> WeakPtr<T>::get() const
{
    RefMan<T> res = 0;
    if ( ptr_ && ptr_->tryRef() )
    {
        //reffed once through tryRef
        res = (T*)ptr_;
 
        //unref the ref from tryRef
        ptr_->unRef();
    }
 
    return res;
}
 
 
template <class T> inline
bool WeakPtrSet<T>::operator+=( RefMan<T>& toadd )
{
    T* ptr = toadd.ptr();
    return WeakPtrSet<T>::operator+=( WeakPtr<T>(ptr) );
}
 
template <class T> inline
bool WeakPtrSet<T>::operator+=( const WeakPtr<T>& toadd )
{
    lock_.lock();
 
    const bool docleanup = blockcleanup_.setIfValueIs( 0, -1, nullptr );
    for ( int idx=ptrs_.size()-1; idx>=0; idx-- )
    {
        if ( docleanup && !ptrs_[idx] )
            { ptrs_.removeSingle( idx ); continue; }
 
        if ( ptrs_[idx]==toadd )
        {
            if ( docleanup )
                blockcleanup_ = 0;
            lock_.unLock();
            return false;
        }
    }
 
    if ( docleanup )
        blockcleanup_ = 0;
 
    ptrs_ += toadd;
    lock_.unLock();
 
    return true;
}
 
 
template <class T> inline
int WeakPtrSet<T>::size() const
{
    lock_.lock();
    const int res = ptrs_.size();
    lock_.unLock();
    return res;
}
 
 
template <class T> inline
RefMan<T> WeakPtrSet<T>::operator[]( int idx )
{
    lock_.lock();
    RefMan<T> res = ptrs_.validIdx(idx) ? ptrs_[idx].get() : RefMan<T>( 0 );
    lock_.unLock();
    return res;
}
 
 
 
template <class T> inline
ConstRefMan<T> WeakPtrSet<T>::operator[]( int idx ) const
{
    lock_.lock();
    ConstRefMan<T> res = ptrs_.validIdx(idx) ? ptrs_[idx].get() :
                                               ConstRefMan<T>( 0 );
    lock_.unLock();
    return res;
}