/*
* Copyright (c) 2003 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 various helper functions used for
*                serialization.
*
*/


/////////////////////////////////////////////////////////////////////
// RPointerArray utilities
/////////////////////////////////////////////////////////////////////

// -----------------------------------------------------------------------------
// CopyPointerArrayL
// -----------------------------------------------------------------------------
//
template <class T>
void CopyPointerArrayL(RPointerArray<T>& aNew, const RPointerArray<T>& aOld)
{
    for (TInt i = 0; i < aOld.Count(); ++i)
    {
        T* item = TTraits<T>::CopyLC(*aOld[i]);
        User::LeaveIfError(aNew.Append(item));
        CleanupStack::Pop(item);
    }
}

// -----------------------------------------------------------------------------
// ExternalizePointerArrayL
// -----------------------------------------------------------------------------
//
template <class T>
void ExternalizePointerArrayL(const RPointerArray<T>& aArray,
                              RWriteStream& aStream)
{
    aStream.WriteInt32L(aArray.Count());
    for (TInt i = 0; i < aArray.Count(); ++i)
    {
        TTraits<T>::WriteToStreamL(*aArray[i], aStream);
    }
}

// -----------------------------------------------------------------------------
// InternalizePointerArrayL
// -----------------------------------------------------------------------------
//
template <class T>
void InternalizePointerArrayL(RPointerArray<T>& aArray, RReadStream& aStream)
{
    TInt count = aStream.ReadInt32L();
    for (TInt i = 0; i < count; ++i)
    {
        T* item = TTraits<T>::ReadFromStreamLC(aStream);
        User::LeaveIfError(aArray.Append(item));
        CleanupStack::Pop(item);
    }
}

// -----------------------------------------------------------------------------
// PointerArraySizeForStreamingL
// -----------------------------------------------------------------------------
//
template <class T>
TInt PointerArraySizeForStreamingL(const RPointerArray<T>& aArray)
{
    TInt size = sizeof(TInt32);
    for (TInt i = aArray.Count(); 0 < i;)
    {
        size += TTraits<T>::SizeForStreamingL(*aArray[--i]);
    }
    return size;
}

/////////////////////////////////////////////////////////////////////
// RArray utilities
/////////////////////////////////////////////////////////////////////

// -----------------------------------------------------------------------------
// CopyArrayL
// -----------------------------------------------------------------------------
//
template <class T>
void CopyArrayL(RArray<T>& aNew, const RArray<T>& aOld)
{
    for (TInt i = 0; i < aOld.Count(); ++i)
    {
        User::LeaveIfError(aNew.Append(aOld[i]));
    }
}

// -----------------------------------------------------------------------------
// ExternalizeArrayL
// -----------------------------------------------------------------------------
//
template <class T>
void ExternalizeArrayL(const RArray<T>& aArray, RWriteStream& aStream)
{
    aStream.WriteInt32L(aArray.Count());
    for (TInt i = 0; i < aArray.Count(); ++i)
    {
        aStream.WriteL(TPckgC<T>(aArray[i]));
    }
}

// -----------------------------------------------------------------------------
// InternalizeArrayL
// -----------------------------------------------------------------------------
//
template <class T>
void InternalizeArrayL(RArray<T>& aArray, RReadStream& aStream)
{
    TInt count = aStream.ReadInt32L();
    for (TInt i = 0; i < count; ++i)
    {
        T item;
        TPckg<T> itemPckg(item);
        aStream.ReadL(itemPckg);
        User::LeaveIfError(aArray.Append(item));
    }
}

// -----------------------------------------------------------------------------
// ArraySizeForStreamingL
// -----------------------------------------------------------------------------
//
template <class T>
TInt ArraySizeForStreamingL(const RArray<T>& aArray)
{
    return sizeof(TInt32) + aArray.Count() * sizeof(T);
}