TnbDntStr.h

[詳解]

#pragma once
#include "TnbStrVector.h"
 
 
 
//T-TestCaseコードカバレッジDisable
#pragma comment(user,"T-Coverage Disable")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CDoubleNullTerminateStr : public IComparableT<TNB::CDoubleNullTerminateStr>
{
    CVectorT<TCHAR> m_vtcText;          
public:
 
    CDoubleNullTerminateStr(LPCTSTR lpszStr = NULL)
    {
        Set(lpszStr);
    }
 
    CDoubleNullTerminateStr(const CDoubleNullTerminateStr& d) : m_vtcText(d.m_vtcText) 
    {
    }
 
    virtual INT_PTR Compare(const CDoubleNullTerminateStr& t) const
    {
        return STRLIB::Compare(ToString(), t.ToString());
    }
 
    void Empty(void)
    {
        m_vtcText.RemoveAll();
        m_vtcText.Add(0);
        m_vtcText.Add(0);
    }
 
    void SetDntStr(LPCTSTR lpszzDntStr, TCHAR tcSepaChar = 0)
    {
        if ( lpszzDntStr != NULL )
        {
            LPCTSTR P = lpszzDntStr;
            int i = 0;
            while ( P[i] != tcSepaChar || P[i + 1] != tcSepaChar )
            {
                i++;
            }
            m_vtcText.SetElements(i + 2, lpszzDntStr);
            if ( tcSepaChar != 0 )
            {
                loop ( i, m_vtcText.GetSize() )
                {
                    if ( m_vtcText[i] == tcSepaChar )
                    {
                        m_vtcText.Set(i, 0);
                    }
                }
            }
        }
        else
        {
            Empty();
        }
    }
 
    void Set(LPCTSTR lpszStr)
    {
        Empty();
        Add(lpszStr);
    }
 
    void Set(const CStrVector& vstr)
    {
        Empty();
        Add(vstr);
    }
 
    void Add(LPCTSTR lpszStr)
    {
        if ( lpszStr != NULL )
        {
            size_t iStrSize = STRLIB::GetLen(lpszStr);
            if ( iStrSize > 0 )
            {
                size_t iVecSize = m_vtcText.GetSize();
                if ( iVecSize > 2 )
                {
                    //Emptyじゃない時NULLを一つ残す。
                    m_vtcText.SetSize(iVecSize - 1);
                    m_vtcText.AddElements(iStrSize, lpszStr);
                }
                else
                {
                    m_vtcText.SetElements(iStrSize, lpszStr);
                }
                m_vtcText.Add(0);
                m_vtcText.Add(0);
            }
        }
    }
 
    void Add(const CStrVector& vstr)
    {
        loop ( i, vstr.GetSize() )
        {
            Add(vstr[i]);
        }
    }
 
    operator LPCTSTR(void) const
    {
        return m_vtcText.ReferBuffer();
    }
 
    size_t GetSize(void) const
    {
        return m_vtcText.GetSize();
    }
 
    CStrVector ToStrVector(void) const
    {
        CStrVector vstr;
        LPCTSTR P = m_vtcText.ReferBuffer();
        while ( true )
        {
            vstr.Add(P);
            P += STRLIB::GetLen(P) + 1;
            if ( *P == 0 )
            {
                break;
            }
        }
        return vstr;
    }
 
    CStr ToString(TCHAR tcSepaChar = '|') const
    {
        CStr strResult;
        CStrVector vstr = ToStrVector();
        loop ( i, vstr.GetSize() )
        {
            strResult += vstr[i];
            strResult += tcSepaChar;
        }
        strResult += tcSepaChar;
        return strResult;
    }
 
    LPTSTR GetBuffer(int iLength)
    {
        return m_vtcText.GetBuffer(iLength);
    }
 
    void ReleaseBuffer(void)
    {
        m_vtcText.ReleaseBuffer();
        CDoubleNullTerminateStr str;
        str.SetDntStr(m_vtcText.ReferBuffer());
        m_vtcText = str.m_vtcText;
    }
};
 
 
 
}; // TNB
 
 
 
//T-TestCaseコードカバレッジEnable
#pragma comment(user,"T-Coverage Enable")