TnbStr.h

[詳解]

#pragma once
#include "TnbSerializer.h"
#include "TnbStrLib.h"
#include "TnbTinyStringFormater.h"
 
 
 
//T-TestCaseコードカバレッジDisable
#pragma comment(user,"T-Coverage Disable")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#ifndef _TnbDOXYGEN //Document 作成用シンボル
 // CStrTのNULL状態
// _SELECTANY LPCVOID gpStrNull = &g_plNullBase[3];
#define gpStrNull (LPCVOID)(&(g_plNullBase[3]))
#endif
 
 
 
template<typename TYP>
class CStrT
{
public:
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
    // const_iterator型宣言
    typedef const TYP* const_iterator;
    // iterator型宣言
    typedef TYP* iterator;
    #endif //_TnbDOXYEM
 
    const_iterator begin(void) const { return m_lpBuf; }
 
    const_iterator end(void) const { return begin() + GetLength(); }
 
    iterator begin(void) { GetBuffer(); ReleaseBuffer(); return m_lpBuf; }
 
    iterator end(void) { return begin() + GetLength(); }
 
    iterator insert(iterator ite, const TYP& t = TYP())
    {
        INDEX index = ite - begin();
        Insert(index, t);
        return begin() + index;
    }
 
    void push_front(TYP t) { Insert(0, t); }
 
    void push_back(TYP t) { operator+=(t); }
 
 
    //-------------------------
 
 
    CStrT(void)
    {
        m_InitBuf(); 
    }
 
    CStrT(const CStrT& str)
    {
        if ( ! str.IsEmpty() )
        {
            ::InterlockedIncrement(str.m_GetRefP());
            m_lpBuf = str.m_lpBuf;
        }
        else
        {
            m_InitBuf();
        }
    }
 
    CStrT(const char* lpText)
    {
        if ( lpText != NULL && *lpText != 0 )
        {
            m_lpBuf = ms_NewBuf(TYP(), lpText);
        }
        else
        {
            m_InitBuf();
        }
    }
 
    CStrT(const WCHAR* lpText)
    {
        if ( lpText != NULL && *lpText != 0 )
        {
            m_lpBuf = ms_NewBuf(TYP(), lpText);
        }
        else
        {
            m_InitBuf();
        }
    }
 
    void Empty(void)
    {
        if ( m_lpBuf != static_cast<const TYP*>(gpStrNull) ) 
        {
            if ( ::InterlockedDecrement(m_GetRefP()) <= 0 ) 
            {
                ms_Delete(m_lpBuf);
            }
            m_InitBuf();
        }
        ASEERT_NULLBASE;
    }
 
    ~CStrT(void)
    {
        Empty(); 
    }
 
    CStrT& operator=(const CStrT& other)
    {
        if ( ! other.IsEmpty() )
        {
            ::InterlockedIncrement(other.m_GetRefP());
            m_SetBuf(other.m_lpBuf);
        }
        else
        {
            Empty();
        }
        return *this;
    }
 
    CStrT& operator=(const char* lpText)
    {
        if ( lpText != NULL && *lpText != 0 )
        {
            m_SetBuf(ms_NewBuf(TYP(), lpText));
        }
        else 
        {
            Empty();
        }
        return *this;
    }
 
    CStrT& operator=(const WCHAR* lpText)
    {
        if ( lpText != NULL && *lpText != 0 ) 
        {
            m_SetBuf(ms_NewBuf(TYP(), lpText));
        }
        else 
        {
            Empty();
        }
        return *this;
    }
 
    CStrT& SetFromLeft(const TYP* lpText, size_t iLen)
    {
        if ( lpText == NULL || STRLIB::GetLen(lpText) <= iLen )
        {
            operator=(lpText);
        }
        else if ( iLen <= 0 )
        {
            Empty();
        }
        else
        {
            TYP* P = ms_NewBuf(TYP(), ms_NullStr(), iLen);
            MemCopy(P, lpText, iLen);
            P[iLen] = 0;
            ms_CalcInfoPointer(P)->lLength = iLen;
            m_SetBuf(P);
        }
        return *this;
    }
 
    CStrT& operator+=(const char* lpText)
    {
        return m_AddText(lpText);
    }
 
    CStrT& operator+=(const WCHAR* lpText)
    {
        return m_AddText(lpText);
    }
 
    CStrT& operator+=(TYP t)
    {
        TYP at[2] = {t, 0};
        return operator+=(at);
    }
 
