TnbGrid.h

[詳解]

#pragma once
#include "TnbStrVector.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CGrid
{
public:
    
    enum EFieldKind
    {
        EK_String,      
        EK_Integer,     
        EK_Float,       
        EK_Date,        
        EK_Invalid,     
    };
 
    enum EFieldType
    {
        ET_Character    = 'C',      
        ET_Date         = 'D',      
        ET_Numeric      = 'N',      
        ET_Floating     = 'F',      
        ET_Logical      = 'L',      
//      ET_Memo         = 'M',      ///< メモ
    };
 
    struct TFieldInfo
    {
        CStr        name;       
        size_t      width;      
        size_t      decimals;   
        EFieldType  type;       
        TFieldInfo(LPCTSTR lpsz = NULL, size_t w = 0, size_t d = 0, EFieldType t = ET_Character)
            : name(lpsz), width(w), decimals(d), type(t)
        {
        }
        virtual void Deserialize (const IDeserializer& ds)
        {
            ds >> name >> width >> decimals >> type;
        }
        virtual void Serialize (ISerializer& _sr) const
        {
            _sr << name << width << decimals << type;
        }
    };
 
    struct TDate
    {
        WORD year;      
        BYTE month;     
        BYTE day;       
        TDate(WORD y = 2000, BYTE m = 1, BYTE d = 1) : year(y), month(m), day(d)
        {
        }
        int Get(void) const
        {
            return year * 10000 + month * 100 + day;
        }
        void Set(int i)
        {
            year = down_cast<WORD>(i / 10000);
            month = down_cast<BYTE>((i / 100) % 100);
            day = down_cast<BYTE>(i % 100);
        }
    };
 
 
    //---------------------------
 
 
    CGrid(void)
    {
    }
 
    void AllDelete(void)
    {
        m_records.RemoveAll();
        m_fields.RemoveAll();
    }
 
    size_t GetFieldCount(void) const
    {
        return m_fields.GetSize();
    }
 
    size_t GetRecordCount(void) const
    {
        return m_records.GetSize();
    }
 
    INDEX FindFieldName(LPCTSTR lpszFieldName) const
    {
        loop ( i, m_fields.GetSize() )
        {
            if ( m_fields[i].name.IsEqual(lpszFieldName) )
            {
                return i;
            }
        }
        return INVALID_INDEX;
    }
 
    EFieldKind GetFieldInfo(TFieldInfo& _fi, INDEX field) const
    {
        if ( m_fields.IsInRange(field) )
        {
            _fi = m_fields[field];
            return m_ToKind(_fi);
        }
        return EK_Invalid;
    }
 
    INDEX AddField(const TFieldInfo& fi)
    {
        if ( GetRecordCount() == 0 && ! fi.name.IsEmpty() && FindFieldName(fi.name) == INVALID_INDEX && fi.width >= 1 && fi.width <= 254 )
        {
            return m_fields.Add(fi);
        }
        return INVALID_INDEX;
    }
 
    INDEX AddCharacterField(LPCTSTR lpszFieldName, size_t width)
    {
        TFieldInfo fi(lpszFieldName, width, 0, ET_Character);
        return AddField(fi);
    }
 
    INDEX AddNumericField(LPCTSTR lpszFieldName, size_t width, size_t dec = 0)
    {
        TFieldInfo fi(lpszFieldName, width, dec, ET_Numeric);
        if ( width >= dec + 1 )
        {
            return AddField(fi);
        }
        return INVALID_INDEX;
    }
 
    INDEX AddFloatingField(LPCTSTR lpszFieldName, size_t width, size_t dec = 0)
    {
        TFieldInfo fi(lpszFieldName, width, dec, ET_Floating);
        if ( width >= dec + 1 )
        {
            return AddField(fi);
        }
        return INVALID_INDEX;
    }
 
    INDEX AddDateField(LPCTSTR lpszFieldName)
    {
        TFieldInfo fi(lpszFieldName, 8, 0, ET_Date);
        return AddField(fi);
    }
 
    bool DeleteField(INDEX field)
    {
        if ( GetRecordCount() == 0 )
        {
            return m_fields.Remove(field);
        }
        return false;
    }
 
    bool AllDeleteRecord(void)
    {
        return m_records.RemoveAll();
    }
 
    INDEX AddRecord(void)
    {
        size_t len = GetFieldCount();
        if ( len != 0 )
        {
            CDataVector dv;
            dv.SetSize(len);
            return m_records.Add(dv);
        }
        return INVALID_INDEX;
    }
 
    bool InsertRecord(INDEX record)
    {
        size_t len = GetFieldCount();
        if ( len != 0 )
        {
            CDataVector dv;
            dv.SetSize(len);
            return m_records.Insert(record, dv);
        }
        return false;
    }
 
    bool DeleteRecord(INDEX record)
    {
        return m_records.Remove(record);
    }
 
    bool SetNullRecord(INDEX record, INDEX field)
    {
        TData* D = m_Ref(record, field);
        if ( D != NULL )
        {
            D->SetString(_T(""));
            return true;
        }
        return false;
    }
 
    bool SetStringRecord(INDEX record, INDEX field, LPCTSTR lpszString)
    {
        TData* D = m_Ref(record, field);
        if ( D != NULL )
        {
            D->SetString(lpszString);
            return true;
        }
        return false;
    }
 
    bool SetIntegerRecord(INDEX record, INDEX field, int value)
    {
        if ( m_ToKind(field) == EK_Integer )
        {
            TData* D = m_Ref(record, field);
            if ( D != NULL )
            {
                D->SetFloat(value);
                return true;
            }
        }
        return false;
    }
 
    bool SetFloatRecord(INDEX record, INDEX field, double value)
    {
        if ( m_ToKind(field) == EK_Float )
        {
            TData* D = m_Ref(record, field);
            if ( D != NULL )
            {
                D->SetFloat(value);
                return true;
            }
        }
        return false;
    }
 
    bool SetDateRecord(INDEX record, INDEX field, const TDate& date)
    {
        if ( m_ToKind(field) == EK_Date )
        {
            TData* D = m_Ref(record, field);
            if ( D != NULL )
            {
                D->SetFloat(date.Get());
                return true;
            }
        }
        return false;
    }
 
    bool IsNullRecord(INDEX record, INDEX field) const
    {
        const TData* D = m_Ref(record, field);
        if ( D != NULL )
        {
            return (D->hasString && D->string.IsEmpty());
        }
        return true;
    }
 
    CStr GetStringRecord(INDEX record, INDEX field, bool isAdjust = false) const
    {
        CStr str;
        const TData* D = m_Ref(record, field);
        if ( D != NULL )
        {
            const TFieldInfo& F = m_fields[field];
            EFieldKind k = m_ToKind(F);
            if ( D->hasString )
            {
                // データが文字列なのでそのまま
                str = D->string;
            }
            else if ( k == EK_Float )
            {
                ASSERT( F.decimals > 0 );
                if ( F.type == ET_Floating )
                {
                    CStr f;
                    f.Format(_T("%%.%de"), F.decimals);
                    str.Format(f, D->value);
                }
                else if ( F.type == ET_Numeric )
                {
                    CStr f;
                    f.Format(_T("%%.%df"), F.decimals);
                    str.Format(f, D->value);
                }
                else
                {
                    ASSERTLIB( false );
                }
            }
            else
            {
                int v = ToInt(D->value);
                str.Format(_T("%d"), v);
            }
            if ( isAdjust )
            {
                size_t l = str.GetLength();
                if ( l < F.width )
                {
                    CStr sp = CStr::Lineup(' ', F.width - l);
                    if ( k == EK_String || k == EK_Date )
                    {
                        str += sp;
                    }
                    else
                    {
                        str = sp + str;
                    }
                }
                if ( str.GetLength() > F.width )
                {
                    if ( k == EK_String || k == EK_Date )
                    {
                        str = str.Left(F.width);
                    }
                    else
                    {
                        str = str.Right(F.width);
                    }
                }
            }
        }
        return str;
    }
 
    int GetIntegerRecord(INDEX record, INDEX field) const
    {
        int r = 0;
        const TData* D = m_Ref(record, field);
        if ( D != NULL )
        {
            if ( D->hasString )
            {
                r = D->string.ToInt();
            }
            else
            {
                r = ToInt(D->value);
            }
        }
        return r;
    }
 
    double GetFloatRecord(INDEX record, INDEX field) const
    {
        double r = 0;
        const TData* D = m_Ref(record, field);
        if ( D != NULL )
        {
            if ( D->hasString )
            {
                r = D->string.ToDouble();
            }
            else
            {
                r = D->value;
            }
        }
        return r;
    }
 
    TDate GetDateRecord(INDEX record, INDEX field) const
    {
        TDate d;
        d.Set(GetIntegerRecord(record, field));
        return d;
    }
 
protected:
    void Dump(void)
    {
    #ifdef _DEBUG
        TFieldInfo fi;
        size_t fc = GetFieldCount();
        CWorkMemT<size_t> wd(fc); 
        // フィールド
        TRACE0("    |");
        loop ( i, fc )
        {
            GetFieldInfo(fi, i);
            wd[i] = max(fi.name.GetLength(), fi.width);
            TRACE1("%s", CStr::Fmt(CStr::Fmt(_T("%%-%ds|"), wd[i]), fi.name));
        }
        TRACE0("\n");
        ::Sleep(10);
        // フィールド(型)
        TRACE0("    |");
        loop ( i, fc )
        {
            GetFieldInfo(fi, i);
            CStr s = CStr::Fmt(_T("%C,%d,%d"), fi.type, fi.width, fi.decimals);
            TRACE1("%s", CStr::Fmt(CStr::Fmt(_T("%%-%ds|"), wd[i]), s));
        }
        TRACE0("\n");
        ::Sleep(10);
        // セパレータ
        TRACE0("----+");
        loop ( i, fc )
        {
            TRACE1("%s", CStr::Lineup('-', wd[i]) + "+");
        }
        TRACE0("\n");
        ::Sleep(10);
        // レコード
        loop ( j, GetRecordCount() )
        {
            TRACE1("%4d|", j + 1);
            loop ( i, fc )
            {
                TRACE1("%s", CStr::Fmt(CStr::Fmt(_T("%%-%ds|"), wd[i]), GetStringRecord(j, i, true)));
            }
            TRACE0("\n");
            ::Sleep(10);
        }
    #endif // _DEBUG
    }
 
private:
    EFieldKind m_ToKind(const TFieldInfo& info) const
    {
        switch ( info.type )
        {
        case ET_Character:  // 文字列
        case ET_Logical:    // 論理(?,Y,N,T,F)
//      case ET_Memo:       // メモ
            return EK_String;
        case ET_Date:       // 年月日
            return EK_Date;
        case ET_Numeric:    // 数値
        case ET_Floating:
            if ( info.decimals == 0 )
            {
                return EK_Integer;
            }
            return EK_Float;
        default:
            break;
        }
        return EK_String;
//      return EK_Invalid;
    }
    // フィールドインデックスから種類を
    EFieldKind m_ToKind(INDEX field) const
    {
        if ( m_fields.IsInRange(field) )
        {
            return m_ToKind(m_fields[field]);
        }
        return EK_Invalid;
    }
    struct TData
    {
        bool    hasString;  
        CStr    string;     
        double  value;      
        TData(void) : hasString(true)
        {
        }
        void SetString(LPCTSTR lpsz)
        {
            hasString = true;
            string = lpsz;
        }
        void SetFloat(double v)
        {
            hasString = false;
            value = v;
        }
        virtual void Deserialize (const IDeserializer& ds)
        {
            ds >> hasString >> string >> value;
        }
        virtual void Serialize (ISerializer& _sr) const
        {
            _sr << hasString << string << value;
        }
    };
    const TData* m_Ref(INDEX record, INDEX field) const
    {
        if ( m_fields.IsInRange(field) && m_records.IsInRange(record) )
        {
            const CDataVector& v = m_records[record];
            ASSERT( v.IsInRange(field) );
            return &v[field];
        }
        return NULL;
    }
    TData* m_Ref(INDEX record, INDEX field)
    {
        if ( m_fields.IsInRange(field) && m_records.IsInRange(record) )
        {
            CDataVector& v = m_records[record];
            ASSERT( v.IsInRange(field) );
            return &v[field];
        }
        return NULL;
    }
 
    CVectorT<TFieldInfo>    m_fields;       
    typedef CVectorT<TData> CDataVector;    
    CVectorT<CDataVector>   m_records;      
    friend class CGridTest;
};
 
 
 
}; // TNB