MboRefCntPtr.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* Name:      MboRefCntPtr.h
 *
 * Requires:  
 * - Mbo.h
 * - MboSynch.h
 * - MboSynch.cpp
 */
/* ------------------------------------------------------------------------ */

#ifndef _MBOREFCNTPTR_H_
#define _MBOREFCNTPTR_H_

#include "Mbo.h"
#include "MboSynch.h"

#if MBO_USE_DEBUG_NEW
#pragma push_macro("new")
#define new DEBUG_NEW
#endif

namespace mbo
{

/* ------------------------------------------------------------------------ */
template <class _Ty, 
          class _THREAD_MODEL = ThreadModel
         >
struct RefCntRep
{
    typedef RefCntRep<_Ty, _THREAD_MODEL>      Rep;

    typedef IncDecVal  refcount_type;

    mutable refcount_type refCnt;

    _Ty* pData;

    inline RefCntRep(_IN _Ty* p = NULL) 
        : refCnt(p ? 1 : 0)
        , pData(p) 
    {
    }

    inline RefCntRep& AddRef() 
    { 
        _THREAD_MODEL::Increment(&refCnt); 
        return *this;
    }

    inline bool Release() 
    { 
        return !_THREAD_MODEL::Decrement(&refCnt); 
    }

    static Rep* Alloc(_IN _Ty* p) 
    { 
        return new Rep(p); 
    }

    static void Dealloc(_IN Rep *& pRep) 
    { 
        if (pRep)
        {
            if (pRep->pData)
            {
                delete pRep->pData;
            }
            delete pRep; 
            pRep = 0;
        }
    }
};

template <class _Ty>
class NullPointer
{
protected:

    class nullptr_access: public mbo::runtime_error {
    public:

        explicit nullptr_access(_IN const char *szWhat = "Null pointer access")
            : mbo::runtime_error(szWhat)
        {
        }
    };

public:

    inline _Ty& operator*()
    {
        throw nullptr_access();
#if defined(_MSC_VER) && _MSC_VER < 1300
        return *((_Ty*)(0));
#endif
    }

    inline const _Ty& operator*() const
    {
        throw nullptr_access();
#if defined(_MSC_VER) && _MSC_VER < 1300
        return *((const _Ty*)(0));
#endif
    }

    inline operator bool() const
    {
        return false;
    }
};

template <class _Ty, 
          class _THREAD_MODEL,
          class _THREAD_MODEL_PTR
         >
class RefCntConstPtr;

template<class ThreadModel1, class ThreadModel2>
struct AutoFastLock
{
    typedef typename ThreadModel1::Lock  FastLock;
};

template<>
struct AutoFastLock<MultiThreadedModel, SingleThreadedModel>
{
    typedef CLockFake  FastLock;
};

template<>
struct AutoFastLock<SingleThreadedModel, MultiThreadedModel>
{
    typedef CLockFake  FastLock;
};

template<>
struct AutoFastLock<SingleThreadedModel, SingleThreadedModel>
{
    typedef CLockFake  FastLock;
};

/* ------------------------------------------------------------------------ */
template <class _Ty, 
          class _THREAD_MODEL     = ThreadModel,
          class _THREAD_MODEL_PTR = SingleThreadedModel
         >
class RefCntPtr: public AutoFastLock<_THREAD_MODEL, _THREAD_MODEL_PTR>
{
public:
    typedef _THREAD_MODEL                    ThreadModel;    
    typedef _THREAD_MODEL_PTR                ThreadModelPtr; 
    typedef _Ty                              Type;           
    typedef RefCntRep<_Ty, ThreadModel>      RepType;        
    typedef typename RepType::refcount_type  refcount_type;  
    typedef NullPointer<_Ty>                 NullPtr;        
    typedef typename ThreadModel::Lock       ExtLock;        
    typedef typename ThreadModel::CriticalSection CriticalSection;      
    typedef RefCntConstPtr<Type, ThreadModel, ThreadModelPtr> ConstPtr; 
protected:
    RepType* pRep;

    mutable CriticalSection mx;

    inline void __release()
    {
        if (pRep && pRep->Release())
        {
            RepType::Dealloc(pRep); 
        }
    }

public:

    inline RefCntPtr(_IN _Ty* p = 0)
        : pRep(p ? RepType::Alloc(p) : 0) 
    {
    }

