TnbExInifileAccessor.h

[詳解]

#pragma once
#ifdef _WIN32_WCE
 #error not support "ExInifileAccessor"
#endif // _WIN32_WCE
 
 
 
#include "TnbInifileAccessor.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CExInifileAccessor : public CInifileAccessor
{
    DEFSUPER(CInifileAccessor);
    enum { E_BufferSize = 65536 };      
    static EKind ms_CheckKind(LPCTSTR lpsz)
    {
        if ( lpsz[0] != '_' || lpsz[2] != '_' )
        {
            return EK_Nothing;
        }
        switch ( lpsz[1] )
        {
        case EK_String:         // 文字列
        case EK_PluralStrings:  // 複数の文字列群
        case EK_Binary:         // バイナリ
        case EK_Dword:          // 32Bit Unsigned
        case EK_Longlong:       // 64Bit Signed
            break;
        default:
            return EK_Nothing;
        }
        return static_cast<EKind>(lpsz[1]);
    }
 
    static CStr ms_ToWritingStr(LPCTSTR lpsz)
    {
        CStr s = lpsz;
        if ( s.IsEmpty() )
        {
            s = _T("@");
        }
        else
        {
            s.Replace(_T("\\"), _T("\\\\"));
            s.Replace(_T("\n"), _T("\\n"));
            s.Replace(_T("\r"), _T("\\r"));
            s.Replace(_T("="), _T("\\-"));
            s.Replace(_T(" "), _T("\\_"));
        }
        return s;
    }
 
    static CStr ms_ToOriginalStr(LPCTSTR lpsz)
    {
        CStr s = lpsz;
        s.Replace(_T("\\_"), _T(" "));
        s.Replace(_T("\\n"), _T("\n"));
        s.Replace(_T("\\r"), _T("\r"));
        s.Replace(_T("\\-"), _T("="));
        s.Replace(_T("\\\\"), _T("\\"));
        return s;
    }
 
    bool m_Write(EKind eKind, LPCTSTR lpszSectionName, LPCTSTR lpszKey, LPCTSTR lpszData)
    {
        CStr s = CStr::Fmt(_T("_%c_%s"), eKind, lpszData);
        return !! ::WritePrivateProfileString(
                            lpszSectionName,
                            ms_ToWritingStr(lpszKey),
                            ms_ToWritingStr(s),
                            GetBaseFileName()
        );
    }
 
    CStr m_Query(LPCTSTR lpszSectionName, LPCTSTR lpszKey) const
    {
        CStr strValue;
        ::GetPrivateProfileString(
                                lpszSectionName,
                                ms_ToWritingStr(lpszKey),
                                _T(""),
                                strValue.GetBuffer(E_BufferSize),
                                E_BufferSize,
                                GetBaseFileName());
        strValue.ReleaseBuffer();
        strValue = ms_ToOriginalStr(strValue); 
        return strValue.Mid(3);
    }
 
public:
 
    explicit CExInifileAccessor(LPCTSTR lpszFile = NULL) : _super(lpszFile)
    {
    }
 
    virtual CStrVector EnumKeyNames(LPCTSTR lpszSectionName) const
    {
        CStrVector vstr = _super::EnumKeyNames(lpszSectionName);
        loop ( i, vstr.GetSize() )
        {
            vstr[i] = ms_ToOriginalStr(vstr[i]);
        }
        return vstr;
    }
 
    virtual EKind GetKeyKind(LPCTSTR lpszSectionName, LPCTSTR lpszKey) const
    {
        TCHAR atcBuf[16];
        DWORD dwRc = ::GetPrivateProfileString(
                                lpszSectionName,
                                ms_ToWritingStr(lpszKey),
                                _T(""),
                                atcBuf,
                                16,
                                GetBaseFileName());
        if ( dwRc < 3 )
        {
            return EK_Nothing;
        }
        return ms_CheckKind(atcBuf);
    }
 
    virtual CValue QueryValue(LPCTSTR lpszSectionName, LPCTSTR lpszKey) const
    {
        CValue v;
        CStr str = m_Query(lpszSectionName, lpszKey);
        switch ( GetKeyKind(lpszSectionName, lpszKey) )
        {
        case EK_Nothing:
            break;
        case EK_String:
            v = CValue(str);
            break;
        case EK_PluralStrings:
            v = CValue(StrToStrVectorEx(str));
            break;
        case EK_Binary:
            v = CValue(CStrOperator::HexStringToBinary(str));
            break;
        case EK_Dword:
            v = CValue(static_cast<DWORD>(str.ToLonglong()));
            break;
        case EK_Longlong:
            v = CValue(str.ToLonglong());
            break;
        default:
            ASSERT(false);
            break;
        }
        return v;
    }
 
    virtual bool WriteValue(LPCTSTR lpszSectionName, LPCTSTR lpszKey, const IAccessor::CValue& value) 
    {
        EKind kind = value.GetKind();
        if ( kind == EK_Nothing )
        {
            return _super::WriteValue(lpszSectionName, lpszKey, value);
        }
        return m_Write(kind, lpszSectionName, lpszKey, value.QueryString());
    }
};
 
 
 
}; // TNB