F:/My Projects/LSEngine/Modules/LSTL/Src/Map/LSTLMap.h

#ifndef __LSTL_MAP_H__
#define __LSTL_MAP_H__

#include "../LSTLib.h"
#include "../Algorithm/LSTLAlgorithm.h"
#include "../Vector/LSTLVector.h"
#include "LSTLMapBase.h"
#include "Search/LSSTDSearch.h"
#include <new>

#pragma warning( push )

// warning C4127: conditional expression is constant
#pragma warning( disable : 4127 )

namespace lstl {

        template <typename _tKeyType, typename _tMappedType>
        class CMap : protected CMapBase {
        public :
                // == Various constructors.
                LSE_CALL                                                                CMap() {
                }
                explicit LSE_CALL                                               CMap( const CMap<_tKeyType, _tMappedType> &_mSrc ) :
                        m_vPairs( _mSrc.m_vPairs ) {
                }
                explicit LSE_CALL                                               CMap( CAllocator * _paAllocator ) :
                        m_vPairs( _paAllocator ) {
                }
                LSE_CALL                                                                ~CMap() {
                        Reset();
                }


                // == Types.
                typedef struct LSTL_PAIR {
                        _tKeyType                                                       tKey;

                        _tMappedType                                            tValue;

                        LSTL_PAIR & LSE_CALL                            operator = ( const LSTL_PAIR &_pSrc ) {
                                tKey = _pSrc.tKey;
                                tValue = _pSrc.tValue;
                                return (*this);
                        }

                        LSBOOL LSE_CALL                                         operator < ( const _tKeyType &_tVal ) const {
                                return tKey < _tVal;
                        }

                        LSBOOL LSE_CALL                                         operator == ( const _tKeyType &_tVal ) const {
                                return tKey == _tVal;
                        }

                        LSE_CALL                                                        LSTL_PAIR() :
                                tKey(),
                                tValue() {
                        }
                } * LPLSTL_PAIR, * const LPCLSTL_PAIR;


                // == Operators.
                _tMappedType & LSE_CALL                                 operator [] ( const _tKeyType &_tKey ) {
                        _tMappedType * ptValue = NULL;
                        _tMappedType tDefault = _tMappedType();
                        if ( !Insert( _tKey, tDefault, &ptValue ) ) {
                                throw LSSTD_E_OUTOFMEMORY;
                        }
                        return (*ptValue);
                }

                const _tMappedType & LSE_CALL                   operator [] ( const _tKeyType &_tKey ) const {
                        LSUINT32 ui32Index;
                        if ( !GetItemIndex( _tKey, ui32Index ) ) {
                                // The const form of this function can only be used when values are
                                //      known to exist in the list.
                                throw LSSTD_E_INVALIDCALL;
                        }
                        return m_vPairs[ui32Index].tValue;
                }

                CMap<_tKeyType, _tMappedType> & LSE_CALL
                                                                                                operator = ( const CMap<_tKeyType, _tMappedType> &_mSrc ) {
                        // The copy is as easy as copying the vector.
                        m_vPairs = _mSrc.m_vPairs;
                        return (*this);
                }


                // == Functions.
                LSBOOL LSE_CALL                                                 Allocate( LSUINT32 _ui32Total ) {
                        return m_vPairs.Allocate( _ui32Total );
                }

                LSBOOL LSE_CALL                                                 Insert( const LSTL_PAIR * _ppPairs, LSUINT32 _ui32Total ) {
                        for ( LSUINT32 I = _ui32Total; I--; ) {
                                if ( !Insert( _ppPairs[I] ) ) { return false; }
                        }
                        return true;
                }

                LSBOOL LSE_CALL                                                 Insert( const LSTL_PAIR &_pPair, _tMappedType ** _pptReturnValue = NULL ) {
                        LSUINT32 ui32Index;
                        if ( !GetItemIndex( _pPair.tKey, ui32Index ) ) {
                                // Insert the item at the given index.
                                if ( !m_vPairs.Insert( _pPair, ui32Index ) ) {
                                        if ( _pptReturnValue ) {
                                                (*_pptReturnValue) = NULL;
                                        }
                                        return false;
                                }
                        }
                        if ( _pptReturnValue ) {
                                (*_pptReturnValue) = &m_vPairs[ui32Index].tValue;
                        }
                        return true;
                }

