F:/My Projects/LSEngine/Modules/LSTL/Src/Vector/LSTLVector.h

#ifndef __LSTL_VECTOR_H__
#define __LSTL_VECTOR_H__

#include "../LSTLib.h"
#include "LSTLSVectorCrtp.h"

namespace lstl {

        template <typename _tType, typename _tDataType = LSUINT16, unsigned _uAllocSize = 512UL>
        class CVector : public CSVectorCrtp<CVector<_tType, _tDataType, _uAllocSize>, _tType, _tDataType, _uAllocSize> {
        public :
                // == Various constructors.
                LSE_CALL                                                                CVector() :
                        m_paOurAllocator( Parent::m_paDefaultAllocator ) {
                }
                explicit LSE_CALL                                               CVector( LSUINT32 _tTotal ) :
                        m_paOurAllocator( Parent::m_paDefaultAllocator ) {
                        Allocate( _tTotal );
                }
                explicit LSE_CALL                                               CVector( CAllocator * _paAllocator ) :
                        m_paOurAllocator( _paAllocator ) {
                        if ( !m_paOurAllocator ) {
                                m_paOurAllocator = Parent::m_paDefaultAllocator;
                        }
                }
                LSE_CALL                                                                CVector( LSUINT32 _tTotal, CAllocator * _paAllocator ) :
                        m_paOurAllocator( _paAllocator ) {
                        if ( !m_paOurAllocator ) {
                                m_paOurAllocator = Parent::m_paDefaultAllocator;
                        }
                        Allocate( _tTotal );
                }
                LSE_CALL                                                                CVector( const CVector<_tType, _tDataType, _uAllocSize> &_vOther, CAllocator * _paAllocator = NULL ) :
                        m_paOurAllocator( _paAllocator ) {
                        if ( !m_paOurAllocator ) {
                                m_paOurAllocator = Parent::m_paDefaultAllocator;
                        }
                        (*this) = _vOther;
                }
                LSE_CALL                                                                ~CVector() {
                        Reset();
                }


                // == Functions.
                LSBOOL LSE_CALL                                                 Allocate( LSUINT32 _ui32Total ) {
                        // If allocating 0 bytes, just reset the list.
                        if ( !_ui32Total ) {
                                Reset();
                                return true;
                        }

                        // Destroy items that are going to be removed.
                        if ( Parent::m_tLen ) {
                                for ( LSUINT32 I = Parent::m_tLen; --I >= _ui32Total; ) {
                                        Parent::Destroy( static_cast<_tDataType>(I) );
                                }
                        }
                        // Adjust the length.
                        if ( Parent::m_tLen > static_cast<_tDataType>(_ui32Total) ) {
                                Parent::m_tLen = static_cast<_tDataType>(_ui32Total);
                        }

                        // Attempt to allocate.
                        _tType * ptNew = reinterpret_cast<_tType *>(m_paOurAllocator->Alloc( _ui32Total * sizeof( _tType ) ));
                        if ( !ptNew ) { return false; }

                        // Construct and copy all the items in the newly allocated array.
                        for ( LSUINT32 I = Parent::m_tLen; I--; ) {
                                // Construct new.
                                new( &ptNew[I] ) _tType;
                                // Copy from old to new.
                                ptNew[I] = Parent::m_ptData[I];
                                // Destroy old.
                                Parent::Destroy( static_cast<_tDataType>(I) );
                        }
                        // Remove the old list.
                        if ( Parent::m_ptData ) {
                                m_paOurAllocator->Free( Parent::m_ptData );
                        }

                        // Success.
                        Parent::m_ptData = ptNew;
                        Parent::m_tAllocated = static_cast<_tDataType>(_ui32Total);
                        return true;
                }

                LSVOID LSE_CALL                                                 Reset() {
                        for ( LSUINT32 I = Parent::m_tLen; I--; ) {
                                Parent::Destroy( static_cast<_tDataType>(I) );
                        }
                        if ( Parent::m_ptData ) {
                                m_paOurAllocator->Free( Parent::m_ptData );
                                Parent::m_ptData = NULL;
                        }
                        Parent::m_tLen = Parent::m_tAllocated = 0;
                }

