F:/My Projects/LSEngine/Modules/LSTL/Src/Set/LSTLSet.h

#ifndef __LSTL_SET_H__
#define __LSTL_SET_H__

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

#pragma warning( push )

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

namespace lstl {

        template <typename _tKeyType>
        class CSet : protected CSetBase {
        public :
                // == Various constructors.
                LSE_CALL                                                                CSet() {
                }
                explicit LSE_CALL                                               CSet( const CSet<_tKeyType> &_sSrc ) :
                        m_vKeys( _sSrc.m_vKeys ) {
                }
                explicit LSE_CALL                                               CSet( CAllocator * _paAllocator ) :
                        m_vKeys( _paAllocator ) {
                }
                LSE_CALL                                                                ~CSet() {
                }


                // == Operators.
                CSet<_tKeyType> & LSE_CALL                              operator = ( const CSet<_tKeyType> &_sSrc ) {
                        // The copy is as easy as copying the vector.
                        m_vKeys = _sSrc.m_vKeys;
                        return (*this);
                }


                // == Functions.
                LSBOOL LSE_CALL                                                 AllocateAtLeast( LSUINT32 _ui32Size ) {
                        if ( m_vKeys.GetAllocated() >= _ui32Size ) { return true; }
                        return m_vKeys.Allocate( _ui32Size );
                }

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

                LSBOOL LSE_CALL                                                 Insert( const _tKeyType &_tKey ) {
                        LSUINT32 ui32Index;
                        if ( !GetItemIndex( _tKey, ui32Index ) ) {
                                // Insert the item at the given index.
                                if ( !m_vKeys.Insert( _tKey, ui32Index ) ) {
                                        return false;
                                }
                        }
                        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_vKeys.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_vKeys.Remove( ui32Index );
                        }
                }

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

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

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

                const _tKeyType & LSE_CALL                              GetByIndex( LSUINT32 _ui32Index ) const {
                        return m_vKeys[_ui32Index];
                }

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

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

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

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

        protected :
                // == Members.
                CVector<_tKeyType, LSUINT32>                    m_vKeys;

        };

}       // namespace lstl

#pragma warning( pop )

#endif  // __LSTL_SET_H__