    void FormatV(const TYP* lpszFormat, va_list V)
    {
        m_SetBuf(ms_Format(lpszFormat, V));
    }
 
    void Format(const TYP* lpszFormat, ...)
    {
        va_list args;
        va_start(args, lpszFormat);
        FormatV(lpszFormat, args);
        va_end(args);
    }
 
    operator const TYP*(void) const
    {
        return m_lpBuf;
    }
 
    const TYP* ReferBuffer(void) const
    {
        return m_lpBuf;
    }
 
    void SetAt(INDEX index, TYP t)
    {
        if ( ! IsInRange(index, GetLength()) )
        {
            ASSERT1( false, "CStrT::SetAt()", "範囲外のIndex(%d)が指定されました。", index );
            return;
        }
        m_Separate();
        m_lpBuf[index] = t;
    }
 
    void Insert(INDEX index, const TYP* lpText)
    {
        if ( GetLength() <= index )
        {
            m_AddText(lpText);
            return;
        }
        size_t iAddSize = STRLIB::GetLen(lpText);
        size_t iNowSize = GetLength();
        if ( *(m_GetRefP()) != 1 || m_GetBufSize() <= iAddSize + iNowSize )
        {
            TYP* P = ms_NewBuf(TYP(), m_lpBuf, iAddSize);   //足りないので新たに確保
            m_SetBuf(P);
        }
        // ずらす(NUL文字も含めるので、LOOP一回多くしている) 
        for ( INT_PTR i = iNowSize - index; i >= 0; i-- )
        {
            m_lpBuf[index + i + iAddSize] = m_lpBuf[index + i];
        }
        // 植え込み
        loop ( i, iAddSize )
        {
            m_lpBuf[index + i] = lpText[i];
        }
        m_GetInfoP()->lLength = iAddSize + iNowSize;
    }
 
    void InsertAt(INDEX index, TYP c)
    {
        TYP buf[2] = { c, 0 };
        Insert(index, buf);
    }
 
    int Delete(INDEX index, size_t iLen = 1)
    {
        if ( ! IsInRange(index, GetLength()) )
        {
            ASSERT1( false, "CStrT::Delete()", "範囲外のIndex(%d)が指定されました。", index );
            return 0;
        }
        if ( iLen == 0 )
        {
            ASSERT1( false, "CStrT::Delete()", "範囲外の長さ(%d)が指定されました。", 0 );
            return 0;
        }
        iLen--;
        if ( index + iLen >= GetLength() )
        {
            *this = Left(index);
            return 0;
        }
        m_Separate();
        size_t iDelSize = STRLIB::GetCharSize(m_lpBuf[index + iLen]) + iLen;
        size_t iSize = GetLength() - iDelSize;
        for ( size_t i = index; i < iSize; i++ ) 
        {
            m_lpBuf[i] = m_lpBuf[i + iDelSize];
        }
        m_lpBuf[iSize] = 0;
        m_GetInfoP()->lLength -= iDelSize;
        ASSERTLIB( STRLIB::GetLen(m_lpBuf) == GetLength() );
        return iDelSize;
    }
 
    void DeleteLast(void)
    {
        INT_PTR len = GetLength();
        if ( len > 0 )
        {
            m_Separate();
            m_lpBuf[len - 1] = 0;
            m_GetInfoP()->lLength -= 1;
            ASSERTLIB( STRLIB::GetLen(m_lpBuf) == GetLength() );
        }
    }
 
    TYP GetAt(INDEX index) const
    {
        if ( IsInRange(index, GetLength()) )
        {
            return m_lpBuf[index];
        }
        ASSERT1( false, "CStrT::GetAt()", "範囲外のIndex(%d)が指定されました。", index );
        return 0;
    }
 
    size_t GetLength(void) const
    {
        return m_GetInfoP()->lLength;
    }
 
    bool IsEmpty(void) const
    {
        return m_GetInfoP()->lLength == 0;
    }
 
    INT_PTR Find(TYP t, INDEX iFromIndex = 0) const
    {
        return STRLIB::IndexOf(m_lpBuf, t, iFromIndex);
    }
 
    INT_PTR Find(const TYP* lpsz, INDEX iFromIndex = 0) const
    {
        return STRLIB::IndexOf(m_lpBuf, lpsz, iFromIndex);
    }
 
