cRefPtr.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cRefPtr_H
#define _INC_cRefPtr_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cPtrFacade.h"
#include "cInterlockedVal.h"
#include "IUnknown.h"
#include "cTimeSys.h"   // TIMESYSD_t
#include "cMem.h"
 
namespace Gray
{
        class GRAYCORE_LINK cRefBase : public IUnknown  // virtual
        {
 
#ifdef _DEBUG
                static const int k_REFCOUNT_DEBUG = 0x20000000;         
#endif
                static const int k_REFCOUNT_STATIC = 0x40000000;        
                static const int k_REFCOUNT_DESTRUCT = 0x80000000;      
                static const int k_REFCOUNT_MASK = 0xE0000000;          
 
        private:
                mutable cInterlockedInt m_nRefCount;    
 
        private:
                void _InternalAddRef() noexcept
                {
#ifdef _DEBUG
                        DEBUG_CHECK(isValidObj());
                        DEBUG_CHECK(!isDestructing());
                        const int iRefCount = get_RefCount();
                        if (isSmartDebug())
                        {
                                ASSERT(iRefCount != 123123);    // dummy for breakpoint.
                        }
                        ASSERT(iRefCount < (~k_REFCOUNT_MASK));
#endif
                        m_nRefCount.IncV();
                }
                void _InternalRelease()
                {
#ifdef _DEBUG
                        ASSERT(isValidObj());
                        ASSERT(!isDestructing());
                        const int iRefCount2 = get_RefCount();
                        if (isSmartDebug())
                        {
                                ASSERT(iRefCount2 != 123123); // dummy for breakpoint.
                        }
#endif
                        const int iRefCount = m_nRefCount.Dec();
                        if (iRefCount == 0)
                        {
                                onFinalRelease();
                        }
                        else
                        {
                                ASSERT(iRefCount > 0);
                        }
                }
 
        public:
 
                explicit cRefBase(int iRefCount = 0) noexcept
                        : m_nRefCount(iRefCount)
                {
                }
                virtual ~cRefBase()
                {
                        ASSERT(get_RefCount() == 0);
                }
 
                int get_RefCount() const noexcept
                {
                        return m_nRefCount.get_Value() & ~k_REFCOUNT_MASK;
                }
                HASHCODE_t get_HashCode() const noexcept
                {
                        return ((HASHCODE_t)(UINT_PTR)(void*)this);
                }
                STDMETHOD_(HASHCODE_t, get_HashCodeX)() const noexcept 
                {
                        return get_HashCode();
                }
 
                // do something when no-one wants this anymore. cache or delete?
                virtual void onFinalRelease()
                {
                        SetDestructing();
                        delete this;
                }
 
                bool isValidObj() const noexcept
                {
                        // Is this really a valid object?
                        // does it have proper vtable ?
                        if (!cMem::IsValid(this))
                                return false;
#if defined(_DEBUG) && ! defined(__GNUC__)
                        return IS_TYPE_OF(cRefBase, this);
#else
                        return true;
#endif
                }
 
                // COM IUnknown compliant methods.
                STDMETHOD_(ULONG, AddRef)(void) override
                {
                        _InternalAddRef();
                        return (ULONG)get_RefCount();
                }
                STDMETHOD_(ULONG, Release)(void) override
                {
                        int iRefCount = get_RefCount();
                        _InternalRelease();     // this could get deleted here!
                        return (ULONG)(iRefCount - 1);
                }
                STDMETHOD(QueryInterface)(const IID& riid, /* [iid_is][out] */ void __RPC_FAR* __RPC_FAR* ppvObject) override
                {
                        if (cMem::Compare(&riid, &__uuidof(IUnknown), sizeof(riid)) == 0)
                        {
                                *ppvObject = this;
                                _InternalAddRef();
                                return S_OK;
                        }
                        *ppvObject = nullptr;
                        return E_NOINTERFACE;   // E_NOTIMPL
                }
 
#if 0 // def _DEBUG // for testing.
                void IncRefCount()
                {
                        AddRef();
                }       // always go through the COM interface!
                void DecRefCount()
                {
                        Release();
                }
#else
                void IncRefCount()
                {
                        _InternalAddRef();
                }
                void DecRefCount()
                {
                        _InternalRelease();
                }
#endif
 
                bool isStaticConstruct() const noexcept
                {
                        return(m_nRefCount.get_Value() & k_REFCOUNT_STATIC) ? true : false;
                }
                void StaticConstruct()
                {
                        ASSERT(m_nRefCount.get_Value() == 0);  // only call in constructor!
                        m_nRefCount.AddX(k_REFCOUNT_STATIC);
                }
                void StaticDestruct()
                {
                        ASSERT(isStaticConstruct());
                        m_nRefCount.put_Value(0);
                }
 
