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

#ifndef __LSTL_SVECTORCRTP_H__
#define __LSTL_SVECTORCRTP_H__

#include "../LSTLib.h"
#include "LSTLVectorBase.h"
#include <cassert>
#include <new>

namespace lstl {

        template <typename _tDerivedType,
                typename _tType, typename _tDataType = LSUINT16, unsigned _uAllocSize = 512UL>
        class CSVectorCrtp : protected CVectorBase {
        public :
                // == Various constructors.
                LSE_CALL                                        CSVectorCrtp() :
                        m_tLen( 0 ),
                        m_tAllocated( 0 ),
                        m_ptData( NULL ) {
                }
                LSE_CALL                                        CSVectorCrtp( const CSVectorCrtp<_tDerivedType, _tType, _tDataType, _uAllocSize> &_vcSource ) :
                        m_tLen( 0 ),
                        m_tAllocated( 0 ),
                        m_ptData( NULL ) {
                        (*this) = _vcSource;
                }


                // == Operators.
                const _tType & LSE_CALL         operator [] ( LSUINT32 _ui32Index ) const {
                        assert( _ui32Index < m_tLen );
                        return m_ptData[_ui32Index];
                }

                _tType & LSE_CALL                       operator [] ( LSUINT32 _ui32Index ) {
                        assert( _ui32Index < m_tLen );
                        return m_ptData[_ui32Index];
                }

                CSVectorCrtp<_tDerivedType, _tType, _tDataType, _uAllocSize> & LSE_CALL
                                                                        operator = ( const CSVectorCrtp<_tDerivedType, _tType, _tDataType, _uAllocSize> &_vcOther ) {
                        // Clear every item in this list.
                        static_cast<_tDerivedType *>(this)->ResetNoDealloc();

                        // If the allocation is too small or too high, reallocate.
                        if ( m_tAllocated < _vcOther.m_tLen || m_tAllocated >= (_vcOther.m_tLen << 1UL) ) {
                                static_cast<_tDerivedType *>(this)->Allocate( _vcOther.m_tLen );
                        }

                        // Copy items one-by-one.
                        for ( LSUINT32 I = 0UL; I < _vcOther.Length(); ++I ) {
                                if ( !static_cast<_tDerivedType *>(this)->Push( _vcOther[I] ) ) { throw LSSTD_E_OUTOFMEMORY; }
                        }
                        return (*this);
                }


                // == Functions.
                LSVOID LSE_CALL                         Reset() {
                        for ( LSINT32 I = static_cast<LSINT32>(m_tLen); --I >= 0; ) {
                                Destroy( static_cast<_tDataType>(I) );
                        }
                        m_paDefaultAllocator->Free( m_ptData );
                        m_ptData = NULL;
                        m_tLen = m_tAllocated = 0;
                }

                LSVOID LSE_CALL                         ResetNoDealloc() {
                        for ( LSINT32 I = static_cast<LSINT32>(m_tLen); --I >= 0; ) {
                                Destroy( static_cast<_tDataType>(I) );
                        }
                        m_tLen = 0;
                }

                LSVOID LSE_CALL                         Trash() {
                        for ( _tDataType I = m_tLen; I--; ) {
                                Destroy( I );
                        }
                        m_ptData = NULL;
                        m_tLen = m_tAllocated = 0;
                }

