TnbAccessor.h

[詳解]

#pragma once
#include "TnbStrVector.h"
#include "TnbCollection.h"
#include "TnbStrOperator.h"
#include "TnbSerializeAdapter.h"
#ifdef _TnbDOXYGEN  //Document作成用シンボル
 #define _TnbACCESSOR_Tree_ENABLE 
#endif
#ifdef _TnbACCESSOR_Tree_ENABLE
 #include "TnbTree.h"
 #include "TnbMap.h"
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
struct IAccessor
{
    enum EKind
    {
        EK_Nothing      = 'n',  
        EK_String       = 's',  
        EK_PluralStrings= 'p',  
        EK_Binary       = 'b',  
        EK_Dword        = 'd',  
        EK_Longlong     = 'i',  
    };
 
    class CValue
    {
        EKind       m_eKind;        
        CStr        m_strData;      
        LONGLONG    m_llData;       
        CByteVector m_vbData;       
    public:
    
        CValue(void) : m_eKind(EK_Nothing) 
        {
        }
 
        CValue(LPCTSTR lpsz) : m_eKind(EK_String), m_strData(lpsz)
        {
        }
 
        CValue(const CStrVector& vstr) : m_eKind(EK_PluralStrings), m_strData(StrVectorToStrEx(vstr)) 
        {
        }
 
        CValue(const IConstCollectionT<BYTE>& c) : m_eKind(EK_Binary)
        {
            m_vbData.Copy(c);
        }
 
        CValue(size_t len, LPCVOID P) : m_eKind(EK_Binary)
        {
            m_vbData.CopyElements(len, static_cast<const BYTE*>(P));
        }
 
        CValue(DWORD dw) : m_eKind(EK_Dword), m_llData(dw) 
        {
        }
 
        CValue(LONGLONG ll) : m_eKind(EK_Longlong), m_llData(ll)
        {
        }
 
        EKind GetKind(void) const { return m_eKind; }
 
        bool IsNull(void) const { return m_eKind == EK_Nothing; }
 
        CStr QueryString(void) const
        {
            CStr s;
            switch ( m_eKind )
            {
            case EK_String:         // 文字列
            case EK_PluralStrings:  // 複数の文字列群
                s = m_strData;
                break;
            case EK_Binary:         // バイナリ
                s = CStrOperator::BinaryToHexString(m_vbData);
                break;
            case EK_Dword:          // 32Bit
                s = CStr::Fmt(_T("%u"), static_cast<DWORD>(m_llData));
                break;
            case EK_Longlong:       // 64Bit
                s = CStr::Fmt(_T("%I64d"), m_llData);
                break;
            case EK_Nothing:
                break;
            }   
            return s;
        }
 
        CStrVector QueryPluralStrings(void) const
        {
            CStrVector vstr;
            if ( m_eKind == EK_PluralStrings || m_eKind == EK_String )
            {
                vstr = StrToStrVectorEx(m_strData);
            }
            return vstr;
        }
 
        CByteVector QueryData(void) const
        {
            if ( m_eKind != EK_Binary )
            {
                return CStrOperator::HexStringToBinary(QueryString());
            }
            return m_vbData;
        }
 
        DWORD QueryDword(void) const
        {
            return static_cast<DWORD>(QueryLonglong()); 
        }
 
        LONGLONG QueryLonglong(void) const
        {
            if ( m_eKind == EK_Longlong || m_eKind == EK_Dword )
            {
                return m_llData;
            }
            return QueryString().ToLonglong(); 
        }
    };
 
    #ifdef _TnbACCESSOR_Tree_ENABLE
 
    typedef CMapT<CStr, CValue, LPCTSTR> CKeyMap;
 
    typedef CTreeT<CStr, CValue, LPCTSTR> CKeyTree;
 
    #endif
    
    class CSection
    {
        IAccessor*      m_piAccessor;   
        CStr            m_strSection;   
        bool m_IsEmpty(const CValue& v) const
        {
            bool r = v.IsNull();
            if ( ! r && v.GetKind() == EK_String )
            {
                r = v.QueryString().IsEmpty();
            }
            return r;
        }
        CSection(void);
    public:
 
        CSection(const IAccessor* I, LPCTSTR lpszSectionName) 
            : m_piAccessor(const_cast<IAccessor *>(I)), m_strSection(lpszSectionName)
        {
            if ( I == NULL )
            {
                ASSERT0( false, "CSection::CSection()", "IAccessor が指定されていません。" );
                throw CNullPointerException();
            }
        }
 
