/*
* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  
*
*
*/
#include "FastAllocator.h"
#include "MemoryManager.h"
#include "MemoryPool.h"

EXPORT_C RFastAllocator::RFastAllocator(CFastMemoryPool* aPool) : iHeap( User::Heap() ), iPool( aPool )
{
    iHeapBase = (TUint32)iHeap.Base() & 0xffff0000;
}

EXPORT_C RFastAllocator::~RFastAllocator()
{
}


EXPORT_C TAny* RFastAllocator::Alloc(TInt aSize)
{
    return iPool->Allocate( aSize );
}

EXPORT_C void RFastAllocator::Free(TAny* aPtr)
{
    // make sure we go to the right memory pool
    if( IsLocatedInHeap( aPtr ) )
        iHeap.Free( aPtr );
    else
        iPool->Free( aPtr );
}

EXPORT_C TAny* RFastAllocator::ReAlloc(TAny* aPtr, TInt aSize, TInt aMode)
{
    TAny* p(NULL);
    TInt originalSize(0);
    
    // check the right memory pool
    if( IsLocatedInHeap( aPtr ) )
        {
        // allocate in memory manager's pool
        p = iPool->Allocate( aSize );
        TInt cpSize = iHeap.AllocLen( aPtr );
        originalSize = cpSize;
        cpSize = cpSize < aSize ? cpSize : aSize;
        memcpy( p, aPtr, cpSize );
        iHeap.Free( aPtr );
        }
    else
        {
        originalSize = iPool->MemorySize(aPtr);
        p = iPool->ReAllocate( aPtr, aSize );
        }

    // Handle aMode.
    // ENeverMove: Don't move memory on realloc, return NULL if it was moved.
    // EAllowMoveOnShrink: Allow moving memory on realloc when size requested
    //    is smaller, return NULL if moved and request size is greater (equal).
    if ( (aMode == ENeverMove && p != aPtr) ||
         (aMode == EAllowMoveOnShrink && originalSize >= aSize && p != aPtr) )
        {
        Free(p);
        return NULL;
        }

    return p;
}

EXPORT_C TInt RFastAllocator::AllocLen(const TAny* aCell) const
{
    return iPool->MemorySize( (void*)(aCell) );
}

EXPORT_C TInt RFastAllocator::Compress()
{
    // DO NOTHING
    return 0;
}

EXPORT_C void RFastAllocator::Reset()
{
    // DO NOTHING
}

EXPORT_C TInt RFastAllocator::AllocSize(TInt& aTotalAllocSize) const
{
    // allocated cell size
    aTotalAllocSize = 0;
    return 0;
}

EXPORT_C TInt RFastAllocator::Available(TInt& aBiggestBlock) const
{
    // make sure the caller is not scared of futher allocation
    aBiggestBlock = KMaxTInt;
    return KMaxTUint;
}

EXPORT_C TInt RFastAllocator::DebugFunction(TInt, TAny*, TAny*)
{
    return 0;
}

EXPORT_C TInt RFastAllocator::Extension_(TUint, TAny*&, TAny*)
{
    return 0;
}

TBool RFastAllocator::IsLocatedInHeap( TAny* aPtr ) const
{
    // Quick check first, the initial heap size is usually defined as
    // 0x5000. For memory cell allocated in this heap, it's address 
    // share the same upper 16 bits with heap base address.
    if( ((TUint32)aPtr & 0xffff0000) != iHeapBase ) return EFalse;

    // very rare case, check it anyway
    TUint32 top = iHeapBase + iHeap.Size();
    return ( (TUint32)aPtr >= iHeapBase && (TUint32)aPtr <= top );
}

// END OF FILE