TnbInifileAccessor.h

[詳解]

#pragma once
#ifndef _WIN32_WCE
 
#include "TnbAccessor.h"
#include "TnbDntStr.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CInifileAccessor : public CAbstractAccessor
{
    DEFSUPER(CAbstractAccessor);
public:
 
    explicit CInifileAccessor(LPCTSTR lpszFile = NULL) : _super()
    {
        CInifileAccessor::SetBase(lpszFile); 
    }
 
    void SetBase(LPCTSTR lpszFile = NULL)
    {
        m_strFile = (lpszFile == NULL) ? MakeInifilePath() : lpszFile;
    }
 
    static CStr MakeInifilePath(void)
    {
        CStr str = _super::MakeDefineFilePath();
        str += _T(".ini");
        return str;
    }
 
    CStr GetBaseFileName(void) const
    {
        return m_strFile;
    }
 
    bool ExistBaseFile(void) const
    {
        DWORD r = ::GetFileAttributes(m_strFile);
        return ToInt(r) >= 0;
    }
 
    bool NewBaseFile(bool isUnicode = false)
    {
        bool r = false;
        HANDLE h = ::CreateFile(m_strFile, GENERIC_WRITE | GENERIC_READ, 0, NULL, CREATE_ALWAYS, 0, NULL);
        // 書込み
        if ( h != INVALID_HANDLE_VALUE )
        {
            if ( isUnicode )
            {
                BYTE buf[2] = { 0xFF, 0xFE };
                DWORD writed;
                if ( ::WriteFile(h, buf, 2, &writed, NULL) && 2 == writed )
                {
                    r = true;
                }
            }
            else
            {
                r = true;
            }
            ::CloseHandle(h);
        }
        return r;
    }
 
    virtual CStr GetTypeName(void) const
    {
        return _T("Inifile");
    }
 
    virtual bool Flush(void) 
    {
        ::WritePrivateProfileString(NULL, NULL, NULL, m_strFile);   //戻り値は必ずfalse(仕様)なので見ない
        return true;
    }
 
    virtual CStrVector EnumSectionNames(LPCTSTR lpszSectionName = NULL) const
    {
        CStrVector vs;
        CDoubleNullTerminateStr dntstr;
        DWORD dwRc = ::GetPrivateProfileSectionNames(
                            dntstr.GetBuffer(E_BufferSize),
                            E_BufferSize,
                            m_strFile);
        dntstr.ReleaseBuffer();
        if ( dwRc <= 0 )
        {
            return vs;
        }
        vs = dntstr.ToStrVector();
        CStr ss = lpszSectionName;
        size_t len = ss.GetLength();
        if ( ! ss.IsEmpty() )
        {
            loop ( i, vs.GetSize() )
            {
                CStr s;
                if ( STRLIB::Compare(vs[i], ss, len, NORM_IGNORECASE) == 0 )
                {
                    s = vs[i].Mid(len);
                    if ( ! s.IsEmpty() && s[0] == '\\' )
                    {
                        s = s.Mid(1);
                    }
                    else
                    {
                        s.Empty();
                    }
                }
                vs[i] = s;
            }
        }
        CStrVector vstrSecNames;
        loop ( i, vs.GetSize() )
        {
            if ( ! vs[i].IsEmpty() )
            {
                CStr s = vs[i];
                INDEX d = s.Find(_T('\\'));
                if ( d != INVALID_INDEX )
                {
                    s = s.Left(d);
                }
                if ( vstrSecNames.Find(s) == INVALID_INDEX )
                {
                    vstrSecNames.Add(s);
                }
            }
        }
        return vstrSecNames;
    }
 
    virtual bool DeleteSection(LPCTSTR lpszSectionName)
    {
        CStrVector vs;
        CDoubleNullTerminateStr dntstr;
        DWORD dwRc = ::GetPrivateProfileSectionNames(
                            dntstr.GetBuffer(E_BufferSize),
                            E_BufferSize,
                            m_strFile);
        dntstr.ReleaseBuffer();
        if ( dwRc <= 0 )
        {
            return false;
        }
        vs = dntstr.ToStrVector();
        CStr ss = lpszSectionName;
        size_t len = ss.GetLength();
        loop ( i, vs.GetSize() )
        {
            if ( STRLIB::Compare(vs[i], ss, len, NORM_IGNORECASE) == 0 )
            {
                if ( ! ::WritePrivateProfileString(vs[i], NULL, NULL, m_strFile) )
                {
                    return false;
                }
            }
        }
        return true;
    }
 
    virtual CStrVector EnumKeyNames(LPCTSTR lpszSectionName) const
    {
        CStrVector vstrKeyNames;
        CDoubleNullTerminateStr dntstr;
        DWORD dwRc = ::GetPrivateProfileSection(
                            lpszSectionName,
                            dntstr.GetBuffer(E_BufferSize),
                            E_BufferSize,
                            m_strFile);
        dntstr.ReleaseBuffer();
        if ( dwRc > 0 )
        {
            CStrVector vstr = dntstr.ToStrVector();
            loop ( i, vstr.GetSize() )
            {
                vstrKeyNames.Add(vstr[i].FindCut('='));
            }
        }
        return vstrKeyNames;
    }
 
    virtual EKind GetKeyKind(LPCTSTR lpszSectionName, LPCTSTR lpszKey) const
    {
        CStr dmy;
        if ( ! m_QueryString(dmy, lpszSectionName, lpszKey) )
        {
            return EK_Nothing;
        }
        return EK_String;
    }
 
    virtual CValue QueryValue(LPCTSTR lpszSectionName, LPCTSTR lpszKey) const
    {
        CStr s;
        if ( m_QueryString(s, lpszSectionName, lpszKey) )
        {
            return CValue(s);
        }
        return CValue();
    }
 
    virtual bool WriteValue(LPCTSTR lpszSectionName, LPCTSTR lpszKey, const IAccessor::CValue& value)
    {
        if ( value.GetKind() == EK_Nothing )
        {
            return m_Delete(lpszSectionName, lpszKey);
        }
        return m_WriteString(lpszSectionName, lpszKey, value.QueryString());
    }
 
private:
    enum { E_BufferSize = 65536 };      
 
    CStr m_GetString(LPCTSTR lpszSectionName, LPCTSTR lpszKey, LPCTSTR lpszDefault) const
    {
        ASSERT( lpszDefault != NULL );
        CStr strValue;
        ::GetPrivateProfileString(
                            lpszSectionName,
                            lpszKey,
                            lpszDefault,
                            strValue.GetBuffer(E_BufferSize),
                            E_BufferSize,
                            m_strFile);
        strValue.ReleaseBuffer();
        return strValue;
    }
 
    bool m_QueryString(CStr& _r, LPCTSTR lpszSectionName, LPCTSTR lpszKey) const
    {
        _r = m_GetString(lpszSectionName, lpszKey, _T("*1"));
        if ( _r.Compare(_T("*1")) == 0 )
        {
            _r = m_GetString(lpszSectionName, lpszKey, _T("*2"));
            if ( _r.Compare(_T("*2")) == 0 )
            {
                return false;
            }
        }
        return true;
    }
 
    bool m_WriteString(LPCTSTR lpszSectionName, LPCTSTR lpszKey, LPCTSTR lpszData)
    {
        DWORD len = down_cast<DWORD>(STRLIB::GetLen(lpszData));
        CWorkMemT<TCHAR> work(len + 2);
        DWORD r = ::GetPrivateProfileString(lpszSectionName, lpszKey, _T(""), work, len + 2, m_strFile);
        if ( r == len && STRLIB::Compare(lpszData, work) == 0 )
        {
            return true;
        }
        return !! ::WritePrivateProfileString(lpszSectionName, lpszKey, lpszData, m_strFile);
    }
 
    bool m_Delete(LPCTSTR lpszSectionName, LPCTSTR lpszKey)
    {
        if ( GetKeyKind(lpszSectionName, lpszKey) != EK_Nothing )
        {
            return !! ::WritePrivateProfileString(lpszSectionName, lpszKey, NULL, m_strFile);
        }
        return false;
    }
 
    CStr        m_strFile;              
    CStr        m_strSection;           
};
 
 
 
}; // TNB
 
#else // _WIN32_WCE
 
#include "TnbCeInifileAccessor.h"
 
#endif // _WIN32_WCE