YiCowPtr.h

Go to the documentation of this file.

// © You i Labs Inc. 2000-2017. All rights reserved.
#ifndef _YI_COWPTR_H_
#define _YI_COWPTR_H_

#include "smartptr/YiDeleteFunctors.h"
#include "smartptr/YiReferenceCounter.h"
#include "utility/YiRtti.h"

template<typename YI_PTR_TYPE, typename YI_DELETE_FUNCTOR = CYICheckedDeleteFunctor<YI_PTR_TYPE> >
class CYICowPtr
{
    template<typename YI_OTHER_PTR_TYPE, typename YI_OTHER_DELETE_FUNCTOR> friend class CYICowPtr;
protected:

    YI_DELETE_FUNCTOR DeleteFunc;
    CYIReferenceCounter *m_pRefCounter;
    YI_PTR_TYPE *m_pData;

    inline void Ref()
    {
        if(m_pData)
        {
            if(!m_pRefCounter)
            {
                m_pRefCounter = new CYIReferenceCounter();
            }
            else
            {
                m_pRefCounter->StrongRef();
                m_pRefCounter->WeakRef();
            }
        }
    }

    inline void Deref()
    {
        if(m_pRefCounter)
        {
            if(m_pRefCounter->StrongDeref() == 0)
            {
                if(m_pData)
                {
                    DeleteFunc(m_pData);
                    m_pData = nullptr;
                }

            }

            if (m_pRefCounter->WeakRef() == 0)
            {
                delete m_pRefCounter;
                m_pRefCounter = nullptr;
            }
        }
    }

public:
    typedef YI_PTR_TYPE * CYICowPtr<YI_PTR_TYPE, YI_DELETE_FUNCTOR>::* YI_UNSPECIFIED_BOOL_TYPE;

    inline CYICowPtr() :
        m_pRefCounter(nullptr),
        m_pData(nullptr)
    {
    }

    inline explicit CYICowPtr(YI_PTR_TYPE *pData) :
        m_pRefCounter(nullptr),
        m_pData(pData)
    {
        Ref();
    }

    inline CYICowPtr(const CYICowPtr<YI_PTR_TYPE, YI_DELETE_FUNCTOR> &rOther) :
            m_pRefCounter(rOther.m_pRefCounter), m_pData(rOther.m_pData)
    {
        Ref();
    }

    template<typename YI_OTHER_PTR_TYPE, typename YI_OTHER_DELETE_FUNCTOR>
    inline CYICowPtr(const CYICowPtr<YI_OTHER_PTR_TYPE, YI_OTHER_DELETE_FUNCTOR> &rOther) :
            m_pRefCounter(rOther.m_pRefCounter), m_pData((YI_PTR_TYPE*) rOther.m_pData)
    {
        Ref();
    }

    inline ~CYICowPtr()
    {
        Deref();
    }

    inline void Detach()
    {
        if (m_pData && GetRefCount() > 1)
        {
            YI_PTR_TYPE *pCloneData = new YI_PTR_TYPE(*m_pData);
            Deref();
            m_pRefCounter = nullptr;
            m_pData = pCloneData;
            Ref();
        }
    }

    inline void Reset()
    {
        *this = CYICowPtr<YI_PTR_TYPE, YI_DELETE_FUNCTOR>();
    }

    inline const YI_PTR_TYPE &operator*() const
    {
        YI_ASSERT(m_pData, "CYICowPtr", "Attempted to dereference a null copy-on-write pointer.");
        return *m_pData;
    }

    inline YI_PTR_TYPE &operator*()
    {
        YI_ASSERT(m_pData, "CYICowPtr", "Attempted to dereference a null copy-on-write pointer.");
        Detach();
        return *m_pData;
    }


    inline const YI_PTR_TYPE *operator->() const
    {
        YI_ASSERT(m_pData, "CYICowPtr", "Attempted to dereference a null copy-on-write pointer.");
        return m_pData;
    }

    inline YI_PTR_TYPE *operator->()
    {
        YI_ASSERT(m_pData, "CYICowPtr", "Attempted to dereference a null copy-on-write pointer.");
        Detach();
        return m_pData;
    }

    inline bool operator!() const
    {
        return m_pData == nullptr;
    }

    inline operator YI_UNSPECIFIED_BOOL_TYPE() const
    {
        return m_pData == nullptr ? nullptr : &CYICowPtr<YI_PTR_TYPE, YI_DELETE_FUNCTOR>::m_pData;
    }