    INT_PTR FindOneOf(const TYP* lpsz, INDEX iFromIndex = 0) const
    {
        return STRLIB::IndexOneOf(m_lpBuf, lpsz, iFromIndex);
    }
 
    INT_PTR ReverseFind(TYP t) const
    {
        INT_PTR lRc = -1;
        INT_PTR iPos = 0;
        while ( true )
        {
            INT_PTR r = STRLIB::IndexOf(m_lpBuf, t, iPos);
            if ( r < 0 )
            {
                break;
            }
            lRc = r;
            iPos = r + STRLIB::GetCharSize(m_lpBuf[r]);
        }
        return lRc;
    }
 
    INT_PTR ReverseFind(const TYP* lpsz) const
    {
        INT_PTR lRc = -1;
        INT_PTR iPos = 0;
        while ( true )
        {
            INT_PTR r = STRLIB::IndexOf(m_lpBuf, lpsz, iPos);
            if ( r < 0 )
            {
                break;
            }
            lRc = r;
            iPos = r + STRLIB::GetCharSize(m_lpBuf[r]);
        }
        return lRc;
    }
 
    INT_PTR ReverseFindOneOf(const TYP* lpsz) const
    {
        INT_PTR lRc = -1;
        INT_PTR iPos = 0;
        while ( true )
        {
            INT_PTR r = STRLIB::IndexOneOf(m_lpBuf, lpsz, iPos);
            if ( r < 0 )
            {
                break;
            }
            lRc = r;
            iPos = r + STRLIB::GetCharSize(m_lpBuf[r]);
        }
        return lRc;
    }
 
    int operator-(const TYP* lpszSubject) const
    {
        return Compare(lpszSubject);
    }
 
    int Compare(const TYP* lpszSubject) const
    {
        return STRLIB::Compare(m_lpBuf, lpszSubject);
    }
 
    bool IsEqual(const TYP* lpszSubject) const { return Compare(lpszSubject) == 0; }
 
    int CompareNoCase(const TYP* lpszSubject) const
    {
        return STRLIB::Compare(m_lpBuf, lpszSubject, -1, NORM_IGNORECASE);
    }
 
    int CompareByOption(const TYP* lpszSubject, DWORD dwCmpFlags) const
    {
        return STRLIB::Compare(m_lpBuf, lpszSubject, -1, dwCmpFlags);
    }
 
    bool IsEqualNoCase(const TYP* lpszSubject) const { return CompareNoCase(lpszSubject) == 0; }
 
    bool operator==(const TYP* lpszSubject) const { return Compare(lpszSubject) == 0; }
 
    bool operator!=(const TYP* lpszSubject) const { return Compare(lpszSubject) != 0; }
 
    bool operator>(const TYP* lpszSubject) const { return Compare(lpszSubject) > 0; }
 
    bool operator>=(const TYP* lpszSubject) const { return Compare(lpszSubject) >= 0; }
 
    bool operator<(const TYP* lpszSubject) const { return Compare(lpszSubject) < 0; }
 
    bool operator<=(const TYP* lpszSubject) const { return Compare(lpszSubject) <= 0; }
 
    CStrT Mid(INDEX iOffset, size_t iSize = INVALID_SIZE) const
    {
        CStrT str;
        size_t l = GetLength();
        if ( l > iOffset && iSize != 0 )
        {
            if ( iSize == INVALID_SIZE || iOffset + iSize > l )
            {
                iSize = l - iOffset;
            }
            // = サイズの補正
            if ( sizeof(TYP) == 1 )
            {
                size_t iPos = 0;
                while ( iPos < iSize )
                {
                    iPos += STRLIB::GetCharSize(m_lpBuf[iOffset + iPos]);
                }
                iSize = iPos;
            }           
            TYP* P = ms_NewBuf(TYP(), ms_NullStr(), iSize);
            MemCopy(P, &m_lpBuf[iOffset], iSize);
            P[iSize] = 0;
            ms_CalcInfoPointer(P)->lLength = iSize;
            str.m_SetBuf(P);
            ASSERTLIB( STRLIB::GetLen(str.m_lpBuf) == str.GetLength() );
        }
        return str;
    }
 
    CStrT Left(size_t iSize) const
    {
        return Mid(0, iSize);
    }
 
    CStrT Right(INT_PTR iSize) const
    {
        size_t l = GetLength();
        if ( static_cast<size_t>(iSize) > l )
        {
            return *this;
        }
        return Mid(l - iSize);
    }
 
