TnbTinyCsvReader.h

[詳解]

#pragma once
#include "TnbBlocklinkVector.h"
#include "TnbFile.h"
#include "TnbStrVector.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CTinyCsvReader
{
public:
 
    bool ReadCsv(LPCTSTR lpszFileName)
    {
        m_content.RemoveAll();
        CByteVector vb;
        if ( CFileReader::ReadAll(vb, lpszFileName) )
        {
            vb.Add(0);  //終端
            LPCSTR lpsz = reinterpret_cast<LPCSTR>(vb.ReferBuffer());
            m_content = m_SeparateLine(lpsz);
            return true;
        }
        return false;
    }
 
    size_t GetLineCount(void) const
    {
        return m_content.GetSize();
    }
        
    CVectorT<int> Get(INDEX line, int emptyValue) const
    {
        CBlockLinkVectorT<int> vs;
        if ( m_content.GetSize() > line )
        {
            LPCSTR lpsz = m_content[line].ReferBuffer();
            int s;
            if ( lpsz[0] != 0 )
            {
                while ( true )
                {
                    INT_PTR r = m_FindComma(lpsz);
                    if ( r < 0 )
                    {
                        s = (*lpsz == 0) ? emptyValue : ::atoi(lpsz);
                    }
                    else if ( r == 0 )
                    {
                        s = emptyValue;
                        lpsz++;
                    }
                    else
                    {
                        s = ::atoi(lpsz);
                        lpsz += r + 1;
                    }
                    vs.Add(s);
                    if ( r < 0 )
                    {
                        break;
                    }
                }
            }
        }
        CVectorT<int> v;
        v.Copy(vs);
        return v;
    }
 
    CVectorT<double> Get(INDEX line, double emptyValue) const
    {
        CBlockLinkVectorT<double> vs;
        if ( m_content.GetSize() > line )
        {
            LPCSTR lpsz = m_content[line].ReferBuffer();
            double s;
            if ( lpsz[0] != 0 )
            {
                while ( true )
                {
                    INT_PTR r = m_FindComma(lpsz);
                    if ( r < 0 )
                    {
                        s = (*lpsz == 0) ? emptyValue : ::atof(lpsz);
                    }
                    else if ( r == 0 )
                    {
                        s = emptyValue;
                        lpsz++;
                    }
                    else
                    {
                        s = ::atof(lpsz);
                        lpsz += r + 1;
                    }
                    vs.Add(s);
                    if ( r < 0 )
                    {
                        break;
                    }
                }
            }
        }
        CVectorT<double> v;
        v.Copy(vs);
        return v;
    }
 
private:
 
    inline const char* m_FindCr(const char* lpsz) const
    {
        while ( *lpsz != 0 )
        {
            if ( *lpsz == 0x0D )
            {
                return lpsz;
            }
            lpsz ++;
        }
        return NULL;
    }
 
    inline INT_PTR m_FindComma(const char* lpsz) const
    {
        INT_PTR r = 0;
        while ( *lpsz != 0 )
        {
            if ( *lpsz == ',' )
            {
                return r;
            }
            lpsz++;
            r++;
        }
        return -1;
    }
 
    const char* m_GetLine(CStrT<char>& _strLine, const char* lpsz)
    {
        _strLine.Empty();
        const char* P = NULL;
        P = m_FindCr(lpsz);
        if ( P == NULL )
        {
            //見つからなかった。全部が一行
            _strLine = lpsz;
        }
        else
        {
            INT_PTR iLen = P - lpsz;
            if ( iLen > 0 )
            {
                char* Q = _strLine.GetBuffer(iLen);
                memcpy(Q, lpsz, iLen);
                Q[iLen] = 0;
                _strLine.ReleaseBuffer();
            }
            if ( *P++ == 0x0D )
            {
                if ( *P == 0x0A )
                {
                    P++;
                }
            }
        }
        return P;
    }
 
    CVectorT<CStrT<char> > m_SeparateLine(const char* lpsz)
    {
        CBlockLinkVectorT<CStrT<char> > vs;
        CStrT<char> s;
        const char* P = lpsz;
        while ( P != NULL )
        {
            P = m_GetLine(s, P);
            vs.Add(s);
        }
        CVectorT<CStrT<char> > v;
        v.Copy(vs);
        return v;
    }
 
    CStrVector m_content;
};
 
 
 
}; // TNB