1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Serialize and deserialize data between client and server

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include <e32def.h>

    20 

    21 #include "mdcserializationbuffer.h"

    22 #include "mdcserializationtype.h"

    23 

    24 #ifdef _DEBUG

    25 #include <e32debug.h>

    26 _LIT( KCMdCSerializationBuffer, "CMdCSerializationBuffer" );

    27 

    28 enum TSerializedBufferType

    29 	{

    30 	ESerializedBufferTBool,

    31 	ESerializedBufferTInt8,

    32 	ESerializedBufferTUint8,

    33 	ESerializedBufferTInt16,

    34 	ESerializedBufferTUint16,

    35 	ESerializedBufferTInt32,

    36 	ESerializedBufferTUint32,

    37 	ESerializedBufferTUint,

    38 	ESerializedBufferTInt64,

    39 	ESerializedBufferTReal32,

    40 	ESerializedBufferTReal64,

    41 	ESerializedBufferTTime,

    42 	ESerializedBufferTText8,

    43 	ESerializedBufferTText16,

    44 	ESerializedBufferTMdCValueUnion,

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

    46 	};

    47 #endif

    48 

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

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

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

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

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

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

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

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

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

    58 

    59 // artificial types

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

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

    62 

    63 

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

    65 	{

    66 	TInt desLength = aDes.Length();

    67 

    68 	if( KSerializedDesMaxLength < desLength )

    69 		{

    70 		desLength = KSerializedDesMaxLength;

    71 		}

    72 

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

    74 	// possible needed 1 byte padding

    75 	return KRequiredSizeForEmptyText

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

    77 	}

    78 

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

    80 	{

    81 	TInt desLength = aDes.Length();

    82 

    83 	if( KSerializedDesMaxLength < desLength )

    84 		{

    85 		desLength = KSerializedDesMaxLength;

    86 		}

    87 

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

    89 	return KRequiredSizeForEmptyText + desLength * KRealRequiredSizeForTUint16;

    90 	}

    91 

    92 EXPORT_C CMdCSerializationBuffer* CMdCSerializationBuffer::NewL( TInt32 aSize )

    93 	{

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

    95     CleanupStack::Pop( buffer );

    96     return buffer;

    97     }

    98 

    99 EXPORT_C CMdCSerializationBuffer* CMdCSerializationBuffer::NewLC( TInt32 aSize )

   100 	{

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

   102     CleanupStack::PushL( buffer );

   103     buffer->ConstructL( aSize );

   104     return buffer;

   105 	}

   106 

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

   108 	{

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

   110     CleanupStack::Pop( buffer );

   111     return buffer;

   112     }

   113 

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

   115 	{

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

   117     CleanupStack::PushL( buffer );

   118     buffer->ConstructL( aBuffer, aSize );

   119     return buffer;

   120 	}

   121 

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

   123 	{

   124 	const TInt newDesLength = aMsg.GetDesLength( aIndex );

   125 	if ( newDesLength < 0 )

   126 		{

   127 		User::Leave( KErrBadDescriptor );

   128 		}

   129 

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

   131     CleanupStack::PushL(buf);

   132     buf->ConstructL(newDesLength);

   133 	

   134     TPtr8 bufferPtr(buf->Buffer());

   135 	aMsg.ReadL( aIndex, bufferPtr );

   136 

   137 	return buf;

   138 	}

   139 

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

   141 	{

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

   143 	CleanupStack::Pop(buf);

   144 	return buf;

   145 	}

   146 

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

   148 	{

   149 	const TInt newDesLength = aBuffer.Size();

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

   151 	TPtr8 bufferPtr( buf->Buffer() );

   152 	bufferPtr.Copy( aBuffer.Buffer() );

   153 	return buf;

   154 	}

   155 

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

   157 	{

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

   159 	CleanupStack::Pop(buf);

   160 	return buf;

   161 	}

   162 

   163 CMdCSerializationBuffer::~CMdCSerializationBuffer()

   164 	{

   165 	delete iHeapBuffer;

   166 	}

   167 

   168 EXPORT_C TPtr8 CMdCSerializationBuffer::Buffer() const

   169 	{	

   170 	return iBuffer;

   171 	}

   172 

   173 EXPORT_C TPtr8* CMdCSerializationBuffer::BufferPtr() const

   174 	{

   175 	return (TPtr8*)&iBuffer;

   176 	}

   177 

   178 EXPORT_C const TPtr8* CMdCSerializationBuffer::BufferConstPtr() const

   179 	{

   180 	return &iBuffer;

   181 	}

   182 

   183 EXPORT_C TUint32 CMdCSerializationBuffer::Size() const

   184 	{

   185 	return (TUint32)iBuffer.Length();

   186 	}

   187 

   188 EXPORT_C void CMdCSerializationBuffer::PositionL( TUint32 aPosition )

   189 	{

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

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

   192 	

   193 	if( aPosition <= Size() )

   194 		{

   195 		iPosition = aPosition;

   196 		return;

   197 		}

   198 	else

   199 		{

   200 		User::Leave( KErrTooBig );

   201 		}

   202 	}

   203 

   204 EXPORT_C TUint32 CMdCSerializationBuffer::Position() const

   205 	{

   206 	return iPosition;

   207 	}

   208 

   209 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TBool aValue )

   210 	{

   211 	INSERTTYPE(ESerializedBufferTBool);

   212 	

   213 	TInt32 value = aValue;

   214 	return InsertL( value );

   215 	}

   216 

   217 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TInt8 aValue )

   218 	{

   219 	INSERTTYPE(ESerializedBufferTInt8);

   220 	

   221 	TInt16 value = aValue;

   222 	return InsertL( value );

   223 	}

   224 

   225 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TUint8 aValue )

   226 	{

   227 	INSERTTYPE(ESerializedBufferTUint8);

   228 	

   229 	TUint16 value = aValue;

   230 	return InsertL( value );

   231 	}

   232 

   233 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TInt16 aValue )

   234 	{

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

   236 

   237 	INSERTTYPE(ESerializedBufferTInt16);

   238 

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

   240 	

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

   242 

   243 	iPosition += KRealRequiredSizeForTInt16;

   244 	

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

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

   247 	

   248 	return iPosition;

   249 	}

   250 

   251 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TUint16 aValue )

   252 	{

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

   254 

   255 	INSERTTYPE(ESerializedBufferTUint16);

   256 

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

   258 	

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

   260 

   261 	iPosition += KRealRequiredSizeForTUint16;

   262 	

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

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

   265 	

   266 	return iPosition;

   267 	}

   268 

   269 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TInt32 aValue )

   270 	{

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

   272 

   273 	INSERTTYPE(ESerializedBufferTInt32);

   274 

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

   276 	

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

   278 

   279 	iPosition += KRealRequiredSizeForTInt32;

   280 	

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

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

   283 	

   284 	return iPosition;

   285 	}

   286 

   287 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TUint32 aValue )

   288 	{

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

   290 

   291 	INSERTTYPE(ESerializedBufferTUint32);

   292 

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

   294 	

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

   296 

   297 	iPosition += KRealRequiredSizeForTUint32;

   298 	

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

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

   301 	

   302 	return iPosition;

   303 	}

   304 

   305 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TInt64 aValue )

   306 	{

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

   308 

   309 	INSERTTYPE(ESerializedBufferTInt64);

   310 

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

   312 

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

   314 

   315 	iPosition += KRealRequiredSizeForTInt64;

   316 	

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

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

   319 	

   320 	return iPosition;

   321 	}

   322 

   323 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TUint aValue )

   324 	{

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

   326 

   327 	INSERTTYPE(ESerializedBufferTUint);

   328 

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

   330 	

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

   332 

   333 	iPosition += sizeof( TUint );

   334 	

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

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

   337 	

   338 	return iPosition;

   339 	}

   340 

   341 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TReal32 aValue )

   342 	{

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

   344 

   345 	INSERTTYPE(ESerializedBufferTReal32);

   346 

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

   348 

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

   350 

   351 	iPosition += KRealRequiredSizeForTReal32;

   352 	

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

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

   355 	

   356 	return iPosition;

   357 	}

   358 

   359 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TReal64 aValue )

   360 	{

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

   362 

   363 	INSERTTYPE(ESerializedBufferTReal64);

   364 

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

   366 	

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

   368 

   369 	iPosition += KRealRequiredSizeForTReal64;

   370 	

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

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

   373 	

   374 	return iPosition;

   375 	}

   376 

   377 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TTime aValue )

   378 	{

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

   380 

   381 	INSERTTYPE(ESerializedBufferTTime);

   382 

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

   384 

   385 	TInt64 value = aValue.Int64();

   386 	

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

   388 

   389 	iPosition += KRealRequiredSizeForTTime;

   390 	

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

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

   393 

   394 	return iPosition;

   395 	}

   396 

   397 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TDesC8& aValue )

   398 	{

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

   400 

   401 	INSERTTYPE(ESerializedBufferTText8);

   402 

   403 	const TInt desLength = aValue.Length();

   404 	

   405 	if( KSerializedDesMaxLength < desLength )

   406 		{

   407 		User::Leave( KErrTooBig );

   408 		}

   409 

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

   411 

   412 	const TSerializedDesLength serDesLength = (TSerializedDesLength)desLength;

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

   414 

   415 	iPosition += KRealRequiredSizeForEmptyText;

   416 

   417 	if( desLength == 0 )

   418 		{

   419 		return iPosition;

   420 		}

   421 

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

   423 	

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

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

   426 

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

   428 

   429 	iPosition += desLength * KRealRequiredSizeForTUint8;

   430 

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

   432 	if( iPosition & 1 )

   433 		{

   434 		iPosition += sizeof( KPadding8 );

   435 		}

   436 

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

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

   439 

   440 	return iPosition;

   441 	}

   442 

   443 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TDesC16& aValue )

   444 	{

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

   446 

   447 	INSERTTYPE(ESerializedBufferTText16);

   448 

   449 	const TInt desLength = aValue.Length();

   450 	

   451 	if( KSerializedDesMaxLength < desLength )

   452 		{

   453 		User::Leave( KErrTooBig );

   454 		}

   455 

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

   457 

   458 	const TSerializedDesLength serDesLength = (TSerializedDesLength)desLength;

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

   460 

   461 	iPosition += KRealRequiredSizeForEmptyText;

   462 

   463 	if( desLength == 0 )

   464 		{

   465 		return iPosition;

   466 		}

   467 

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

   469 

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

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

   472 

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

   474 

   475 	iPosition += desLength * KRealRequiredSizeForTUint16;

   476 	

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

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

   479 	

   480 	return iPosition;

   481 	}

   482 

   483 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL( TMdCValueUnion& aValue )

   484 	{

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

   486 

   487 	INSERTTYPE(ESerializedBufferTMdCValueUnion);

   488 

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

   490 

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

   492 

   493 	iPosition += KRealRequiredSizeForTMdCValueUnion;

   494 	

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

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

   497 	

   498 	return iPosition;

   499 

   500 	}

   501 EXPORT_C TUint32 CMdCSerializationBuffer::InsertL(TMdCSerializationType& aValue,

   502 		TUint32 aSize)

   503 	{

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

   505 

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

   507 

   508 	TMdCSerializationType* value = &aValue;

   509 

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

   511 

   512 	iPosition += aSize;

   513 

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

   515 	if( iPosition & 1 )

   516 		{

   517 		iPosition += sizeof( KPadding8 );

   518 		}

   519 

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

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

   522 

   523 	return iPosition;

   524 	}

   525 

   526 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TBool& aDestination)

   527 	{

   528 	CHECKTYPE(ESerializedBufferTBool);

   529 

   530 	TInt32 value;

   531 	ReceiveL(value);

   532 	aDestination = value ? ETrue : EFalse;

   533 	return iPosition;

   534 	}

   535 

   536 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TInt8& aDestination)

   537 	{

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

   539 

   540 	CHECKTYPE(ESerializedBufferTInt8);

   541 

   542 	TInt16 value;

   543 	ReceiveL(value);

   544 	aDestination = (TInt8)value;

   545 	return iPosition;

   546 	}

   547 

   548 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TUint8& aDestination)

   549 	{

   550 	CHECKTYPE(ESerializedBufferTUint8);

   551 

   552 	TUint16 value;

   553 	ReceiveL(value);

   554 	aDestination = (TUint8)value;

   555 	return iPosition;

   556 	}

   557 	

   558 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TInt16& aDestination)

   559 	{

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

   561 

   562 	CHECKTYPE(ESerializedBufferTInt16);

   563 

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

   565 

   566 	Mem::Copy(&aDestination, ptr, sizeof(aDestination));

   567 

   568 	iPosition += KRealRequiredSizeForTInt16;

   569 

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

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

   572 	

   573 	return iPosition;

   574 	}

   575 

   576 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TUint16& aDestination)

   577 	{

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

   579 

   580 	CHECKTYPE(ESerializedBufferTUint16);

   581 

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

   583 

   584 	Mem::Copy(&aDestination, ptr, sizeof(aDestination));

   585 

   586 	iPosition += KRealRequiredSizeForTUint16;

   587 

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

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

   590 	

   591 	return iPosition;

   592 	}

   593 

   594 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TInt32& aDestination)

   595 	{

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

   597 

   598 	CHECKTYPE(ESerializedBufferTInt32);

   599 

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

   601 

   602 	Mem::Copy(&aDestination, ptr, sizeof(aDestination));

   603 

   604 	iPosition += KRealRequiredSizeForTInt32;

   605 	

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

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

   608 	

   609 	return iPosition;

   610 	}

   611 

   612 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TUint32& aDestination)

   613 	{

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

   615 

   616 	CHECKTYPE(ESerializedBufferTUint32);

   617 

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

   619 

   620 	Mem::Copy(&aDestination, ptr, sizeof(aDestination));  

   621 	

   622 	aDestination = *ptr;

   623 

   624 	iPosition += KRealRequiredSizeForTUint32;

   625 

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

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

   628 	

   629 	return iPosition;

   630 	}

   631 

   632 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TInt64& aDestination)

   633 	{

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

   635 

   636 	CHECKTYPE(ESerializedBufferTInt64);

   637 

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

   639 

   640 	Mem::Copy(&aDestination, ptr, sizeof(aDestination));

   641 

   642 	iPosition += KRealRequiredSizeForTInt64;

   643 	

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

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

   646 	

   647 	return iPosition;

   648 	}

   649 

   650 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TUint& aDestination)

   651 	{

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

   653 

   654 	CHECKTYPE(ESerializedBufferTUint);

   655 

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

   657 

   658 	Mem::Copy(&aDestination, ptr, sizeof(aDestination));

   659 

   660 	iPosition += sizeof( TUint );

   661 

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

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

   664 	

   665 	return iPosition;

   666 	}

   667 

   668 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TReal32& aDestination)

   669 	{

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

   671 

   672 	CHECKTYPE(ESerializedBufferTReal32);

   673 

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

   675 

   676 	Mem::Copy(&aDestination, ptr, sizeof(aDestination));

   677 

   678 	iPosition += KRealRequiredSizeForTReal32;

   679 	

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

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

   682 	

   683 	return iPosition;

   684 	}

   685 

   686 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TReal64& aDestination)

   687 	{

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

   689 

   690 	CHECKTYPE(ESerializedBufferTReal64);

   691 

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

   693 

   694 	Mem::Copy(&aDestination, ptr, sizeof(aDestination));

   695 

   696 	iPosition += KRealRequiredSizeForTReal64;

   697 

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

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

   700 	

   701 	return iPosition;

   702 	}

   703 

   704 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TTime& aDestination)

   705 	{

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

   707 

   708 	CHECKTYPE(ESerializedBufferTTime);

   709 

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

   711 

   712 	TInt64 value;

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

   714 

   715 	aDestination = value;

   716 

   717 	iPosition += KRealRequiredSizeForTInt64;

   718 

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

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

   721 	

   722 	return iPosition;

   723 	}

   724 

   725 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TMdCValueUnion& aDestination)

   726 	{

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

   728 

   729 	CHECKTYPE(ESerializedBufferTMdCValueUnion);

   730 

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

   732 

   733 	Mem::Copy(&aDestination, ptr, sizeof(aDestination));

   734 

   735 	iPosition += KRealRequiredSizeForTMdCValueUnion;

   736 

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

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

   739 	

   740 	return iPosition;

   741 	}

   742 

   743 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TMdCSerializationType& aDestination,

   744 		TUint32 aSize)

   745 	{

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

   747 

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

   749 

   750 	TMdCSerializationType* value = &aDestination;

   751 

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

   753 

   754 	iPosition += aSize;

   755 

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

   757 	if( iPosition & 1 )

   758 		{

   759 		iPosition += sizeof( KPadding8 );

   760 		}

   761 

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

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

   764 	

   765 	return iPosition;

   766 	}

   767 

   768 

   769 EXPORT_C TSerializedDesLength CMdCSerializationBuffer::ReceiveDesciptorLength() const

   770 	{

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

   772 

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

   774 

   775 	TSerializedDesLength desLength;

   776 	Mem::Copy(&desLength, ptr, sizeof(desLength));

   777 

   778 	return desLength;

   779 	}

   780 

   781 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TDes8& aDestination)

   782 	{

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

   784 

   785 	CHECKTYPE(ESerializedBufferTText8);

   786 

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

   788 

   789 	TSerializedDesLength desLength;

   790 	Mem::Copy(&desLength, ptr, sizeof(desLength));

   791 

   792 	iPosition += KRealRequiredSizeForEmptyText;

   793 

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

   795 

   796 	aDestination.SetLength( desLength );

   797 

   798 	TPtrC8 desPtrC8((TUint8*)aDestination.Ptr(), aDestination.Length());

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

   800 

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

   802 

   803 	iPosition += desLength * KRealRequiredSizeForTUint8;

   804 

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

   806 	if( iPosition & 1 )

   807 		{

   808 		iPosition += sizeof( KPadding8 );

   809 		}

   810 

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

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

   813 	

   814 	return iPosition;

   815 	}

   816 

   817 EXPORT_C TUint32 CMdCSerializationBuffer::ReceiveL(TDes16& aDestination)

   818 	{

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

   820 

   821 	CHECKTYPE(ESerializedBufferTText16);

   822 

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

   824 

   825 	TSerializedDesLength desLength;

   826 	Mem::Copy(&desLength, ptr, sizeof(desLength));

   827 

   828 	iPosition += KRealRequiredSizeForEmptyText;

   829 

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

   831 

   832 	aDestination.SetLength( desLength );

   833 

   834 	TPtrC16 desPtrC16((TUint16*)aDestination.Ptr(), aDestination.Length());

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

   836 

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

   838 

   839 	iPosition += desLength * KRealRequiredSizeForTUint16;

   840 	

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

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

   843 	

   844 	return iPosition;

   845 	}

   846 

   847 EXPORT_C HBufC8* CMdCSerializationBuffer::ReceiveDes8L()

   848 	{

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

   850 

   851 	CHECKTYPE(ESerializedBufferTText8);

   852 

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

   854 

   855 	TSerializedDesLength desLength;

   856 	Mem::Copy(&desLength, ptr, sizeof(desLength));

   857 

   858 	iPosition += KRealRequiredSizeForEmptyText;

   859 	

   860 	if( desLength == 0 )

   861 		{

   862 		return NULL;

   863 		}

   864 	

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

   866 	

   867 	HBufC8* desBuf = HBufC8::NewL( desLength );

   868 	desBuf->Des().SetLength( desLength );

   869 	

   870 	TPtrC8 desPtrC8((TUint8*)desBuf->Ptr(), desBuf->Length());

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

   872 

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

   874 

   875 	iPosition += desLength * KRealRequiredSizeForTUint8;

   876 

   877 	if( iPosition & 1 )

   878 		{

   879 		iPosition += sizeof( KPadding8 );

   880 		}

   881 

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

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

   884 	

   885 	return desBuf;

   886 	}

   887 

   888 EXPORT_C HBufC16* CMdCSerializationBuffer::ReceiveDes16L()

   889 	{

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

   891 

   892 	CHECKTYPE(ESerializedBufferTText16);

   893 

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

   895 

   896 	TSerializedDesLength desLength;

   897 	Mem::Copy(&desLength, ptr, sizeof(desLength));

   898 

   899 	iPosition += KRealRequiredSizeForEmptyText;

   900 	

   901 	if( desLength == 0 )

   902 		{

   903 		return NULL;

   904 		}

   905 	

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

   907 	

   908 	HBufC16* desBuf = HBufC16::NewL( desLength );

   909 	desBuf->Des().SetLength( desLength );

   910 

   911 	TPtrC16 desPtrC16((TUint16*)desBuf->Ptr(), desBuf->Length());

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

   913 

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

   915 

   916 	iPosition += desLength * KRealRequiredSizeForTUint16;

   917 	

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

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

   920 	

   921 	return desBuf;

   922 	}

   923 

   924 EXPORT_C TPtrC8 CMdCSerializationBuffer::ReceivePtr8L()

   925 	{

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

   927 

   928 	CHECKTYPE(ESerializedBufferTText8);

   929 

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

   931 

   932 	TSerializedDesLength desLength;

   933 	Mem::Copy(&desLength, ptr, sizeof(desLength));

   934 

   935 	iPosition += KRealRequiredSizeForEmptyText;

   936 

   937 	TPtrC8 bufPtr8((const TUint8*)(iBuffer.Ptr() + iPosition), (TInt)desLength);

   938 

   939 	iPosition += desLength * KRealRequiredSizeForTUint8;

   940 

   941 	if( iPosition & 1 )

   942 		{

   943 		iPosition += sizeof( KPadding8 );

   944 		}

   945 

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

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

   948 

   949 	return bufPtr8;

   950 	}

   951 

   952 EXPORT_C TPtrC16 CMdCSerializationBuffer::ReceivePtr16L()

   953 	{

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

   955 

   956 	CHECKTYPE(ESerializedBufferTText16);

   957 

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

   959 

   960 	TSerializedDesLength desLength;

   961 	Mem::Copy(&desLength, ptr, sizeof(desLength));

   962 

   963 	iPosition += KRealRequiredSizeForEmptyText;

   964 

   965 	TPtrC16 bufPtr16((const TUint16*)(iBuffer.Ptr() + iPosition), (TInt)desLength);

   966 

   967 	iPosition += desLength * KRealRequiredSizeForTUint16;

   968 

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

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

   971 

   972 	return bufPtr16;

   973 	}

   974 

   975 CMdCSerializationBuffer::CMdCSerializationBuffer() 

   976 	: iHeapBuffer( NULL ), iBuffer( NULL, 0 ), iPosition( 0 )

   977 	{

   978 	}

   979 

   980 void CMdCSerializationBuffer::ConstructL( TInt32 aSize )

   981 	{

   982    	if(aSize < 0)

   983 		{

   984 		User::Leave( KErrBadDescriptor );

   985 		}	

   986 	

   987     iHeapBuffer = HBufC8::NewL( aSize );

   988 	iHeapBuffer->Des().SetLength( aSize );

   989 

   990     iBuffer.Set( iHeapBuffer->Des() );

   991 

   992 #ifdef _DEBUG

   993     // for testing initilize to 0x99

   994     TUint8* ptr = (TUint8*)(iBuffer.Ptr());

   995     for(TInt32 i = 0; i < aSize; i++)

   996     	{

   997     	ptr[i] = 0x99;

   998     	}

   999 #endif

  1000 	}

  1001 

  1002 void CMdCSerializationBuffer::ConstructL( TUint8* aBuffer, TInt32 aSize )

  1003 	{

  1004    	if(aSize < 0)

  1005 		{

  1006 		User::Leave( KErrBadDescriptor );

  1007 		}	

  1008 	

  1009     iBuffer.Set( aBuffer, aSize, aSize );

  1010 	}

  1011 

  1012 #ifdef _DEBUG

  1013 void CMdCSerializationBuffer::InsertTypeL( TUint16 aType )

  1014 	{

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

  1016 

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

  1018 	

  1019 	Mem::Copy(ptr, &aType, sizeof(aType));

  1020 

  1021 	iPosition += KRealRequiredSizeForTUint16;

  1022 	

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

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

  1025 	}

  1026 

  1027 void CMdCSerializationBuffer::CheckTypeL( TUint16 aType )

  1028 	{

  1029 	_LIT( KErrDescription, "Incorrect types!" );

  1030 	TUint16 type;

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

  1032 

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

  1034 

  1035 	Mem::Copy(&type, ptr, sizeof(type));

  1036 

  1037 	iPosition += KRealRequiredSizeForTUint16;

  1038 

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

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

  1041 

  1042 	

  1043 	if ( aType == ESerializedBufferTText && (type == ESerializedBufferTText8 || type == ESerializedBufferTText16) )

  1044 		{

  1045 		aType = type;

  1046 		}

  1047 

  1048 #ifdef _DEBUG

  1049 	if (type != aType)

  1050 		{

  1051 		RDebug::Print( _L("Incorrect serialization buffer types, actual: %S, wanted: %S, position: %u"),

  1052 				&GetPropertyName(type), &GetPropertyName(aType), iPosition );

  1053 		}

  1054 #endif

  1055 	__ASSERT_DEBUG( type == aType, User::Panic( KErrDescription, KErrArgument ) );

  1056 	}

  1057 

  1058 const TDesC& CMdCSerializationBuffer::GetPropertyName( TUint16 aType )

  1059 	{

  1060 	_LIT( KSerializeTBool, "TBool" );

  1061 	_LIT( KSerializeTInt8, "TInt8" );

  1062 	_LIT( KSerializeTUint8, "TUint8" );

  1063 	_LIT( KSerializeTInt16, "TInt16" );

  1064 	_LIT( KSerializeTUint16, "Uint16" );

  1065 	_LIT( KSerializeTInt32, "TInt32" );

  1066 	_LIT( KSerializeTUint32, "TUint32" );

  1067 	_LIT( KSerializeTUint, "TUint" );

  1068 	_LIT( KSerializeTInt64, "TInt64" );

  1069 	_LIT( KSerializeTReal32, "TReal32" );

  1070 	_LIT( KSerializeTReal64, "TReal64" );

  1071 	_LIT( KSerializeTTime, "TTime" );

  1072 	_LIT( KSerializeTText8, "TText8" );

  1073 	_LIT( KSerializeTText16, "TText16" );

  1074 	_LIT( KSerializeTMdCValueUnion, "TMdCValueUnion" );

  1075 

  1076 	switch (aType)

  1077 		{

  1078 		case ESerializedBufferTBool:

  1079 			return KSerializeTBool;

  1080 		case ESerializedBufferTInt8:

  1081 			return KSerializeTInt8;

  1082 		case ESerializedBufferTUint8:

  1083 			return KSerializeTUint8;

  1084 		case ESerializedBufferTInt16:

  1085 			return KSerializeTInt16;

  1086 		case ESerializedBufferTUint16:

  1087 			return KSerializeTUint16;

  1088 		case ESerializedBufferTInt32:

  1089 			return KSerializeTInt32;

  1090 		case ESerializedBufferTUint32:

  1091 			return KSerializeTUint32;

  1092 		case ESerializedBufferTUint:

  1093 			return KSerializeTUint;

  1094 		case ESerializedBufferTInt64:

  1095 			return KSerializeTInt64;

  1096 		case ESerializedBufferTReal32:

  1097 			return KSerializeTReal32;

  1098 		case ESerializedBufferTReal64:

  1099 			return KSerializeTReal64;

  1100 		case ESerializedBufferTTime:

  1101 			return KSerializeTTime;

  1102 		case ESerializedBufferTText8:

  1103 			return KSerializeTText8;

  1104 		case ESerializedBufferTText16:

  1105 			return KSerializeTText16;

  1106 		case ESerializedBufferTMdCValueUnion:

  1107 			return KSerializeTMdCValueUnion;

  1108 		default:

  1109 			User::Panic( _L("Unknown serialization type!"), KErrNotFound );

  1110 		}

  1111 	return KSerializeTText16;

  1112 	}

  1113 #endif