spl/collection/Vector.h

Go to the documentation of this file.

/*
 *   This file is part of the Standard Portable Library (SPL).
 *
 *   SPL is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   SPL is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with SPL.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef _tvector_h
#define _tvector_h

#include <spl/types.h>
#include <spl/Debug.h>

#include <spl/collection/Array.h>
#include <spl/Exception.h>
#include <spl/collection/IEnumerable.h>
#include <spl/IIterator.h>
#include <spl/Memory.h>
#include <spl/RefCountPtr.h>

template<typename T>
class Vector : public IEnumerable<T>
{
protected:
        T *m_data;
        int m_pos;              
        int m_size;             
        virtual RefCountPtr<IIterator<T> > IteratorPtr()
        {
                return RefCountPtr<IIterator<T> >(new Iterator(this));
        }

public:
        class Iterator : public IIterator<T>
        {
        private:
                const Vector<T> *m_ap;
                int m_pos;

        public:
                Iterator(const Vector<T> *ap)
                : m_ap(ap), m_pos(-1)
                {
                }

                Iterator(const Iterator& vi)
                : m_ap(vi.m_ap), m_pos(vi.m_pos)
                {
                }

                virtual bool Next()
                {
                        if (++m_pos >= m_ap->Count())
                        {
                                return false;
                        }
                        return true;
                }

                virtual bool Prev()
                {
                        if (--m_pos < 0)
                        {
                                return false;
                        }
                        return true;
                }

                virtual T Current()
                {
                        return m_ap->ElementAt(m_pos);
                }

                virtual T& CurrentRef()
                {
                        return m_ap->ElementAtRef(m_pos);
                }       
        };

        Vector(int count = 10) 
        : m_pos(0), m_size(count)
        {
                if ( NULL == (m_data = new T[m_size]) )
                {
                        throw OutOfMemoryException();
                }
                //memset(m_data, 0, m_size * sizeof(T));
#ifdef DEBUG
                // The debug memory checks need this zero'ed for native types of T
                for ( int x = 0; x < m_size; x++ )
                {
                        m_data[x] = T();
                }
#endif
        }

        Vector(const Vector& v) : m_pos(v.m_pos), m_size(v.m_size)
        {
                m_data = new T[m_size];

                for ( int x = 0; x < m_size; x++ )
                {
                        m_data[x] = v.m_data[x];
                }
        }

        virtual ~Vector()
        {
                ASSERT_MEM( m_data, sizeof(T) * m_size );
                delete[] m_data;
        }

        Vector& operator =(const Vector& v)
        {
                Vector<T>::ValidateMem();

                delete[] m_data;

                m_pos = v.m_pos;
                m_size = v.m_size;
                m_data = new T[m_size];

                for ( int x = 0; x < m_size; x++ )
                {
                        m_data[x] = v.m_data[x];
                }

                return *this;
        }

        inline Iterator Begin() const
        {
                return Iterator(this);
        }

        inline void Add( T item )
        {
                if ( m_pos == m_size )
                {
                        Extend(m_size*2);
                }
                m_data[m_pos++] = item;
        }

        void AddRange(const Array<T>& a, const int offset, const int len)
        {
                for ( int x = 0; x + offset < a.Length() && x < len; x++ )
                {
                        Add(a[x+offset]);
                }
        }

        inline void AddRange(const Array<T>& a, const int len)
        {
                AddRange(a, 0, len);
        }

        inline void AddRange(const Array<T>& a)
        {
                AddRange(a, 0, a.Length());
        }

        void AddRange(const Vector<T>& v)
        {
                for (int x = 0; x < v.Count(); x++)
                {
                        Add(v.ElementAt(x));
                }
        }

        void AddRangeWithPad(const Array<T>& a, int count)
        {
                for (int x = 0; x < count; x++)
                {
                        if (x < a.Length())
                        {
                                Add(a[x]);
                        }
                        else
                        {
                                Add(T());
                        }
                }
        }

        void AddRangeWithLeadingPad(Array<T>& a, int count)
        {
                int diff = count - a.Length();
                ASSERT(diff >= 0);

                for (int x = 0; x < count; x++)
                {
                        if (x >= diff)
                        {
                                Add(a[x - diff]);
                        }
                        else
                        {
                                Add(T());
                        }
                }
        }

        void SetElementAt( T item, int pos )
        {
                if ( pos >= m_size )
                {
                        ExtendTo(pos+1);
                }
                if ( pos >= m_pos )
                {
                        m_pos = pos + 1;
                }
                m_data[pos] = item;
        }

        void Insert( T item, int pos )
        {
                if ( m_pos+1 >= m_size )
                {
                        ExtendTo(m_size+10);
                }
                memcpy(&m_data[pos+1], &m_data[pos], (m_pos - pos)*sizeof(T));
                m_data[pos] = item;
                m_pos++;
                ASSERT_PTR( &m_data[m_pos] );
                ASSERT_MEM( m_data, sizeof(T) * m_size );
        }

        inline T ElementAt( const int pos ) const
        {
                ASSERT( pos >= 0 );
                ASSERT( pos < m_pos );
                ASSERT_MEM( m_data, sizeof(T) * m_size );
                if ( pos >= m_pos || 0 > pos )
                {
                        throw IndexOutOfBoundsException();
                }
                return m_data[pos];
        }

        inline T& ElementAtRef( const int pos ) const
        {
                ASSERT( pos >= 0 );
                ASSERT( pos < m_pos );
                ASSERT_MEM( m_data, sizeof(T) * m_size );
                if ( pos >= m_pos || 0 > pos )
                {
                        throw IndexOutOfBoundsException();
                }
                return m_data[pos];
        }

        T RemoveAt( const int pos )
        {
                if ( pos >= m_pos )
                {
                        return T();
                }
                T element = ElementAt(pos);
                ASSERT_MEM( m_data, sizeof(T) * m_size );
                ASSERT_PTR( &m_data[pos] );
                memcpy(&m_data[pos], &m_data[pos+1], (m_pos - pos)*sizeof(T));
                m_pos--;
                ASSERT_PTR( &m_data[m_pos] );
                ASSERT_MEM( m_data, sizeof(T) * m_size );
                return element;
        }

        inline T& operator[] (const int idx) const
        {
                return ElementAtRef(idx);
        }

        void Remove( const T& item )
        {
                int count = Count();
                for ( int x = 0; x < count; x++ )
                {
                        if ( item ==  ElementAt(x) )
                        {
                                RemoveAt( x );
                                return;
                        }
                }
        }

        inline T Pop(  )
        {
                ASSERT( m_pos > 0 );
                if (m_pos == 0)
                {
                        return T();
                }
                return m_data[--m_pos];
        }

        inline T Peek(  ) const
        {
                ASSERT( m_pos > 0 );
                if (m_pos == 0)
                {
                        throw Exception("Stack empty");
                }
                return m_data[m_pos-1];
        }

        inline T& PeekRef(  ) const
        {
                ASSERT( m_pos > 0 );
                if (m_pos == 0)
                {
                        throw Exception("Stack empty");
                }
                return m_data[m_pos-1];
        }

        inline void Clear()
        {
                m_pos = 0;
        }

        inline int Count() const
        {
                return m_pos;
        }

        Vector<T> *Copy() const
        {
                Vector<T> *vec = new Vector<T>();
                int count = Count();
                for ( int x = 0; x < count; x++ )
                {
                        vec->Add( ElementAt(x) );
                }
                return vec;
        }

        inline T *Data() { return m_data; }

        void EnsureElementTo(int size)
        {
                if ( size <= Count() )
                {
                        return;
                }
                ExtendTo(size);
        }

        void SetCount(int cnt)
        {
                ASSERT( cnt < m_size );
                m_pos = cnt;
        }

        inline RefCountPtr<Array<T> > ToArray() const
        {
                return ToArray(Count());
        }

        inline RefCountPtr<Array<T> > ToArray(int count) const
        {
                return RefCountPtr<Array<T> >(new Array<T>(m_data, count));
        }

#if defined(DEBUG) || defined(_DEBUG)
        void CheckMem() const
        {
                DEBUG_NOTE_MEM_ALLOCATION( m_data );
                for ( int x = 0; x < m_size; x++ )
                {
                        ValidateType( m_data[x] );
                }
        }

        void ValidateMem() const
        {
                ASSERT_MEM(m_data, sizeof(T) * m_size);
        }
#endif

protected:
        void ExtendTo(int index)
        {
                ASSERT_MEM(m_data, sizeof(T) * m_size);

                if (index > m_size)
                {
                        Extend(index+1);
                        ASSERT_MEM(m_data, sizeof(T) * m_size);
                }
                ASSERT_MEM(m_data, sizeof(T) * m_size);
        }

        void Extend(int newlen)
        {
                ASSERT_MEM(m_data, sizeof(T) * m_size);

                int x;
                T *newbuf;

                if ((newbuf = new T[newlen]) == NULL)
                {
                        throw OutOfMemoryException();
                }
                for ( x = 0; x < m_size; x++ )
                {
                        newbuf[x] = m_data[x];
                }
                //memset(&newbuf[m_size], 0, (newlen - m_size) * sizeof(T));
#ifdef DEBUG
                // The debug memory checks need this zero'ed for native types of T
                for ( x = m_size; x < newlen; x++ )
                {
                        newbuf[x] = T();
                }
#endif
                m_size = newlen;
                delete[] m_data;
                m_data = newbuf;
                ASSERT_MEM(m_data, sizeof(T) * m_size);
        }
};

REGISTER_TYPEOF( 170, Vector<char> );
REGISTER_TYPEOF( 171, Vector<byte> );
REGISTER_TYPEOF( 172, Vector<int16> );
REGISTER_TYPEOF( 173, Vector<uint16> );
REGISTER_TYPEOF( 174, Vector<int32> );
REGISTER_TYPEOF( 175, Vector<uint32> );
REGISTER_TYPEOF( 176, Vector<int64> );
REGISTER_TYPEOF( 177, Vector<uint64> );
REGISTER_TYPEOF( 178, Vector<float32> );
REGISTER_TYPEOF( 179, Vector<float64> );

#endif