F:/My Projects/LSEngine/Modules/LSMemLib/Src/LSAMemLib.h

#ifndef __LSA_MEMLIB_H__
#define __LSA_MEMLIB_H__

#include "OSHeap/LSAOsHeap.h"
#include "Allocators/LSAStdAllocator.h"


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// MACROS
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// It is better to call the full version of new, as:
//      new( __FILE__, __LINE__ ).
// Use the LSENEW macro to make this easier.
#define LSENEW                                                                          new( __FILE__, __LINE__ )
#define LSEDELETE                                                                       delete

#if !defined( __CRTDECL )
#define __CRTDECL
#endif  // #if !defined( __CRTDECL )

namespace lsa {

        class CMemLib {
        public :
                // == Functions.
                static LSBOOL LSE_CALL                                          Init( LSA_SIZE _sDefaultSize, LSBOOL _bGrowable );

                static LSVOID LSE_CALL                                          Destroy();

                static CStdAllocator * LSE_CALL                         GetAllocatorD( LSA_SIZE _sDefaultSize, LSBOOL _bGrowable LSA_DEBUGPARMSDECL );

                static LSBOOL LSE_CALL                                          DestroyAllocator( CStdAllocator * _psaAllocator );

                static LSVOID * LSE_CALL                                        AllocD( LSA_SIZE _sSize, LSUINT32 _ulAlign = 0 LSA_DEBUGPARMSDECL );

                static LSVOID * LSE_CALL                                        CAllocD( LSA_SIZE _sSize, LSUINT32 _ulAlign = 0 LSA_DEBUGPARMSDECL );

                static LSBOOL LSE_CALL                                          Free( LSVOID * _pvAddr );

                static LSVOID * LSE_CALL                                        ReAllocD( LSVOID * _pvAddr, LSA_SIZE _sSize LSA_DEBUGPARMSDECL );
                
                static LSBOOL LSE_CALL                                          Ready();
                
                static LSVOID LSE_CALL                                          ReleaseEmptyPools();

                static LSUINT32 LSE_CALL                                        GetAllocationCounter();

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

                static LSA_SIZE LSE_CALL                                        GetTotalAllocatedSize();

                template <class _cType>
                static _cType * LSE_CALL                                        New( CStdAllocator * _psaAllocator LSA_DEBUGPARMSDECL );

                template <class _cType>
                static LSVOID LSE_CALL                                          Delete( CStdAllocator * _psaAllocator, _cType * _pcObject );

#ifdef LSA_DEBUG
                static CStdAllocator * LSE_CALL                         GetThisAllocator()                                      { return &m_saAllocator; }
#endif  // #ifdef LSA_DEBUG

#ifdef LSA_DEBUG
#define MAllocAligned( _sSize, _ulAlign )                       AllocD( _sSize, _ulAlign, __FILE__, __LINE__ )
#define MAlloc( _sSize )                                                        AllocD( _sSize, 0, __FILE__, __LINE__ )
#define CMAllocAligned( _sSize, _ulAlign )                      CAllocD( _sSize, _ulAlign, __FILE__, __LINE__ )
#define CMAlloc( _sSize )                                                       CAllocD( _sSize, 0, __FILE__, __LINE__ )
#define MReAlloc( _pvAddr, _sSize )                                     ReAllocD( _pvAddr, _sSize, __FILE__, __LINE__ )
#define MGetAllocator( _sDefaultSize, _bGrowable )      GetAllocatorD( _sDefaultSize, _bGrowable, __FILE__, __LINE__ )
#define MNew( _psaAllocator, _cType )                           New<_cType>( _psaAllocator, __FILE__, __LINE__ )
#define MDelete( _psaAllocator, _cType, _pcObject )     Delete<_cType>( _psaAllocator, _pcObject )
#else   // #ifdef LSA_DEBUG
#define MAllocAligned( _sSize, _ulAlign )                       AllocD( _sSize, _ulAlign )
#define MAlloc( _sSize )                                                        AllocD( _sSize, 0 )
#define CMAllocAligned( _sSize, _ulAlign )                      CAllocD( _sSize, _ulAlign )
#define CMAlloc( _sSize )                                                       CAllocD( _sSize, 0 )
#define MReAlloc( _pvAddr, _sSize )                                     ReAllocD( _pvAddr, _sSize )
#define MGetAllocator( _sDefaultSize, _bGrowable )      GetAllocatorD( _sDefaultSize, _bGrowable )
#define MNew( _psaAllocator, _cType )                           New<_cType>( _psaAllocator )
#define MDelete( _psaAllocator, _cType, _pcObject )     Delete<_cType>( _psaAllocator, _pcObject )
#endif  // #ifdef LSA_DEBUG