    CStrT Sandwich(const TYP* lpszBefore, const TYP* lpszAfter) const
    {
        CStrT str = lpszBefore;
        str += m_lpBuf;
        str += lpszAfter;
        return str;
    }
 
    int ToInt(INDEX iOffset = 0, int iBase = 10) const
    {
        int i = 0;
        if ( IsInRange(iOffset, GetLength()) )
        {
            i = STRLIB::ToInt(&m_lpBuf[iOffset], iBase);
        }
        return i;
    }
 
    DWORD ToDword(INDEX iOffset = 0, int iBase = 10) const
    {
        int i = 0;
        if ( IsInRange(iOffset, GetLength()) )
        {
            i = STRLIB::ToDword(&m_lpBuf[iOffset], iBase);
        }
        return i;
    }
 
    double ToDouble(INDEX iOffset = 0) const
    {
        double a = 0;
        if ( IsInRange(iOffset, GetLength()) )
        {
            a = STRLIB::ToDouble(&m_lpBuf[iOffset]);
        }
        return a;
    }
 
    LONGLONG ToLonglong(INDEX iOffset = 0) const
    {
        LONGLONG ll = 0;
        if ( IsInRange(iOffset, GetLength()) )
        {
            ll = STRLIB::ToLonglong(&m_lpBuf[iOffset]);
        }
        return ll;
    }
 
    TYP* GetBuffer(size_t iLength = 0)
    {
        size_t lNowBufSize = m_GetBufSize();
        if ( lNowBufSize == 0 )
        {
            //今、空っぽ
            if ( iLength > 0 )
            {
                m_SetBuf(ms_New(TYP(), iLength + 1));
                *m_lpBuf = 0;
            }
            else
            {
                return NULL;
            }
        }
        else if ( lNowBufSize < iLength )
        {
            //サイズ拡張
            TYP* P = ms_New(TYP(), iLength); 
            MemCopy(P, m_lpBuf, lNowBufSize);
            m_SetBuf(P);
        }
        else if ( *(m_GetRefP()) > 1 )
        {
            //共有している,複製する必要有り
            TYP* P = ms_New(TYP(), lNowBufSize); 
            MemCopy(P, m_lpBuf, lNowBufSize);
            m_SetBuf(P);
        }
        m_GetInfoP()->lLength = 0;
        return m_lpBuf;
    }
 
    void ReleaseBuffer(void)
    {
        if ( *(m_GetRefP()) == 1 )
        {
            m_GetInfoP()->lLength = STRLIB::GetLen(m_lpBuf);
        }
    }
 
    CStrT& TrimLeft(TYP t = ' ')
    {
        return m_TrimLeft(t);
    }
 
    CStrT& TrimLeft(const TYP* lpsz)
    {
        return m_TrimLeft(lpsz);
    }
 
    CStrT& TrimRight(TYP t = ' ')
    {
        return m_TrimRight(t);
    }
 
    CStrT& TrimRight(const TYP* lpsz)
    {
        return m_TrimRight(lpsz);
    }
 
    CStrT& Trim(TYP t = ' ')
    {
        m_TrimLeft(t);
        return m_TrimRight(t);
    }
 
    CStrT& Trim(const TYP* lpsz)
    {
        m_TrimLeft(lpsz);
        return m_TrimRight(lpsz);
    }
 
    int Replace(TYP tOld, TYP tNew)
    {
        return m_Replace(tOld, tNew);
    }
 
    int Replace(const TYP* lpszOld, TYP tNew)
    {
        return m_Replace(lpszOld, tNew);
    }
 
    int Replace(const TYP* lpszOld, const TYP* lpszNew)
    {
        int iRc = 0;
        if ( lpszOld != NULL) 
        {
            size_t iOldLen = STRLIB::GetLen(lpszOld);
            size_t iNewLen = (lpszNew == NULL) ? 0 : STRLIB::GetLen(lpszNew);
            size_t iLength = GetLength();
            //いくつあるか調べる
            int iCount = 0;
            INT_PTR index = 0;
            INT_PTR r;
            while ( (r = STRLIB::IndexOf(m_lpBuf, lpszOld, index)) >= 0 )
            {
                iCount++;
                index = r + iOldLen;
            }
            iLength += (iNewLen - iOldLen) * iCount;
            //確保して順次コピーする
            TYP* P = ms_NewBuf(TYP(), ms_NullStr(), iLength);
            TYP* pNew = P;
            TYP* pOld = m_lpBuf;
            while ( (r = STRLIB::IndexOf(pOld, lpszOld, 0)) >= 0 )
            {
                MemCopy(pNew, pOld, r);         //キー文字までコピー
                pNew += r;
                MemCopy(pNew, lpszNew, iNewLen);    //新しい文字をコピー
                pNew += iNewLen;
                pOld += iOldLen+r;
                iRc++;
            }
            MemCopy(pNew, pOld, STRLIB::GetLen(pOld) + 1);
            m_SetBuf(P);
            m_GetInfoP()->lLength = iLength;
            ASSERTLIB( STRLIB::GetLen(m_lpBuf) == GetLength() );
        }
        return iRc;
    }
 
