TnbTemporaryAccessor.h

[詳解]

#pragma once
#include "TnbAccessor.h"
#include "TnbMap.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CTemporaryAccessor : public CAbstractAccessor
{
    DEFSUPER(CAbstractAccessor);
    typedef CMapT<CStr, CValue, LPCTSTR> CKeyMap;       
 
    mutable CStr            m_strSecName;               
    mutable CKeyMap*        m_pmapKey;                  
 
protected:
 
    mutable CMapT<CStr, CKeyMap, LPCTSTR> m_mapSec; 
 
private:
 
    void m_Reset(void) const
    {
        m_pmapKey = NULL;
    }
 
    CKeyMap* m_CheckKeyMapP(void) const
    {
        if ( m_pmapKey == NULL && m_mapSec.HasKey(m_strSecName) )
        {
            m_pmapKey = &(m_mapSec[m_strSecName]);
        }
        return m_pmapKey;
    }
 
    CKeyMap* m_GetKeyMapP(void)
    {
        if ( m_pmapKey == NULL )
        {
            m_pmapKey = &(m_mapSec[m_strSecName]);
        }
        return m_pmapKey;
    }
 
    void m_SetSectionName(LPCTSTR lpszSectionName) const
    {
        if ( m_strSecName != lpszSectionName )
        {
            m_Reset();
            m_strSecName = lpszSectionName;
        }
    }
 
    bool m_Write(LPCTSTR lpszKey, const CValue& v)
    {
        CKeyMap* P = m_GetKeyMapP();
        if ( P != NULL )
        {
            (*P)[lpszKey] = v;
            return true;
        }
        return false;
    }
 
    bool m_Delete(LPCTSTR lpszKey)
    {
        CKeyMap* P = m_CheckKeyMapP();
        return (P != NULL) ? P->RemoveKey(lpszKey) : false;
    }   
 
public:
    
    CTemporaryAccessor(void) : _super(), m_pmapKey(NULL)
    {
    }
 
    virtual CStr GetTypeName(void) const
    {
        return _T("Temp");
    }
 
    virtual bool Flush(void)
    {
        return true;
    }
 
    virtual CStrVector EnumSectionNames(LPCTSTR lpszSectionName = NULL) const
    {
        CStrVector vs = m_mapSec.EnumKeys();
        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)
    {
        m_Reset();
        CStrVector vs = m_mapSec.EnumKeys();
        CStr ss = lpszSectionName;
        size_t len = ss.GetLength();
        loop ( i, vs.GetSize() )
        {
            if ( STRLIB::Compare(vs[i], ss, len, NORM_IGNORECASE) == 0 )
            {
                if ( ! m_mapSec.RemoveKey(vs[i]) )
                {
                    return false;
                }
            }
        }
        return true;
    }
 
    virtual CStrVector EnumKeyNames(LPCTSTR lpszSectionName) const
    {
        m_SetSectionName(lpszSectionName);
        CKeyMap* P = m_CheckKeyMapP();
        return (P == NULL) ? CStrVector() : P->EnumKeys();
    }
 
    virtual EKind GetKeyKind(LPCTSTR lpszSectionName, LPCTSTR lpszKey) const
    {
        m_SetSectionName(lpszSectionName);
        CKeyMap* P = m_CheckKeyMapP();
        if ( P == NULL )
        {
            return EK_Nothing;
        }
        CValue v;
        return (P->Lookup(lpszKey, v)) ? v.GetKind() : EK_Nothing;
    }
 
    virtual CValue QueryValue(LPCTSTR lpszSectionName, LPCTSTR lpszKey) const
    {
        m_SetSectionName(lpszSectionName);
        CKeyMap* P = m_CheckKeyMapP();
        CValue v;
        if ( P != NULL )
        {
            P->Lookup(lpszKey, v);
        }
        return v;
    }
 
    virtual bool WriteValue(LPCTSTR lpszSectionName, LPCTSTR lpszKey, const IAccessor::CValue& value)
    {
        m_SetSectionName(lpszSectionName);
        if ( value.GetKind() == EK_Nothing )
        {
            return m_Delete(lpszKey); 
        }
        return m_Write(lpszKey, value);
    }
};
 
 
 
}; // TNB