TnbTmlValue.h

[詳解]

#pragma once
#include "TnbAttributedVector.h"
#include "TnbDummyCollection.h"
#include "TnbStr.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CTmlValue : public IComparableT<CTmlValue>
{
public:
 
    enum EKind
    {
        EMPTY   = 0,    
        INTEGER = 1,    
        FLOAT   = 2,    
        DATA    = 3     
    };
 
    CTmlValue(const CTmlValue& other) : m_param(other.m_param)
    {
    }
 
    CTmlValue(void) : m_param()
    {
    }
 
    CTmlValue(int i) : m_param()
    {
        m_param.Set(i);
    }
 
    CTmlValue(double i) : m_param()
    {
        m_param.Set(i);
    }
 
    CTmlValue& operator=(const CTmlValue& v)
    {
        m_param = v.m_param;
        return *this;
    }
 
    CTmlValue& SetString(LPCSTR lpszData)
    {
        m_param.Set(STRLIB::GetLen(lpszData), lpszData);
        return *this;
    }
 
    CTmlValue& operator=(const CByteVector& v)
    {
        m_param.Set(v.GetSize(), v.ReferBuffer());
        return *this;
    }
 
    CTmlValue& SetData(size_t len, LPCVOID P)
    {
        m_param.Set(len, P);
        return *this;
    }
 
    bool AddWildPoint(INDEX index)
    {
        return HasData() && m_param.dataBytes.SetAttribute(index, WILDCARD);
    }
 
    INT_PTR Compare(ICollectionT<CByteVector>& _vvbWild, const CTmlValue& other) const
    {
        _vvbWild.RemoveAll();
        EKind kind = (m_param.eKind >= other.m_param.eKind) ? m_param.eKind : other.m_param.eKind;
        if ( kind != DATA )
        {
            return m_CompareNum(m_param, other.m_param);
        }
        const CDataBytes& leftData = m_param.GetData();
        const CDataBytes& rightData = other.m_param.GetData();
        //
        size_t srcPos = 0;
        size_t wildPos = 0;
        size_t srcPosMax = leftData.GetSize();
        size_t wildPosMax = rightData.GetSize();
        BYTE B;
        while ( true )
        {
            if ( wildPos >= wildPosMax )
            {
                return 1;
            }
            if ( rightData.GetAttribute(wildPos) == WILDCARD )
            {
                //ワイルド発見！
                wildPos++;
                while ( wildPos < wildPosMax )
                {
                    if ( rightData.GetAttribute(wildPos) != WILDCARD )
                    {
                        break;
                    }
                    wildPos++;
                }
                CByteVector vb;
                if ( wildPos >= wildPosMax )
                {
                    //ワイルドが最後。
                    while ( true )
                    {
                        if ( srcPos >= srcPosMax )
                        {
                            _vvbWild.Add(vb);
                            break;
                        }
                        B = leftData.Get(srcPos);
                        vb.Add(B);
                        srcPos++;
                    }
                    return 0;
                }
                while ( true )
                {
                    B = leftData.Get(srcPos);
                    if ( B == rightData.Get(wildPos) )
                    {
                        //ワイルドの次の文字を発見
                        _vvbWild.Add(vb);
                        break;
                    }
                    vb.Add(B);
                    srcPos++;
                    if ( srcPos >= srcPosMax )
                    {
                        return -1;
                    }
                }
            }
            if ( srcPos >= srcPosMax )
            {
                return 1;
            }
            INT_PTR r = leftData.Get(srcPos);
            r -= rightData.Get(wildPos);
            if ( r != 0 )
            {
                return r;
            }
            srcPos++;
            wildPos++;
            if ( wildPos >= wildPosMax && srcPos >= srcPosMax )
            {
                break;
            }
        }
        return 0;
    }
 
    virtual INT_PTR Compare(const CTmlValue& other) const
    {
        CDummyCollectionT<CByteVector> vv;
        return Compare(vv, other);
    }
 
    CTmlValue operator+(const CTmlValue& other) const
    {
        CTmlValue v;
        EKind kind = (m_param.eKind >= other.m_param.eKind) ? m_param.eKind : other.m_param.eKind;
        switch ( kind )
        {
        case INTEGER:
            v = m_param.GetInteger() + other.m_param.GetInteger();
            break;
        case FLOAT:
            v = m_param.GetFloat() + other.m_param.GetFloat();
            break;
        case DATA:
            v.m_param.Set(m_param.GetData() + other.m_param.GetData());
            break;
        case EMPTY:
        default:
            break;
        }
        return v;
    }
 
    CTmlValue operator-(const CTmlValue& other) const
    {
        CTmlValue v;
        EKind kind = (m_param.eKind >= other.m_param.eKind) ? m_param.eKind : other.m_param.eKind;
        switch ( kind )
        {
        case INTEGER:
            v = m_param.GetInteger() - other.m_param.GetInteger();
            break;
        case FLOAT:
            v = m_param.GetFloat() - other.m_param.GetFloat();
            break;
        case DATA:
            v = *this;
            break;
        case EMPTY:
        default:
            break;
        }
        return v;
    }
 
    CTmlValue operator*(const CTmlValue& other) const
    {
        CTmlValue v;
        EKind kind = (m_param.eKind >= other.m_param.eKind) ? m_param.eKind : other.m_param.eKind;
        switch ( kind )
        {
        case INTEGER:
            v = m_param.GetInteger() * other.m_param.GetInteger();
            break;
        case FLOAT:
            v = m_param.GetFloat() * other.m_param.GetFloat();
            break;
        case DATA:
            v = *this;
            if ( m_param.eKind == DATA )
            {
                v.m_param.dataBytes.RemoveAll();
                loop ( i, other.m_param.GetInteger() )
                {
                    v.m_param.dataBytes += m_param.dataBytes;
                }
            }
            break;
        case EMPTY:
        default:
            break;
        }
        return v;
    }
 
    CTmlValue operator/(const CTmlValue& other) const
    {
        CTmlValue v;
        EKind kind = (m_param.eKind >= other.m_param.eKind) ? m_param.eKind : other.m_param.eKind;
        switch ( kind )
        {
        case INTEGER:
            v = m_param.GetInteger() / other.m_param.GetInteger();
            break;
        case FLOAT:
            v = m_param.GetFloat() / other.m_param.GetFloat();
            break;
        case DATA:
            v = *this;
            break;
        case EMPTY:
        default:
            break;
        }
        return v;
    }
 
    CVectorT<INDEX> GetWildCardPositions(void) const
    {
        CVectorT<INDEX> vid;
        if ( HasData() )
        {
            loop ( i, m_param.dataBytes.GetSize() )
            {
                if ( m_param.dataBytes.GetAttribute(i) == WILDCARD )
                {
                    vid.Add(i);
                }
            }
        }
        return vid;
    }
 
    bool HasData(void) const
    {
        return m_param.eKind == DATA;
    }
 
    EKind Getkind(void) const
    {
        return m_param.eKind;
    }
 
    int GetInteger(void) const
    {
        return HasData() ? atoi(m_param.GetString()) : m_param.GetInteger();
    }
 
    double GetFloat(void) const
    {
        return HasData() ? atof(m_param.GetString()) : m_param.GetFloat();
    }
 
    CAscii GetString(void) const
    {
        return m_param.GetString();
    }
 
    CByteVector GetData(void) const
    {
//      return m_param.GetData().Refer();
        return m_param.GetData();
    }
 
    size_t GetDataSize(void) const
    {
        return m_param.GetData().GetSize();
    }
 
private:
 
    enum EAttr
    {
        NORMAL = 0,     
        WILDCARD = 1,   
    };
 
    typedef CAttributedVectorT<BYTE, BYTE> CDataBytes;
 
    struct TParam
    {
        EKind       eKind;          
        CDataBytes  dataBytes;      
        int         iValue;         
        double      doValue;        
        TParam(void) : iValue(0), doValue(0.0), eKind(EMPTY)
        {
        }
        TParam(const TParam& p) : eKind(p.eKind), dataBytes(p.dataBytes), iValue(p.iValue), doValue(p.doValue)
        {
        }
        TParam& operator=(const TParam& p)
        {
            eKind = p.eKind;
            dataBytes = p.dataBytes;
            iValue = p.iValue;
            doValue = p.doValue;
            return *this;
        }
        void Set(EKind e, int i = 0, double d = 0.0, const CDataBytes* D = NULL)
        {
            eKind = e;
            if ( D == NULL )
            {
                dataBytes.RemoveAll();
            }
            else
            {
                dataBytes = *D;
            }
            iValue = i;
            doValue = d;
        }
        void Empty(void) 
        {
            Set(EMPTY); 
        }
        void Set(int i)
        {
            Set(INTEGER, i, i);
        }
        void Set(double i) 
        {
            Set(FLOAT, ToInt(i), i); 
        }
        void Set(const CDataBytes& d)
        {
            Set(DATA, 0, 0.0, &d); 
        }
        void Set(size_t l, LPCVOID P)
        {
            CDataBytes d;
            d.SetElements(l, static_cast<const BYTE*>(P));
            Set(d);
        }
        int GetInteger(void) const
        {
            return iValue;
        }
        double GetFloat(void) const
        {
            return (eKind <= INTEGER) ? iValue : doValue;
        }
        CAscii GetString(void) const
        {
            CAscii a;
            switch ( eKind )
            {
            case INTEGER:
                a.Format("%d", iValue);
                break;
            case FLOAT:
                a.Format("%.0f", doValue);
                break; 
            case DATA:
                {
                    size_t l = dataBytes.GetSize();
                    if ( l > 0 )
                    {
                        LPSTR P = a.GetBuffer(l);
                        dataBytes.GetElements(l, reinterpret_cast<BYTE*>(P));
                        P[l] = 0;
                        a.ReleaseBuffer();
                    }
                }
                break;
            default:
                break;
            }
            return a;
        }
        CDataBytes GetData(void) const
        {
            CDataBytes d;
            switch ( eKind )
            {
            case DATA:
                d = dataBytes;
                break;
            case INTEGER:
            case FLOAT:
                {
                    CAscii a = GetString();
                    d.SetElements(a.GetLength(), reinterpret_cast<const BYTE*>(LPCSTR(a)));
                }
                break;
            default:
                break;
            }
            return d;
        }
    };
 
    TParam m_param; 
 
    INT_PTR m_CompareNum(const TParam& p1, const TParam& p2) const
    {
        if ( p1.eKind == DATA || p2.eKind == DATA )
        {
            ASSERT(false);
            return 0;
        }
        if ( p1.eKind <= INTEGER && p2.eKind <= INTEGER )
        {
            return IComparatorT<int>::GetDefault().CompareTo(p1.iValue, p2.iValue);
        }
        return IComparatorT<double>::GetDefault().CompareTo(p1.doValue, p2.doValue);
    }
 
    friend class CTmlValueTest;
};
 
 
 
