TnbSimpleMap.h

[詳解]

#pragma once
#include "TnbSimpleVector.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename KEY, typename VAL, typename INK=KEY>
class CSimpleMapT
{
public:
 
    struct TParam
    {
        KEY     key;    
        VAL     val;    
        TParam(INK k = KEY(), VAL v = VAL()) : key(k), val(v)
        {}
    };
 
    explicit CSimpleMapT(void) : m_isValidLast(false)
    {
    }
 
    explicit CSimpleMapT(size_t bufferSize) : m_isValidLast(false), m_map(bufferSize)
    {
    }
 
    CSimpleMapT(const CSimpleMapT& other)
    {
        m_map = other.m_map;
    }
 
    CSimpleMapT& operator=(const CSimpleMapT& other)
    {
        m_map = other.m_map;
        return *this;
    }
 
    size_t GetSize(void) const
    {
        return m_map.GetSize();
    }
 
    VAL& operator[](INK key)
    {
        INDEX i = Find(key);
        if ( i != INVALID_INDEX )
        {
            return m_map[i].val;
        }
        i = m_map.Add(TParam(key, VAL()));
        m_lastKey = key;
        m_lastIndex = i;
        m_isValidLast = true;
        return m_map[i].val;
    }
 
    const VAL& operator[](INK key) const
    {
        INDEX i = Find(key);
        if ( i != INVALID_INDEX )
        {
            return m_map[i].val;
        }
        throw CEmptyException();
    }
 
    bool RemoveKey(INK key)
    {
        INDEX i = Find(key);
        if ( i != INVALID_INDEX )
        {
            m_map.Remove(i);
            m_isValidLast = false;
            return true;
        }
        return false;
    }
 
    const TParam& Ref(INDEX index) const
    {
        return m_map[index];
    }
 
    bool Remove(INDEX index)
    {
        m_isValidLast = false;
        return m_map.Remove(index);
    }
 
    INDEX Find(INK key) const
    {
        if ( m_isValidLast && m_lastKey == key )
        {
            ASSERT( m_map[m_lastIndex].key == m_lastKey );
            return m_lastIndex;
        }
        loop ( i, m_map.GetSize() )
        {
            if ( m_map[i].key == key )
            {
                m_lastKey = key;
                m_lastIndex = i;
                m_isValidLast = true;
                return i;
            }
        }
        return INVALID_INDEX;
    }
    bool HasKey(INK key) const
    {
        return Find(key) != INVALID_INDEX;
    }
 
    void RemoveAll(void)
    {
        m_isValidLast = false;
        m_map.RemoveAll();
    }
 
private:
    CSimpleVectorT<TParam>  m_map;  
    mutable bool    m_isValidLast;  
    mutable INK     m_lastKey;      
    mutable INDEX   m_lastIndex;    
};
 
 
 
}; // TNB