/*

* 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:  Common utility functions

*

*/

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

// Copies elements from one array of objects of type T  to another

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

//

template<typename T>

inline void CopyArrayL(const TArray<T>& aSrc, RArray<T>& aDest)

    {

    aDest.Reset();

    for (TInt i=0; i < aSrc.Count(); ++i)

        {

        aDest.AppendL(aSrc[i]);

        }

    }

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

// Copies elements from one array of descriptors to another

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

//

inline void CopyArrayL(const MDesCArray& aSrc, CDesCArray& aDest)

    {

    MPXUser::CopyArrayL(aSrc, aDest);

    }

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

// Transfer a buffer from server

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

//

inline void TransferBufferFromServerL(const RMPXSession& aSess,

                                      TInt aCmd,

                                      TInt aSize,

                                      CBufBase*& aBuffer)

    {

    delete aBuffer;

    aBuffer = NULL;

    if (aSize==0)

        {

        User::Leave(KErrArgument);

        }

    CBufBase* buffer = MPXUser::CreateBufferLC(aSize);

    TPtr8 ptr(buffer->Ptr(0));

    aSess.SendReceiveL(aCmd,TIpcArgs(&ptr));

    CleanupStack::Pop(buffer);

    aBuffer = buffer;

    }

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

// Internalize a pointer array from stream

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

//

template<typename T>

inline void InternalizeL(RPointerArray<T>& aArray, RReadStream& aStream)

    {

    TInt n=aStream.ReadInt32L();

    for (TInt i=0;i<n;++i)

        {

        T* entry = new (ELeave) T;

        CleanupStack::PushL(entry);

        aStream >> *entry;

        aArray.AppendL(entry);

        CleanupStack::Pop(entry);

        }

    }

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

// Internalize a pointer array from stream

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

//

template<typename T>

inline void InternalizeCObjectArrayL(

    RPointerArray<T>& aArray,

    RReadStream& aStream)

    {

    TInt n=aStream.ReadInt32L();

    for (TInt i=0;i<n;++i)

        {

        T* entry = T::NewL();

        CleanupStack::PushL(entry);

        aStream >> *entry;

        aArray.AppendL(entry);

        CleanupStack::Pop(entry);

        }

    }

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

// Internalize an array from stream

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

//

template<typename T>

inline void InternalizeL(RArray<T>& aArray, RReadStream& aStream)

    {

    TInt n=aStream.ReadInt32L();

    for (TInt i=0;i<n;++i)

        {

        TPckgBuf<T> item;

        aStream.ReadL(item);

        aArray.AppendL(item());

        }

    }

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

// Internalize a descriptor array from stream

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

//

inline void InternalizeL(CDesCArray& aArray, RReadStream& aStream)

    {

    TInt n=aStream.ReadInt32L();

    for (TInt i=0;i<n;++i)

        {

        TInt length=aStream.ReadInt32L();

        HBufC* item = HBufC::NewLC(length);

        TPtr ptr = item->Des();

        aStream.ReadL(ptr, length);

        aArray.AppendL(*item);

        CleanupStack::PopAndDestroy(item);

        }

    }

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

// Exernalize a pointer array to stream

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

//

template<typename T>

inline void ExternalizeL(const TArray<T*>& aArray, RWriteStream& aStream)

    {

    TInt len = aArray.Count();

    aStream.WriteInt32L(len);

    for(TInt i = 0;i<len;i++)

        {

        T &entry = *aArray[i];

        aStream << entry;

        }

    }

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

// Externalize an array to stream

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

//

template<typename T>

inline void ExternalizeL(const TArray<T>& aArray, RWriteStream& aStream)

    {

    TInt n=aArray.Count();

    aStream.WriteInt32L(n);

    for (TInt i=0;i<n;++i)

        {

        TPckgBuf<T> item(aArray[i]);

        aStream.WriteL(item);

        }

    }

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

// Externalize a descriptor array to stream

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

//

inline void ExternalizeL(const MDesCArray& aArray, RWriteStream& aStream)

    {

    TInt n=aArray.MdcaCount();

    aStream.WriteInt32L(n);

    for (TInt i=0;i<n;++i)

        {

        TInt length=aArray.MdcaPoint(i).Length();

        aStream.WriteInt32L(length);

        aStream.WriteL(aArray.MdcaPoint(i));

        }

    }

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