        CStr GetSectionName(void) const
        {
            return m_strSection;
        }
 
        bool CanQuery(void) const
        {
            CStr s = m_strSection;
            INT_PTR d = s.ReverseFind('\\');
            if ( d >= 0 )
            {
                s = s.Left(d);
            }
            CStrVector vs = m_piAccessor->EnumSectionNames();
            return vs.Find(s) != INVALID_INDEX;
        }
 
        bool InSubSection(LPCTSTR lpszSubName)
        {
            if ( STRLIB::GetLen(lpszSubName) > 0 && STRLIB::IndexOf(lpszSubName, '\\') < 0 )
            {
                if ( ! m_strSection.IsEmpty() )
                {
                    m_strSection += _T('\\');
                }
                m_strSection += lpszSubName;
                return true;
            }
            return false;
        }
 
        void PreviousSubSection(void)
        {
            INT_PTR d = m_strSection.ReverseFind('\\');
            if ( d >= 0 )
            {
                m_strSection = m_strSection.Left(d);
            }
            else
            {
                m_strSection.Empty();
            }
        }
 
        const IAccessor* ReferAccessor(void) const
        {
            return m_piAccessor;
        }
 
        CStrVector EnumSectionNames(void) const
        {
            return m_piAccessor->EnumSectionNames(m_strSection);
        }
 
        CStrVector EnumKeyNames(void) const
        {
            return m_piAccessor->EnumKeyNames(m_strSection);
        }
 
        bool DeleteAllKeys(void)
        {
            return m_piAccessor->DeleteSection(m_strSection);
        }
 
        EKind GetKeyKind(LPCTSTR lpszKey) const
        {
            return m_piAccessor->GetKeyKind(m_strSection, lpszKey);
        }
 
        bool HasKey(LPCTSTR lpszKey) const
        {
            return GetKeyKind(lpszKey) != EK_Nothing;
        }
 
        bool DeleteKey(LPCTSTR lpszKey)
        {
            return m_piAccessor->WriteValue(m_strSection, lpszKey, CValue());
        }
 
        bool WriteValue(LPCTSTR lpszKey, const CValue& value)
        {
            return m_piAccessor->WriteValue(m_strSection, lpszKey, value);
        }
 
        CValue QueryValue(LPCTSTR lpszKey) const
        {
            return m_piAccessor->QueryValue(m_strSection, lpszKey);
        }
        
        bool WriteString(LPCTSTR lpszKey, LPCTSTR lpszValue)
        {
            return WriteValue(lpszKey, CValue(lpszValue));
        }
 
        CStr QueryString(LPCTSTR lpszKey, LPCTSTR lpszDefault = NULL) const
        {
            const CValue& v = QueryValue(lpszKey);
            return v.IsNull() ? lpszDefault : v.QueryString();
        }
 
        bool WritePluralStrings(LPCTSTR lpszKey, const CStrVector& vs)
        {
            return WriteValue(lpszKey, CValue(vs));
        }
 
        CStrVector QueryPluralStrings(LPCTSTR lpszKey) const
        {
            return QueryValue(lpszKey).QueryPluralStrings();
        }
 
        bool WriteData(LPCTSTR lpszKey, const IConstCollectionT<BYTE>& c)
        {
            return WriteValue(lpszKey, CValue(c));
        }
 
        bool WriteData(LPCTSTR lpszKey, size_t len, LPCVOID P)
        {
            return WriteValue(lpszKey, CValue(len, P));
        }
 
        CByteVector QueryData(LPCTSTR lpszKey) const
        {
            return QueryValue(lpszKey).QueryData();
        }
 
        bool WriteDword(LPCTSTR lpszKey, DWORD dwValue)
        {
            return WriteValue(lpszKey, CValue(dwValue));
        }
 
        DWORD QueryDword(LPCTSTR lpszKey, DWORD dwDefault = 0) const
        {
            const CValue& v = QueryValue(lpszKey);
            return m_IsEmpty(v) ? dwDefault : v.QueryDword();
        }
 
        bool WriteLonglong(LPCTSTR lpszKey, LONGLONG llValue)
        {
            return WriteValue(lpszKey, CValue(llValue));
        }
 