    int Remove(TYP t)
    {
        TYP aBuf[2] = {t, 0};
        const TYP* P = NULL;
        return Replace(aBuf, P);
    }
 
    CStrT FindCut(TYP c, CStrT* _pstrRest = NULL) const
    {
        INT_PTR r = STRLIB::IndexOf(m_lpBuf, c, 0);
        if ( r >= 0 && _pstrRest != NULL )
        {
            *_pstrRest = Mid(r + 1);
        }
        return Mid(0, r);
    }
 
    void MakeUpper(void)
    {
        ms_strupr(m_lpBuf);
    }
 
    void MakeLower(void)
    {
        ms_strlwr(m_lpBuf);
    }
 
 
    //------------------------------------
 
 
    static CStrT IntToString(int value)
    {
        CStrT s;
        LPTSTR p = s.GetBuffer(32);
        INT_PTR i = CTinyStringFormaterT<TYP>::FormatInt(p, value);
        p[i] = 0;
        s.ReleaseBuffer();
        return s;
    }
 
    static CStrT DwordToString(DWORD value)
    {
        CStrT s;
        LPTSTR p = s.GetBuffer(32);
        INT_PTR i = CTinyStringFormaterT<TYP>::FormatDword(p, value);
        p[i] = 0;
        s.ReleaseBuffer();
        return s;
    }
 
    static CStrT ToHexString(DWORD value, size_t width)
    {
        CStrT s;
        LPTSTR p = s.GetBuffer(width);
         CTinyStringFormaterT<TYP>::FormatHex(p, value, width);
        s.ReleaseBuffer();
        return s;
    }
 
    static CStrT Fmt(const TYP* lpszFormat, ...)
    {
        va_list args;
        va_start(args, lpszFormat);
        CStrT str;
        str.FormatV(lpszFormat, args);
        va_end(args);
        return str;
    }
 
    static CStrT Lineup(TYP t, size_t length)
    {
        TYP* P = ms_NewBuf(TYP(), ms_NullStr(), length);
        loop ( i, length )
        {
            P[i] = t;
        }
        P[length] = 0;
        ms_CalcInfoPointer(P)->lLength = length;
        CStrT str;
        str.m_SetBuf(P);
        ASSERTLIB( STRLIB::GetLen(str.m_lpBuf) == str.GetLength() );
        return str;
    }
 
    static CStrT Lineup(const TYP* lpsz, int iSize)
    {
        size_t l = STRLIB::GetLen(lpsz);
        TYP* P = ms_NewBuf(TYP(), ms_NullStr(), iSize * l);
        TYP* Q = P;
        loop ( i, iSize )
        {
            loop ( j, l )
            {
                *Q++ = lpsz[j];
            }
        }
        *Q = 0;
        ms_CalcInfoPointer(P)->lLength = iSize * l;
        CStrT str;
        str.m_SetBuf(P);
        ASSERTLIB( STRLIB::GetLen(str.m_lpBuf) == str.GetLength() );
        return str;
    }
 
    template<typename ITE>
    static CStrT FromIterator(ITE is, ITE ie = ITE(), size_t max = INVALID_SIZE)
    {
        CStrT s;
        while ( is != ie && *is != 0 && max-- != 0)
        {
            s += *is++;
        }
        return s;
    }
 
    static CStrT FromWindowText(HWND hWnd)
    {
        CStrT s;
        int iLen = ::GetWindowTextLength(hWnd);
        if ( iLen != 0 )
        {
            CWorkMemT<TCHAR> m(iLen + 1);
            ::GetWindowText(hWnd, m, iLen + 1);
            s.m_SetBuf(ms_NewBuf(TYP(), m));
        }
        return s;
    }
 
