TnbMap.h

[詳解]

#pragma once
#include "TnbPair.h"
#include "TnbVector.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename KEY, typename VAL, typename INK=KEY>
class CMapT : public ICollectionT<TNB::CPairT<KEY,VAL> >
{
    typedef ICollectionT<TNB::CPairT<KEY,VAL> > _super; 
    DEFSUPER(_super);
public:
 
    typedef TNB::CPairT<KEY,VAL> CPair; 
 
    class CConstKeysAdapter : public IConstCollectionT<KEY>
    {
        DEFSUPER(IConstCollectionT<KEY>);
        const CMapT* m_pMap;                    
    public:
        CConstKeysAdapter(const CMapT* map) : _super(), m_pMap(map) {}
        virtual bool Lock(DWORD dwTime = INFINITE) const
        {
            return m_pMap->Lock();
        }
        virtual void Unlock(void) const
        {
            m_pMap->Unlock();
        }
        virtual size_t GetSize(void) const
        {
            return m_pMap->GetSize();
        }
        virtual const KEY& At(INDEX index) const
        {
            return m_pMap->At(index).first;
        }
    };
 
    class CConstValuesAdapter : public IConstCollectionT<VAL>
    {
        DEFSUPER(IConstCollectionT<VAL>);
        const CMapT* m_pMap;                
    public:
        CConstValuesAdapter(const CMapT* map) : _super(), m_pMap(map) {}
        virtual bool Lock(DWORD dwTime = INFINITE) const
        {
            return m_pMap->Lock();
        }
        virtual void Unlock(void) const
        {
            m_pMap->Unlock();
        }
        virtual size_t GetSize(void) const
        {
            return m_pMap->GetSize();
        }
        virtual const VAL& At(INDEX index) const
        {
            return m_pMap->At(index).second;
        }
    };
 
private:
 
    CVectorT< CPair >   m_vPair;    
 
    const VAL* m_SearchKey(INK key) const
    {
        const CPair* P = m_vPair.ReferBuffer();
        if ( P != NULL )
        {
            loop ( i, m_vPair.GetSize() )
            {
                if ( P[i].first == key )
                {
                    return &(P[i].second);
                }
            }
        }
        return NULL;
    }
 
    VAL* m_SearchKey(INK key)
    {
        loop ( i, m_vPair.GetSize() )
        {
            if ( m_vPair[i].first == key )
            {
                return &(m_vPair[i].second);
            }
        }
        return NULL;
    }
 
public:
 
    explicit CMapT(size_t size = 0) : _super(), m_vPair(size) 
    {
    }
 
    CMapT(const CMapT& map) : _super(), m_vPair(map.m_vPair)
    {
    }
 
    virtual ~CMapT(void) 
    {
    }
 
    CMapT& operator=(const CMapT& other)
    {
        m_vPair = other.m_vPair;
        return *this;
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const
    {
        return m_vPair.Lock();
    }
 
    virtual void Unlock(void) const
    {
        m_vPair.Unlock();
    }
 
    void SetIncrementSize(size_t size)
    {
        m_vPair.SetIncrementSize(size); 
    }
 
    virtual size_t GetSize(void) const
    {
        return m_vPair.GetSize();
    }
 
    virtual CPair Get(INDEX index) const
    {
        return m_vPair.Get(index);
    }
 
    virtual const CPair& At(INDEX index) const
    {
        return m_vPair.At(index);
    }
 
    virtual CPair& Ref(INDEX index)
    {
        return m_vPair.Ref(index);
    }
 
    virtual bool Set(INDEX index, const CPair& t)
    {
        return m_vPair.Set(index, t);
    }
 
    virtual INDEX Add(const CPair& t)
    {
        SetKey(t.first, t.second);
        return 0;
    }
 
    virtual size_t Append(const IConstCollectionT<CPair>& c)
    {
        EXCLUSIVE2(&c, this);
        loop ( i, c )
        {
            RemoveKey(c.At(i).first);
        }
        return _super::Append(c);
    }
 
    virtual bool Remove(INDEX index)
    {
        return m_vPair.Remove(index);
    }
 
    virtual bool RemoveAll(void)
    {
        return m_vPair.RemoveAll();
    }
 
    virtual bool SetSize(size_t size)
    {
        return false;
    }
 
    void SetKey(INK key, const VAL& newValue)
    {
        EXCLUSIVE(this);
        operator[](key) = newValue;
    }
 
    VAL& operator[](INK key)
    {
        VAL* P = m_SearchKey(key);
        if ( P == NULL )
        {
            CPair t;
            t.first = key;
            m_vPair.Add(t);
            P = m_SearchKey(key);
        }
        return *P;
    }
 
    const VAL& operator[](INK key) const
    {
        const VAL* P = m_SearchKey(key);
        if ( P == NULL ){ throw CEmptyException(); }
        return *P;
    }
 
    bool RemoveKey(INK key)
    {
        EXCLUSIVE(this);
        const CPair* P = m_vPair.ReferBuffer();
        loop ( i, m_vPair.GetSize() )
        {
            if ( P[i].first == key )
            {
                m_vPair.Remove(i);
                return true;
            }
        }
        return false;
    }
 
    const VAL* GetValuePtr(INK key) const
    {
        EXCLUSIVE(this);
        return m_SearchKey(key);
    }
 
    VAL* GetValuePtr(INK key)
    {
        EXCLUSIVE(this);
        return m_SearchKey(key);
    }
 
    bool Get(INDEX index, KEY& _rKey, VAL& _rValue) const
    {
        EXCLUSIVE(this);
        if ( ! TNB::IsInRange(index, m_vPair.GetSize()) )
        {
            return false;
        }
        const CPair* P = m_vPair.ReferBuffer();
        _rKey = P[index].first;
        _rValue = P[index].second;
        return true;
    }
 
    bool Lookup(INK key, VAL& _rValue) const
    {
        EXCLUSIVE(this);
        const VAL* P = m_SearchKey(key);
        if ( P == NULL ){ return false; }
        _rValue = *P;
        return true;
    }
 
    bool HasKey(INK key) const
    {
        EXCLUSIVE(this);
        return m_SearchKey(key) != NULL;
    }
 
    CVectorT<KEY> EnumKeys(void) const
    {
        EXCLUSIVE(this);
        CVectorT<KEY> v;
        v.Copy(GetKeysAdapter());
        return v;
    }
    
    virtual bool IsEqual(const IConstCollectionT<TNB::CPairT<KEY,VAL> >& c) const
    {
        if ( this == &c )
        { 
            return true; 
        }
        EXCLUSIVE2(&c, this);
        size_t size = GetSize();
        if ( size != c.GetSize() )
        {
            return false; 
        }
        const IComparatorT<VAL>& comparator = IComparatorT<VAL>::GetDefault();
        loop ( i, size )
        {
            const KEY& k = c.At(i).first;
            const VAL* p = GetValuePtr(k);
            if ( p == NULL )
            {
                return false;
            }
            const VAL& v = c.At(i).second;
            if ( ! comparator.IsEqualTo(v, *p) )
            {
                return false;
            }
        }
        return true;
    }
 
    CConstKeysAdapter GetKeysAdapter(void) const
    {
        return CConstKeysAdapter(this);
    }
 
    CConstValuesAdapter GetValuesAdapter(void) const
    {
        return CConstValuesAdapter(this);
    }
 
private:
    friend class CMapTest;  
};
 
 
 
typedef TNB::CMapT<CStr, CStr, LPCTSTR> CStrsMap;
 
typedef TNB::CMapT<CAscii, CAscii, LPCSTR> CAsciisMap;
 
 
 
}; // TNB