// Helper function to create an array from buf.

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

//

template<typename T>

inline void CreateFromBufferL(const CBufBase &aBuf, CArrayFix<T>*& aArray)

    {

    delete aArray;

    aArray = NULL;

    RBufReadStream rs(aBuf);

    CleanupClosePushL(rs);

    CArrayFix<T>* array=new(ELeave)CArrayFixFlat<T>(1); //magic number

    CleanupStack::PushL(array);

    rs >> *array;

    CleanupStack::Pop(array);

    aArray = array;

    CleanupStack::PopAndDestroy(&rs);

    }

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

// Helper function to create a descriptor array from buf.

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

//

inline void CreateFromBufferL(const CBufBase &aBuf, CDesCArray*& aArray)

    {

    delete aArray;

    aArray = NULL;

    RBufReadStream rs(aBuf);

    CleanupClosePushL(rs);

    CDesCArray* array=new(ELeave)CDesCArrayFlat(1); //magic number

    CleanupStack::PushL(array);

    InternalizeL(*array, rs);

    CleanupStack::Pop(array);

    aArray = array;

    CleanupStack::PopAndDestroy(&rs);

    }

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

// Helper function to create an array from buf.

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

//

template<typename T>

inline void CreateFromBufferL(const CBufBase &aBuf, RPointerArray<T>& aArray)

    {

    aArray.ResetAndDestroy();

    RBufReadStream rs(aBuf);

    CleanupClosePushL(rs);

    InternalizeL(aArray, rs);

    CleanupStack::PopAndDestroy(&rs);

    }

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

// Helper function to create an array from buf.

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

//

template<typename T>

inline void CreateFromBufferL(const CBufBase &aBuf, RArray<T>& aArray)

    {

    aArray.Reset();

    RBufReadStream rs(aBuf);

    CleanupClosePushL(rs);

    InternalizeL(aArray, rs);

    CleanupStack::PopAndDestroy(&rs);

    }

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

// Retrieves an object of from buffer

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

//

template<typename T>

inline void CreateFromBufferL(const CBufBase &aBuf, T*& aObject)

    {

    delete aObject;

    aObject = NULL;

    RBufReadStream rs(aBuf);

    CleanupClosePushL(rs);

    aObject=new(ELeave)T;

    CleanupStack::PushL(aObject);

    rs>>*aObject;

    CleanupStack::Pop(aObject);

    CleanupStack::PopAndDestroy(&rs);

    }

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

// Retrieves an object of from buffer

// Note: class T must implement T::NewL(RReadStream& aStream) constructor

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

//

template<typename T>

inline void NewFromBufferL(const CBufBase &aBuf, T*& aObject)

    {

    delete aObject;

    aObject = NULL;

    RBufReadStream rs(aBuf);

    CleanupClosePushL(rs);

    aObject=T::NewL();

    CleanupStack::PushL(aObject);

    rs>>*aObject;

    CleanupStack::Pop(aObject);

    CleanupStack::PopAndDestroy(&rs);

    }

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

// Retrieves an object of from message buffer

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

//

template<typename T>

inline void CreateFromMessageL(const RMessage2& aMessage,

                              TInt aMsgSlot,

                              T*& aObject)

    {

    CBufBase* buffer(NULL);

    MPXUser::CreateBufferL(aMessage, aMsgSlot, buffer);

    CleanupStack::PushL(buffer);

    CreateFromBufferL<T>(*buffer, aObject);

    CleanupStack::PopAndDestroy(buffer);

    }

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

// Retrieves an object of from message buffer

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

//

template<typename T>

inline void NewFromMessageL(const RMessage2& aMessage,

                            TInt aMsgSlot,

                            T*& aObject)

    {

    CBufBase* buffer(NULL);

    MPXUser::CreateBufferL(aMessage, aMsgSlot, buffer);

    CleanupStack::PushL(buffer);

    NewFromBufferL<T>(*buffer, aObject);

    CleanupStack::PopAndDestroy(buffer);

    }

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

// Copy an object into the buffer

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

//

template<typename T>

inline void CreateBufferL(const T& aObj, CBufBase*& aBuffer)

    {

    delete aBuffer;

    aBuffer = NULL;

    CBufBase* buffer = CBufFlat::NewL(KMPXBufGranularity);

    CleanupStack::PushL(buffer);

    RBufWriteStream ws(*buffer);

    CleanupClosePushL(ws);

    ws<<aObj;

    ws.CommitL();

    CleanupStack::PopAndDestroy(&ws);

    buffer->Compress();

    CleanupStack::Pop(buffer);

    aBuffer = buffer;

    }

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