    #ifdef __AFX_H__
 
    static CStrT FromWindowText(CWnd* pcWnd)
    {
        return FromWindowText(pcWnd->GetSafeHwnd());
    }
 
    #endif
 
private:
 
    template<typename TYP>
    class CGroupT
    {
    public:
        CGroupT(TYP c) : m_char(c), m_lpsz(NULL)
        {
        }
        CGroupT(const TYP* lpsz) : m_char(0), m_lpsz(lpsz)
        {
        }
        bool IsEqual(TYP c) const
        {
            if ( m_char != 0 )
            {
                return c == m_char;
            }
            return STRLIB::IndexOf(m_lpsz, c) >= 0;
        }
    private:
        TYP                 m_char;
        const TYP*          m_lpsz;
    };
 
    CStrT& m_TrimLeft(CGroupT<TYP> t)
    {
        m_Separate();
        size_t l = GetLength();
        loop ( i, l ) 
        {
            if ( ! t.IsEqual(m_lpBuf[i]) ) 
            {
                m_GetInfoP()->lLength -= i;
                for ( size_t j = 0; i < l + 1; i++, j++ ) 
                {
                    m_lpBuf[j] = m_lpBuf[i];
                }
                ASSERTLIB( STRLIB::GetLen(m_lpBuf) == GetLength() );
                return *this;
            }
        }
        Empty();
        return *this;
    }
 
    CStrT& m_TrimRight(CGroupT<TYP> t)
    {
        m_Separate();
        size_t l = GetLength();
        for ( INT_PTR i = l - 1; i >= 0; i-- ) 
        {
            if ( ! t.IsEqual(m_lpBuf[i]) ) 
            {
                m_GetInfoP()->lLength = static_cast<size_t>(i + 1);
                m_lpBuf[i + 1] = 0;
                ASSERTLIB( STRLIB::GetLen(m_lpBuf) == GetLength() );
                return *this;
            }
        }
        Empty();
        return *this;
    }
 
    int m_Replace(CGroupT<TYP> tOld, TYP tNew)
    {
        int iRc = 0;
        if ( tNew != 0 ) 
        {
            m_Separate();
            size_t l = GetLength();
            for ( size_t i = 0; i < l; i += STRLIB::GetCharSize(m_lpBuf[i]) ) 
            {
                if ( tOld.IsEqual(m_lpBuf[i]) )
                {
                    m_lpBuf[i] = tNew;
                    iRc++;
                }
            }
        }
        return iRc;
    }
    
    struct TInfo
    {
        LONG    lRef;           
        size_t  lLength;        
        size_t  lBufSize;       
    };
 
    static TInfo* ms_CalcInfoPointer(LPVOID lpsz)
    {
        BYTE* B = static_cast<BYTE*>(lpsz);
        return reinterpret_cast<TInfo*>(B - sizeof(TInfo));
    }
 
    static char* ms_New(char d, size_t iLen)
    {
        BYTE* B = new BYTE[iLen + sizeof(TInfo)];
        TInfo* I = reinterpret_cast<TInfo*>(B);
        I->lRef = 1;
        I->lLength = 0;
        I->lBufSize = iLen;
        return reinterpret_cast<char*>(B + sizeof(TInfo));
    }
 
    static WCHAR* ms_New(WCHAR d, size_t iLen)
    {
        BYTE* B = new BYTE[iLen * sizeof(WCHAR) + sizeof(TInfo)];
        TInfo* I = reinterpret_cast<TInfo*>(B);
        I->lRef = 1;
        I->lLength = 0;
        I->lBufSize = iLen;
        return reinterpret_cast<WCHAR*>(B + sizeof(TInfo));
    }
    
    static void ms_Delete(LPVOID pMem)
    {
        ASSERTLIB( pMem != gpStrNull );
        BYTE* B = static_cast<BYTE*>(pMem);
        delete[] (B - sizeof(TInfo));
    }
 
    template<typename T>
    static T* ms_Format(const T* lpsz, va_list V)
    {
        size_t iLen = 1024 + STRLIB::GetLen(lpsz);
        while ( true )
        {
            CWorkMemT<T> work(iLen); 
            if ( STRLIB::VPrintF(work, iLen, lpsz, V) )
            {
                size_t r = STRLIB::GetLen(work);
                T* X = ms_New(T(), r + 1);
                const T* W = work;
                MemCopy(X, W, r + 1);
                ms_CalcInfoPointer(X)->lLength = r;
                return X;
            }
            iLen *= 2;
        }
    }
 
