TnbTree.h

[詳解]

#pragma once
#include "TnbPointerHandle.h"
#include "TnbMap.h"
#include "TnbCollectionAdapter.h"
#include "TnbStr.h"
#include "TnbSerializeAdapter.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename KEY, typename VAL, typename INK = KEY>
class CTreeT : public ISerializable
{
    #ifndef _TnbDOXYGEN //Document作成用シンボル
 
    class COneHandle;                                       
    typedef CMapT<KEY,COneHandle,INK> CMapKey;              
    struct TOne
    {
        VAL                         value;                  
        CPointerHandleT< CMapKey >  hpMap;                  
        TOne(void) : value(VAL()) {}
    };
 
    class COneHandle : public CPointerHandleT<TOne>, public ISerializable
    {
        DEFSUPER(CPointerHandleT<TOne>);
    public:
        COneHandle(void) {}
        COneHandle(TOne* P) : _super(P) {}
        COneHandle(const COneHandle& other) : _super(other) {}
        virtual void Serialize(ISerializer& _sr) const
        {
            _sr << ((*this)->value);
            size_t l = 0;
            if ( ! ((*this)->hpMap.IsNull()) )
            {
                l = (*this)->hpMap->GetSize();
            }
            _sr << l;
            if ( l > 0 )
            {
                _sr << *((*this)->hpMap);
            }
        }
        virtual void Deserialize(const IDeserializer& ds)
        {
            COneHandle o = new TOne;
            ds >> (o->value);
            size_t l = 0;
            ds >> l;
            if ( l > 0 )
            {
                o->hpMap = new CMapKey;
                ds >> *(o->hpMap);
            }
            *this = o;
        }
    };
 
    typedef typename CMapKey::CConstKeysAdapter CConstKeysAdapter;  
 
    #endif //_TnbDOXYGEN
 
    COneHandle  m_one;              
 
public:
 
    struct ICommand
    {
        virtual ~ICommand(void) {}
 
        virtual bool OnFound(int iNestLevel, const KEY& key, const VAL& value, const CTreeT& tree) = 0;
    };
 
private:
 
    bool m_Scan(ICommand* I, const CTreeT& tree, int& _iNestLevel)
    {
        _iNestLevel++;
        CTreeT::CConstKeysAdapter vkey = tree.GetKeysAdapter();
        loop ( i, vkey.GetSize() )
        {
            const KEY& k = vkey.At(i);
            ASSERTLIB(tree.HasKey(k));
            if ( ! I->OnFound(_iNestLevel, k, tree.At(k), tree) )
            {
                return false;
            }
            if ( tree.HasLeaf(k) && ! m_Scan(I, tree(k), _iNestLevel) )
            {
                return false;
            }
        }
        _iNestLevel--;
        return true;
    }
 
public:
 
    CTreeT(void) : m_one(new TOne)
    {
        m_one->hpMap = new CMapKey;
    }
 
    CTreeT(const CTreeT& other) : m_one(other.m_one) 
    {
    }
 
    virtual ~CTreeT(void)
    {
        m_one.Null();
    }
 
    CTreeT& operator=(const CTreeT& other)
    {
        m_one = other.m_one;
        return *this;
    }
 
    const VAL& AtSelf(void) const
    {
        return m_one->value;
    }
 
    VAL& AtSelf(void)
    {
        return m_one->value;
    }
 
    bool HasKey(INK key) const
    {
        return m_one->hpMap->HasKey(key);
    }
 
    const VAL& At(INK key) const
    {
        if ( HasKey(key) )
        {
            return  m_one->hpMap->operator[](key)->value;
        }
        throw CEmptyException();
    }
 
    const VAL& operator[](INK key) const
    {
        return At(key);
    }
 
    VAL& At(INK key)
    {
        if ( ! HasKey(key) )
        {
            COneHandle P = new TOne;
            P->value = VAL();
            m_one->hpMap->SetKey(key, P);
        }
        return  m_one->hpMap->operator[](key)->value;
    }
 
    VAL& operator[](INK key)
    {
        return At(key);
    }
 
    VAL Get(INK key) const
    {
        return At(key);
    }
 
    size_t GetSize(void) const
    {
        return m_one->hpMap->GetSize();
    }
 
    CVectorT<KEY> EnumKeys(void) const
    {
        return m_one->hpMap->EnumKeys();
    }
 
    bool Set(INK key, VAL v)
    {
        if ( HasKey(key) )
        {
            m_one->hpMap->operator[](key)->value = v;
            return true;
        }
        return false;
    }
 
    bool Add(INK key, VAL v)
    {
        if ( HasKey(key) )
        {
            return false;
        }
        COneHandle P = new TOne;
        P->value = v;
        m_one->hpMap->SetKey(key, P);
        return true;
    }
 