        private :
                // == Members.
                static CStdAllocator                                            m_saAllocator;
                
                static LSBOOL                                                           m_bAllocatorReady;
        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Functions.
        LSE_INLINE LSBOOL LSE_CALL CMemLib::Ready() {
                return m_bAllocatorReady;
        }

        template <class _cType> _cType * LSE_CALL CMemLib::New( CStdAllocator * _psaAllocator LSA_DEBUGPARMSDEF ) {
                if ( !_psaAllocator ) { return LSENEW _cType(); }
                LSVOID * pvNew = _psaAllocator->Alloc( sizeof( _cType ), 16UL LSA_DEBUGPARMSPASS );
                if ( !pvNew ) { return NULL; }
                return new( pvNew ) _cType();
        }

        template <class _cType> LSVOID LSE_CALL CMemLib::Delete( CStdAllocator * _psaAllocator, _cType * _pcObject ) {
                if ( !_pcObject ) { return; }
                if ( !_psaAllocator ) {
                        LSEDELETE _pcObject;
                        return;
                }
                _pcObject->~_cType();
                _psaAllocator->Free( _pcObject );
        }

}       // namespace lsa


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// OVERRIDES
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
#ifdef __GNUC__
#define LSA_THROW                                                                       throw()
#define LSA_THROW_BAD                                                           throw( std::bad_alloc )
#else
#define LSA_THROW                                                                       
#define LSA_THROW_BAD                                                           
#endif  // #ifdef __GNUC__
// Standard new.
void * __CRTDECL                                                                        operator new( size_t _stSize, const LSCHAR * _pcFile, lsstd::LSUINT32 _ui32Line );
void * __CRTDECL                                                                        operator new( size_t _stSize ) LSA_THROW_BAD;
// Standard delete.
void __CRTDECL                                                                          operator delete( void * _pvAddr, const LSCHAR * _pcFile, lsstd::LSUINT32 _ui32Line );
void __CRTDECL                                                                          operator delete( void * _pvAddr ) LSA_THROW;

// Array new.
void * __CRTDECL                                                                        operator new [] ( size_t _stSize, const LSCHAR * _pcFile, lsstd::LSUINT32 _ui32Line );
void * __CRTDECL                                                                        operator new [] ( size_t _stSize ) LSA_THROW_BAD;
// Array delete.
void __CRTDECL                                                                          operator delete [] ( void * _pvAddr, const LSCHAR * _pcFile, lsstd::LSUINT32 _ui32Line );
void __CRTDECL                                                                          operator delete [] ( void * _pvAddr ) LSA_THROW;

// No-throw new.
void * __CRTDECL                                                                        operator new( size_t _stSize, const std::nothrow_t &_tNoThrow, const LSCHAR * _pcFile, lsstd::LSUINT32 _ui32Line );
void * __CRTDECL                                                                        operator new( size_t _stSize, const std::nothrow_t &_tNoThrow ) LSA_THROW;
// No-throw delete.
void __CRTDECL                                                                          operator delete( void * _pvAddr, const std::nothrow_t &_tNoThrow, const LSCHAR * _pcFile, lsstd::LSUINT32 _ui32Line );
void __CRTDECL                                                                          operator delete( void * _pvAddr, const std::nothrow_t &_tNoThrow ) LSA_THROW;

// Array no-throw new.
void * __CRTDECL                                                                        operator new [] ( size_t _stSize, const std::nothrow_t &_tNoThrow, const LSCHAR * _pcFile, lsstd::LSUINT32 _ui32Line );
void * __CRTDECL                                                                        operator new [] ( size_t _stSize, const std::nothrow_t &_tNoThrow ) LSA_THROW;
// Array no-throw delete.
void __CRTDECL                                                                          operator delete [] ( void * _pvAddr, const std::nothrow_t &_tNoThrow, const LSCHAR * _pcFile, lsstd::LSUINT32 _ui32Line );
void __CRTDECL                                                                          operator delete [] ( void * _pvAddr, const std::nothrow_t &_tNoThrow ) LSA_THROW;

#endif  // __LSA_MEMLIB_H__