    static size_t ms_GetSecureSize(size_t iSize, size_t iExSize = INVALID_SIZE)
    {
        if ( iExSize != INVALID_SIZE )
        {
            iSize += iExSize;
            size_t l = iSize / 8;
            l = (l < 4) ? 4 : ((l > 1024) ? 1024 : l);
            iSize += l;
        }
        return iSize + 1;
    }
 
    static LPSTR ms_NewBuf(char d, LPCSTR lpsz, size_t iExSize = INVALID_SIZE)
    {
        if ( d == 1 )
        {
            return NULL; 
        }
        size_t iSize = STRLIB::GetLen(lpsz);
        LPSTR P = ms_New(char(), ms_GetSecureSize(iSize, iExSize)); 
        MemCopy(P, lpsz, iSize + 1);
        ms_CalcInfoPointer(P)->lLength = iSize;
        return P;
    }
 
    static LPSTR ms_NewBuf(char d, LPCWSTR lpsz, size_t iExSize = INVALID_SIZE)
    {
        int size = ::WideCharToMultiByte(CP_ACP, 0, lpsz, -1, NULL, 0, NULL, NULL);
        char* P = ms_New(char(), ms_GetSecureSize(size, iExSize)); 
        ::WideCharToMultiByte(CP_ACP, 0, lpsz, TNB::ToInt(STRLIB::GetLen(lpsz) + 1), P, size, NULL, NULL);
        ms_CalcInfoPointer(P)->lLength = size - 1;
        return P; 
    }
    
    static LPWSTR ms_NewBuf(WCHAR d, LPCSTR lpsz, size_t iExSize = INVALID_SIZE)
    {
        int size = ::MultiByteToWideChar(CP_ACP, 0, lpsz, -1, NULL, 0); 
        WCHAR* P = ms_New(WCHAR(), ms_GetSecureSize(size, iExSize));
        ::MultiByteToWideChar(CP_ACP, 0, lpsz, TNB::ToInt(STRLIB::GetLen(lpsz) + 1), P, size); 
        ms_CalcInfoPointer(P)->lLength = size - 1;
        return P; 
    }
    
    static LPWSTR ms_NewBuf(WCHAR d, LPCWSTR lpsz, size_t iExSize = INVALID_SIZE)
    {
        if ( d == 1 )
        {
            return NULL;
        }
        size_t iSize = STRLIB::GetLen(lpsz);
        LPWSTR P = ms_New(WCHAR(), ms_GetSecureSize(iSize, iExSize)); 
        MemCopy(P, lpsz, iSize + 1);
        ms_CalcInfoPointer(P)->lLength = iSize;
        return P;
    }
 
    static const TYP* ms_NullStr(void) 
    {
        return static_cast<const TYP*>(gpStrNull);
    }
 
    // 小文字化
    static void ms_strlwr(LPSTR _p)
    {
        strlwr(_p);
    }
 
    // 小文字化
    static void ms_strlwr(LPWSTR _p)
    {
        wcslwr(_p);
    }
    
    // 大文字化
    static void ms_strupr(LPSTR _p)
    {
        strupr(_p);
    }
 
    // 大文字化
    static void ms_strupr(LPWSTR _p)
    {
        wcsupr(_p);
    }
 
 
    //--------------------------
    
 
    void m_InitBuf(void)
    {
        const TYP* P = static_cast<const TYP*>(gpStrNull); 
        m_lpBuf = const_cast<TYP*>(P); 
    }
 
    TInfo* m_GetInfoP(void) const
    {
        return ms_CalcInfoPointer(m_lpBuf);
    }
 
    LONG* m_GetRefP(void) const
    {
        return &(m_GetInfoP()->lRef);
    }
 
    size_t m_GetBufSize(void) const
    {
        return m_GetInfoP()->lBufSize;
    }
    
    void m_SetBuf(TYP* P)
    {
        Empty();
        m_lpBuf = P;
    }
    
    void m_Separate(void)
    {
        if ( *(m_GetRefP()) > 1 )
        {
            //共有している,複製する必要有り
            TYP* P = ms_NewBuf(TYP(), m_lpBuf);
            m_SetBuf(P);
        }
    }
 