    bool Remove(INK key)
    {
        if ( ! HasKey(key) )
        {
            return false;
        }
        return m_one->hpMap->RemoveKey(key);
    }
    
    bool HasLeaf(INK key) const
    {
        if ( ! HasKey(key) )
        {
            return false;
        }
        const CPointerHandleT<TOne>& c = m_one->hpMap->operator[](key);
        if ( c->hpMap.IsNull() )
        {
            return false;
        }
        return ! c->hpMap->IsEmpty();
    }
 
    bool AddLeaf(INK key, CTreeT<KEY,VAL,INK>& other)
    {
        if ( HasKey(key) )
        {
            return false;
        }
        //add 自分の子供、親でないことを確認。
        m_one->hpMap->SetKey(key, other.m_one);
        return true;
    }
 
    void RemoveAll(void)
    {
        m_one = new TOne;
        m_one->hpMap = new CMapKey;
    }
 
    CConstKeysAdapter GetKeysAdapter(void) const
    {
        return m_one->hpMap->GetKeysAdapter();
    }
 
    CTreeT<KEY,VAL,INK> Refer(INK key)
    {
        if ( ! HasKey(key) )
        {
            COneHandle P = new TOne;
            P->value = VAL();
            m_one->hpMap->SetKey(key, P);
        }
        COneHandle& c = m_one->hpMap->operator[](key);
        if ( c->hpMap.IsNull() )
        {
            c->hpMap = new CMapKey;
        }
        CTreeT t;
        t.m_one = c;
        return t;
    }
 
    CTreeT<KEY,VAL,INK> operator()(INK key)
    {
        return Refer(key);
    }
 
    const CTreeT<KEY,VAL,INK> Refer(INK key) const
    {
        if ( ! HasKey(key) )
        { 
            throw CEmptyException();
        }
        const COneHandle& c = m_one->hpMap->operator[](key);
        if ( c->hpMap.IsNull() )
        {
            throw CEmptyException();
        }
        CTreeT t;
        t.m_one = c;
        return t;
    }
 
    const CTreeT<KEY,VAL,INK> operator()(INK key) const
    {
        return Refer(key);
    }
 
    virtual void Serialize(ISerializer& _sr) const
    {
        _sr << m_one;
    }
 
    virtual void Deserialize(const IDeserializer& ds)
    {
        ds >> m_one;
    }
 
    CTreeT<KEY,VAL,INK> Clone(void) const
    {
        CVectorT<BYTE> vb;
        CSerializeAdapter sr(&vb);
        sr << m_one;
        CTreeT t;
        CDeserializeAdapter ds(&vb);
        ds >> t.m_one;
        return t;
    }
 
    bool Scan(ICommand* I)
    {
        int iNestLevel = 0;
        if ( ! I->OnFound(iNestLevel, KEY(), AtSelf(), *this) )
        {
            return false;
        }
        return m_Scan(I, *this, iNestLevel);
    }
 
private:
    friend class CTreeTest;
};
 
 
 
class CStrsTree : public CTreeT<CStr,CStr,LPCTSTR>
{
    typedef CTreeT<CStr,CStr,LPCTSTR> _super;   
    DEFSUPER(_super);
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
 
    class CToStringCommand : public _super::ICommand
    {
        CStr m_str;     
        virtual bool OnFound(int iNestLevel, const CStr& key, const CStr& value, const _super& tree)
        {
            m_str += CStr::Fmt(_T("%s[+]%s = %s\n")
                            , CStr::Lineup(_T(" |"), iNestLevel)
                            , key
                            , value);
            return true;
        }
    public:
        CStr GetString(void) { return m_str; }
    };
 
    #endif //_TnbDOXYGEN
 
public:
    CStrsTree(void) : _super()
    {
    }
 
    CStrsTree(const CTreeT<CStr,CStr,LPCTSTR>& other) : _super(other) 
    {
    }
 
    CStrsTree& operator=(const CTreeT<CStr,CStr,LPCTSTR>& other)
    {
        _super::operator=(other);
        return *this;
    }
 
    CStr ToString(void)
    {
        CToStringCommand c;
        _super::Scan(&c);
        return c.GetString();
    }
    CStrsTree Refer(LPCTSTR key)
    {
        return _super::Refer(key);
    }
 
    CStrsTree operator()(LPCTSTR key)
    {
        return Refer(key);
    }
 
    const CStrsTree Refer(LPCTSTR key) const
    {
        return _super::Refer(key);
    }
 
    const CStrsTree operator()(LPCTSTR key) const
    {
        return Refer(key);
    }
 
    CStrsTree Clone(void) const
    {
        return _super::Clone();
    }
};
 
 
 
}; // TNB