TnbPointerHandle.h

[詳解]

#pragma once
#include "TnbDef.h"
#pragma warning( disable : 4284 )
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP, typename DELE, INT_PTR NUL = 0>
class CPointerHandleBaseT
{
    struct THead
    {
        LONG    refs;           
        TYP     type;           
        THead(TYP t = reinterpret_cast<TYP>(NUL), LONG l = 1) : refs(l) , type(t) 
        {
        }
    };
 
    THead*  m_ptHead;           
 
    void m_SetHeadNull(void)
    {
        m_ptHead = reinterpret_cast<THead*>(g_plNullBase);
    }
 
    bool m_IsHeadNull(void)
    {
        return m_ptHead == reinterpret_cast<THead*>(g_plNullBase);
    }
 
    void m_Null(void)
    {
        if ( ! m_IsHeadNull() )
        {
            if ( ::InterlockedDecrement(&(m_ptHead->refs)) <= 0 )
            {
                if ( m_ptHead->type != reinterpret_cast<TYP>(NUL) )
                {
                    DELE()(m_ptHead->type);
                }
                delete m_ptHead;
            }
            m_SetHeadNull();
        }
    }
 
public:
 
    CPointerHandleBaseT(void)
    {
        m_SetHeadNull(); 
        if ( NUL != 0 ) { m_ptHead = new THead; }
    }
 
    CPointerHandleBaseT(TYP t)
    {
        m_SetHeadNull();
        operator=(t);
    }
 
    CPointerHandleBaseT(const CPointerHandleBaseT& other)
    {
        m_SetHeadNull();
        operator=(other);
    }
 
    ~CPointerHandleBaseT(void)
    {
        m_Null(); 
    }
 
    CPointerHandleBaseT& operator=(TYP t)
    {
        if ( m_ptHead->type != t )
        {
            if ( t != reinterpret_cast<TYP>(NUL) )
            {
                m_Null();
                m_ptHead = new THead(t);
            }
            else
            {
                Null();
            }
        }
        return *this;
    }
 
    CPointerHandleBaseT& operator=(const CPointerHandleBaseT& other)
    {
        if ( m_ptHead != other.m_ptHead )
        {
            if ( other.IsNull() )
            {
                //t は空。
                Null();
            }
            else if ( InterlockedCompareExchange(&(other.m_ptHead->refs), 2, 1) == 1 )
            {
                //前が１だったら２にして、新しくバッファアドレスを共有
                m_Null();
                m_ptHead = other.m_ptHead;
            }
            else if ( (other.m_ptHead->refs) >= 1 )
            {
                //前が１以上だったら＋１して、新しくバッファアドレスを共有
                m_Null();
                other.m_ptHead->refs++; // 参照数をプライス１
                m_ptHead = other.m_ptHead;
            }
        }
        ASEERT_NULLBASE;
        return *this;
    }
 
    bool IsNull(void) const 
    {
        return m_ptHead->type == reinterpret_cast<TYP>(NUL);
    }
 
    int SetReferCount(int iCount)
    {
        if ( m_IsHeadNull() ){ return 0; }
        return ::InterlockedExchange(&(m_ptHead->refs), iCount);
    }
 
    int GetReferCount(void) const { return m_ptHead->refs; }
 
    void Null(void)
    {
        m_Null();
        if ( NUL != 0 )
        {
            m_ptHead = new THead;
        }
    }
 
    TYP* ReferP(void) { return &(m_ptHead->type); }
 
    TYP const* ReferP(void) const { return &(m_ptHead->type); }
 
    operator TYP(void) { return m_ptHead->type; }
 
    operator const TYP(void) const { return m_ptHead->type; }
 
    TYP operator->(void) { return m_ptHead->type; }
 
    const TYP operator->(void) const { return m_ptHead->type; }
 
    bool operator==(TYP t) const { return m_ptHead->type == t; }
 
    bool operator!=(TYP t) const { return ! operator==(t); }
 
private:
    friend class CPointerHandleTest;    
};
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
struct TPhDeleteSinglePtr
{
    template<typename TYP> void operator()(TYP* P) { delete P; }
};
struct TPhDeleteArrayPtr
{
    template<typename TYP> void operator()(TYP* P) { delete[] P; }
};
 
#endif // _TnbDOXYGEN
 
 
 
template<typename TYP>
class CPointerHandleT : public CPointerHandleBaseT<TYP*, TPhDeleteSinglePtr>
{
    typedef CPointerHandleBaseT<TYP*, TPhDeleteSinglePtr> _super;   
    DEFSUPER(_super);
public:
 
    CPointerHandleT(void) : _super() 
    {
    }
 
    CPointerHandleT(TYP* P) : _super(P) 
    {
    }
 
    CPointerHandleT(const CPointerHandleT& t) : _super(t) 
    {
    }
 
    TYP& operator*(void) { return **_super::ReferP(); }
 
    const TYP& operator*(void) const { return **_super::ReferP(); }
};
 
 
 
template<typename TYP>
class CArrayPtrHandleT : public CPointerHandleBaseT<TYP*, TPhDeleteArrayPtr>
{
    typedef CPointerHandleBaseT<TYP*, TPhDeleteArrayPtr> _super;    
    DEFSUPER(_super);
public:
 
    CArrayPtrHandleT(void) : _super() 
    {
    }
 
    CArrayPtrHandleT(TYP* P) : _super(P) 
    {
    }
 
    CArrayPtrHandleT(const CArrayPtrHandleT& t) : _super(t) 
    {
    }
 
    TYP& operator[](int ind) { return (*_super::ReferP())[ind]; }
 
    const TYP& operator[](int ind) const { return (*_super::ReferP())[ind]; }
};
 
 
 
};//TNB