/*

* Copyright (c) 2009 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:  Serialize and deserialize data between client and server

*

*/

// INCLUDE FILES

#include <e32def.h>

#include "mdcserializationbuffer.h"

#include "mdcserializationtype.h"

#ifdef _DEBUG

#include <e32debug.h>

_LIT( KCMdCSerializationBuffer, "CMdCSerializationBuffer" );

enum TSerializedBufferType

	{

	ESerializedBufferTBool,

	ESerializedBufferTInt8,

	ESerializedBufferTUint8,

	ESerializedBufferTInt16,

	ESerializedBufferTUint16,

	ESerializedBufferTInt32,

	ESerializedBufferTUint32,

	ESerializedBufferTUint,

	ESerializedBufferTInt64,

	ESerializedBufferTReal32,

	ESerializedBufferTReal64,

	ESerializedBufferTTime,

	ESerializedBufferTText8,

	ESerializedBufferTText16,

	ESerializedBufferTMdCValueUnion,

	ESerializedBufferTText, // DON'T USE, special case ONLY for ReceiveDesciptorLength

	};

#endif

const TUint32 KRealRequiredSizeForTUint8  = CMdCSerializationBuffer::KRequiredSizeForTUint16 - CMdCSerializationBuffer::KRequiredSizeForTypeCheck;

const TUint32 KRealRequiredSizeForTInt16  = CMdCSerializationBuffer::KRequiredSizeForTInt16 - CMdCSerializationBuffer::KRequiredSizeForTypeCheck;

const TUint32 KRealRequiredSizeForTUint16 = CMdCSerializationBuffer::KRequiredSizeForTUint16 - CMdCSerializationBuffer::KRequiredSizeForTypeCheck;

const TUint32 KRealRequiredSizeForTInt32  = CMdCSerializationBuffer::KRequiredSizeForTInt32 - CMdCSerializationBuffer::KRequiredSizeForTypeCheck;

const TUint32 KRealRequiredSizeForTUint32 = CMdCSerializationBuffer::KRequiredSizeForTUint32 - CMdCSerializationBuffer::KRequiredSizeForTypeCheck;

const TUint32 KRealRequiredSizeForTInt64  = CMdCSerializationBuffer::KRequiredSizeForTInt64 - CMdCSerializationBuffer::KRequiredSizeForTypeCheck;

const TUint32 KRealRequiredSizeForTReal32 = CMdCSerializationBuffer::KRequiredSizeForTReal32 - CMdCSerializationBuffer::KRequiredSizeForTypeCheck;

const TUint32 KRealRequiredSizeForTReal64 = CMdCSerializationBuffer::KRequiredSizeForTReal64 - CMdCSerializationBuffer::KRequiredSizeForTypeCheck;

const TUint32 KRealRequiredSizeForTTime   = CMdCSerializationBuffer::KRequiredSizeForTTime - CMdCSerializationBuffer::KRequiredSizeForTypeCheck;

// artificial types

const TUint32 KRealRequiredSizeForEmptyText = CMdCSerializationBuffer::KRequiredSizeForEmptyText - CMdCSerializationBuffer::KRequiredSizeForTypeCheck;

const TUint32 KRealRequiredSizeForTMdCValueUnion = CMdCSerializationBuffer::KRequiredSizeForTMdCValueUnion - CMdCSerializationBuffer::KRequiredSizeForTypeCheck;

