F:/My Projects/LSEngine/Modules/LSTL/Src/MultiMap/LSTLMultiMap.h

#ifndef __LSTL_MULTIMAP_H__
#define __LSTL_MULTIMAP_H__

#include "../LSTLib.h"
#include "../Algorithm/LSTLAlgorithm.h"
#include "../Vector/LSTLVector.h"
#include "LSTLMultiMapBase.h"

#pragma warning( push )

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

namespace lstl {

        template <typename _tKeyType, typename _tMappedType>
        class CMultiMap : protected CMultiMapBase {
                // All is public.  This class has no secrets.
        public :
                // == Various constructors.
                LSE_CALL                                                                CMultiMap() {
                }
                explicit LSE_CALL                                               CMultiMap( const CMultiMap<_tKeyType, _tMappedType> &_mmSrc ) :
                        m_vPairs( _mmSrc.m_vPairs ) {
                }
                explicit LSE_CALL                                               CMultiMap( CAllocator * _paAllocator ) :
                        m_vPairs( _paAllocator ) {
                }
                LSE_CALL                                                                ~CMultiMap() {
                }


                // == Operators.
                CMultiMap & LSE_CALL                                    operator = ( const CMultiMap &_mmOther ) {
                        m_vPairs = _mmOther.m_vPairs;

                        return (*this);
                }


                // == Functions.
                LSBOOL LSE_CALL                                                 Insert( const _tKeyType &_tKey, const _tMappedType &_tValue, _tMappedType ** _pptReturnValue = NULL ) {
                        LSUINT32 ui32Index;
                        if ( !GetItemIndex( _tKey, ui32Index ) ) {
                                // Pair does not exist, so add it.
                                LSTL_PAIR pPair;
                                pPair.tKey = _tKey;
                                // Do not add the value.
                                if ( !m_vPairs.Insert( pPair, ui32Index ) ) {
                                        if ( _pptReturnValue ) {
                                                (*_pptReturnValue) = NULL;
                                        }
                                        return false;
                                }
                                // It was inserted.  Apply the allocator to the vector.
                                m_vPairs[ui32Index].vValues.SetAllocator( GetAllocator() );
                        }

                        // Key already exists.  Add the mapped value to it.
                        LSUINT32 ui32Total = m_vPairs[ui32Index].vValues.Length();
                        if ( !m_vPairs[ui32Index].vValues.Push( _tValue ) ) {
                                if ( _pptReturnValue ) {
                                        (*_pptReturnValue) = NULL;
                                }
                                return false;
                        }
                        if ( _pptReturnValue ) {
                                (*_pptReturnValue) = &m_vPairs[ui32Index].vValues[ui32Total];
                        }
                        return true;
                }

                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                                                 ResetNoDealloc() {
                        m_vPairs.ResetNoDealloc();
                }

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

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

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

                LSUINT32 LSE_CALL                                               ItemsOnKey( LSUINT32 _ui32Index ) const {
                        return m_vPairs[_ui32Index].vValues.Length();
                }

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

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

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

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

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


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

                        CVector<_tMappedType, LSUINT16, 1024UL>
                                                                                                vValues;

                        LSTL_PAIR & LSE_CALL                            operator = ( const LSTL_PAIR &_pSrc ) {
                                tKey = _pSrc.tKey;
                                vValues = _pSrc.vValues;
                                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(),
                                vValues() {
                        }
                } * LPLSTL_PAIR, * const LPCLSTL_PAIR;

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

        };

}       // namespace lstl

#pragma warning( pop )

#endif  // __LSTL_MULTIMAP_H__