TnbSimpleVector.h

[詳解]

#pragma once
#include "TnbException.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP>
class CSimpleVectorT
{
public:
    explicit CSimpleVectorT(void) : m_bufferSize(0), m_dataSize(0), m_pBuffer(NULL)
    {
    }
 
    explicit CSimpleVectorT(size_t bufferSize) : m_bufferSize(bufferSize), m_dataSize(0)
    {
        m_pBuffer = new TYP[m_bufferSize];
    }
 
    CSimpleVectorT(const CSimpleVectorT& other) : m_bufferSize(0), m_dataSize(0), m_pBuffer(NULL)
    {
        operator=(other);
    }
 
    virtual ~CSimpleVectorT(void)
    {
        RemoveAll();
    }
 
    CSimpleVectorT& operator=(const CSimpleVectorT& other)
    {
        size_t l = other.GetSize();
        SetSize(l);
        loop ( i, l )
        {
            Set(i, other.At(i));
        }
        return *this;
    }
 
    const TYP& At(INDEX index) const
    {
        if ( m_dataSize <= index ) { throw CIndexOutOfBoundsException(); }
        return m_pBuffer[index];
    }
 
    TYP& At(INDEX index) 
    {
        if ( m_dataSize <= index ) { throw CIndexOutOfBoundsException(); }
        return m_pBuffer[index];
    }
 
    const TYP& operator[](INDEX index) const
    {
        if ( m_dataSize <= index ) { throw CIndexOutOfBoundsException(); }
        return m_pBuffer[index];
    }
 
    TYP& operator[](INDEX index)
    {
        if ( m_dataSize <= index ) { throw CIndexOutOfBoundsException(); }
        return m_pBuffer[index];
    }
    
    bool Set(INDEX index, const TYP& t)
    {
        if ( m_dataSize <= index ) { return false; }
        m_pBuffer[index] = t;
        return true;
    }
 
    bool IsInRange(INDEX index) const
    {
        return TNB::IsInRange(index, GetSize());
    }
 
    bool IsEmpty(void) const
    {
        return m_dataSize == 0;
    }
 
    size_t GetSize(void) const
    {
        return m_dataSize;
    }
 
    operator size_t(void) const
    {
        return m_dataSize;
    }
 
    TYP* ReferBuffer(void)
    {
        return m_pBuffer;
    }
 
    const TYP* ReferBuffer(void) const
    {
        return m_pBuffer;
    }
 
    void SetSize(size_t s)
    {
        if ( s == 0 )
        {
            RemoveAll();
        }
        else if ( s > GetSize() )
        {
            if ( m_bufferSize < s )
            {
                m_bufferSize = m_GetSecureSize(s + 1);
                TYP* P = new TYP[m_bufferSize];
                loop ( i, m_dataSize )
                {
                    P[i] = m_pBuffer[i];
                }
                if ( m_pBuffer != NULL )
                {
                    delete[] m_pBuffer;
                }
                m_pBuffer = P;
            }
        }
        m_dataSize = s;
    }
 
    INDEX Add(const TYP& t)
    {
        if ( m_bufferSize <= m_dataSize )
        {
            m_bufferSize = m_GetSecureSize(m_bufferSize + 1);
            TYP* P = new TYP[m_bufferSize];
            loop ( i, m_dataSize )
            {
                P[i] = m_pBuffer[i];
            }
            if ( m_pBuffer != NULL )
            {
                delete[] m_pBuffer;
            }
            m_pBuffer = P;
        }
        m_pBuffer[m_dataSize] = t;
        m_dataSize += 1;
        return m_dataSize - 1;
    }
 
    bool Remove(INDEX index)
    {
        if ( IsInRange(index) ) 
        {
            for ( INDEX i = index ; i < m_dataSize - 1; i++ )
            {
                m_pBuffer[i] = m_pBuffer[i + 1];
            }
            m_dataSize--;
            return true;
        }
        return false;
    }
 
    void RemoveAll(void)
    {
        m_bufferSize = 0;
        m_dataSize = 0;
        if ( m_pBuffer != NULL )
        {
            delete[] m_pBuffer;
            m_pBuffer = NULL;
        }
    }
 
    INDEX Find(const TYP& t) const
    {
        loop ( i, m_dataSize )
        {
            if ( m_pBuffer[i] == t )
            {
                return i;
            }
        }
        return INVALID_INDEX;
    }
 
private:
    size_t  m_bufferSize;   
    size_t  m_dataSize;     
    TYP *   m_pBuffer;      
    size_t m_GetSecureSize(size_t size)
    {
        size_t marginSize = size / 8;
        marginSize = (marginSize < 4) ? 4 : ((marginSize > 1024) ? 1024 : marginSize);
        return size + marginSize;
    }
};
 
 
 
}; // TNB