/*

* 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 "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:  Inline implementation of heap manager 

*

*/

#include <mpxuser.h>

// -----------------------------------------------------------------------------

// Client handle

// -----------------------------------------------------------------------------

//

inline TUint RMPXHeapManager::ClientHandle(TUint8* aBase,TInt aClientIndex)

    { 

    // We assume here that the chunk base address ends in 0x00 so we can put the client

    // index at this location, so we must make sure that is true, and that there are

    // no more clients than will fit, i.e. 0xff (255)

    // 

    MPX_ASSERT(aBase&&aClientIndex>=0&&aClientIndex<ENumClients);

    MPX_ASSERT(((TUint)aBase&0xff)==0);

    TUint h=(TUint)aBase|aClientIndex;

    MPX_ASSERT((h&0xff)==aClientIndex);

    MPX_ASSERT(reinterpret_cast<TUint8*>(h&0xffffff00)==aBase);

    return h; 

    }

// -----------------------------------------------------------------------------

// Client index

// -----------------------------------------------------------------------------

// 

inline TInt RMPXHeapManager::ClientIndex(TUint aClientHandle)

    { 

    MPX_ASSERT(aClientHandle);

    return aClientHandle&0xff; 

    }

// -----------------------------------------------------------------------------

// Chunk Base

// -----------------------------------------------------------------------------

// 

inline TUint8* RMPXHeapManager::ChunkBase(TUint aClientHandle)

    { 

    MPX_ASSERT(aClientHandle);

    return reinterpret_cast<TUint8*>(aClientHandle&0xffffff00); 

    }

// -----------------------------------------------------------------------------

// Absolute pointer to T (thread relative)

// -----------------------------------------------------------------------------

//

template<typename T>  

inline T* RMPXHeapManager::Ptr(TUint aClientHandle,TInt aOffset)

    { 

    T* ptr=reinterpret_cast<T*>(ChunkBase(aClientHandle)+aOffset);

    MPX_ASSERT(aOffset==((TUint8*)ptr-ChunkBase(aClientHandle))); 

    return ptr; 

    }

// -----------------------------------------------------------------------------

// Relative offset from absolute pointer

// -----------------------------------------------------------------------------

//

inline TInt RMPXHeapManager::Offset(TUint aClientHandle,TAny* aPtr)

    { 

    TInt o=((TUint8*)aPtr-ChunkBase(aClientHandle));

    MPX_ASSERT(aPtr==reinterpret_cast<TAny*>(ChunkBase(aClientHandle)+o));

    return o; 

    }

// -----------------------------------------------------------------------------

// RMPXHeapManager::HeapManager

// -----------------------------------------------------------------------------

//

inline RMPXHeapManager& RMPXHeapManager::HeapManager(TUint aClientHandle)

    { return *Ptr<RMPXHeapManager>(aClientHandle); }

// -----------------------------------------------------------------------------

// Frees an offset on the chunk

// -----------------------------------------------------------------------------

//

inline TInt RMPXHeapManager::Free(TUint aClientHandle,TInt aOffset)

    {

    return Free(aClientHandle,Ptr<TAny>(aClientHandle,aOffset));

    }

// -----------------------------------------------------------------------------

// Allocate an object on the chunk

// -----------------------------------------------------------------------------

//

template<typename T> 

inline T* RMPXHeapManager::Alloc(TUint aClientHandle)

    {

    T* obj=NULL;

    TAny* ptr=Alloc(aClientHandle,sizeof(T));

    if (ptr)

        {

        obj=new(ptr)T;

        }

    MPX_ASSERT_WORD_ALIGNED(obj);

    return obj;

    }

// -----------------------------------------------------------------------------

// Copy a buffer on the chunk

// -----------------------------------------------------------------------------

//

inline TInt RMPXHeapManager::Copy(TUint aClientHandle,TInt aSrcOffset,TInt aSize)

    {

    return Copy(aClientHandle,RMPXHeapManager::Ptr<TAny>(aClientHandle,aSrcOffset),aSize);

    }

// End of file