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
________________________________________________________________________

-*/

#include "atomic.h"
#include "objectset.h"
#include "thread.h"

template <class T> class WeakPtr;
template <class T> class RefMan;
template <class T> class ConstRefMan;



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:
                                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 Threads::SpinLock   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:
    bool                operator+=(const WeakPtr<T>&);
                        //Returns if added (i.e. not duplicate)
    bool                operator+=(RefMan<T>&);
                        //Returns if added (i.e. not duplicate)
    int                 size() const;
    RefMan<T>           operator[](int);
    ConstRefMan<T>      operator[](int) const;

    int                 indexOf(T*) const;


private:

    TypeSet<WeakPtr<T> >                ptrs_;
    mutable Threads::SpinLock           lock_;
};


mGlobal(Basic) void unRefPtr( const RefCount::Referenced* ptr );

mGlobal(Basic) void unRefNoDeletePtr( const RefCount::Referenced* ptr );

mGlobal(Basic) const RefCount::Referenced*
refPtr( const RefCount::Referenced* ptr );

template <class T> inline
void unRefAndZeroPtr( T*& ptr )
{ unRefPtr( static_cast<RefCount::Referenced*>( ptr ) ); ptr = 0; }

template <class T> inline
void unRefAndZeroPtr( const T*& ptr )
{ unRefPtr( static_cast<const RefCount::Referenced*>( ptr ) ); ptr = 0; }

mObjectSetApplyToAllFunc( deepUnRef, unRefPtr( os[idx] ), os.plainErase() )
mObjectSetApplyToAllFunc( deepUnRefNoDelete, unRefNoDeletePtr( os[idx] ),
                         os.plainErase() )
mObjectSetApplyToAllFunc( deepRef, refPtr( os[idx] ), )



//Implementations and legacy stuff below


template <class T>
WeakPtr<T>& WeakPtr<T>::operator=(const WeakPtr<T>& p)
{
    RefMan<T> ptr = p.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>& n)
{
    T* ptr = n.ptr();
    return WeakPtrSet<T>::operator+=( WeakPtr<T>( ptr ) );
}

template <class T> inline
bool WeakPtrSet<T>::operator+=(const WeakPtr<T>& n)
{
    lock_.lock();

    const bool cleanup = blockcleanup_.setIfValueIs( 0, -1 );
    //Clean up old pointers
    for ( int idx=ptrs_.size()-1; idx>=0; idx-- )
    {
        if ( cleanup && !ptrs_[idx] )
        {
            ptrs_.removeSingle( idx );
            continue;
        }
        
        if ( ptrs_[idx]==n )
        {
            if ( cleanup ) blockcleanup_ = 0;
            lock_.unLock();
            return false;
        }
    }
    
    if ( cleanup ) blockcleanup_ = 0;

    ptrs_ += n;
    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
{
    return const_cast<WeakPtrSet<T>*>( this )->operator[](idx);
}