TnbTinyStringFormater.h

[詳解]

#pragma once
#include <TnbDef.h>
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP = TCHAR>
class CTinyStringFormaterT : CCopyImpossible
{
public:
 
    CTinyStringFormaterT(void) : m_pos(0), m_pWork(NULL), m_workSize(0)
    {
    }
 
    void Initialize(TYP* _P, size_t len)
    {
        m_pWork = _P;
        m_workSize = len;
        m_pos = 0;
    }
 
    size_t GetLength(void) const
    {
        return m_pos;
    }
 
    operator const TYP*(void) const
    {
        return m_pWork;
    }
 
    size_t GetRemainingLength(void) const
    {
        if ( m_workSize < m_pos )
        {
            return 0;
        }
        return m_workSize - m_pos;
    }
 
    void AddTerminateChar(void)
    {
        ASSERT( m_pWork != NULL );
        ASSERT( m_pos + 1 <= m_workSize );
        m_pWork[m_pos] = 0;
    }
 
    void AddFormatInt(int value, size_t width)
    {
        ASSERT( m_pWork != NULL );
        ASSERT( m_pos + width <= m_workSize );
        FormatInt(&m_pWork[m_pos], value, width);
        m_pos += width;
    }
 
    void AddFormatInt(int value)
    {
        ASSERT( m_pWork != NULL );
        m_pos += FormatInt(&m_pWork[m_pos], value);
    }
 
    void AddFormatHexInt(DWORD value, size_t width)
    {
        ASSERT( m_pWork != NULL );
        ASSERT( m_pos + width <= m_workSize );
        FormatHex(&m_pWork[m_pos], value, width);
        m_pos += width;
    }
 
    void AddChar(TCHAR c)
    {
        ASSERT( m_pWork != NULL );
        ASSERT( m_pos + 1 <= m_workSize );
        m_pWork[m_pos] = c;
        m_pos++;
    }
 
    template<typename XX>
    void AddLiteral(const XX& literal)
    {
        const TYP* lpsz = literal;          // ここでエラー出る場合、引数に文字列リテラル以外を渡している可能性有りです
        size_t len = sizeof(literal) / sizeof(TYP);
        Add(lpsz, len - 1); //終端は入れない
    }
 
    void Add(const TYP* lpsz)
    {
        ASSERT( m_pWork != NULL );
        size_t len = STRLIB::GetLen(lpsz);
        ASSERT( m_pos + len <= m_workSize );
        memcpy(&m_pWork[m_pos], lpsz, len * sizeof(TYP));
        m_pos += len;
    }
 
    void Add(const TYP* lpsz, size_t len)
    {
        ASSERT( m_pWork != NULL );
        ASSERT( m_pos + len <= m_workSize );
        memcpy(&m_pWork[m_pos], lpsz, len * sizeof(TYP));
        m_pos += len;
    }
 
 
    //-------------------------------
 
 
    static void FormatInt(TYP* _P, int value, size_t width)
    {
        unsigned int v = (value < 0) ? -value : value;
        size_t j = 0;
        loop_dn ( i, width )
        {
            j = i;
            _P[i] = static_cast<TYP>('0' + (v % 10));
            v /= 10;
            if ( v == 0 )
            {
                break;
            }
        }
        if ( value < 0 && j > 0 )
        {
            _P[j - 1] = '-';
            j--;
        }
        if ( j > 0 )
        {
            loop ( i , j )
            {
                _P[i] = ' ';
            }
        }
    }
 
    static INT_PTR FormatInt(TYP* _P, int value)
    {
        TYP* Q = _P;
        if ( value == 0 )
        {
            *_P++ = '0';
        }
        else
        {
            unsigned int v = (value < 0) ? -value : value;
            if ( value < 0 )
            {
                *_P++ = '-';
            }
            int j = 0;
            TYP buf[32];
            while ( v > 0 )
            {
                buf[j++] = static_cast<TYP>('0' + (v % 10));
                v /= 10;
            }
            loop_dn ( i, j )
            {
                *_P++ = buf[i];
            }
        }
        return _P - Q;
    }
 
    static void FormatInt0(TYP* _P, int value, size_t width)
    {
        unsigned int v = (value < 0) ? -value : value;
        loop_dn ( i, width )
        {
            _P[i] = static_cast<TYP>('0' + (v % 10));
            v /= 10;
        }
        if ( value < 0 )
        {
            _P[0] = '-';
        }
    }
 
    static void FormatDword(TYP* _P, DWORD value, size_t width)
    {
        loop_dn ( i, width )
        {
            _P[i] = static_cast<TYP>('0' + (v % 10));
            v /= 10;
            if ( v == 0 )
            {
                break;
            }
        }
        if ( j > 0 )
        {
            loop ( i , j )
            {
                _P[i] = ' ';
            }
        }
    }
 
    static INT_PTR FormatDword(TYP* _P, DWORD value)
    {
        TYP* Q = _P;
        if ( value == 0 )
        {
            *_P++ = '0';
        }
        else
        {
            int j = 0;
            TCHAR buf[32];
            while ( value > 0 )
            {
                buf[j++] = static_cast<TYP>('0' + (value % 10));
                value /= 10;
            }
            loop_dn ( i, j )
            {
                *_P++ = buf[i];
            }
        }
        return _P - Q;
    }
 
    static void FormatDword0(TYP* _P, DWORD value, size_t width)
    {
        loop_dn ( i, width )
        {
            _P[i] = static_cast<TYP>('0' + (value % 10));
            value /= 10;
        }
    }
 
    static void FormatHex(TYP* _P, DWORD value, size_t width)
    {
        loop_dn ( i, width )
        {
            _P[i] =  STRLIB::IntToHexChar(value & 0xF);
            value >>= 4;
        }
    }
 
private:
    TYP*            m_pWork;        
    size_t          m_workSize;     
    INDEX           m_pos;          
    friend class CTinyStringFormaterTest;
};
 
 
 
class CTinyStringFormater : public CTinyStringFormaterT<>
{
};
 
 
 
}; // TNB