TnbUtf8Str.h

[詳解]

#pragma once
#include "TnbStr.h"
#include "TnbVector.h"
 
 
 
//T-TestCaseコードカバレッジDisable
#pragma comment(user,"T-Coverage Disable")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CUtf8Str : public IComparableT<TNB::CUtf8Str>
{
    CVectorT<char> m_vtcText;           
public:
 
    CUtf8Str(void)
    {
        Empty();
    }
 
    CUtf8Str(const CUtf8Str& uft8) : m_vtcText(uft8.m_vtcText) 
    {
    }
 
    CUtf8Str(LPCSTR lpszUtf8)
    {
        SetOfUtf8(lpszUtf8);
    }
 
    CUtf8Str(const CAscii& ascii)
    {
        SetOfAscii(ascii);
    }
 
    CUtf8Str(const CUnicode& unicode)
    {
        SetOfUnicode(unicode);
    }
 
    CUtf8Str& operator=(const CUtf8Str& other)
    {
        m_vtcText = other.m_vtcText;
        return *this;
    }
 
    virtual INT_PTR Compare(const CUtf8Str& t) const
    {
        return STRLIB::Compare(ReferBuffer(), t.ReferBuffer());
    }
 
    void Empty(void)
    {
        m_vtcText.RemoveAll();
        m_vtcText.Add(0);
    }
 
    bool IsEmpty(void) const
    {
        return GetLength() == 0;
    }
 
    void SetOfUtf8(LPCSTR lpszUtf8)
    {
        if ( lpszUtf8 == NULL )
        {
            Empty();
        }
        else
        {
            size_t iSize = STRLIB::GetLen(lpszUtf8);
            MemCopy(m_vtcText.GetBuffer(iSize + 1), lpszUtf8, iSize + 1);
            m_vtcText.ReleaseBuffer();
        }
    }
 
    void SetOfUnicode(LPCWSTR lpszUnicode)
    {
        TTRACE0("UNICODE 文字列を UTF8 文字列に変換\n");
        if ( lpszUnicode != NULL )
        {
            size_t iSize = STRLIB::GetLen(lpszUnicode);
            if ( iSize > 0 )
            {
                int nLen = ::WideCharToMultiByte(CP_UTF8, 0, lpszUnicode, -1, NULL, 0, NULL, NULL);
                ::WideCharToMultiByte(CP_UTF8, 0, lpszUnicode, -1, m_vtcText.GetBuffer(nLen), nLen, NULL, NULL);
                m_vtcText.ReleaseBuffer();
                return;
            }
        }
        Empty();
    }
 
    void SetOfAscii(LPCSTR lpszAscii)
    {
        SetOfUnicode(CUnicode(lpszAscii));
    }
 
    CUtf8Str& operator+=(const CUtf8Str& uft8)
    {
        m_vtcText.SetSize(GetLength());
        m_vtcText += uft8.m_vtcText;
        return *this;
    }
 
    CUtf8Str operator+(const CUtf8Str& uft8) const
    {
        CUtf8Str newUTF8 = *this;
        newUTF8 += uft8;
        return newUTF8;
    }
 
    size_t GetLength(void) const
    {
        return STRLIB::GetLen(ReferBuffer());
    }
 
    CUnicode ToUnicode(void) const
    {
        TTRACE0("UTF8 文字列を UNICODE 文字列に変換\n");
        LPCSTR P = m_vtcText.ReferBuffer();
        int nLen = ::MultiByteToWideChar(CP_UTF8, 0, P, -1, NULL, 0); 
        CUnicode uni;
        ::MultiByteToWideChar(CP_UTF8, 0, P, -1, uni.GetBuffer(nLen), nLen); 
        uni.ReleaseBuffer();
        return uni;
    }
 
    CAscii ToAscii(void) const
    {
        return CAscii(ToUnicode()); 
    }
 
    CStr ToStr(void) const
    {
        return CStr(ToUnicode());
    }
 
    LPCSTR ReferBuffer(void) const
    {
        return m_vtcText.ReferBuffer();
    }
 
    operator LPCSTR (void) const
    {
        return ReferBuffer();
    }
 
    LPSTR GetBuffer(int iLength)
    {
        return m_vtcText.GetBuffer(iLength);
    }
 
    void ReleaseBuffer(void)
    {
        m_vtcText.ReleaseBuffer();
        CUtf8Str s;
        s.SetOfUtf8(m_vtcText.ReferBuffer());
        m_vtcText = s.m_vtcText;
    }
};
 
 
 
}; // TNB
 
 
 
//T-TestCaseコードカバレッジEnable
#pragma comment(user,"T-Coverage Enable")