typedef CVectorT<CTmlValue> CTmlValuesVector;
 
 
 
class CTmlValueCarrier
{
public:
 
    CTmlValueCarrier(void) : m_pValueRef(NULL), m_valueReal(), m_strExName()
    {
    }
 
    CTmlValueCarrier(const CTmlValueCarrier& other) 
        : m_pValueRef(other.m_pValueRef), m_valueReal(other.m_valueReal), m_strExName(other.m_strExName)
    {
    }
 
    CTmlValueCarrier& operator=(const CTmlValueCarrier& other) 
    {
        m_pValueRef = other.m_pValueRef;
        m_valueReal = other.m_valueReal;
        m_strExName = other.m_strExName;
        return *this;
    }
 
    CTmlValueCarrier& operator=(int i)
    {
        m_strExName.Empty();
        m_valueReal = i;
        m_pValueRef = NULL;
        return *this;
    }
 
    CTmlValueCarrier& operator=(double i)
    {
        m_strExName.Empty();
        m_valueReal = i;
        m_pValueRef = NULL;
        return *this;
    }
 
    CTmlValueCarrier& operator=(const CTmlValue& v)
    {
        m_strExName.Empty();
        m_valueReal = v;
        m_pValueRef = NULL;
        return *this;
    }
 
    void SetRef(CTmlValue& v)
    {
        m_pValueRef = &v;
    }
 
    void Set(LPCSTR lpsz)
    {
        m_strExName = lpsz;
    }
 
    void Empty(void)
    {
        m_strExName.Empty();
        m_valueReal = 0;
        m_pValueRef = NULL;
    }
 
    LPCSTR GetExName(void) const
    {
        return m_strExName;
    }
 
    const CTmlValue& operator()(void) const
    {
        return (m_pValueRef == NULL) ? m_valueReal : *m_pValueRef;
    }
 
    CTmlValue& operator()(void)
    {
        return (m_pValueRef == NULL) ? m_valueReal : *m_pValueRef;
    }
 
private:
    CTmlValue*      m_pValueRef;    
    CTmlValue       m_valueReal;    
    CAscii          m_strExName;    
};
 
 
 
}; // TNB