TnbMutualAccessor.h

[詳解]

#pragma once
#include "TnbAccessor.h"
#include "TnbSerializer.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CMutualAccessor
{
public:
 
    struct IWorker
    {
        virtual ~IWorker(void) {}
 
        virtual bool MutualAccessWorks(IAccessor::CSection& sec, LPCTSTR lpszKey, bool isQuery) = 0;
 
        #ifndef _TnbDOXYGEN //Document作成用シンボル
            virtual bool Works(IAccessor::CSection& sec, LPCTSTR lpszKey, bool isQuery)
            {
                return MutualAccessWorks(sec, lpszKey, isQuery);
            }
        #endif
    };
 
    class CSubSection
    {
    public:
        CSubSection(CMutualAccessor* P, LPCTSTR lpszSub) : m_pMu(P), m_success(false)
        {
            m_success = m_pMu->InSubSection(lpszSub);
        }
        ~CSubSection(void)
        {
            if ( m_success )
            {
                m_pMu->PreviousSubSection();
            }
        }
    private:
        CMutualAccessor*    m_pMu;      
        bool                m_success;  
    };
 
 
    //----------------------------------------------------------------
 
 
    enum EMode
    {
        QUERY,  
        WRITE,  
    };
 
    CMutualAccessor(IAccessor* pAccessor, EMode mode = QUERY) 
        : m_sec(IAccessor::CSection(pAccessor, _T(""))), m_isQuery(mode == QUERY)
    {
    }
 
    CMutualAccessor(IAccessor::CSection& sec, EMode mode = QUERY) 
        : m_sec(sec), m_isQuery(mode == QUERY)
    {
    }
 
    bool InSubSection(LPCTSTR lpszSection)
    {
        return m_Result(m_sec.InSubSection(lpszSection));
    }
 
    void PreviousSubSection(void)
    {
        m_sec.PreviousSubSection();
    }
 
    bool IsQueryMode(void) const
    {
        return m_isQuery; 
    }
 
    bool IsWriteMode(void) const
    {
        return ! m_isQuery; 
    }
 
    IAccessor::CSection* operator->(void)
    {
        return &m_sec;
    }
 
    bool Works(LPCTSTR lpszKey, bool& _boValue, bool def = false)
    {
        CStrVector vs;
        vs.Add(_T("false"));
        vs.Add(_T("true"));
        DWORD w = _boValue;
        bool r = Works(lpszKey, w, vs, def);
        _boValue = (w != 0);
        return m_Result(r);
    }
 
    bool Works(LPCTSTR lpszKey, BYTE& _bValue, BYTE def = 0)
    {
        if ( m_isQuery )
        {
            DWORD w = m_sec.QueryDword(lpszKey, def);
            _bValue = static_cast<BYTE>(w);
            return true;
        }
        return m_Result(m_sec.WriteDword(lpszKey, _bValue));
    }
 
    bool Works(LPCTSTR lpszKey, WORD& _wValue, WORD def = 0)
    {
        if ( m_isQuery )
        {
            DWORD w = m_sec.QueryDword(lpszKey, def);
            _wValue = static_cast<WORD>(w);
            return true;
        }
        return m_Result(m_sec.WriteDword(lpszKey, _wValue));
    }
 
    bool Works(LPCTSTR lpszKey, short& _value, short def = 0)
    {
        if ( m_isQuery )
        {
            DWORD w = m_sec.QueryDword(lpszKey, def);
            _value = static_cast<short>(w);
            return true;
        }
        return m_Result(m_sec.WriteDword(lpszKey, _value));
    }
 
    bool Works(LPCTSTR lpszKey, DWORD& _dwValue, DWORD def = 0)
    {
        if ( m_isQuery )
        {
            _dwValue = m_sec.QueryDword(lpszKey, def);
            return true;
        }
        return m_Result(m_sec.WriteDword(lpszKey, _dwValue));
    }
 
    bool Works(LPCTSTR lpszKey, int& _iValue, int def = 0)
    {
        if ( m_isQuery )
        {
            LONGLONG l = m_sec.QueryLonglong(lpszKey, def);
            _iValue = static_cast<int>(l);
            return true;
        }
        return m_Result(m_sec.WriteLonglong(lpszKey, _iValue));
    }
 
    bool Works(LPCTSTR lpszKey, long& _lValue, long def = 0)
    {
        if ( m_isQuery )
        {
            LONGLONG l = m_sec.QueryLonglong(lpszKey, def);
            _lValue = static_cast<long>(l);
            return true;
        }
        return m_Result(m_sec.WriteLonglong(lpszKey, _lValue));
    }
 
    bool Works(LPCTSTR lpszKey, LONGLONG& _llValue, LONGLONG def = 0)
    {
        if ( m_isQuery )
        {
            _llValue = m_sec.QueryLonglong(lpszKey, def);
            return true;
        }
        return m_Result(m_sec.WriteLonglong(lpszKey, _llValue));
    }
 
    bool Works(LPCTSTR lpszKey, double& _value, double def = 0.0)
    {
        if ( m_isQuery )
        {
            CByteVector vb = m_sec.QueryData(lpszKey);
            _value = def;
            if ( vb.GetSize() == sizeof(double) )
            {
                _value = *reinterpret_cast<const double*>(vb.ReferBuffer());
 
            }
            return true;
        }
        return m_Result(m_sec.WriteData(lpszKey, CConstAdapterT<BYTE>(sizeof(double), &_value)));
    }
 
    bool Works(LPCTSTR lpszKey, CStr& _strValue, LPCTSTR def = NULL)
    {
        if ( m_isQuery )
        {
            _strValue = m_sec.QueryString(lpszKey, def);
            return true;
        }
        return m_Result(m_sec.WriteString(lpszKey, _strValue));
    }
 
    bool Works(LPCTSTR lpszKey, size_t size, LPVOID P)
    {
        if ( m_isQuery )
        {
            CByteVector vb = m_sec.QueryData(lpszKey);
            memset(P, 0, size);
            if ( vb.GetSize() == size )
            {
                vb.GetElements(size, static_cast<BYTE*>(P));
            }
            return true;
        }
        return m_Result(m_sec.WriteData(lpszKey, CConstAdapterT<BYTE>(size, P)));
    }
 
    bool Works(LPCTSTR lpszKey, ICollectionT<BYTE>& _c)
    {
        if ( m_isQuery )
        {
            CByteVector vb = m_sec.QueryData(lpszKey);
            _c.Copy(vb);
            return true;
        }
        return m_Result(m_sec.WriteData(lpszKey, _c));
    }
 
    bool Works(LPCTSTR lpszKey, ISerializable& _s)
    {
        ASSERTLIB( false ); // このメソッドは潜在的なバグのある可能性があります。
        CSubSection sub(this, lpszKey);
        bool r = false;
        try
        {
            CMySerializer sr(&m_sec);
            if ( m_isQuery )
            {
                sr >> _s;
            }
            else
            {
                m_sec.DeleteAllKeys();
                sr << _s;
            }
            r = true;
        }
        catch ( CNoSuchTypeException& e )
        {
            e.OnCatch();
        }
        return r;
    } 
 
    bool Works(LPCTSTR lpszKey, DWORD& _dwValue, const CStrVector& vs, DWORD def = 0)
    {
        if ( m_isQuery )
        {
            _dwValue = def;
            if ( ! m_sec.HasKey(lpszKey) )
            {
                return true;
            }
            CStr s = m_sec.QueryString(lpszKey);
            INDEX r = vs.Find(s);
            if ( r != INVALID_INDEX )
            {
                _dwValue = r;
                return true;
            }
            return m_Result(false);
        }
        if ( vs.GetSize() > _dwValue )
        {
            return m_Result(m_sec.WriteString(lpszKey, vs[_dwValue]));
        }
        m_sec.DeleteKey(lpszKey);
        return m_Result(false);
    }
 
    bool Works(LPCTSTR lpszKey, IWorker& _worker)
    {
        bool r = _worker.Works(m_sec, lpszKey, m_isQuery);
        return m_Result(r);
    }
 
#ifdef __AFX_H__
    bool Works(LPCTSTR lpszKey, CString& _strValue, LPCTSTR def = NULL)
    {
        if ( m_isQuery )
        {
            _strValue = m_sec.QueryString(lpszKey, def);
            return true;
        }
        CStr s = _strValue;
        return m_Result(m_sec.WriteString(lpszKey, s));
    }
 
    bool Works(LPCTSTR lpszKey, HWND hWnd, LPCTSTR def = NULL)
    {
        if ( m_isQuery )
        {
            m_sec.QueryWindowText(lpszKey, hWnd, def);
            return true;
        }
        return m_Result(m_sec.WriteWindowText(lpszKey, hWnd));
    }
 
    bool Works(LPCTSTR lpszKey, CComboBox& comboBox, int def = 0)
    {
        if ( m_isQuery )
        {
            comboBox.SetCurSel(m_sec.QueryDword(lpszKey, def));
            return true;
        }
        return m_Result(m_sec.WriteDword(lpszKey, comboBox.GetCurSel()));
    }
 
    bool Works(LPCTSTR lpszKey, CButton& button, int def = BST_UNCHECKED)
    {
        if ( m_isQuery )
        {
            button.SetCheck(m_sec.QueryDword(lpszKey, def));
            return true;
        }
        return m_Result(m_sec.WriteDword(lpszKey, button.GetCheck()));
    }
#endif //__AFX_H__
 
protected:
 
    virtual void OnFalse(void) const
    {
    }
 
private:
 
    bool                    m_isQuery;      
    IAccessor::CSection     m_sec;          
    bool m_Result(bool r) const
    {
        if ( ! r )
        {
            OnFalse();
        }
        return r;
    }
 
    // シリアライザー
    class CMySerializer : public ISerializer, public IDeserializer
    {
    public:
        CMySerializer(IAccessor::CSection* P) : m_pSec(P), m_count(0)
        {
        }
        virtual void AddRaw(size_t size, LPCVOID P)
        {
            m_pSec->WriteData(CStr::Fmt(_T("%04d"), m_count), CConstAdapterT<BYTE>(size, P));
            m_count++;
        }
        virtual void GetRaw(size_t size, LPVOID _P) const
        {
            CByteVector vb = m_pSec->QueryData(CStr::Fmt(_T("%04d"), m_count));
            if ( size != vb.GetSize() )
            {
                throw CNoSuchTypeException();
            }
            vb.GetElements(size, static_cast<BYTE*>(_P));
            m_count++;
        }
    private:
        mutable int             m_count;    
        IAccessor::CSection*    m_pSec;     
    };
};
 
 
 
}; // TNB