                LSBOOL LSE_CALL                                                 Insert( const _tType &_tVal, LSUINT32 _ui32Index ) {
                        assert( _ui32Index <= Parent::m_tLen );
                        // If inserting at the end, just push the item.
                        if ( _ui32Index == Parent::m_tLen ) { return this->Push( _tVal ); }

                        // Now we know we are inserting in the middle somewhere.
                        if ( Parent::m_tLen == Parent::m_tAllocated ) {
                                // Overflow checking.
                                _tDataType tNewTotal = Parent::m_tAllocated + _uAllocSize;
                                assert( tNewTotal > Parent::m_tAllocated );
                                if ( !Allocate( tNewTotal ) ) { return false; }
                        }

                        // Move other items.
                        // Since this is not a PoD handler, we cannot simply move memory.
                        // The last item has not been constructed yet, so we cannot call its copy operator yet.
                        this->Construct( Parent::m_tLen );
                        // Move items up one-by-one.
                        for ( LSUINT32 I = Parent::m_tLen; I > _ui32Index; --I ) {
                                Parent::m_ptData[I] = Parent::m_ptData[I-1UL];
                        }
                        // No need to destroy/construct the item at the given location.  Its copy operator should handle freeing of
                        //      its memory.
                        Parent::m_ptData[_ui32Index] = _tVal;
                        ++Parent::m_tLen;
                        return true;
                }

                LSVOID LSE_CALL                                                 RemoveRangeNoDealloc( LSUINT32 _ui32Index, LSUINT32 _ui32Total ) {
                        if ( _ui32Total == 0UL ) { return; }
                        assert( _ui32Index < Parent::m_tLen );
                        assert( _ui32Index + _ui32Total <= Parent::m_tLen );
                        LSUINT32 ui32End = Parent::m_tLen - _ui32Total;
                        
                        // Copy items over it.
                        // Since this is not a PoD handler, we cannot simply move memory.
                        LSUINT32 ui32CopyEnd = Parent::m_tLen - _ui32Total;
                        for ( LSUINT32 I = _ui32Index; I < ui32CopyEnd; ++I ) {
                                Parent::m_ptData[I] = Parent::m_ptData[I+_ui32Total];
                        }

                        // Destroy the tail items that were moved down.
                        for ( LSINT32 I = static_cast<LSINT32>(Parent::m_tLen); --I >= static_cast<LSINT32>(ui32End); ) {
                                // Destruct the item.
                                Parent::Destroy( static_cast<_tDataType>(I) );
                        }
                        Parent::m_tLen = Parent::m_tLen - static_cast<_tDataType>(_ui32Total);
                }

                // Set the allocator.  Causes the object to be fully reset.  Cannot be used on
                //      lists that have contents already.
                LSVOID LSE_CALL                                                 SetAllocator( CAllocator * _paAllocator ) {
                        Reset();
                        m_paOurAllocator = _paAllocator;
                        if ( !m_paOurAllocator ) {
                                m_paOurAllocator = Parent::m_paDefaultAllocator;
                        }
                }

                // Get our allocator.
                CAllocator * LSE_CALL                                   GetAllocator() {
                        return m_paOurAllocator;
                }

                LSVOID LSE_CALL                                                 Trash() {
                        for ( _tDataType I = Parent::m_tLen; I--; ) {
                                Parent::m_ptData[I].Trash();
                                Parent::Destroy( I );
                        }
                        Parent::m_ptData = NULL;
                        Parent::m_tLen = Parent::m_tAllocated = 0;
                }

        protected :
                // == Members.
                // The allocator we should use.
                CAllocator *                                                    m_paOurAllocator;

        private :
                typedef CSVectorCrtp<CVector<_tType, _tDataType, _uAllocSize>, _tType, _tDataType, _uAllocSize>
                        Parent;
        };

}       // namespace lstl

#endif  // __LSTL_VECTOR_H__