        LONGLONG QueryLonglong(LPCTSTR lpszKey, LONGLONG llDefault = 0) const
        {
            const CValue& v = QueryValue(lpszKey);
            return m_IsEmpty(v) ? llDefault : v.QueryLonglong();
        }
 
        template<typename TYP>
        bool WriteStruct(LPCTSTR lpszKey, const TYP& t)
        {
            CByteVector vb;
            vb.SetElements(sizeof(TYP), reinterpret_cast<const BYTE*>(&t));
            return WriteData(lpszKey, vb);
        }
 
        template<typename TYP>
        bool QueryStruct(LPCTSTR lpszKey, TYP& _t) const
        {
            const CByteVector& v = QueryData(lpszKey);
            if ( v.GetSize() != sizeof(TYP) )
            {
                return false;
            }
            BYTE* B = reinterpret_cast<BYTE*>(&_t);
            MemCopy(B, v.ReferBuffer(), sizeof(TYP));
            return true;
        }
 
        bool WriteVector(const CVectorT<CValue>& vv)
        {
            bool r = true;
            r &= m_piAccessor->DeleteSection(m_strSection);
            size_t len = vv.GetSize();
            r &= WriteLonglong(_T("size"), len);
            loop ( i, len )
            {
                r &= WriteValue(CStr::Fmt(_T("%d"), i + 1), vv[i]);
            }
            return r;
        }
 
        CVectorT<CValue> QueryVector(void) const
        {
            CVectorT<CValue> vv;
            size_t len = QueryDword(_T("size"), 0);
            vv.SetSize(len);
            loop ( i, len )
            {
                vv[i] = QueryValue(CStr::Fmt(_T("%d"), i + 1));
            }
            return vv;
        }
 
        bool WriteSerializableData(LPCTSTR lpszKey, const ISerializable& s)
        {
            CByteVector vb;
            try
            {
                CSerializeAdapter sa(&vb);
                sa << s;
                return WriteData(lpszKey, vb);
            }
            catch ( ... )
            {
                return false;
            }
            return false;
        }
 
        bool QuerySerializableData(LPCTSTR lpszKey, ISerializable& _d) const
        {
            CByteVector vb = QueryData(lpszKey);
            if ( ! vb.IsEmpty() )
            {
                try
                {
                    CDeserializeAdapter da(&vb);
                    da >> _d;
                    return true;
                }
                catch ( ... )
                {
                    return false;
                }
            }
            return false;
        }
 
        #ifdef __AFX_H__
        
        bool WriteWindowText(LPCTSTR lpszKey, HWND hWnd)
        {
            CStr s;
            int l = ::GetWindowTextLength(hWnd);
            if ( l > 0 )
            {
                ::GetWindowText(hWnd, s.GetBuffer(l + 2), l + 1);
                s.ReleaseBuffer();
                return WriteString(lpszKey, s);
            }
            return DeleteKey(lpszKey);
        }
 
        bool QueryWindowText(LPCTSTR lpszKey, HWND hWnd, LPCTSTR lpszDefault = NULL) const
        {
            CStr s = QueryString(lpszKey, lpszDefault);
            return !! ::SetWindowText(hWnd, s);
        }
 
        #endif
 
        #ifdef _TnbACCESSOR_Tree_ENABLE
 
        CKeyMap GetKeyMap(void) const
        {
            CKeyMap map;
            const CStrVector& vstr = EnumKeyNames();
            loop ( i, vstr.GetSize() )
            {
                map[vstr[i]] = QueryValue(vstr[i]);
            }
            return map;
        }
 
        void GetKeyTree(CKeyTree& _tree) const
        {
            const CStrVector& vs = EnumSectionNames();
            loop ( i, vs.GetSize() )
            {
                CSection s = *this;
                s.InSubSection(vs[i]);
                s.GetKeyTree(_tree.Refer(vs[i]));
                s.PreviousSubSection();
            }
            const CKeyMap& mapKey = GetKeyMap();
            CStr key;
            CValue value;
            loop ( i, mapKey.GetSize() )
            {
                mapKey.Get(i, key, value);
                if ( key.IsEmpty() )
                {
                    _tree.AtSelf() = value;
                }
                else
                {
                    _tree.Add(key, value);
                }
            }
        }
 