    template<typename T>
    CStrT& m_AddText(const T* lpText)
    {
        if ( lpText != NULL && *lpText != 0 )
        {
            TYP* pNew = ms_NewBuf(TYP(), lpText);
            size_t iAddSize = ms_CalcInfoPointer(pNew)->lLength;
            size_t iNowSize = GetLength();
            if ( *(m_GetRefP()) == 1 && m_GetBufSize() > iAddSize + iNowSize )
            {
                MemCopy(&m_lpBuf[iNowSize], pNew, iAddSize + 1);
            }
            else
            {
                TYP* P = ms_NewBuf(TYP(), m_lpBuf, iAddSize);
                MemCopy(&P[iNowSize], pNew, iAddSize + 1);
                m_SetBuf(P);
            }
            m_GetInfoP()->lLength = iAddSize + iNowSize;
            ASSERTLIB( STRLIB::GetLen(m_lpBuf) == GetLength() );
            ms_Delete(pNew);
        }
        return *this;
    }
 
    TYP*    m_lpBuf;            
};
 
 
 
typedef TNB::CStrT<char>    CAscii;
 
 
 
typedef TNB::CStrT<WCHAR>   CUnicode;
 
 
 
typedef TNB::CStrT<TCHAR>   CStr;
 
 
 
inline CAscii operator+(LPCSTR lpsz, const CAscii& str)
{
    CAscii s = lpsz;
    return s += str;
}
 
inline CAscii operator+(const CAscii& str1, const CAscii& str2)
{
    CAscii s = str1;
    return s += str2;
}
 
inline CUnicode operator+(LPCWSTR lpsz, const CUnicode& str)
{
    CUnicode s = lpsz;
    return s += str;
}
 
inline CUnicode operator+(const CUnicode& str1, const CUnicode& str2)
{
    CUnicode s = str1;
    return s += str2;
}
 
inline ISerializer& operator<<(ISerializer& _sr, const char* P)
{
    TRACE0("Serialize[string(ascii)]\n");
    size_t l = STRLIB::GetLen(P);
    ASSERTLIB( l >= 0 );
    _sr << l << l;
    size_t iSize = (l + 1) * sizeof(char);
    _sr.AddRaw(iSize, P);
    return _sr;
}
 
inline ISerializer& operator<<(ISerializer& _sr, const CAscii& t)       
{
    const char* P = t;
    return operator<<(_sr, P);
}
 
inline const IDeserializer& operator>>(const IDeserializer& ds, CAscii& _t)     
{
    TRACE0("Deserialize[string(ascii)]\n");
    int l1, l2;
    ds >> l1 >> l2;
    if ( l1 != l2 )
    {
        throw CInvalidParamException();
    }
    l1++;
    ds.GetRaw(l1 * sizeof(char), _t.GetBuffer(l1 * sizeof(char)));
    _t.ReleaseBuffer();
    return ds;
}
 
inline ISerializer& operator<<(ISerializer& _sr, const WCHAR* P)
{
    TRACE0("Serialize[string(unicode)]\n");
    size_t l = STRLIB::GetLen(P);
    ASSERTLIB( l >= 0 );
    _sr << l << l;
    size_t iSize = (l + 1) * sizeof(WCHAR);
    _sr.AddRaw(iSize, P);
    return _sr;
}
 
inline ISerializer& operator<<(ISerializer& _sr, const CUnicode& t)     
{
    const WCHAR* P = t;
    return operator<<(_sr, P);
}
 
inline const IDeserializer& operator>>(const IDeserializer& ds, CUnicode& _t)   
{
    TRACE0("Deserialize[string(unicode)]\n");
    int l1, l2;
    ds >> l1 >> l2;
    if ( l1 != l2 )
    {
        throw CInvalidParamException();
    }
    l1++;
    ds.GetRaw(l1 * sizeof(WCHAR), _t.GetBuffer(l1 * sizeof(WCHAR)));
    _t.ReleaseBuffer();
    return ds;
}
 
 
 
namespace HASH
{
    inline DWORD CalcHash(const CAscii& str)
    {
        return CalcHash(str.GetLength(), str.operator LPCSTR());
    }
 
    inline DWORD CalcHash(const CUnicode& str)
    {
        return CalcHash(str.GetLength() * 2, str.operator LPCWSTR());
    }
};
 
 
 
}; // TNB
 
 
 
//T-TestCaseコードカバレッジEnable
#pragma comment(user,"T-Coverage Enable")