metadataengine/common/src/mdcserializationbuffer.cpp
changeset 0 c53acadfccc6
child 7 3cebc1a84278
equal deleted inserted replaced
-1:000000000000 0:c53acadfccc6
       
     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