                bool isDestructing() noexcept
                {
                        return(m_nRefCount.get_Value() & k_REFCOUNT_DESTRUCT) ? true : false;
                }
                void SetDestructing()
                {
                        if (isDestructing())
                                return;
                        ASSERT(get_RefCount() == 0);
                        m_nRefCount.put_Value(k_REFCOUNT_DESTRUCT);
                }
 
#ifdef _DEBUG
                bool isSmartDebug() const
                {
                        return(m_nRefCount.get_Value() & k_REFCOUNT_DEBUG) ? true : false;
                }
                void SetSmartDebug()
                {
                        if (isSmartDebug())
                                return;
                        m_nRefCount.AddX(k_REFCOUNT_DEBUG);
                }
#endif
        };
 
        template<class TYPE = cRefBase >
        class cRefPtr
                : public cPtrFacade < TYPE >
        {
 
                typedef cRefPtr<TYPE> THIS_t;
                typedef cPtrFacade<TYPE> SUPER_t;
 
        protected:
                void IncRefFirst()  
                {
                        if (this->m_p != nullptr)
                        {
                                cRefBase* p = this->m_p;
                                p->IncRefCount();
#ifdef _DEBUG
                                ASSERT(!isCorruptPtr());
#endif
                        }
                }
 
        public:
                cRefPtr() noexcept
                {
                }
                cRefPtr(const TYPE* p2)
                        : cPtrFacade<TYPE>(const_cast<TYPE*>(p2))
                {
                        IncRefFirst();
                }
                cRefPtr(const THIS_t& ref)
                        : cPtrFacade<TYPE>(ref.get_Ptr())
                {
                        IncRefFirst();
                }
 
#if 0
                cRefPtr(THIS_t&& ref)
                        : cPtrFacade<TYPE>(ref)
                {
                }
#endif
 
                cRefPtr(const TYPE* p2, TIMESYSD_t dwWaitMS)
                        : cPtrFacade<TYPE>(const_cast<TYPE*>(p2))
                {
                        UNREFERENCED_PARAMETER(dwWaitMS);
                        IncRefFirst();
                }
                ~cRefPtr()
                {
                        ReleasePtr();
                }
 
                bool isValidPtr() const
                {
#ifdef _DEBUG
                        ASSERT(!isCorruptPtr());
#endif
                        return this->m_p != nullptr;
                }
                bool isCorruptPtr() const
                {
                        if (this->m_p == nullptr)       // nullptr is not corrupt.
                                return false;
                        // ASSERT( DYNPTR_CAST(TYPE,this->m_p) != nullptr );
                        cRefBase* p = DYNPTR_CAST(cRefBase, this->m_p);
                        if (p == nullptr)
                                return true;
                        if (p->get_RefCount() <= 0)
                                return true;
                        return false;
                }
                void put_Ptr(TYPE* p)
                {
                        if (p != this->m_p)
                        {
                                ReleasePtr();
                                this->AttachPtr(p);
                                IncRefFirst();
                        }
                }
                void ReleasePtr()
                {
                        TYPE* p2 = this->m_p;
                        if (p2 != nullptr)
                        {
#ifdef _DEBUG
                                ASSERT(!isCorruptPtr());
#endif
                                this->m_p = nullptr;    // make sure possible destructors called in DecRefCount don't reuse this.
                                p2->DecRefCount();      // this might delete this ?
                        }
                }
                int get_RefCount() const
                {
                        if (this->m_p == nullptr)
                                return 0;
                        return this->m_p->get_RefCount();
                }
 
                // Assignment ops.
                THIS_t& operator = (const TYPE* p2)
                {
                        put_Ptr(const_cast<TYPE*>(p2));
                        return *this;
                }
                THIS_t& operator = (const THIS_t& ref)
                {
                        put_Ptr(ref.get_Ptr());
                        return *this;
                }
 
#if 0
                THIS_t& operator = (THIS_t&& ref)
                {
                        this->m_p = ref.m_p; ref.m_p = nullptr;
                        return *this;
                }
#endif
 
#if 1
                template<class _TYPE_2> operator cRefPtr<_TYPE_2>() const
                {
                        return cRefPtr<_TYPE_2>((this->m_p)); // this will automatically give an error if classes are unrelated. static_cast<_TYPE_2>
                }
#endif
 
        };
 
        // The lowest (un-type checked) smart pointer.
        typedef GRAYCORE_LINK cRefPtr<> cRefBasePtr;
 
#ifdef GRAY_DLL // force implementation/instantiate for DLL/SO.
        template class GRAYCORE_LINK cRefPtr < cRefBase >;
#endif
 
}
 
#endif // _INC_cRefPtr_H