/*
* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Collection of tools used to pack and unpack
* data transferred over IPC.
*
*/
// INCLUDE FILES
#include <E32Std.h>
#include "PEngMessagePacker.h"
_LIT( KPEngMsgPckPanic, "PEngMsgPckr" );
enum TPEngMsgPckPanicReason
{
EResetIntArrayBufLength,
EIntArrayCountBufLength,
EIntFromArrayIndexNegative,
EIntFromArrayIndexTooLarge
};
// ====================== MEMBER FUNCTIONS ======================================
// =============================================================================
// ===================== DESCRIPTOR ARRAY PACKING ==============================
// =============================================================================
// -----------------------------------------------------------------------------
// PEngMessagePacker::DesArrayPackageSize()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt PEngMessagePacker::DesArrayPackageSize( const MDesCArray& aDesArray )
{
TInt count ( aDesArray.MdcaCount() );
TInt len( count + 1 ); // once more count on the begining of buf
for ( TInt x( 0 ) ; x < count ; x++ )
{
len += aDesArray.MdcaPoint( x ).Length();
}
return len;
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::DesArrayPackageSize()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt PEngMessagePacker::DesArrayPackageSize( const TDesC& aDesAsArray )
{
return aDesAsArray.Length() + 2; // length and cout
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::PackDesArrayL()
// -----------------------------------------------------------------------------
//
EXPORT_C HBufC16* PEngMessagePacker::PackDesArrayL( const MDesCArray& aDesArray )
{
HBufC16* desBuffer = HBufC16::NewL( DesArrayPackageSize( aDesArray ) );
TPtr des = desBuffer->Des();
TInt count ( aDesArray.MdcaCount() );
des.Append( ( TUint16* ) &count, 1 );
for ( TInt x( 0 ) ; x < count ; x++ )
{
TPtrC element( aDesArray.MdcaPoint( x ) );
TInt length( element.Length() );
des.Append( reinterpret_cast<TUint16*> ( &length ), 1 );
des.Append( element );
}
return desBuffer;
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::PackDesArray()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt PEngMessagePacker::PackDesArray( TDes& aBuffer,
const MDesCArray& aDesArray )
{
aBuffer.Zero();
if ( aBuffer.MaxLength() < DesArrayPackageSize( aDesArray ) )
{
return KErrArgument;
}
TInt count ( aDesArray.MdcaCount() );
aBuffer.Append( reinterpret_cast<TUint16*> ( &count ), 1 );
for ( TInt x( 0 ) ; x < count ; x++ )
{
TPtrC element( aDesArray.MdcaPoint( x ) );
TInt length( element.Length() );
aBuffer.Append( reinterpret_cast<TUint16*> ( &length ), 1 );
aBuffer.Append( element );
}
return KErrNone;
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::PackOneDesAsArrayL()
// -----------------------------------------------------------------------------
//
EXPORT_C HBufC16* PEngMessagePacker::PackOneDesAsArrayL( const TDesC& aDes )
{
HBufC16* desBuffer = HBufC16::NewL( aDes.Length() + 2 ); // count and size
TPtr des = desBuffer->Des();
TInt count( 1 ); //Only one descriptor is packed
des.Append( reinterpret_cast<TUint16*> ( &count ), 1 );
TInt length( aDes.Length() );
des.Append( reinterpret_cast<TUint16*> ( &length ), 1 );
des.Append( aDes );
return desBuffer;
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::PackOneDesAsArray()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt PEngMessagePacker::PackOneDesAsArray( TDes& aBuffer,
const TDesC& aDes )
{
aBuffer.Zero();
if ( aBuffer.MaxLength() < ( aDes.Length() + 2 ) ) // count and size
{
return KErrArgument;
}
TInt count( 1 );
aBuffer.Append( reinterpret_cast<TUint16*> ( &count ), 1 );
TInt length( aDes.Length() );
aBuffer.Append( reinterpret_cast<TUint16*> ( &length ), 1 );
aBuffer.Append( aDes );
return KErrNone;
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::AppendToDesArray()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt PEngMessagePacker::AppendToDesArray( TDes& aBuffer,
const TDesC& aDes )
{
// is anything in the array?
TInt count( 0 ); // if array will be empty
if ( aBuffer.Length() == 0 )
{
// first element appent count first
aBuffer.Append( reinterpret_cast<TUint16*> ( &count ), 1 );
}
// check space
if ( ( aBuffer.Length() + aDes.Length() + 1 ) > aBuffer.MaxLength() )
{
return KErrBadDescriptor;
}
TInt length( aDes.Length() );
aBuffer.Append( reinterpret_cast<TUint16*> ( &length ), 1 );
aBuffer.Append( aDes );
// update count
count = ( TInt ) ( aBuffer[ 0 ] ); // count is first
count++;
aBuffer[ 0 ] = static_cast<TUint16> ( count );
return KErrNone;
}
// =============================================================================
// =================== DESCRIPTOR ARRAY EXTRACTING =============================
// =============================================================================
// -----------------------------------------------------------------------------
// PEngMessagePacker::DesArrayCount()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt PEngMessagePacker::DesArrayCount( const TDesC& aBuffer )
{
if ( aBuffer.Length() == 0 )
{
return 0; // des is empty
}
return ( TInt ) ( aBuffer[ 0 ] );
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::UnpackDesArrayL()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt PEngMessagePacker::UnpackDesArrayL( const TDesC& aBuffer,
CDesCArray& aArray )
{
return UnpackDesTempArrayL( aBuffer, aArray );
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::UnpackDesArrayL()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt PEngMessagePacker::UnpackDesArrayL( const TDesC& aBuffer,
CPtrCArray& aArray )
{
return UnpackDesTempArrayL( aBuffer, aArray );
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::UnpackDesArrayLC()
// -----------------------------------------------------------------------------
//
EXPORT_C CDesCArray* PEngMessagePacker::UnpackDesArrayLC( const TDesC& aBuffer )
{
TInt count ( DesArrayCount( aBuffer ) );
CDesC16ArrayFlat* desArray = new( ELeave ) CDesC16ArrayFlat( ++count );
CleanupStack::PushL( desArray );
UnpackDesArrayL( aBuffer, *desArray );
return desArray;
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::UnpackFirstDesFromArrayL()
// -----------------------------------------------------------------------------
//
EXPORT_C HBufC* PEngMessagePacker::UnpackFirstDesFromArrayL( const TDesC& aBuffer )
{
// Ignore count, read length of des
TInt desL ( ( TInt ) ( aBuffer[1] ) ); // first was count
// First two are info about count and length
// Returns buffer ownership to caller
return aBuffer.Mid( 2, desL ).AllocL();
}
// =============================================================================
// ===================== INTEGER ARRAY HANDLING ================================
// =============================================================================
// -----------------------------------------------------------------------------
// AppendInt32ToDesc()
// -----------------------------------------------------------------------------
//
void AppendInt32ToDesc( TDes& aBuffer, TInt32 aValue )
{
aBuffer.Append( ( TUint16* ) &aValue, 2 ); //TInt32 ==> 2 x 16bytes
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::TIntArrayPackageSize()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt PEngMessagePacker::TIntArrayPackageSize( TInt aElementCount )
{
TInt size = 2; //array count is stored to 32 bit ==> 2 x 16bytes
size += aElementCount * 2; //each array element takes 2 x 16bytes
return size;
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::PackTIntArrayL()
// -----------------------------------------------------------------------------
//
EXPORT_C HBufC16* PEngMessagePacker::PackTIntArrayL( const RArray<TInt>& aTIntArray )
{
TInt packSize = PEngMessagePacker::TIntArrayPackageSize( aTIntArray.Count() );
HBufC* packBuf = HBufC::NewL( packSize );
TPtr pack = packBuf->Des();
//Add first the count
TInt32 count( aTIntArray.Count() );
AppendInt32ToDesc( pack, count );
//Then entries
for ( TInt ix( 0 ) ; ix < count ; ix++ )
{
TInt32 intValue = aTIntArray[ ix ];
AppendInt32ToDesc( pack, intValue );
}
return packBuf;
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::ResetTIntArray()
// -----------------------------------------------------------------------------
//
EXPORT_C void PEngMessagePacker::ResetTIntArray( TDes& aBuffer )
{
__ASSERT_ALWAYS( aBuffer.MaxLength() >= 2,
User::Panic( KPEngMsgPckPanic, EResetIntArrayBufLength ) );
aBuffer.Zero();
//Reset first the count
AppendInt32ToDesc( aBuffer, 0 ); //No entries ==> count is 0
//Then entries
const TInt placeCount = ( aBuffer.MaxLength() - 2 ) / 2;
for ( TInt ix = 0; ix < placeCount; ix++ )
{
AppendInt32ToDesc( aBuffer, KErrNotFound ); //Entries are reset to -1
}
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::TIntArrayCount()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt PEngMessagePacker::TIntArrayCount( const TDesC& aBuffer )
{
//Array count is stored in the start of buffer, 2 x 16bytes
__ASSERT_ALWAYS( aBuffer.Length() >= 2,
User::Panic( KPEngMsgPckPanic, EIntArrayCountBufLength ) );
TInt32 count = *( TInt32* ) aBuffer.Ptr();
return count;
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::TIntFromArray()
// -----------------------------------------------------------------------------
//
EXPORT_C TInt PEngMessagePacker::TIntFromArray( const TDesC& aBuffer,
TInt aIndex )
{
//Assert index range
__ASSERT_ALWAYS( aIndex >= 0,
User::Panic( KPEngMsgPckPanic, EIntFromArrayIndexNegative ) );
__ASSERT_ALWAYS( aIndex < PEngMessagePacker::TIntArrayCount( aBuffer ),
User::Panic( KPEngMsgPckPanic, EIntFromArrayIndexTooLarge ) );
TInt entryOffset = 2; //array count is in the start, 2 x 16bytes
entryOffset += aIndex * 2; //each entry takes 2 x 16bytes
TInt entryValue = *( TInt32* ) aBuffer.Mid( entryOffset ).Ptr();
return entryValue;
}
// -----------------------------------------------------------------------------
// PEngMessagePacker::UnpackDesTempArrayL()
// -----------------------------------------------------------------------------
//
template<class T>
TInt PEngMessagePacker::UnpackDesTempArrayL( const TDesC& aBuffer,
T& aArray )
{
TInt count ( DesArrayCount( aBuffer ) );
TInt desOffset( 1 ); // start with first element
for ( TInt x( 0 ) ; x < count ; x++ )
{
// get length of the des
TInt desL ( static_cast<TUint16> ( ( aBuffer[ desOffset ] ) ) );
// get offset to the beginning of the packed descriptor
desOffset++;
aArray.AppendL( aBuffer.Mid( desOffset, desL ) );
// move to length info of another packed des
desOffset += desL;
}
return count;
}
// End of File