    inline CYICowPtr<YI_PTR_TYPE, YI_DELETE_FUNCTOR> &operator=(const CYICowPtr<YI_PTR_TYPE, YI_DELETE_FUNCTOR> &rOther)
    {
        if (m_pData != rOther.m_pData)
        {
            Deref();
            m_pRefCounter = rOther.m_pRefCounter;
            m_pData = rOther.m_pData;
            Ref();
        }
        return *this;
    }

    template<typename YI_OTHER_PTR_TYPE, typename YI_OTHER_DELETE_FUNCTOR>
    inline CYICowPtr<YI_PTR_TYPE, YI_DELETE_FUNCTOR> &operator=(const CYICowPtr<YI_OTHER_PTR_TYPE, YI_OTHER_DELETE_FUNCTOR> &rOther)
    {
        if (m_pData != rOther.m_pData)
        {
            Deref();
            m_pRefCounter = rOther.m_pRefCounter;
            m_pData = (YI_PTR_TYPE*) rOther.m_pData;
            Ref();
        }
        return *this;
    }

    inline const YI_PTR_TYPE *Get() const
    {
        return m_pData;
    }

    inline bool IsNull() const
    {
        return m_pData == nullptr;
    }

    inline int32_t GetRefCount() const
    {
        if(m_pRefCounter)
        {
            return m_pRefCounter->GetStrongRefCount();
        }
        return 0;
    }

    inline void Swap(CYICowPtr<YI_PTR_TYPE, YI_DELETE_FUNCTOR> &rPtr)
    {
        std::swap(m_pRefCounter, rPtr.m_pRefCounter);
        std::swap(m_pData, rPtr.m_pData);
    }


};


template<typename YI_L_PTR_TYPE, typename YI_L_DELETE_FUNCTOR, typename YI_R_PTR_TYPE, typename YI_R_DELETE_FUNCTOR>
inline bool operator==(const CYICowPtr<YI_L_PTR_TYPE, YI_L_DELETE_FUNCTOR> &rLhs, const CYICowPtr<YI_R_PTR_TYPE, YI_R_DELETE_FUNCTOR> &rRhs)
{
    return rLhs.Get() == rRhs.Get();
}

template<typename YI_L_PTR_TYPE, typename YI_L_DELETE_FUNCTOR, typename YI_R_PTR_TYPE, typename YI_R_DELETE_FUNCTOR>
inline bool operator!=(const CYICowPtr<YI_L_PTR_TYPE, YI_L_DELETE_FUNCTOR> &rLhs, const CYICowPtr<YI_R_PTR_TYPE, YI_R_DELETE_FUNCTOR> &rRhs)
{
    return rLhs.Get() != rRhs.Get();
}

template<typename YI_L_PTR_TYPE, typename YI_L_DELETE_FUNCTOR, typename YI_R_PTR_TYPE>
inline bool operator==(const CYICowPtr<YI_L_PTR_TYPE, YI_L_DELETE_FUNCTOR> &rLhs, const YI_R_PTR_TYPE *pRhs)
{
    return rLhs.Get() == pRhs;
}

template<typename YI_L_PTR_TYPE, typename YI_L_DELETE_FUNCTOR, typename YI_R_PTR_TYPE>
inline bool operator!=(const CYICowPtr<YI_L_PTR_TYPE, YI_L_DELETE_FUNCTOR> &rLhs, const YI_R_PTR_TYPE *pRhs)
{
    return rLhs.Get() != pRhs;
}

template<typename YI_L_PTR_TYPE, typename YI_R_PTR_TYPE, typename YI_R_DELETE_FUNCTOR>
inline bool operator==(const YI_L_PTR_TYPE *pLhs, const CYICowPtr<YI_R_PTR_TYPE, YI_R_DELETE_FUNCTOR> &rRhs)
{
    return pLhs == rRhs.Get();
}

template<typename YI_L_PTR_TYPE, typename YI_R_PTR_TYPE, typename YI_R_DELETE_FUNCTOR>
inline bool operator!=(const YI_L_PTR_TYPE *pLhs, const CYICowPtr<YI_R_PTR_TYPE, YI_R_DELETE_FUNCTOR> &rRhs)
{
    return pLhs != rRhs.Get();
}

#endif /* _YI_COWPTR_H_ */