TnbStrAdder.h

[詳解]

#pragma once
#include "TnbBlockLinkVector.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CStrAdder : CCopyImpossible
{
public:
 
    CStrAdder(void) : m_length(0)
    {
    }
 
    ~CStrAdder(void)
    {
        Empty();
    }
 
    size_t GetLength(void) const
    {
        return m_length;
    }
 
    operator LPCTSTR(void) const
    {
        if ( m_string.GetSize() == 0 )
        {
            m_string.Resize(m_length + 1);
            m_string[m_length] = 0;
            size_t a = 0;
            loop ( i, m_work )
            {
                const TParam& p = m_work[i];
                if ( p.length == 1 )
                {
                    m_string[a] = p.one;
                }
                else if ( p.length > 1 )
                {
                    memcpy(&m_string[a], p.pMany, p.length * sizeof(TCHAR));
                }
                a += p.length;
            }
        }
        return m_string;
    }
 
    void Empty(void)
    {
        m_length = 0;
        loop ( i, m_work )
        {
            m_work[i].Empty();
        }
        m_work.RemoveAll();
        m_string.Free();
    }
 
    int AddFormat(size_t len, LPCTSTR lpszFmt, ...)
    {
        va_list args;
        va_start(args, lpszFmt);
        TParam& p = m_New();
        p.SetLength(max(2, len));
        LPTSTR lpszWork = p.pMany;
        #if _MSC_VER < 1400 || defined(_WIN32_WCE)
            int r = _vstprintf(lpszWork, lpszFmt, args);
        #else
            int r = _vstprintf_s(lpszWork, len, lpszFmt, args);
        #endif
        if ( ToInt(len) < r )
        {
            ASSERT0( false, "CStrAdder::AddFormat", "用意したサイズを超えました" );
            r = -1;
        }
        if ( r == 1 )
        {
            TCHAR c = lpszFmt[0];
            p.Set(c);
        }
        else if ( r > 1 )
        {
            p.length = r;
            m_length += r;
        }
        else
        {
            p.Empty();
            size_t l = m_work.GetSize();
            m_work.SetSize(l - 1);
        }
        va_end(args);
        return r;
    }
 
    size_t AddFormat(LPCTSTR lpszFmt, ...)
    {
        va_list args;
        va_start(args, lpszFmt);
        CStr s;
        s.FormatV(lpszFmt, args);
        Add(s);
        va_end(args);
        return s.GetLength();
    }
 
    void Add(LPCTSTR lpsz)
    {
        TParam& p = m_New();
        p.Set(lpsz);
        m_length += p.length;
    }
 
    void operator+=(LPCTSTR lpsz)
    {
        Add(lpsz);
    }
 
    void Add(TCHAR c)
    {
        TParam& p = m_New();
        p.Set(c);
        m_length += 1;
    }
 
    void operator+=(TCHAR c)
    {
        Add(c);
    }
 
    void Regulate(size_t len)
    {
    }
 
private:
    struct TParam
    {
        size_t  length;         
        union
        {
            TCHAR   one;        
            TCHAR*  pMany;      
        };
        TParam(void) : length(0)
        {
        }
        void SetLength(size_t len)
        {
            Empty();
            length = len;
            if ( length > 1 )
            {
                pMany = new TCHAR[length + 1];
            }
        }
        void Set(LPCTSTR lpsz)
        {
            Empty();
            length = STRLIB::GetLen(lpsz);
            if ( length == 1 )
            {
                one = lpsz[0];
            }
            else if ( length > 1 )
            {
                pMany = new TCHAR[length + 1];
                STRLIB::Copy(pMany, lpsz);
            }
        }
        void Set(TCHAR c)
        {
            Empty();
            length = 1;
            one = c;
        }
        void Empty(void)
        {
            if ( length > 1 )
            {
                delete[] pMany;
            }
            length = 0;
        }
    };
    TParam& m_New(void)
    {
        m_string.Free();
        INDEX r = m_work.Add(TParam());
        return m_work[r];
    }
    CBlockLinkVectorT<TParam>   m_work;     
    size_t                      m_length;   
    mutable CWorkMemT<TCHAR>    m_string;   
};
 
 
 
}; //TNB