// Create the buffer from an array

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

//

template<typename T>

inline void CreateBufferL(const TArray<T>& aArray, CBufBase*& aBuffer)

    {

    delete aBuffer;

    aBuffer = NULL;

    TInt size=aArray.Count()*sizeof(TPckgBuf<T>)+sizeof(TInt);

    CBufBase* buffer = MPXUser::CreateBufferLC(size);

    RBufWriteStream ws(*buffer);

    CleanupClosePushL(ws);

    ExternalizeL(aArray, ws);

    ws.CommitL();

    CleanupStack::PopAndDestroy(&ws);

    buffer->Compress();

    CleanupStack::Pop(buffer);

    aBuffer = buffer;

    }

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

// Create the buffer from an array of object

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

//

template<typename T>

inline void CreateBufferL(const TArray<T*>& aArray, CBufBase*& aBuffer)

    {

    delete aBuffer;

    aBuffer = NULL;

    CBufBase* buffer = CBufFlat::NewL(KMPXBufGranularity);

    CleanupStack::PushL(buffer);

    RBufWriteStream ws(*buffer);

    CleanupClosePushL(ws);

    ExternalizeL(aArray, ws);

    ws.CommitL();

    CleanupStack::PopAndDestroy(&ws);

    buffer->Compress();

    CleanupStack::Pop(buffer);

    aBuffer = buffer;

    }

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

// Copy an array from the server

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

//

template<typename T>

void ArrayFromServerL(const RMPXSession& aSess,

                      TInt aCmd,

                      TInt aSize,

                      CArrayFixBase*& aArray)

    {

    delete aArray;

    aArray = NULL;

    CBufBase* buffer(NULL);

    TransferBufferFromServerL(aSess, aCmd, aSize, buffer);

    if (!buffer)

        {

        CleanupStack::PushL(buffer);

        CArrayFix<T>* array = NULL;

        CreateFromBufferL<T>(*buffer, array);

        aArray = array;

        CleanupStack::PopAndDestroy(buffer);

        }

    }

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

// Copy an array from the server

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

//

template<typename T>

void ArrayFromServerL(const RMPXSession& aSess,

                      TInt aCmd,

                      TInt aSize,

                      RPointerArray<T>& aArray)

    {

    CBufBase* buffer(NULL);

    TransferBufferFromServerL(aSess, aCmd, aSize, buffer);

    CleanupStack::PushL(buffer);

    CreateFromBufferL<T>(*buffer, aArray);

    CleanupStack::PopAndDestroy(buffer);

    }

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

// Copy an array from the server

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

//

template<typename T>

void ArrayFromServerL(const RMPXSession& aSess,

                      TInt aCmd,

                      TInt aSize,

                      RArray<T>& aArray)

    {

    CBufBase* buffer(NULL);

    TransferBufferFromServerL(aSess, aCmd, aSize, buffer);

    CleanupStack::PushL(buffer);

    CreateFromBufferL<T>(*buffer, aArray);

    CleanupStack::PopAndDestroy(buffer);

    }

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

//  Packages an object of type T into a descriptor and writes back to the

//  client space in message slot aMsgSlot of aMessage.

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

//

template<typename T> void WriteL(const RMessage2& aMessage,

                                 TInt aMsgSlot,T aValue)

    {

    TPckgC<T> value(aValue);

    aMessage.WriteL(aMsgSlot,value);

    }

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

// Default constructor

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

//

template <class T>

inline RMPXPointerArray<T>::RMPXPointerArray()

        {

        }

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

// Closes the array and frees all resources;

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

//

template <class T>

inline void RMPXPointerArray<T>::Close()

        {

        this->ResetAndDestroy();

        RPointerArray<T>::Close();

        }

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

// Destructor

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

//

template <class T>

inline RMPXPointerArray<T>::~RMPXPointerArray()

    {

    Close();

    }

template<typename T>

inline void DeleteL(const T* aItem, RPointerArray<T>& aArray)

    {

    TInt index = aArray.FindL(aItem);

    aArray.Remove(index);

    delete aItem;

    }

// End of file