TnbTmlVariableManager.h

[詳解]

#pragma once
#include "TnbTmlValue.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CTmlVariableManager
{
public:
 
    struct TVarValue
    {
        CAscii      name;   
        CTmlValue   value;  
    };
 
    typedef CVectorT<TVarValue> CVaVaVector;
 
    typedef CVectorT<CVaVaVector> CVaVaVectors;
 
    struct TArrayValue
    {
        CAscii              name;   
        CTmlValuesVector    values; 
    };
 
    typedef CVectorT<TArrayValue> CArVaVector;
 
    typedef CVectorT<CArVaVector> CArVaVectors;
 
 
    //-----------------------------
 
 
    CTmlVariableManager(void)
    {
    }
 
    CTmlVariableManager(const CTmlVariableManager& other) : m_aVava(other.m_aVava), m_aArva(other.m_aArva)
    {
    }
 
    CVaVaVectors& ReferVarArrays(void)
    {
        return m_aVava;
    }
 
    CArVaVectors& ReferArrayArrays(void)
    {
        return m_aArva;
    }
 
    INT_PTR GetLevel(void) const
    {
        return m_aVava.GetSize();
    }
 
    CTmlValue* FindValue(LPCSTR lpszName)
    {
        INT_PTR iDim1 = m_aVava.GetSize();
        for( INT_PTR i = iDim1 - 1; i >= 0; i-- )
        {
            CVaVaVector& va = m_aVava.Ref(i);
            INT_PTR iDim2 = va.GetSize();
            for( INT_PTR j = 0; j < iDim2; j++ )
            {
                TVarValue& T = va.Ref(j);
                if ( T.name.Compare(lpszName) == 0 )
                {
                    return &T.value;
                }
            }
        }
        return NULL;
    }
 
    CTmlValuesVector* FindArray(LPCSTR lpszName)
    {
        INT_PTR iDim1 = m_aArva.GetSize();
        for( INT_PTR i = iDim1 - 1; i >= 0; i-- )
        {
            CArVaVector& va = m_aArva.Ref(i);
            INT_PTR iDim2 = va.GetSize();
            for( INT_PTR j = 0; j < iDim2; j++ )
            {
                TArrayValue& T = va.Ref(j);
                if ( T.name.Compare(lpszName) == 0 )
                {
                    return &T.values;
                }
            }
        }
        return NULL;
    }
 
    void Empty(void)
    {
        m_aVava.RemoveAll();
        m_aArva.RemoveAll();
    }
 
    void IncLevel(void)
    {
        m_aVava.Add(CVaVaVector());
        m_aArva.Add(CArVaVector());
        //
        TTRACE1("CTmlVariableManager::レベル++ NowLvl=%d\n", GetLevel());
    }
 
    bool DecLevel(void)
    {
        INT_PTR l = m_aVava.GetSize();
        if ( l <= 0 )
        {
            return false;
        }
        #ifdef _DEBUG
            CAscii s;
            {
                CVaVaVector& va = m_aVava.Ref(l - 1);
                INT_PTR iDim = va.GetSize();
                for( INT_PTR i = 0; i < iDim; i++ )
                {
                    s.Format( "    del-> 変数 %s (=%s)\n",
                                    va[i].name,
                                    va[i].value.GetString() 
                    );
                    ::OutputDebugStringA( s );
                }
            }
            //
            {
                CArVaVector& va = m_aArva.Ref(l - 1);
                INT_PTR iDim = va.GetSize();
                for( INT_PTR i = 0; i < iDim; i++ )
                {
                    s.Format( "    del-> 配列 %s(%d)\n",
                                    va[i].name,
                                    va[i].values.GetSize() 
                    );
                    ::OutputDebugStringA( s );
                }
            }
 
        #endif
        //
        m_aVava.SetSize(l - 1);
        m_aArva.SetSize(l - 1);
        TTRACE1( "CTmlVariableManager::レベル-- NowLvl=%d\n", GetLevel() );
        return true;
    }
 
    bool DecLevels(INT_PTR level)
    {
        while( level < GetLevel() )
        {
            if ( ! DecLevel() )
            {
                return false;
            }
        }
        return true;
    }
 
    bool HasNameInNowLevel(LPCSTR lpszName) const
    {
        size_t l = m_aVava.GetSize();
        if ( l > 0 )
        {
            const CVaVaVector& va = m_aVava.At(l - 1);
            loop ( i, va.GetSize() )
            {
                if ( va[i].name.Compare(lpszName) == 0 )
                {
                    return true;
                }
            }
            const CArVaVector& aa = m_aArva.At(l - 1);
            loop ( i, aa.GetSize() )
            {
                if ( aa[i].name.Compare(lpszName) == 0 )
                {
                    return true;
                }
            }
        }
        return false;
    }
 
    bool AddValue(LPCSTR lpszName, const CTmlValue& v)
    {
        size_t l = m_aVava.GetSize();
        if ( l == 0 )
        {
            return false;
        }
        TVarValue vv;
        vv.name = lpszName;
        vv.value = v;
        m_aVava.Ref(l - 1).Add(vv);
        return true;
    }
 
    bool AddArray(LPCSTR lpszName, size_t size)
    {
        size_t l = m_aArva.GetSize();
        if ( l == 0 || size == 0 )
        {
            return false;
        }
        TArrayValue d;
        d.name = lpszName;
        d.values.SetSize(size);
        m_aArva.Ref(l - 1).Add(d);
        return true;
    }
 
private:
    CVaVaVectors        m_aVava;        
    CArVaVectors        m_aArva;        
};
 
 
 
}; // TNB