refcount.h

Go to the documentation of this file.

#ifndef refcount_h
#define refcount_h

/*+
________________________________________________________________________

 (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"


#define mInvalidRefCount (-1)


#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; );

template <class T> inline
void unRefAndZeroPtr( T*& ptr )
{
    if ( !ptr ) return;
    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_.get(); }
    inline bool         refIfReffed();
    
private:
    
    Threads::Atomic<od_int32>   count_;
};


#ifdef __win__
# define mDeclareCounters       od_int32 oldcount = count_.get(), newcount = 0
#else
# define mDeclareCounters       od_int32 oldcount = count_.get(), 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


#endif