RefCounted.h

Go to the documentation of this file.

/*  RefCounted.h - reference counted objects
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_RefCounted_h
#define OW32_RefCounted_h

#include <OW32/OW32Libs.h>
#include <OW32/windows.h>
#include <cassert>

namespace OW32
{

class OW32_LIB_EXPORT CRefCountedBase
{
protected:
    mutable LONG m_refCount;

public:
    CRefCountedBase() :
        m_refCount(1)
    {
    }

    virtual ~CRefCountedBase() {}

    virtual LONG AddRef() const = 0;

    virtual LONG Release() const = 0;

private:
    // No autogenerated copy or assignment c'tor 
    // (this would invalidate the reference counting)
    CRefCountedBase(const CRefCountedBase &other);
    CRefCountedBase& operator= (const CRefCountedBase &other);
};

class OW32_LIB_EXPORT CRefCounted : public CRefCountedBase
{
public:
    CRefCounted() {}

    virtual LONG AddRef() const
    {
        return InterlockedIncrement(&m_refCount);
    }


    virtual LONG Release() const
    {
        LONG newCount = InterlockedDecrement(&m_refCount);
        assert(newCount >= 0);
        if (newCount == 0)
            delete this;
        return newCount;
    }

private:
    // No copy or assignment
    CRefCounted(const CRefCounted& other);
    CRefCounted &operator=(const CRefCounted& other);
};

class OW32_LIB_EXPORT CRefCountedSingleThread : public CRefCountedBase
{
public:
    CRefCountedSingleThread() {}

    virtual LONG AddRef() const
    {
        return ++m_refCount;
    }


    virtual LONG Release() const
    {
        LONG newCount = --m_refCount;
        if (newCount == 0)
            delete this;
        return newCount;
    }

private:
    // No copy or assignment
    CRefCountedSingleThread(const CRefCountedSingleThread& other);
    CRefCountedSingleThread &operator=(const CRefCountedSingleThread& other);
};


template <class T>
class CRefCountedWrapper : public CRefCounted, public T
{
public:
    CRefCountedWrapper() {}

private:
    // No copy or assignment
    CRefCountedWrapper(const CRefCountedWrapper& other);
    CRefCountedWrapper &operator=(const CRefCountedWrapper& other);
};

template <class T>
class CRefCountedWrapperSingleThread : public CRefCountedSingleThread, public T
{
public:
    CRefCountedWrapperSingleThread() {}

private:
    // No copy or assignment
    CRefCountedWrapperSingleThread(const CRefCountedWrapperSingleThread& other);
    CRefCountedWrapperSingleThread &operator=(const CRefCountedWrapperSingleThread& other);
};

template <class T>
class CAutoRefCountedPtr
{
private:
    T* m_pObj;

public:
    CAutoRefCountedPtr() :
        m_pObj(0)
    {
    }

    CAutoRefCountedPtr(T* pObj, bool fAddRef=true) :
        m_pObj(pObj)
    {
        if (fAddRef && m_pObj) m_pObj->AddRef();
    }

    CAutoRefCountedPtr(const CAutoRefCountedPtr& other) {
        if (&other == this) { m_pObj = 0; return; }
        m_pObj = other.m_pObj;
        if (m_pObj) m_pObj->AddRef();
    }

    ~CAutoRefCountedPtr() {
        if (m_pObj) m_pObj->Release();
    }

    CAutoRefCountedPtr& operator=(const CAutoRefCountedPtr& other) {
        if (&other == this) return *this;
        if (m_pObj) m_pObj->Release();
        m_pObj = other.m_pObj;
        if (m_pObj) m_pObj->AddRef();
        return *this;
    }

    T* release() {
        T* pObj = m_pObj;
        m_pObj = 0;
        return pObj;
    }

    void reset(T* pObj, bool fAddRef = true) {
        if (m_pObj) m_pObj->Release();
        m_pObj = pObj;
        if (fAddRef && m_pObj) m_pObj->AddRef();
    }

    T* get() const {
        return m_pObj;
    }

    T* operator->() const { return m_pObj; }
    T& operator*() const { return *m_pObj; }
    operator T*() const { return m_pObj; }

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

    /* \brief comparators as compiler can't deduce comparing a T* */
    bool operator<(const CAutoRefCountedPtr<T>& rhs) const { return m_pObj < rhs.m_pObj; }
    bool operator>(const CAutoRefCountedPtr<T>& rhs) const { return m_pObj > rhs.m_pObj; }
};

} // namespace OW32

#endif // OW32_RefCounted_h

---