    template <class _Tx>
    inline RefCntPtr(_IN const _Tx& x)
        : pRep(RepType::Alloc(new _Tx(x)))
    {
    }

    inline RefCntPtr(_IN const RefCntPtr& oth)
        : pRep(0) 
    {   
        FastLock lock(&oth.mx);

        pRep = oth.pRep;
        if (pRep)
        {
            pRep->AddRef(); 
        }
    }

    inline ~RefCntPtr()
    { 
        FastLock lock(&mx);

        __release();
    }                                              

    inline RefCntPtr& operator=(_IN _Ty* p)
    {
        FastLock lock(&mx);

        if (!pRep || pRep->pData != p)
        {
            __release();
            pRep = p ? RepType::Alloc(p) : 0;
        }
        return *this;
    }

    inline RefCntPtr& __assign(_IN const _Ty & ref)
    {
        FastLock lock(&mx);

        if (pRep) 
        {
            if (pRep->pData)
            {
                *pRep->pData = ref;
            }
            else
            {
                pRep->pData = new _Ty(ref);
            }
        }
        else
        {
            pRep = RepType::Alloc(new _Ty(ref));
        }
        return *this;
    }

    inline _Ty & __clone(_IN _OUT _Ty & ref) const
    {
        FastLock lock(&mx);

        ref = pRep && pRep->pData ? *pRep->pData : *NullPtr();

        return ref;
    }

    inline RefCntPtr& operator=(_IN const RefCntPtr& oth)
    {
        FastLock lock(&mx);

        if (pRep != oth.pRep) 
        {
            __release();
            pRep = oth.pRep; 
            if (pRep)
            {
                pRep->AddRef();
            }
        }
        return *this;
    }

#if !defined(_MSC_VER) || _MSC_VER >= 1300
    typedef const RepType* const RefCntPtr::*unspecified_bool_type;

    inline operator unspecified_bool_type() const
    {
        FastLock lock(&mx);

        return (pRep != 0 && pRep->pData != 0) ? &RefCntPtr::pRep : 0;
    }
#else
    inline operator bool() const
    {
        FastLock lock(&mx);

        return (pRep != 0 && pRep->pData != 0);
    }
#endif

    inline refcount_type __referenceCount() const
    { 
        FastLock lock(&mx);

        return pRep ? pRep->refCnt : 0;
    }

    inline ExtLock __getLock() const
    {
        return ExtLock(&mx);
    }

    inline RepType* __getRep()
    {
        return pRep;
    }

    inline const RepType* __getRep() const
    {
        return pRep;
    }

    inline _Ty& operator*()
    {
        FastLock lock(&mx);

        return pRep && pRep->pData ? *pRep->pData : *NullPtr();
    }

    inline const _Ty& operator*() const
    { 
        FastLock lock(&mx);

        return pRep && pRep->pData ? *pRep->pData : *NullPtr();
    }

    inline _Ty* operator->()
    { 
        FastLock lock(&mx);

        return pRep ? pRep->pData : 0;
    }

    inline const _Ty* operator->() const
    { 
        FastLock lock(&mx);

        return pRep ? pRep->pData : 0;
    }

/*  friend class RefCntPtr<_Ty, _THREAD_MODEL, SingleThreadedModel>;
    operator RefCntPtr<_Ty, _THREAD_MODEL, MultiThreadedModel> () const
    {
        FastLock lock(&mx);

        RefCntPtr<_Ty, _THREAD_MODEL, MultiThreadedModel>  copy;
        if (pRep)
        {
            pRep->AddRef();
            copy.pRep = this->pRep;
        }
        return copy;
    }*/
};

/* ------------------------------------------------------------------------ */
template <class _Ty, 
          class _THREAD_MODEL     = ThreadModel,
          class _THREAD_MODEL_PTR = SingleThreadedModel
         >
class RefCntConstPtr: protected RefCntPtr<_Ty, _THREAD_MODEL, _THREAD_MODEL_PTR>
{
public:

    typedef RefCntPtr<_Ty, _THREAD_MODEL, _THREAD_MODEL_PTR> BaseRefCntPtr;

    using BaseRefCntPtr::ThreadModel;
    using BaseRefCntPtr::ThreadModelPtr;
    using BaseRefCntPtr::Type;
    using BaseRefCntPtr::RepType;
    using BaseRefCntPtr::refcount_type;
    using BaseRefCntPtr::NullPtr;
    using BaseRefCntPtr::CriticalSection;
    using BaseRefCntPtr::FastLock;
    using BaseRefCntPtr::ExtLock;
    using BaseRefCntPtr::ConstPtr;
    
public:

    using BaseRefCntPtr::__getLock;
    using BaseRefCntPtr::__referenceCount;

    // TODO instead of the 'using' clause EA 6.1.792 requires us to use
    // an inline call to the inherited base template class destructor.
#ifndef ENTERPRISE_ARCHITECT

    using BaseRefCntPtr::~RefCntPtr;

#else

    ~RefCntConstPtr()
    {
        BaseRefCntPtr::~RefCntPtr();
    }

#endif //ENTERPRISE_ARCHITECT

#if !defined(_MSC_VER) || _MSC_VER >= 1300
    using BaseRefCntPtr::unspecified_bool_type;
    inline operator unspecified_bool_type() const
    {
        FastLock lock(&mx);

        return (pRep != 0 && pRep->pData != 0) ? &RefCntConstPtr::pRep : 0;
    }
#else
    using BaseRefCntPtr::operator bool;
#endif

    inline const RepType* __getRep() const
    {
        return pRep;
    }

    inline RefCntConstPtr()
        : BaseRefCntPtr()
    {
    }

    inline RefCntConstPtr(_IN const _Ty* p)
        : BaseRefCntPtr()
    {
        operator=(p);
    }

    inline RefCntConstPtr(_IN const BaseRefCntPtr& oth)
        : BaseRefCntPtr(/*oth*/) 
    {
        *this = oth;
    }

    inline RefCntConstPtr(_IN const RefCntConstPtr& oth)
        : BaseRefCntPtr(/*oth*/) 
    {   
        *this = oth;
    }

    inline RefCntConstPtr& operator=(_IN const _Ty* p)
    {
        FastLock lock(&mx);

        if (!pRep || pRep->pData != p)
        {
            __release();
            pRep = p ? RepType::Alloc(const_cast<_Ty*>(p)) : 0;
        }
        return *this;
    }

    inline RefCntConstPtr& operator=(_IN const BaseRefCntPtr& oth)
    {
        FastLock lock(&mx);

        if (pRep != oth.__getRep()) 
        {
            __release();
            pRep = const_cast<BaseRefCntPtr&>(oth).__getRep(); 
            if (pRep)
            {
                pRep->AddRef();
            }
        }
        return *this;
    }

    inline const _Ty& operator*() const
    { 
        FastLock lock(&mx);

        return BaseRefCntPtr::operator*();
    }

    inline const _Ty* operator->() const
    { 
        FastLock lock(&mx);

        return BaseRefCntPtr::operator->();
    }
};

/*
template <class _Ty, 
          class _THREAD_MODEL = ThreadModel
         >
class RefCntPtr<_Ty, _THREAD_MODEL, SingleThreadedModel>: public RefCntPtr<_Ty, _THREAD_MODEL_PTR, SingleThreadedModel>
{
public:

    operator RefCntPtr<_Ty, _THREAD_MODEL, MultiThreadedModel> ()
    {
        RefCntPtr<_Ty, _THREAD_MODEL, MultiThreadedModel>  copy;
        copy.rep = this->rep;
        return copy;
    }
};
*/

template <class _Ty, class _THM, class _THM_PTR>
bool operator< (_IN const RefCntPtr<_Ty, _THM, _THM_PTR> & lhs, _IN const RefCntPtr<_Ty, _THM, _THM_PTR> & rhs)
{
    return lhs && rhs && *lhs < *rhs;
}

template <class _Ty, class _THM, class _THM_PTR>
bool operator== (_IN const RefCntPtr<_Ty, _THM, _THM_PTR> & lhs, _IN const RefCntPtr<_Ty, _THM, _THM_PTR> & rhs)
{
    return lhs && rhs && *lhs == *rhs;
}

template <class _Ty, class _THM, class _THM_PTR>
bool operator!= (_IN const RefCntPtr<_Ty, _THM, _THM_PTR> & lhs, _IN const RefCntPtr<_Ty, _THM, _THM_PTR> & rhs)
{
    return !lhs || !rhs || *lhs != *rhs;
}

#if MBO_USE_DEBUG_NEW
#pragma pop_macro("new")
#endif

}; // namespace mbo

#endif // _MBOREFCNTPTR_H_

---