                LSBOOL LSE_CALL                                                 Insert( const _tKeyType &_tKey, const _tMappedType &_tValue, _tMappedType ** _pptReturnValue = NULL ) {
                        LSTL_PAIR pPair;
                        pPair.tKey = _tKey;
                        pPair.tValue = _tValue;
                        return Insert( pPair, _pptReturnValue );
                }

                LSVOID LSE_CALL                                                 RemoveNoDealloc( const _tKeyType * _ptKeys, LSUINT32 _ui32Total ) {
                        for ( LSUINT32 I = _ui32Total; I--; ) {
                                RemoveNoDealloc( _ptKeys[I] );
                        }
                }

                LSVOID LSE_CALL                                                 RemoveNoDealloc( const _tKeyType &_tKey ) {
                        LSUINT32 ui32Index;
                        if ( GetItemIndex( _tKey, ui32Index ) ) {
                                m_vPairs.RemoveNoDealloc( ui32Index );
                        }
                }

                LSVOID LSE_CALL                                                 Remove( const _tKeyType * _ptKeys, LSUINT32 _ui32Total ) {
                        for ( LSUINT32 I = _ui32Total; I--; ) {
                                Remove( _ptKeys[I] );
                        }
                }

                LSVOID LSE_CALL                                                 Remove( const _tKeyType &_tKey ) {
                        LSUINT32 ui32Index;
                        if ( GetItemIndex( _tKey, ui32Index ) ) {
                                m_vPairs.Remove( ui32Index );
                        }
                }

                LSVOID LSE_CALL                                                 RemoveByIndex( LSUINT32 _ui32Index ) {
                        m_vPairs.Remove( _ui32Index );
                }

                LSVOID LSE_CALL                                                 RemoveByIndexNoDealloc( LSUINT32 _ui32Index ) {
                        m_vPairs.RemoveNoDealloc( _ui32Index );
                }

                LSVOID LSE_CALL                                                 ResetNoDealloc() {
                        m_vPairs.ResetNoDealloc();
                }

                LSVOID LSE_CALL                                                 Reset() {
                        m_vPairs.Reset();
                }

                LSUINT32 LSE_CALL                                               Length() const {
                        return m_vPairs.Length();
                }

                _tMappedType & LSE_CALL                                 GetByIndex( LSUINT32 _ui32Index ) {
                        return m_vPairs[_ui32Index].tValue;
                }

                const _tMappedType & LSE_CALL                   GetByIndex( LSUINT32 _ui32Index ) const {
                        return m_vPairs[_ui32Index].tValue;
                }

                _tKeyType & LSE_CALL                                    GetKeyByIndex( LSUINT32 _ui32Index ) {
                        return m_vPairs[_ui32Index].tKey;
                }

                const _tKeyType & LSE_CALL                              GetKeyByIndex( LSUINT32 _ui32Index ) const {
                        return m_vPairs[_ui32Index].tKey;
                }

                LSBOOL LSE_CALL                                                 GetItemIndex( const _tKeyType &_tKey, LSUINT32 &_ui32Index ) const {
                        return CAlgorithm::BSearch( m_vPairs, _tKey, _ui32Index );
                }

                LSBOOL LSE_CALL                                                 ItemExists( const _tKeyType &_tKey ) const {
                        LSUINT32 ui32Index;
                        return GetItemIndex( _tKey, ui32Index );
                }

                LSBOOL LSE_CALL                                                 ItemExists( const _tKeyType &_tKey, LSUINT32 &_ui32Index ) const {
                        return GetItemIndex( _tKey, _ui32Index );
                }

                LSVOID LSE_CALL                                                 SetAllocator( CAllocator * _paAllocator ) {
                        m_vPairs.SetAllocator( _paAllocator );
                }

                CAllocator * LSE_CALL                                   GetAllocator() {
                        return m_vPairs.GetAllocator();
                }

        protected :
                // == Members.
                CVector<LSTL_PAIR, LSUINT32, 1024UL>    m_vPairs;

        };

}       // namespace lstl

#pragma warning( pop )

#endif  // __LSTL_MAP_H__