TnbTextFile.h

[詳解]

#pragma once
#include "TnbFile.h"
#include "TnbConstStrVector.h"
#include "TnbStrAdder.h"
#include "TnbStrVector.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CTextFileWriter : CCopyImpossible
{
public:
 
    CTextFileWriter(void) : m_pWriter(&m_fw), m_isUnicode(false)
    {
    }
 
    bool CanWrite(void) const
    {
        m_pWriter->CanWrite();
    }
 
    void Close(void)
    {
        m_pWriter->Close();
        m_pWriter = &m_fw;
    }
 
    bool New(LPCTSTR lpszName, bool isUnicode = false)
    {
        Close();
        bool r = m_fw.New(lpszName);
        if ( r )
        {
            r = m_Open(&m_fw, isUnicode);
        }
        return r;
    }
 
    bool Open(IWriter* pWriter, bool isUnicode = false)
    {
        Close();
        return m_Open(pWriter, isUnicode);
    }
 
    void WriteLine(LPCSTR lpszLine)
    {
        CAscii s = lpszLine;
        s += "\r\n";
        m_Write(s);
    }
 
    void WriteLine(LPCWSTR lpszLine)
    {
        CUnicode s = lpszLine;
        s += L"\r\n";
        m_Write(s);
    }
 
    void WriteFormat(LPCSTR lpszFormat, ...)
    {
        CAscii s;
        va_list va;
        va_start(va, lpszFormat);
        s.FormatV(lpszFormat, va);
        va_end(va);
        m_Write(s);
    }
 
    void WriteFormat(LPCWSTR lpszFormat, ...)
    {
        CUnicode s;
        va_list va;
        va_start(va, lpszFormat);
        s.FormatV(lpszFormat, va);
        va_end(va);
        m_Write(s);
    }
 
    void Write(const CStrVector& vs)
    {
        CStr s;
        loop ( i, vs )
        {
            s = vs[i];
            s += _T("\r\n");
            m_Write(s);
        }
    }
 
    static bool NewFile(LPCTSTR lpszName, const CStrVector& vs, bool isUnicode = false)
    {
        CTextFileWriter w;
        if ( w.New(lpszName, isUnicode) )
        {
            try
            {
                w.Write(vs);
                return true;
            }
            catch ( ... )
            {
            }
        }
        return false;
    }
 
private:
    bool m_Open(IWriter* pWriter, bool isUnicode = false)
    {
        if ( pWriter->CanWrite() && pWriter->GetSize() == 0 )
        {
            m_isUnicode = isUnicode;
            if ( ! m_isUnicode )
            {
                return true;
            }
            else
            {
                const BYTE buf[2] = { 0xFF, 0xFE };
                try
                {
                    pWriter->Write(2, buf);
                    m_pWriter = pWriter;
                    return true;
                }
                catch ( ... )
                {
                }
            }
        }
        return false;
    }
    // 書込み(ASCII文字列指定)
    void m_Write(const CStrT<char>& str)
    {
        if ( m_isUnicode )
        {
            CUnicode uni = str;
            m_pWriter->Write(uni.GetLength() * 2, uni.operator LPCWSTR());
        }
        else
        {
            m_pWriter->Write(str.GetLength(), str.operator LPCSTR());
        }
    }
    // 書込み(UNICODE文字列指定)
    void m_Write(const CStrT<WCHAR>& str)
    {
        if ( m_isUnicode )
        {
            m_pWriter->Write(str.GetLength() * 2, str.operator LPCWSTR());
        }
        else
        {
            CAscii asc = str;
            m_pWriter->Write(asc.GetLength(), asc.operator LPCSTR());
        }
    }
    bool        m_isUnicode;    
    IWriter*    m_pWriter;      
    CFileWriter m_fw;           
};
 
 
 
class CTextFileReader : CCopyImpossible
{
public:
 
    CTextFileReader(void) : m_hasUnicode(false)
    {
    }
 
    bool HasContents(void) const
    {
        return ! m_contents.IsEmpty();
    }
 
    bool hasUnicodeContents(void) const
    {
        return HasContents() && m_hasUnicode;
    }
 
    void Empty(void)
    {
        m_contents.RemoveAll();
    }
 
    bool Read(LPCTSTR lpszFileName)
    {
        Empty();
        CFileReader fr;
        if ( fr.Open(lpszFileName) )
        {
            return Read(&fr);
        }
        return false;
    }
 
    bool Read(IReader* pReader)
    {
        Empty();
        if ( pReader->CanRead() )
        {
            try
            {
                m_contents = pReader->ReadInto();
                m_contents.Add(0);
                m_contents.Add(0);
                m_hasUnicode = (m_contents[0] == 0xFF && m_contents[1] == 0xFE);
                return true;
            }
            catch ( ... )
            {
            }
        }
        return false;
    }
 
    bool GetContents(CConstStrVectorT<char>& _vs) const
    {
        if ( HasContents() )
        {
            if ( ! m_hasUnicode )
            {
                _vs.SetClone(reinterpret_cast<LPCSTR>(m_contents.ReferBuffer()));
            }
            else
            {
                LPCWSTR lpsz = reinterpret_cast<LPCWSTR>(m_contents.ReferBuffer());
                CAscii a = reinterpret_cast<LPCSTR>(&lpsz[1]);
                _vs.SetClone(a);
            }
            return true;
        }
        return false;
    }
 
    bool GetContents(CConstStrVectorT<WCHAR>& _vs) const
    {
        if ( HasContents() )
        {
            if ( ! m_hasUnicode )
            {
                CUnicode a = reinterpret_cast<LPCSTR>(m_contents.ReferBuffer());
                _vs.SetClone(a);
            }
            else
            {
                LPCWSTR lpsz = reinterpret_cast<LPCWSTR>(m_contents.ReferBuffer());
                _vs.SetClone(&lpsz[1]);
            }
            return true;
        }
        return false;
    }
 
private:
    CByteVector m_contents;     
    bool        m_hasUnicode;   
};
 
 
 
}; // TNB