diff -r 000000000000 -r c53acadfccc6 metadataengine/common/src/mdcserializationbuffer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/metadataengine/common/src/mdcserializationbuffer.cpp Mon Jan 18 20:34:07 2010 +0200 @@ -0,0 +1,1113 @@ +/* +* 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 + +#include "mdcserializationbuffer.h" +#include "mdcserializationtype.h" + +#ifdef _DEBUG +#include +_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) + { + CHECKTYPE(ESerializedBufferTBool); + + TInt32 value; + ReceiveL(value); + aDestination = value ? ETrue : EFalse; + return iPosition; + } + +EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TInt8& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTInt8); + + TInt16 value; + ReceiveL(value); + aDestination = (TInt8)value; + return iPosition; + } + +EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TUint8& aDestination) + { + CHECKTYPE(ESerializedBufferTUint8); + + TUint16 value; + ReceiveL(value); + aDestination = (TUint8)value; + return iPosition; + } + +EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TInt16& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTInt16); + + TInt16* ptr = (TInt16*)(iBuffer.Ptr() + iPosition); + + Mem::Copy(&aDestination, ptr, sizeof(aDestination)); + + 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::ReceiveL(TUint16& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTUint16); + + TUint16* ptr = (TUint16*)(iBuffer.Ptr() + iPosition); + + Mem::Copy(&aDestination, ptr, sizeof(aDestination)); + + 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::ReceiveL(TInt32& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTInt32); + + TInt32* ptr = (TInt32*)(iBuffer.Ptr() + iPosition); + + Mem::Copy(&aDestination, ptr, sizeof(aDestination)); + + 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::ReceiveL(TUint32& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTUint32); + + TUint32* ptr = (TUint32*)(iBuffer.Ptr() + iPosition); + + Mem::Copy(&aDestination, ptr, sizeof(aDestination)); + + aDestination = *ptr; + + 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::ReceiveL(TInt64& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTInt64); + + TInt64* ptr = (TInt64*)(iBuffer.Ptr() + iPosition); + + Mem::Copy(&aDestination, ptr, sizeof(aDestination)); + + 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::ReceiveL(TUint& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTUint); + + TUint* ptr = (TUint*)(iBuffer.Ptr() + iPosition); + + Mem::Copy(&aDestination, ptr, sizeof(aDestination)); + + 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::ReceiveL(TReal32& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTReal32); + + TReal32* ptr = (TReal32*)(iBuffer.Ptr() + iPosition); + + Mem::Copy(&aDestination, ptr, sizeof(aDestination)); + + 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::ReceiveL(TReal64& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTReal64); + + TReal64* ptr = (TReal64*)(iBuffer.Ptr() + iPosition); + + Mem::Copy(&aDestination, ptr, sizeof(aDestination)); + + 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::ReceiveL(TTime& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTTime); + + TInt64* ptr = (TInt64*)(iBuffer.Ptr() + iPosition); + + TInt64 value; + Mem::Copy(&value, ptr, sizeof(value)); + + aDestination = value; + + 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::ReceiveL(TMdCValueUnion& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTMdCValueUnion); + + TMdCValueUnion* ptr = (TMdCValueUnion*)(iBuffer.Ptr() + iPosition); + + Mem::Copy(&aDestination, ptr, sizeof(aDestination)); + + 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::ReceiveL(TMdCSerializationType& aDestination, + TUint32 aSize) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + void* ptr = (void*)(iBuffer.Ptr() + iPosition); + + TMdCSerializationType* value = &aDestination; + + Mem::Copy(value, ptr, 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 TSerializedDesLength CMdCSerializationBuffer::ReceiveDesciptorLength() const + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + TSerializedDesLength* ptr = (TSerializedDesLength*)(iBuffer.Ptr() + KRequiredSizeForTypeCheck + iPosition); + + TSerializedDesLength desLength; + Mem::Copy(&desLength, ptr, sizeof(desLength)); + + return desLength; + } + +EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TDes8& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTText8); + + TSerializedDesLength* ptr = (TSerializedDesLength*)(iBuffer.Ptr() + iPosition); + + TSerializedDesLength desLength; + Mem::Copy(&desLength, ptr, sizeof(desLength)); + + iPosition += KRealRequiredSizeForEmptyText; + + TUint8* bufPtr = (TUint8*)(iBuffer.Ptr() + iPosition); + + aDestination.SetLength( desLength ); + + TPtrC8 desPtrC8((TUint8*)aDestination.Ptr(), aDestination.Length()); + TUint8* desPtr = (TUint8*)desPtrC8.Ptr(); + + Mem::Copy(desPtr, bufPtr, 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::ReceiveL(TDes16& aDestination) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTText16); + + TSerializedDesLength* ptr = (TSerializedDesLength*)(iBuffer.Ptr() + iPosition); + + TSerializedDesLength desLength; + Mem::Copy(&desLength, ptr, sizeof(desLength)); + + iPosition += KRealRequiredSizeForEmptyText; + + TUint16* bufPtr = (TUint16*)(iBuffer.Ptr() + iPosition); + + aDestination.SetLength( desLength ); + + TPtrC16 desPtrC16((TUint16*)aDestination.Ptr(), aDestination.Length()); + TUint16* desPtr = (TUint16*)desPtrC16.Ptr(); + + Mem::Copy(desPtr, bufPtr, 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 HBufC8* CMdCSerializationBuffer::ReceiveDes8L() + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTText8); + + TSerializedDesLength* ptr = (TSerializedDesLength*)(iBuffer.Ptr() + iPosition); + + TSerializedDesLength desLength; + Mem::Copy(&desLength, ptr, sizeof(desLength)); + + iPosition += KRealRequiredSizeForEmptyText; + + if( desLength == 0 ) + { + return NULL; + } + + TUint8* bufPtr = (TUint8*)(iBuffer.Ptr() + iPosition); + + HBufC8* desBuf = HBufC8::NewL( desLength ); + desBuf->Des().SetLength( desLength ); + + TPtrC8 desPtrC8((TUint8*)desBuf->Ptr(), desBuf->Length()); + TUint8* desPtr = (TUint8*)desPtrC8.Ptr(); + + Mem::Copy(desPtr, bufPtr, desLength*sizeof(TUint8)); + + iPosition += desLength * KRealRequiredSizeForTUint8; + + if( iPosition & 1 ) + { + iPosition += sizeof( KPadding8 ); + } + + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + __ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) ); + + return desBuf; + } + +EXPORT_C HBufC16* CMdCSerializationBuffer::ReceiveDes16L() + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTText16); + + TSerializedDesLength* ptr = (TSerializedDesLength*)(iBuffer.Ptr() + iPosition); + + TSerializedDesLength desLength; + Mem::Copy(&desLength, ptr, sizeof(desLength)); + + iPosition += KRealRequiredSizeForEmptyText; + + if( desLength == 0 ) + { + return NULL; + } + + TUint16* bufPtr = (TUint16*)(iBuffer.Ptr() + iPosition); + + HBufC16* desBuf = HBufC16::NewL( desLength ); + desBuf->Des().SetLength( desLength ); + + TPtrC16 desPtrC16((TUint16*)desBuf->Ptr(), desBuf->Length()); + TUint16* desPtr = (TUint16*)desPtrC16.Ptr(); + + Mem::Copy(desPtr, bufPtr, desLength*sizeof(TUint16)); + + iPosition += desLength * KRealRequiredSizeForTUint16; + + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + __ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) ); + + return desBuf; + } + +EXPORT_C TPtrC8 CMdCSerializationBuffer::ReceivePtr8L() + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTText8); + + TSerializedDesLength* ptr = (TSerializedDesLength*)(iBuffer.Ptr() + iPosition); + + TSerializedDesLength desLength; + Mem::Copy(&desLength, ptr, sizeof(desLength)); + + iPosition += KRealRequiredSizeForEmptyText; + + TPtrC8 bufPtr8((const TUint8*)(iBuffer.Ptr() + iPosition), (TInt)desLength); + + iPosition += desLength * KRealRequiredSizeForTUint8; + + if( iPosition & 1 ) + { + iPosition += sizeof( KPadding8 ); + } + + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + __ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) ); + + return bufPtr8; + } + +EXPORT_C TPtrC16 CMdCSerializationBuffer::ReceivePtr16L() + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + CHECKTYPE(ESerializedBufferTText16); + + TSerializedDesLength* ptr = (TSerializedDesLength*)(iBuffer.Ptr() + iPosition); + + TSerializedDesLength desLength; + Mem::Copy(&desLength, ptr, sizeof(desLength)); + + iPosition += KRealRequiredSizeForEmptyText; + + TPtrC16 bufPtr16((const TUint16*)(iBuffer.Ptr() + iPosition), (TInt)desLength); + + iPosition += desLength * KRealRequiredSizeForTUint16; + + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + __ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) ); + + return bufPtr16; + } + +CMdCSerializationBuffer::CMdCSerializationBuffer() + : iHeapBuffer( NULL ), iBuffer( NULL, 0 ), iPosition( 0 ) + { + } + +void CMdCSerializationBuffer::ConstructL( TInt32 aSize ) + { + if(aSize < 0) + { + User::Leave( KErrBadDescriptor ); + } + + iHeapBuffer = HBufC8::NewL( aSize ); + iHeapBuffer->Des().SetLength( aSize ); + + iBuffer.Set( iHeapBuffer->Des() ); + +#ifdef _DEBUG + // for testing initilize to 0x99 + TUint8* ptr = (TUint8*)(iBuffer.Ptr()); + for(TInt32 i = 0; i < aSize; i++) + { + ptr[i] = 0x99; + } +#endif + } + +void CMdCSerializationBuffer::ConstructL( TUint8* aBuffer, TInt32 aSize ) + { + if(aSize < 0) + { + User::Leave( KErrBadDescriptor ); + } + + iBuffer.Set( aBuffer, aSize, aSize ); + } + +#ifdef _DEBUG +void CMdCSerializationBuffer::InsertTypeL( TUint16 aType ) + { + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + TUint16* ptr = (TUint16*)(iBuffer.Ptr() + iPosition); + + Mem::Copy(ptr, &aType, sizeof(aType)); + + iPosition += KRealRequiredSizeForTUint16; + + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + __ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) ); + } + +void CMdCSerializationBuffer::CheckTypeL( TUint16 aType ) + { + _LIT( KErrDescription, "Incorrect types!" ); + TUint16 type; + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + + TUint16* ptr = (TUint16*)(iBuffer.Ptr() + iPosition); + + Mem::Copy(&type, ptr, sizeof(type)); + + iPosition += KRealRequiredSizeForTUint16; + + __ASSERT_DEBUG( (iPosition & 1) == 0, User::Panic( KCMdCSerializationBuffer, KErrCorrupt ) ); + __ASSERT_DEBUG( iPosition <= Size(), User::Panic( KCMdCSerializationBuffer, KErrOverflow ) ); + + + if ( aType == ESerializedBufferTText && (type == ESerializedBufferTText8 || type == ESerializedBufferTText16) ) + { + aType = type; + } + +#ifdef _DEBUG + if (type != aType) + { + RDebug::Print( _L("Incorrect serialization buffer types, actual: %S, wanted: %S, position: %u"), + &GetPropertyName(type), &GetPropertyName(aType), iPosition ); + } +#endif + __ASSERT_DEBUG( type == aType, User::Panic( KErrDescription, KErrArgument ) ); + } + +const TDesC& CMdCSerializationBuffer::GetPropertyName( TUint16 aType ) + { + _LIT( KSerializeTBool, "TBool" ); + _LIT( KSerializeTInt8, "TInt8" ); + _LIT( KSerializeTUint8, "TUint8" ); + _LIT( KSerializeTInt16, "TInt16" ); + _LIT( KSerializeTUint16, "Uint16" ); + _LIT( KSerializeTInt32, "TInt32" ); + _LIT( KSerializeTUint32, "TUint32" ); + _LIT( KSerializeTUint, "TUint" ); + _LIT( KSerializeTInt64, "TInt64" ); + _LIT( KSerializeTReal32, "TReal32" ); + _LIT( KSerializeTReal64, "TReal64" ); + _LIT( KSerializeTTime, "TTime" ); + _LIT( KSerializeTText8, "TText8" ); + _LIT( KSerializeTText16, "TText16" ); + _LIT( KSerializeTMdCValueUnion, "TMdCValueUnion" ); + + switch (aType) + { + case ESerializedBufferTBool: + return KSerializeTBool; + case ESerializedBufferTInt8: + return KSerializeTInt8; + case ESerializedBufferTUint8: + return KSerializeTUint8; + case ESerializedBufferTInt16: + return KSerializeTInt16; + case ESerializedBufferTUint16: + return KSerializeTUint16; + case ESerializedBufferTInt32: + return KSerializeTInt32; + case ESerializedBufferTUint32: + return KSerializeTUint32; + case ESerializedBufferTUint: + return KSerializeTUint; + case ESerializedBufferTInt64: + return KSerializeTInt64; + case ESerializedBufferTReal32: + return KSerializeTReal32; + case ESerializedBufferTReal64: + return KSerializeTReal64; + case ESerializedBufferTTime: + return KSerializeTTime; + case ESerializedBufferTText8: + return KSerializeTText8; + case ESerializedBufferTText16: + return KSerializeTText16; + case ESerializedBufferTMdCValueUnion: + return KSerializeTMdCValueUnion; + default: + User::Panic( _L("Unknown serialization type!"), KErrNotFound ); + } + return KSerializeTText16; + } +#endif