        void GetKeyTree(CStrsTree& _tree) const
        {
            const CStrVector& vs = EnumSectionNames();
            loop ( i, vs.GetSize() )
            {
                CSection s = *this;
                s.InSubSection(vs[i]);
                s.GetKeyTree(_tree.Refer(vs[i]));
                s.PreviousSubSection();
            }
            const CKeyMap& mapKey = GetKeyMap();
            CStr key;
            CValue value;
            loop ( i, mapKey.GetSize() )
            {
                mapKey.Get(i, key, value);
                if ( key.IsEmpty() )
                {
                    _tree.AtSelf() = value.QueryString();
                }
                else
                {
                    _tree.Add(key, value.QueryString());
                }
            }
        }
 
        #endif
    };
 
    virtual ~IAccessor(void)
    {
    }
 
    virtual CStr GetTypeName(void) const = 0;
 
    virtual bool Flush(void) = 0;
 
    virtual CStrVector EnumSectionNames(LPCTSTR lpszSectionName = NULL) const = 0;
 
    virtual bool DeleteSection(LPCTSTR lpszSectionName) = 0;
 
    virtual CStrVector EnumKeyNames(LPCTSTR lpszSectionName) const = 0;
 
    virtual EKind GetKeyKind(LPCTSTR lpszSectionName, LPCTSTR lpszKey) const = 0;
 
    virtual CValue QueryValue(LPCTSTR lpszSectionName, LPCTSTR lpszKey) const = 0;
 
    virtual bool WriteValue(LPCTSTR lpszSectionName, LPCTSTR lpszKey, const IAccessor::CValue& value) = 0;
    
    template<typename TYP>
    static CVectorT<IAccessor::CValue> ToValueVector(const CVectorT<TYP>& vt)
    {
        CVectorT<IAccessor::CValue> vv;
        vv.SetSize(vt.GetSize());
        loop ( i, vt.GetSize() )
        {
            vv[i] = CValue(vt[i]);
        }
        return vv;
    }
};
 
 
 
class CAbstractAccessor : public IAccessor
{
    DEFSUPER(IAccessor);
public:
 
    CSection operator[](LPCTSTR lpszSectionName)
    {
        return CSection(this, lpszSectionName);
    }
 
    const CSection operator[](LPCTSTR lpszSectionName) const
    {
        return CSection(this, lpszSectionName);
    }
 
    virtual bool Flush(void)
    {
        return true; 
    }
 
    bool DeleteAllSection(void)
    {
        bool r = true;
        CStrVector vs = EnumSectionNames(NULL);
        loop ( i, vs.GetSize() )
        {
            r &= DeleteSection(vs[i]);
        }
        return r;
    }
 
    #ifdef _TnbACCESSOR_Tree_ENABLE
 
    void GetKeyTree(CKeyTree& _tree) const
    {
        const CStrVector& vstr = EnumSectionNames();
        CSection(this, _T("")).GetKeyTree(_tree);
        loop ( i, vstr.GetSize() )
        {
            CSection(this, vstr[i]).GetKeyTree(_tree.Refer(vstr[i]));
        }
    }
 
    void GetKeyTree(CStrsTree& _tree) const
    {
        const CStrVector& vstr = EnumSectionNames();
        CSection(this, _T("")).GetKeyTree(_tree);
        loop ( i, vstr.GetSize() )
        {
            CSection(this, vstr[i]).GetKeyTree(_tree.Refer(vstr[i]));
        }
    }
 
    #endif
 
    static CStr MakeDefineFilePath(void)
    {
        CStr str;
        DWORD dwRc = ::GetModuleFileName(NULL, str.GetBuffer(MAX_PATH), MAX_PATH);
        str.ReleaseBuffer();
        ASSERTLIB(dwRc != 0);
        IgnoreUnusedValue(dwRc);
        //
        CStr strWork;
        strWork = str.Left(str.ReverseFind('.'));
        #if defined(_DEBUG) && !defined(_WIN32_WCE)
            strWork += _T(".");
            CStr s;
            DWORD dwLength = MAX_COMPUTERNAME_LENGTH + 1;
            ::GetComputerName(s.GetBuffer(dwLength), &dwLength);
            s.ReleaseBuffer();
            strWork += s;
        #endif
        return strWork;
    }
};
 
 
 
class CDeepAccessFinder
{
public:
 
    CDeepAccessFinder(void) : m_depth(0)
    {
    }
 