                LSBOOL LSE_CALL                         Allocate( LSUINT32 _ui32Total ) {
                        // If allocating 0 bytes, just reset the list.
                        if ( !_ui32Total ) {
                                static_cast<_tDerivedType *>(this)->Reset();
                                return true;
                        }

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

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

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

                _tDataType LSE_CALL                     GetAllocated() const { return m_tAllocated; }

                LSBOOL LSE_CALL                         Resize( LSUINT32 _ui32Total ) {
                        if ( !static_cast<_tDerivedType *>(this)->Allocate( _ui32Total ) ) { return false; }
                        for ( ; m_tLen < _ui32Total; ++m_tLen ) {
                                Construct( m_tLen );
                        }
                        return true;
                }

                LSBOOL LSE_CALL                         ResizeOver( LSUINT32 _ui32Total ) {
                        if ( m_tAllocated < _ui32Total ) {
                                if ( !static_cast<_tDerivedType *>(this)->Allocate( _ui32Total + _uAllocSize ) ) { return false; }
                        }
                        for ( ; m_tLen < _ui32Total; ++m_tLen ) {
                                Construct( m_tLen );
                        }
                        return true;
                }

                LSBOOL LSE_CALL                         Push( const _tType &_tVal ) {
                        // Do we need to allocate more space?
                        if ( m_tLen == m_tAllocated ) {
                                // Overflow checking.
                                _tDataType tNewTotal = static_cast<_tDataType>(m_tAllocated + _uAllocSize);
                                assert( tNewTotal > m_tAllocated );
                                if ( !static_cast<_tDerivedType *>(this)->Allocate( tNewTotal ) ) { return false; }
                        }
                        Construct( m_tLen );
                        m_ptData[m_tLen++] = _tVal;
                        return true;
                }

                LSVOID LSE_CALL                         Pop() {
                        if ( m_tLen == 0 ) { return; }
                        Destroy( --m_tLen );
                        // If there are fewer than half of the allocated space worth of objects,
                        //      adjust the allocation.
                        if ( m_tLen < (m_tAllocated >> 1) ) {
                                static_cast<_tDerivedType *>(this)->Allocate( (m_tAllocated >> 1) );
                        }
                }

                LSVOID LSE_CALL                         PopNoDealloc() {
                        if ( m_tLen == 0 ) { return; }
                        Destroy( --m_tLen );
                }

                LSBOOL LSE_CALL                         Insert( const _tType &_tVal, LSUINT32 _ui32Index ) {
                        assert( _ui32Index <= m_tLen );
                        if ( m_tLen == m_tAllocated ) {
                                // Overflow checking.
                                _tDataType tNewTotal = m_tAllocated + _uAllocSize;
                                assert( tNewTotal > m_tAllocated );
                                if ( !static_cast<_tDerivedType *>(this)->Allocate( tNewTotal ) ) { return false; }
                        }

                        // Move other items.
                        CStd::MemMove( &m_ptData[_ui32Index+1], &m_ptData[_ui32Index], sizeof( _tType ) * (m_tLen - _ui32Index) );
                        // Construct and add.
                        Construct( static_cast<_tDataType>(_ui32Index) );
                        m_ptData[_ui32Index] = _tVal;
                        ++m_tLen;
                        return true;
                }

                LSBOOL LSE_CALL                         Append( const _tType * _ptValues, _tDataType _tTotal ) {
                        LSUINTPTR uiptrNewLen = m_tLen + _tTotal;
                        if ( uiptrNewLen >= m_tAllocated ) {
                                if ( !static_cast<_tDerivedType *>(this)->Allocate( static_cast<_tDataType>(uiptrNewLen + _uAllocSize) ) ) { return false; }
                        }
                        CStd::MemCpy( &m_ptData[m_tLen], _ptValues, sizeof( _tType ) * _tTotal );
                        m_tLen += _tTotal;
                        return true;
                }

                LSVOID LSE_CALL                         Remove( LSUINT32 _ui32Index ) {
                        static_cast<_tDerivedType *>(this)->RemoveRange( _ui32Index, 1 );
                }

                LSVOID LSE_CALL                         RemoveNoDealloc( LSUINT32 _ui32Index ) {
                        static_cast<_tDerivedType *>(this)->RemoveRangeNoDealloc( _ui32Index, 1 );
                }

                LSVOID LSE_CALL                         RemoveRange( LSUINT32 _ui32Index, LSUINT32 _ui32Total ) {
                        static_cast<_tDerivedType *>(this)->RemoveRangeNoDealloc( _ui32Index, _ui32Total );

                        // If there are fewer than half of the allocated space worth of objects,
                        //      adjust the allocation.
                        if ( m_tLen < (m_tAllocated >> 1) ) {
                                static_cast<_tDerivedType *>(this)->Allocate( (m_tAllocated >> 1) );
                        }
                }

                LSVOID LSE_CALL                         RemoveRangeNoDealloc( LSUINT32 _ui32Index, LSUINT32 _ui32Total ) {
                        assert( _ui32Index < m_tLen );
                        assert( _ui32Index + _ui32Total <= m_tLen );
                        LSUINT32 ui32End = _ui32Index + _ui32Total;
                        for ( LSINT32 I = static_cast<LSINT32>(ui32End); --I >= static_cast<LSINT32>(_ui32Index); ) {
                                // Destruct the item.
                                Destroy( static_cast<_tDataType>(I) );
                        }

                        // Copy items over it.
                        CStd::MemMove( &m_ptData[_ui32Index], &m_ptData[_ui32Index+_ui32Total], sizeof( _tType ) * ((m_tLen - _ui32Total) - _ui32Index) );
                        m_tLen = m_tLen - static_cast<_tDataType>(_ui32Total);
                }

                _tDataType LSE_CALL                     Length() const {
                        return m_tLen;
                }

                LSVOID LSE_CALL                         Snap() {
                        static_cast<_tDerivedType *>(this)->Allocate( m_tLen );
                }



        protected :
                // == Members.
                _tType *                                        m_ptData;
                
                _tDataType                                      m_tLen;
                
                _tDataType                                      m_tAllocated;


                // == Functions.
                LSVOID LSE_CALL                         Construct( _tDataType _tIndex ) {
                        new( &m_ptData[_tIndex] ) _tType;
                }
                
                LSVOID LSE_CALL                         Destroy( _tDataType _tIndex ) {
                        // This gives warning C4100 when this class is created with types that have no destructor,
                        //      claiming _tIndex is unreferenced.
                        // Erase this warning with some do-nothing code.
#ifdef LSE_VISUALSTUDIO
                        static_cast<_tDataType>(_tIndex);
#endif  // #ifdef LSE_VISUALSTUDIO
                        m_ptData[_tIndex].~_tType();
                }

        };

}       // namespace lstl

#endif  // __LSTL_SVECTORCRTP_H__