TnbStrOperator.h

[詳解]

#pragma once
#include "TnbStrVector.h"
#include "TnbBlockLinkVector.h"
#include "TnbCollectionAdapter.h"
 
 
 
//T-TestCaseコードカバレッジDisable
#pragma comment(user,"T-Coverage Disable")
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP>
class CStrOperatorT
{
public:
 
    static const TYP* FindCr(const TYP* lpsz)
    {
        if ( lpsz != NULL )
        {
            while ( *lpsz != 0 )
            {
                if ( *lpsz == 0x0D || *lpsz == 0x0A )
                {
                    return lpsz;
                }
                lpsz += STRLIB::GetCharSize(*lpsz);
            }
        }
        return NULL;
    }
 
    static const TYP* GetLine(CStrT<TYP>& _strLine, const TYP* lpsz)
    {
        _strLine.Empty();
        const TYP* P = NULL;
        if ( lpsz != NULL )
        {
            P = FindCr(lpsz);
            if ( P == NULL )
            {
                //見つからなかった。全部が一行
                _strLine = lpsz;
            }
            else
            {
                INT_PTR iLen = P - lpsz;
                if ( iLen > 0 )
                {
                    _strLine.SetFromLeft(lpsz, iLen);
                }
                if ( *P++ == 0x0D )
                {
                    if ( *P == 0x0A )
                    {
                        P++;
                    }
                }
            }
        }
        return P;
    }
 
    static CStrT<TYP> ConnectLines(const CVectorT<CStrT<TYP> >& vs, const TYP* lpszCR = NULL)
    {
        CStrT<TYP> CR = lpszCR;
        if ( lpszCR == NULL )
        {
            CR = "\r\n";
        }
        CStrT<TYP> s;
        loop ( i, vs.GetSize() )
        {
            if ( i != 0 )
            {
                s += CR;
            }
            s += vs[i];
        }
        return s;   
    }
 
    static CVectorT<CStrT<TYP> > SeparateLine(const TYP* lpsz)
    {
        CBlockLinkVectorT<CStrT<TYP> > vs;
        CStrT<TYP> s;
        const TYP* P = lpsz;
        while ( P != NULL )
        {
            P = GetLine(s, P);
            vs.Add(s);
        }
        CVectorT<CStrT<TYP> > v;
        v.Copy(vs);
        return v;
    }
 
    static CVectorT<CStrT<TYP> > SeparatePeriod(const TYP* lpsz, const TYP* lpszMark, bool isCheckDc = true)
    {
        CBlockLinkVectorT<CStrT<TYP> > vs;
        CStrT<TYP> s;
        if ( lpsz[0] != 0 )
        {
            while ( true )
            {
                if ( isCheckDc && lpsz[0] == '\"' )
                {
                    //先頭が " だった。
                    INT_PTR r = STRLIB::IndexOf(lpsz, '\"', 1);
                    if ( r >= 0 )
                    {
                        //次の " を発見
                        bool isEnd = (lpsz[r + 1] == 0);
                        if ( STRLIB::IndexOf(lpszMark, lpsz[r + 1]) >= 0 || isEnd )
                        {
                            // ,"〜", を発見
                            s.SetFromLeft(&lpsz[1], r - 1);
                            lpsz += r + 2;
                            vs.Add(s);
                            if ( isEnd )
                            {
                                break;
                            }
                            continue;
                        }
                    }
                }
                INT_PTR r = STRLIB::IndexOneOf(lpsz, lpszMark);
                if ( r < 0 )
                {
                    s = lpsz;
                }
                else
                {
                    s.SetFromLeft(lpsz, r);
                    lpsz += r + 1;
                }
                vs.Add(s);
                if ( r < 0 )
                {
                    break;
                }
            }
        }
        CVectorT<CStrT<TYP> > v;
        v.Copy(vs);
        return v;
    }
 
    static CVectorT<CStrT<TYP> > SeparatePeriod(const TYP* lpsz, TYP mark, bool isCheckDc = true)
    {
        TYP bb[2] = { mark, 0 };
        return SeparatePeriod(lpsz, bb, isCheckDc);
    }
 
    static CStrT<TYP> BinaryToHexString(const IConstCollectionT<BYTE>& c)
    {
        size_t size = c.GetSize();
        CStrT<TYP> str;
        TYP* P = str.GetBuffer(size * 2 + 2);
        loop ( i, size )
        {
            const BYTE& b = c.At(i);
            *P++ = STRLIB::IntToHexChar(b >> 4);
            *P++ = STRLIB::IntToHexChar(b);
        }
        *P++ = 0;
        str.ReleaseBuffer();
        return str;
    }
 
    static CStrT<TYP> BinaryToHexString(size_t dataSize, LPCVOID P)
    {
        CConstAdapterT<BYTE> cc(dataSize, static_cast<const BYTE*>(P));
        return BinaryToHexString(cc);
    }
 
    static CByteVector HexStringToBinary(const TYP* lpszHex)
    {
        CByteVector vb;
        while ( true )
        {
            TYP c = *lpszHex++;
            if ( c == '_' || c ==' ' || c == '\t' || c =='\n' || c == '\r' || c =='-' )
            {
                continue;
            }
            int r = STRLIB::HexCharToInt(c);
            if ( r < 0 )
            {
                break;
            }
            vb.Add(static_cast<BYTE>(r));
        }
        CByteVector vbr;
        if ( ! vb.IsEmpty() )
        {
            INDEX startIndex = 0;
            size_t size = vb.GetSize();
            if ( (size & 1) != 0 )
            {
                vbr.Add(vb[0]);
                startIndex = 1;
            }
            for ( INDEX i = startIndex; i < size; i += 2 )
            {
                vbr.Add(static_cast<BYTE>((vb[i] << 4) | vb[i + 1]));
            }
        }
        return vbr;
    }
 
    static CStrT<TYP> TabToSpace(const TYP* lpsz, int iTabStep = 4)
    {
        CStrT<TYP> strWork;
        strWork = lpsz;
        while ( true )
        {
            INT_PTR iTabPosition = strWork.Find('\t');
            if ( iTabPosition < 0)
            {
                break;
            }
            strWork = 
                    strWork.Left(iTabPosition) 
                    + CStrT<TYP>::Lineup(' ', iTabStep - (iTabPosition % iTabStep))
                    + &(strWork.operator const TYP*()[iTabPosition + 1]);
        }
        return strWork;
    }
 
private:
    friend class CStrOperatorTest;
};
 
 
 
typedef CStrOperatorT<TCHAR> CStrOperator;
 
typedef CStrOperatorT<char> CAsciiOperator;
 
typedef CStrOperatorT<WCHAR> CUnicodeOperator;
 
 
 
}; // TNB
 
 
 
//T-TestCaseコードカバレッジEnable
#pragma comment(user,"T-Coverage Enable")