    void Execute(IAccessor::CSection& section)
    {
        IAccessor::CSection sec = section;
        m_depth = 0;
        m_Find(sec);
    }
 
protected:
 
    enum EResult
    {
        Next,       
        Previous,   
        Stop,       
    };
 
    virtual EResult OnFindSection(LPCTSTR lpszSection, IAccessor::CSection& sec, int depth)
    {
        return Next;
    }
 
private:
    EResult m_Find(IAccessor::CSection& sec)
    {
        m_depth++;
        CStrVector vs = sec.EnumSectionNames();
        loop ( i, vs )
        {
            IAccessor::CSection s = sec;
            if ( s.InSubSection(vs[i]) )
            {
                EResult r = OnFindSection(vs[i], s, m_depth);
                if ( r == Next )
                {
                    r = m_Find(s);
                }
                if ( r == Previous )
                {
                    break;
                }
                if ( r != Next )
                {
                    m_depth--;
                    return Stop;
                }
            }
        }
        m_depth--;
        return Next;
    }
    int     m_depth;        
};
 
 
 
#ifndef _WIN32_WCE
 
inline bool StoreWindowPlacement(IAccessor::CSection& _sec, HWND hWnd)
{
    bool boRc = true;
    WINDOWPLACEMENT t = { 0 };
    t.length = sizeof(WINDOWPLACEMENT);
    if ( ! ::GetWindowPlacement(hWnd, &t) ){ return false; }
    boRc &= _sec.WriteDword(_T("Valid"), 1);
    boRc &= _sec.WriteLonglong(_T("SX"), t.rcNormalPosition.left);
    boRc &= _sec.WriteLonglong(_T("SY"), t.rcNormalPosition.top);
    boRc &= _sec.WriteLonglong(_T("EX"), t.rcNormalPosition.right);
    boRc &= _sec.WriteLonglong(_T("EY"), t.rcNormalPosition.bottom);
    boRc &= _sec.WriteDword(_T("Show"), ::IsWindowVisible(hWnd));
    boRc &= _sec.WriteDword(_T("Maximize"), ::IsZoomed(hWnd));
    return boRc;
}
 
 
 
inline bool RestoreWindowPlacement(const IAccessor::CSection& sec, HWND hWnd, bool withWindowSize = true, bool withShowHide = false)
{
    if ( sec.QueryDword(_T("Valid"), 0) == 0 )
    {
        return false;
    }
    WINDOWPLACEMENT t = { 0 };
    t.length = sizeof(WINDOWPLACEMENT);
    if ( ! ::GetWindowPlacement(hWnd, &t) )
    {
        return false;
    }
    int width = t.rcNormalPosition.right - t.rcNormalPosition.left;
    int height = t.rcNormalPosition.bottom  - t.rcNormalPosition.top;
    t.rcNormalPosition.left     = static_cast<LONG>(sec.QueryLonglong(_T("SX"), 0));
    t.rcNormalPosition.top      = static_cast<LONG>(sec.QueryLonglong(_T("SY"), 0));
    if ( withWindowSize )
    {
        t.rcNormalPosition.right    = static_cast<LONG>(sec.QueryLonglong(_T("EX"), 100));
        t.rcNormalPosition.bottom   = static_cast<LONG>(sec.QueryLonglong(_T("EY"), 100));
    }
    else
    {
        t.rcNormalPosition.right = t.rcNormalPosition.left + width;
        t.rcNormalPosition.bottom = t.rcNormalPosition.top + height;
    }
    //
    DWORD cx = t.rcNormalPosition.right - t.rcNormalPosition.left;
    DWORD cy = t.rcNormalPosition.bottom - t.rcNormalPosition.top;
    if ( cx > 4000 || cy > 4000 )
    {
        return false;
    }
    t.flags     = WPF_SETMINPOSITION;
    t.showCmd   = SW_HIDE;
    ::SetWindowPlacement(hWnd, &t);
    if ( withShowHide )
    {
        DWORD s = sec.QueryDword(_T("Show"), TRUE);
        ::ShowWindow(hWnd, (s != 0) ? SW_SHOW : SW_HIDE);
    }
    if ( !! sec.QueryDword(_T("Maximize"), FALSE) )
    {
        ::ShowWindow(hWnd, SW_MAXIMIZE);
    }
    return true;
}
 
#endif //_WIN32_WCE
 
 
 
}; // TNB