F:/My Projects/LSEngine/Modules/LSMemLib/Src/Allocators/LSAStdAllocator.h

#ifndef __LSA_STDALLOCATOR_H__
#define __LSA_STDALLOCATOR_H__

#include "../OSHeap/LSAOsHeap.h"
#ifndef LSA_DEBUG
#include "LSASmallAllocator.h"
#endif  // #ifndef LSA_DEBUG
#include "LSAStdAllocatorHeap.h"
#include <new>

#pragma warning( push )

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


namespace lsa {

        class CStdAllocator {
        protected :
                friend class CMemLib;
                // == Various constructors.
                LSE_CALL                                                                        CStdAllocator();
                LSE_CALL                                                                        ~CStdAllocator();


        public :
                // == Functions.
                LSVOID * LSE_CALL                                                       Alloc( LSA_SIZE _sSize, LSUINT32 _ui32Align = 16UL                                              LSA_DEBUGPARMSDECL );

                LSVOID * LSE_CALL                                                       CAlloc( LSA_SIZE _sSize, LSUINT32 _ui32Align = 16UL                                             LSA_DEBUGPARMSDECL );

                LSE_INLINE LSBOOL LSE_CALL                                      Free( LSVOID * _pvAddr );

                LSVOID * LSE_CALL                                                       ReAlloc( LSVOID * _pvAddr, LSA_SIZE _sSize                                                              LSA_DEBUGPARMSDECL );

                LSBOOL LSE_CALL                                                         Clear();

                LSE_INLINE LSVOID LSE_CALL                                      Trash();
                
                LSVOID LSE_CALL                                                         ReleaseEmptyHeaps();

                LSA_SIZE LSE_CALL                                                       PrintAllocations( LSUINT32 _ui32Count = 0UL, LSUINT32 _ui32End = 0xFFFFFFFFUL ) const;

                LSA_SIZE LSE_CALL                                                       GetTotalAllocatedSize();

#ifdef LSA_DEBUG

                LSVOID LSE_CALL                                                         VerifyBlocks() const;
#endif  // #ifdef LSA_DEBUG
                
        protected :
                LSBOOL LSE_CALL                                                         SetSize( LSA_SIZE _sSize, LSBOOL _bGrowable );

                LSBOOL LSE_CALL                                                         AddBlock( LSA_SIZE _sSize );

#ifndef LSA_DEBUG

                LSBOOL LSE_CALL                                                         AddSmallAllocator();
#endif  // #ifndef LSA_DEBUG

                LSE_INLINE static LSVOID * LSE_CALL                     GetStartAddress( const CStdAllocatorHeap * _psahBlock );

                LSE_INLINE static LSA_SIZE LSE_CALL                     GetMinSizeOfBlock( const CStdAllocatorHeap * _psahBlock );

                LSE_INLINE LSVOID * LSE_CALL                            AllocInternal( LSA_SIZE _sSize, LSUINT32 _ui32Align                                             LSA_DEBUGPARMSDECL );

#ifndef LSA_DEBUG

                LSE_INLINE LSVOID * LSE_CALL                            AllocInternalSmall( LSA_SIZE _sSize, LSUINT32 _ui32Align );
#endif  // #ifndef LSA_DEBUG

                LSVOID * LSE_CALL                                                       ReAllocInternal( CStdAllocatorHeap::LPLSA_ALLOCATIONHEADER &_lpahBlock, LSVOID * _pvAddr, LSA_SIZE _sSize               LSA_DEBUGPARMSDECL );

                // == Members.
                // Thread safety.
                mutable CCriticalSection                                        m_csCrit;

                // Linked list of blocks.
                CStdAllocatorHeap *                                                     m_psahHead;

#ifndef LSA_DEBUG
                // Linked list of small blocks.
                CSmallAllocator *                                                       m_psaSmallHead;
#endif  // #ifndef LSA_DEBUG

                // Total size of the heap.
                LSA_SIZE                                                                        m_sSize;
                // Can the heap grow?
                LSBOOL                                                                          m_bGrowable;

