TnbUnion.h

[詳解]

#pragma once
#include "TnbPointerHandle.h"
#include "TnbException.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CUnion
{
public:
 
    struct IFuncBase
    {
        virtual ~IFuncBase(void) {}
        virtual void Destractor(LPVOID V) = 0;
    };
 
 
    //-----------------
 
 
    CUnion(void) : m_hpHead(new THead) 
    {
    }
 
    template<typename T>
    CUnion(const T& t, DWORD dwParam = 0) : m_hpHead(new THead)
    {
        m_hpHead->Set(t, dwParam, new CFuncT<T>);
    }
 
    CUnion(const CUnion& other) : m_hpHead(other.m_hpHead)
    {
    }
 
    ~CUnion(void)
    {
        Empty();
    }
 
    CUnion& operator=(const CUnion& other)
    {
        m_hpHead = other.m_hpHead;
        return *this;
    }
 
    void Empty(void)
    {
        m_hpHead = new THead;
    }
 
    template<typename T>
    void Set(const T& t, DWORD dwParam = 0)
    {
        m_hpHead = new THead;
        m_hpHead->Set(t, dwParam, new CFuncT<T>);
    }
 
    DWORD GetParam(void) const
    {
        return m_hpHead->m_dwParam;
    }
 
    template<typename T>
    bool Get(T& _t) const
    {
        #ifdef _DEBUG
            if ( strcmp(m_hpHead->m_strType, typeid(T).name()) != 0 )
            {
                return false;   //型が異なる
            }
        #endif
        if ( m_hpHead->m_dwSizeof != sizeof(T) )
        {
            return false;   //型が異なる
        }
        _t = *(static_cast<const T*>(m_hpHead->m_pVal));
        return true;
    }
 
    template<typename T>
    const T& Ref(T* P) const 
    {
        #ifdef _DEBUG
            if ( strcmp(m_hpHead->m_strType, typeid(T).name()) != 0 )
            {
                throw CNoSuchTypeException();   //型が異なる
            }
        #endif
        if ( m_hpHead->m_dwSizeof != sizeof(T) )
        {
            throw CNoSuchTypeException();   //型が異なる
        }
        return *(static_cast<const T*>(m_hpHead->m_pVal));
    }
 
    LPCSTR GetTypeName(void) const
    {
        #ifdef _DEBUG
            return m_hpHead->m_strType;
        #else
            return "";
        #endif
    }
 
protected:
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
 
    struct THead
    {
        IFuncBase*      m_pFuncBase;    
        LPVOID          m_pVal;         
        DWORD           m_dwSizeof;     
        DWORD           m_dwParam;      
        #ifdef _DEBUG
            CSimpleAscii m_strType;     
        #endif
        THead(void) : m_pFuncBase(NULL), m_pVal(NULL), m_dwSizeof(0), m_dwParam(0)
        {
        }
        ~THead(void)
        {
            if ( m_pFuncBase != NULL )
            {
                m_pFuncBase->Destractor(m_pVal);
                delete m_pFuncBase;
                m_pFuncBase = NULL;
            }
        }
        template<typename T>
        void Set(const T& t, DWORD dwParam, IFuncBase* P = NULL)
        {
            m_pFuncBase     = P;
            m_pVal          = new T(t);
            m_dwParam       = dwParam;
            m_dwSizeof      = sizeof(T);
            #ifdef _DEBUG
                m_strType   = typeid(T).name();
            #endif
        }
    };
 
    template<typename T>
    struct CFuncT : IFuncBase
    {
        virtual void Destractor(LPVOID V)
        {
            delete static_cast<T*>(V);
        }
    };
 
    #endif // _TnbDOXYGEN
 
    CPointerHandleT<THead> m_hpHead;    
};
 
 
 
class CUnionEx : public CUnion
{
    DEFSUPER(CUnion);
public:
 
    struct IFuncBaseEx : CUnion::IFuncBase
    {
        virtual void ToString(CSimpleStr& _s, LPVOID V) = 0;
    };
 
 
    //------------
 
 
    CUnionEx(void) : _super() 
    {
    }
 
    template<typename T>
    CUnionEx(const T& t, DWORD dwParam = 0) : m_hpHead(new THead)
    {
        m_hpHead->Set(t, dwParam, new CFuncT<T>);
    }
 
    CUnionEx(const CUnionEx& other) : _super(other)
    {
    }
 
    template<typename T>
    void Set(const T& t, DWORD dwParam = 0)
    {
        m_hpHead = new THead;
        m_hpHead->Set(t, dwParam, new CFuncT<T>);
    }
 
    void ToString(CSimpleStr& _s) const
    {
        if ( m_hpHead->m_pFuncBase == NULL )
        {
            throw CNullPointerException();
        }
        reinterpret_cast<IFuncBaseEx*>(m_hpHead->m_pFuncBase)->ToString(_s, m_hpHead->m_pVal);
    }
 
private:
    template<typename T>
    struct CFuncT : CUnionEx::IFuncBaseEx
    {
        virtual void Destractor(LPVOID V)
        {
            delete static_cast<T*>(V);
        }
        virtual void ToString(CSimpleStr& _s, LPVOID V)
        {
            _s = static_cast<T*>(V)->ToString();
        }
    };
};
 
 
 
};//TNB
 
 
 
#if 0
    int i = 99;
    CStr s = "A";
    CString ss ="X"; 
    CUnion u(i);
    CUnion u2(u);
    TRACE1("%s\n",u.GetTypeName());
    TRACE1("%s\n",u2.GetTypeName());
    u.Put(ss);
    TRACE1("%s\n",u.GetTypeName());
    u.Put(s);
    u.Put(s);
    VERIFY( u.Get(s) );
    VERIFY( ! u2.Get(s) );
    TRACE1("%s\n",u.GetTypeName());
    TRACE1("%s\n",u2.GetTypeName());
    TRACE1("%d\n",u.Ref((CStr*)0).GetLength());
    TRACE1("%s\n",u.Ref((CStr*)0));
    TRACE1("%d\n",u2.Ref((int*)0));
    u.Put(i);
    u.Get(i);
    TRACE1("%s\n",u.GetTypeName());
    TRACE1("%s\n",u2.GetTypeName());
#endif