/*

 * Copyright (c) 2008-2009 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: 

 * Implementation of utility functions for copying and streaming RArray/RpointerArray. 

 *

 */

 /**

  @file 

  @internalTechnology

  @released

 */

 #ifndef STREAMINGARRAY_INL

 #define STREAMINGARRAY_INL

 #include <s32mem.h>

 #include <scs/streamingarray.h>

 #include <scs/nullstream.h>

 #include <scs/streamingarray.h>

 // Traits classes - internally required by RArray/RPointerArray functions

 template <class T>

 class TTraits

 	{

 public:

 	static T* CopyL(const T& aRight) { return T::NewL(aRight);}

 	static T* ReadFromStreamL(RReadStream& aStream) { return T::NewL(aStream); }

 	static T* ReadFromStreamLC(RReadStream& aStream) { return T::NewLC(aStream); }

 	static void WriteToStreamL(const T& aItem, RWriteStream& aStream) { aStream << aItem; }

 	};

 // Specialisation for HBufC

 template <>

 class TTraits<HBufC16>

 	{

 public:

 	static HBufC16* CopyL(const HBufC16& aOther) { return aOther.AllocL();}

 	static HBufC16* ReadFromStreamL(RReadStream& aStream) { return HBufC16::NewL(aStream, KMaxTInt); }

 	static HBufC16* ReadFromStreamLC(RReadStream& aStream) { return HBufC16::NewLC(aStream, KMaxTInt); }

 	static void WriteToStreamL(const HBufC16& aItem, RWriteStream& aStream) { aStream << aItem; }

 	};

 template <>

 class TTraits<HBufC8>

 	{

 public:

 	static HBufC8* CopyL(const HBufC8& aOther) { return aOther.AllocL();}

 	static HBufC8* ReadFromStreamL(RReadStream& aStream) { return HBufC8::NewL(aStream, KMaxTInt); }

 	static HBufC8* ReadFromStreamLC(RReadStream& aStream) { return HBufC8::NewLC(aStream, KMaxTInt); }

 	static void WriteToStreamL(const HBufC8& aItem, RWriteStream& aStream) { aStream << aItem; }

 	};

 // Size calculator - internally required by RPointerArray functions

 template <typename T>

 TInt GetObjectBufferSizeL(const T& aObject)

 	{

 	TInt size(0);

 	RNullWriteStream nullstream;

 	CleanupClosePushL(nullstream);

 	nullstream << aObject;

 	nullstream.CommitL();

 	size = nullstream.BytesWritten();

 	CleanupStack::PopAndDestroy(&nullstream);

 	return size;

 	}

 template <class T>

 TInt ExternalizedBufferSizeL(const RPointerArray<T>& aArray)

 /**

 	Calculates how much buffer is required for a pointers array to be externalized.

 	@param aArray The pointer array whose buffer size will be calculated.

 	@return Returns the number of bytes occupied by the elements of the pointer array.

  */

 	{

 	TInt totalSize(1);	// 1-byte is reserved for the array count

 	TInt count = aArray.Count();

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

 			{

 			totalSize += GetObjectBufferSizeL(*aArray[i]);

 			}

 	return totalSize;

 	}

 // RPointerArray utilities

 template <class T>

 void CopyPointerArrayL(RPointerArray<T>& aTarget, const RPointerArray<T>& aSource)

 	{

 	TInt arrayCount =  aSource.Count();

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

 		{

 		T* item = TTraits<T>::CopyL(*aSource[i]);

 		CleanupStack::PushL(item);

 		User::LeaveIfError(aTarget.Append(item));

 		CleanupStack::Pop(item);

 		}

 	}

 template <class T>

 HBufC8* ExternalizePointersArrayLC(const RPointerArray<T>& aArray, TBool aAddLength)

 	{

 	TInt arraySize = ExternalizedBufferSizeL(aArray);

 	HBufC8 *arrayBuf = HBufC8::NewLC(arraySize + sizeof(TInt32));

 	TPtr8 arrayPtr(arrayBuf->Des());

 	RDesWriteStream stream(arrayPtr);

 	stream.PushL();

 	ExternalizePointersArrayL(aArray, stream, aAddLength);

 	stream.Pop();

 	stream.Release();

 	return arrayBuf;

 	}

 template <class T>

 void ExternalizePointersArrayL(const RPointerArray<T>& aArray, RWriteStream& aStream, TBool aAddLength)

 	{

 	TInt arrayCount = aArray.Count();

 	if(aAddLength)

 		aStream << TCardinality(arrayCount);

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

 		{

 		TTraits<T>::WriteToStreamL(*aArray[i], aStream);

 		}

 	aStream.CommitL();

 	}

 template <class T>

 void InternalizePointersArrayL(RPointerArray<T>& aArray, RReadStream& aStream, TBool aAddLength)

 	{

 	TInt count (0);

 	if(aAddLength)

 		{

 		TCardinality c;

 		aStream >> c;

 		count = c;

 		}

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

 		{

 		T* item = TTraits<T>::ReadFromStreamL(aStream);

 		CleanupStack::PushL(item);

 		User::LeaveIfError(aArray.Append(item));

 		CleanupStack::Pop(item);

 		}

 	}

 // Size calculator - internally required by RArray/RPointerArray functions

 template <class T>

 TInt ExternalizedBufferSizeL(const RArray<T>& aArray)

 /**

 	Calculates how much buffer is required for a fixed length array to be externalized.

 	@param aArray The array whose buffer size will be calculated.

 	@return Returns the number of bytes of the array's dynamic memory.

  */

 	{

 	TInt totalSize(1); // 1-byte is reserved for the array count

 	TInt count = aArray.Count();

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

 			{

 			totalSize += GetObjectBufferSizeL(TPckgC<T>(aArray[i]));

 			}

 	return totalSize;

 	}

 // RArray utilities

 template <class T>

 void CopyFixedLengthArrayL(RArray<T>& aTarget, const RArray<T>& aSource)

 	{

 	TInt arrayCount = aSource.Count();

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

 		{

 		User::LeaveIfError(aTarget.Append(aSource[i]));

 		}

 	}

 template <class T>

 HBufC8* ExternalizeFixedLengthArrayL(const RArray<T>& aArray)

 	{

 	TInt arraySize = ExternalizedBufferSizeL(aArray, arraySize);

 	HBufC8 *arrayBuf = HBufC8::NewLC(arraySize + sizeof(TInt32));

 	TPtr8 arrayPtr(arrayBuf->Des());

 	RDesWriteStream stream(arrayPtr);

 	stream.PushL();

 	ExternalizeFixedLengthArrayL(aArray, stream);

 	stream.Pop();

 	stream.Release();

 	return arrayBuf;

 	}

 template <class T>

 void ExternalizeFixedLengthArrayL(const RArray<T>& aArray, RWriteStream& aStream)

 	{

 	TInt arrayCount = aArray.Count();

 	aStream << TCardinality(arrayCount);

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

 		{

 		aStream.WriteL(TPckgC<T>(aArray[i]));

 		}

 	aStream.CommitL();

 	}

 template <class T>

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

 	{

 	TCardinality c;

 	aStream >> c;

 	TInt count = c;

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

 		{

 		T item;

 		TPckg<T> itemPckg(item);

 		aStream.ReadL(itemPckg);

 		User::LeaveIfError(aArray.Append(item));

 		}

 	}

 #endif /* STREAMINGARRAY_INL*/