EXPORT_C TUint32 CMdCSerializationBuffer::RequiredSize( const TDesC8& aDes )

	{

	TInt desLength = aDes.Length();

	if( KSerializedDesMaxLength < desLength )

		{

		desLength = KSerializedDesMaxLength;

		}

	// Required size for lenght of the descriptor, actual descriptor data and

	// possible needed 1 byte padding

	return KRequiredSizeForEmptyText

	       + (desLength % 2 ? desLength + sizeof( KPadding8 ) : desLength) * KRealRequiredSizeForTUint8;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::RequiredSize( const TDesC16& aDes )

	{

	TInt desLength = aDes.Length();

	if( KSerializedDesMaxLength < desLength )

		{

		desLength = KSerializedDesMaxLength;

		}

	// Required size for lenght of the descriptor and actual descriptor data

	return KRequiredSizeForEmptyText + desLength * KRealRequiredSizeForTUint16;

	}

EXPORT_C CMdCSerializationBuffer* CMdCSerializationBuffer::NewL( TInt32 aSize )

	{

    CMdCSerializationBuffer* buffer = CMdCSerializationBuffer::NewLC( aSize );

    CleanupStack::Pop( buffer );

    return buffer;

    }

EXPORT_C CMdCSerializationBuffer* CMdCSerializationBuffer::NewLC( TInt32 aSize )

	{

    CMdCSerializationBuffer* buffer = new( ELeave ) CMdCSerializationBuffer();

    CleanupStack::PushL( buffer );

    buffer->ConstructL( aSize );

    return buffer;

	}

EXPORT_C CMdCSerializationBuffer* CMdCSerializationBuffer::NewL( TUint8* aBuffer, TInt32 aSize )

	{

    CMdCSerializationBuffer* buffer = CMdCSerializationBuffer::NewLC( aBuffer, aSize );

    CleanupStack::Pop( buffer );

    return buffer;

    }

EXPORT_C CMdCSerializationBuffer* CMdCSerializationBuffer::NewLC( TUint8* aBuffer, TInt32 aSize )

	{

    CMdCSerializationBuffer* buffer = new( ELeave ) CMdCSerializationBuffer();

    CleanupStack::PushL( buffer );

    buffer->ConstructL( aBuffer, aSize );

    return buffer;

	}

EXPORT_C CMdCSerializationBuffer* CMdCSerializationBuffer::NewLC( const RMessage2 &aMsg, TInt aIndex )

	{

	const TInt newDesLength = aMsg.GetDesLength( aIndex );

	if ( newDesLength < 0 )

		{

		User::Leave( KErrBadDescriptor );

		}

    CMdCSerializationBuffer* buf = new (ELeave)CMdCSerializationBuffer(); 

    CleanupStack::PushL(buf);

    buf->ConstructL(newDesLength);

    TPtr8 bufferPtr(buf->Buffer());

	aMsg.ReadL( aIndex, bufferPtr );

	return buf;

	}

EXPORT_C CMdCSerializationBuffer* CMdCSerializationBuffer::NewL( const RMessage2 &aMsg, TInt aIndex )	

	{

	CMdCSerializationBuffer* buf = CMdCSerializationBuffer::NewLC(aMsg, aIndex);

	CleanupStack::Pop(buf);

	return buf;

	}

EXPORT_C CMdCSerializationBuffer* CMdCSerializationBuffer::NewLC( const CMdCSerializationBuffer& aBuffer )

	{

	const TInt newDesLength = aBuffer.Size();

	CMdCSerializationBuffer* buf = CMdCSerializationBuffer::NewLC( newDesLength );

	TPtr8 bufferPtr( buf->Buffer() );

	bufferPtr.Copy( aBuffer.Buffer() );

	return buf;

	}

EXPORT_C CMdCSerializationBuffer* CMdCSerializationBuffer::NewL( const CMdCSerializationBuffer& aBuffer )

	{

	CMdCSerializationBuffer* buf = CMdCSerializationBuffer::NewLC(aBuffer);

	CleanupStack::Pop(buf);

	return buf;

	}

CMdCSerializationBuffer::~CMdCSerializationBuffer()

	{

	delete iHeapBuffer;

	}

EXPORT_C TPtr8 CMdCSerializationBuffer::Buffer() const

	{	

	return iBuffer;

	}

EXPORT_C TPtr8* CMdCSerializationBuffer::BufferPtr() const

	{

	return (TPtr8*)&iBuffer;

	}

EXPORT_C const TPtr8* CMdCSerializationBuffer::BufferConstPtr() const

	{

	return &iBuffer;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::Size() const

	{

	return (TUint32)iBuffer.Length();

	}

EXPORT_C void CMdCSerializationBuffer::PositionL( TUint32 aPosition )

	{

	__ASSERT_DEBUG( aPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrTooBig ) );

	__ASSERT_DEBUG( aPosition % 2 == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	if( aPosition <= Size() )

		{

		iPosition = aPosition;

		return;

		}

	else

		{

		User::Leave( KErrTooBig );

		}

	}

EXPORT_C TUint32 CMdCSerializationBuffer::Position() const

	{

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TBool aValue )

	{

	INSERTTYPE(ESerializedBufferTBool);

	TInt32 value = aValue;

	return InsertL( value );

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TInt8 aValue )

	{

	INSERTTYPE(ESerializedBufferTInt8);

	TInt16 value = aValue;

	return InsertL( value );

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TUint8 aValue )

	{

	INSERTTYPE(ESerializedBufferTUint8);

	TUint16 value = aValue;

	return InsertL( value );

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TInt16 aValue )

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	INSERTTYPE(ESerializedBufferTInt16);

	TInt16* ptr = (TInt16*)(iBuffer.Ptr() + iPosition);

	Mem::Copy(ptr, &aValue, sizeof(aValue));

	iPosition += KRealRequiredSizeForTInt16;

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TUint16 aValue )

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	INSERTTYPE(ESerializedBufferTUint16);

	TUint16* ptr = (TUint16*)(iBuffer.Ptr() + iPosition);

	Mem::Copy(ptr, &aValue, sizeof(aValue));

	iPosition += KRealRequiredSizeForTUint16;

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TInt32 aValue )

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	INSERTTYPE(ESerializedBufferTInt32);

	TInt32* ptr = (TInt32*)(iBuffer.Ptr() + iPosition);

	Mem::Copy(ptr, &aValue, sizeof(aValue));

	iPosition += KRealRequiredSizeForTInt32;

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TUint32 aValue )

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	INSERTTYPE(ESerializedBufferTUint32);

	TUint32* ptr = (TUint32*)(iBuffer.Ptr() + iPosition);

	Mem::Copy(ptr, &aValue, sizeof(aValue));

	iPosition += KRealRequiredSizeForTUint32;

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TInt64 aValue )

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	INSERTTYPE(ESerializedBufferTInt64);

	TInt64* ptr = (TInt64*)(iBuffer.Ptr() + iPosition);

	Mem::Copy(ptr, &aValue, sizeof(aValue));

	iPosition += KRealRequiredSizeForTInt64;

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TUint aValue )

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	INSERTTYPE(ESerializedBufferTUint);

	TUint* ptr = (TUint*)(iBuffer.Ptr() + iPosition);

	Mem::Copy(ptr, &aValue, sizeof(aValue));

	iPosition += sizeof( TUint );

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TReal32 aValue )

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	INSERTTYPE(ESerializedBufferTReal32);

	TReal32* ptr = (TReal32*)(iBuffer.Ptr() + iPosition);

	Mem::Copy(ptr, &aValue, sizeof(aValue));

	iPosition += KRealRequiredSizeForTReal32;

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TReal64 aValue )

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	INSERTTYPE(ESerializedBufferTReal64);

	TReal64* ptr = (TReal64*)(iBuffer.Ptr() + iPosition);

	Mem::Copy(ptr, &aValue, sizeof(aValue));

	iPosition += KRealRequiredSizeForTReal64;

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TTime aValue )

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	INSERTTYPE(ESerializedBufferTTime);

	TInt64* ptr = (TInt64*)(iBuffer.Ptr() + iPosition);

	TInt64 value = aValue.Int64();

	Mem::Copy(ptr, &value, sizeof(value));

	iPosition += KRealRequiredSizeForTTime;

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TDesC8& aValue )

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	INSERTTYPE(ESerializedBufferTText8);

	const TInt desLength = aValue.Length();

	if( KSerializedDesMaxLength < desLength )

		{

		User::Leave( KErrTooBig );

		}

	TSerializedDesLength* ptr = (TSerializedDesLength*)(iBuffer.Ptr() + iPosition);

	const TSerializedDesLength serDesLength = (TSerializedDesLength)desLength;

	Mem::Copy( ptr, &serDesLength, sizeof( serDesLength ) );

	iPosition += KRealRequiredSizeForEmptyText;

	if( desLength == 0 )

		{

		return iPosition;

		}

	TUint8* bufPtr = (TUint8*)(iBuffer.Ptr() + iPosition);

	TPtrC8 desPtrC8 ((TUint8*)aValue.Ptr(), aValue.Length());

	TUint8* desPtr = (TUint8*)desPtrC8.Ptr();

	Mem::Copy( bufPtr, desPtr, desLength * sizeof( TUint8 ) );

	iPosition += desLength * KRealRequiredSizeForTUint8;

	// If position is odd, add padding and goto next even position

	if( iPosition & 1 )

		{

		iPosition += sizeof( KPadding8 );

		}

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TDesC16& aValue )

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	INSERTTYPE(ESerializedBufferTText16);

	const TInt desLength = aValue.Length();

	if( KSerializedDesMaxLength < desLength )

		{

		User::Leave( KErrTooBig );

		}

	TSerializedDesLength* ptr = (TSerializedDesLength*)(iBuffer.Ptr() + iPosition);

	const TSerializedDesLength serDesLength = (TSerializedDesLength)desLength;

	Mem::Copy(ptr, &serDesLength, sizeof(serDesLength));

	iPosition += KRealRequiredSizeForEmptyText;

	if( desLength == 0 )

		{

		return iPosition;

		}

	TUint16* bufPtr = (TUint16*)(iBuffer.Ptr() + iPosition);

	TPtrC16 desPtrC16 ((TUint16*)aValue.Ptr(), aValue.Length());

	TUint16* desPtr = (TUint16*)desPtrC16.Ptr();

	Mem::Copy(bufPtr, desPtr, desLength*sizeof(TUint16));

	iPosition += desLength * KRealRequiredSizeForTUint16;

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TMdCValueUnion& aValue )

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	INSERTTYPE(ESerializedBufferTMdCValueUnion);

	TMdCValueUnion* ptr = (TMdCValueUnion*)(iBuffer.Ptr() + iPosition);

	Mem::Copy(ptr, &aValue, sizeof(aValue));

	iPosition += KRealRequiredSizeForTMdCValueUnion;

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::InsertL(TMdCSerializationType& aValue,

		TUint32 aSize)

	{

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	void* ptr = (void*)(iBuffer.Ptr() + iPosition);

	TMdCSerializationType* value = &aValue;

	Mem::Copy(ptr, value, aSize);

	iPosition += aSize;

	// If position is odd, add padding and goto next even position

	if( iPosition & 1 )

		{

		iPosition += sizeof( KPadding8 );

		}

	__ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) );

	__ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) );

	return iPosition;

	}

EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TBool& aDestination)

	{