/*
* 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:  Implementation of array of fixed size elements on global chunk
*
*/


// -----------------------------------------------------------------------------
// RMPXFixedArrayBase::Close
// -----------------------------------------------------------------------------
//
inline void RMPXFixedArrayBase::Close(TUint aClientHandle)
    {
    Reset(aClientHandle);
    }

// -----------------------------------------------------------------------------
// RMPXFixedArrayBase::Buf
// -----------------------------------------------------------------------------
//
inline TAny* RMPXFixedArrayBase::Buf(TUint aClientHandle) const
    {
    return RMPXHeapManager::Ptr<TAny>(aClientHandle,iDataOffset);
    }

// -----------------------------------------------------------------------------
// RMPXFixedArrayBase::Count
// -----------------------------------------------------------------------------
//
inline TInt RMPXFixedArrayBase::Count() const
    {
    return iCount;
    }

// -----------------------------------------------------------------------------
// RMPXFixedArray::RMPXFixedArray
// -----------------------------------------------------------------------------
//
template <class T>
inline RMPXFixedArray<T>::RMPXFixedArray(const RMPXFixedArray<T>& aArray)
    : RMPXFixedArrayBase(aArray,sizeof(T))
    {      
    }

// -----------------------------------------------------------------------------
// RMPXFixedArray::RMPXFixedArray
// -----------------------------------------------------------------------------
//
template <class T>
inline RMPXFixedArray<T>::RMPXFixedArray()
    : RMPXFixedArrayBase(sizeof(T))
    {    
    }

// -----------------------------------------------------------------------------
// RMPXFixedArray::Copy
// -----------------------------------------------------------------------------
//
template <class T>
inline TInt RMPXFixedArray<T>::Copy(TUint aClientHandle,const TArray<T>& aArray)
    {   
    TInt n=aArray.Count();
    T* ptr=(T*)RMPXFixedArrayBase::Alloc(aClientHandle,n);
    if (ptr)
        {        
        for (TInt i=0;i<n;++i)
            {
            *ptr++=aArray[i];
            }
        }
    MPX_ASSERT(ptr);
    return ptr?KErrNone:KErrNoMemory; 
    }

// -----------------------------------------------------------------------------
// RMPXFixedArray::Array
// -----------------------------------------------------------------------------
//
template <class T>
inline TArray<T> RMPXFixedArray<T>::Array(TUint aClientHandle) const
    {
    TInt thisOffset=RMPXHeapManager::Offset(aClientHandle,(TAny*)this);
    return TArray<T>(CountFunctionR,AtFunctionR,reinterpret_cast<const CBase*>(thisOffset));
    }

// -----------------------------------------------------------------------------
// RMPXFixedArray::CountFunctionR
// -----------------------------------------------------------------------------
//
template <class T>
inline TInt RMPXFixedArray<T>::CountFunctionR(const CBase* aThis)
    {
    // Non-optimal, obtaining client handle every time count is accessed, however
    // there's no choice since the data could be shared by multiple threads and the
    // function signature does not allow the handle to be passed through
    //
    TInt offset=reinterpret_cast<TInt>(aThis);
    TInt ch=RMPXHeapManager::ClientHandle();    
    const RMPXFixedArrayBase* arr=RMPXHeapManager::Ptr<RMPXFixedArrayBase>(ch,offset);
    return arr->Count();
    }

// -----------------------------------------------------------------------------
// RMPXFixedArray::AtFunctionR
// -----------------------------------------------------------------------------
//
template <class T>
inline const TAny* RMPXFixedArray<T>::AtFunctionR(const CBase* aThis,TInt aIndex)
    { 
    // Non-optimal, obtaining client handle every time data is accessed, however
    // there's no choice since the data could be shared by multiple threads and the
    // function signature does not allow the handle to be passed through
    //
    TInt offset=reinterpret_cast<TInt>(aThis);
    TInt ch=RMPXHeapManager::ClientHandle(); 
    const RMPXFixedArrayBase* arr=RMPXHeapManager::Ptr<RMPXFixedArrayBase>(ch,offset);   
    T* ptr=(T*)arr->Buf(ch);
    return &ptr[aIndex];
    }

// End of file