                // Range of addresses covered by this object.
                LSA_SIZE                                                                        m_sLow,
                                                                                                        m_sHi;
        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Functions.
        LSE_INLINE LSBOOL LSE_CALL CStdAllocator::Free( LSVOID * _pvAddr ) {
                if ( !_pvAddr ) { return true; }
                CCriticalSection::CLocker lLock( m_csCrit );
                // Quick range check.
                LSA_SIZE sThis = reinterpret_cast<LSA_SIZE>(_pvAddr);
                if ( sThis < m_sLow || sThis >= m_sHi ) { return false; }
#ifndef LSA_DEBUG
                // Check small heaps.
                for ( CSmallAllocator * psaThis = m_psaSmallHead; psaThis; psaThis = psaThis->m_psaNext ) {
                        if ( psaThis->HaveAddress( _pvAddr ) ) {
                                return psaThis->Free( _pvAddr );
                        }
                }
#endif  // #ifndef LSA_DEBUG

                for ( CStdAllocatorHeap * psahThis = m_psahHead; psahThis; psahThis = psahThis->m_psahNext ) {
                        if ( psahThis->Free( _pvAddr ) ) { return true; }
                }
                return false;
        }

        LSE_INLINE LSVOID LSE_CALL CStdAllocator::Trash() {
                CCriticalSection::CLocker lLock( m_csCrit );
                for ( CStdAllocatorHeap * psahThis = m_psahHead; psahThis; psahThis = psahThis->m_psahNext ) {
                        psahThis->Trash();
                }
#ifndef LSA_DEBUG
                for ( CSmallAllocator * psaThis = m_psaSmallHead; psaThis; psaThis = psaThis->m_psaNext ) {
                        psaThis->Trash();
                }
#endif  // #ifndef LSA_DEBUG
        }

        LSE_INLINE LSVOID * LSE_CALL CStdAllocator::GetStartAddress( const CStdAllocatorHeap * _psahBlock ) {
                LSA_SIZE sStart = reinterpret_cast<LSA_SIZE>(_psahBlock);
                sStart += sizeof( CStdAllocatorHeap );
                sStart = CStdAllocatorHeap::RoundUp( sStart );
                return reinterpret_cast<LSVOID *>(sStart);
        }

        LSE_INLINE LSA_SIZE LSE_CALL CStdAllocator::GetMinSizeOfBlock( const CStdAllocatorHeap * _psahBlock ) {
                LSA_SIZE sStart = reinterpret_cast<LSA_SIZE>(_psahBlock);
                LSA_SIZE sEnd = reinterpret_cast<LSA_SIZE>(GetStartAddress( _psahBlock ));
                // Must have enough space for an allocation-block header and 4 allocation units.
                sEnd += LSA_MIN_ALIGN * 4 + sizeof( CStdAllocatorHeap::LSA_ALLOCATIONHEADER );
                return CStdAllocatorHeap::RoundUp( sEnd ) - sStart;
        }

        LSE_INLINE LSVOID * LSE_CALL CStdAllocator::AllocInternal( LSA_SIZE _sSize, LSUINT32 _ui32Align                                 LSA_DEBUGPARMSDEF ) {
                // Find a block that manages to allocate it.
                for ( CStdAllocatorHeap * psahThis = m_psahHead; psahThis; psahThis = psahThis->m_psahNext ) {
                        LSVOID * pvRet = psahThis->Alloc( _sSize, _ui32Align LSA_DEBUGPARMSPASS );
                        if ( pvRet ) { return pvRet; }
                }
                // No blocks could allocate it.  Fail.
                return NULL;
        }

#ifndef LSA_DEBUG

        LSE_INLINE LSVOID * LSE_CALL CStdAllocator::AllocInternalSmall( LSA_SIZE _sSize, LSUINT32 _ui32Align ) {
                // Find a block that manages to allocate it.
                for ( CSmallAllocator * psaThis = m_psaSmallHead; psaThis; psaThis = psaThis->m_psaNext ) {
                        LSVOID * pvRet = psaThis->Alloc( _sSize, _ui32Align );
                        if ( pvRet ) { return pvRet; }
                }
                // No blocks could allocate it.  Fail.
                return NULL;
        }
#endif  // #ifndef LSA_DEBUG

}       // namespace lsa

#pragma warning( pop )

#endif  // __LSA_STDALLOCATOR_H__