/*
* Copyright (c) 2002 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: 
* package entry and entity class.
*
*/


// INCLUDE FILES
#include    <s32std.h>
#include    "impsfields.h"
#include    "impspacked.h"
#include    "impsutils.h"

// MACROS
#ifndef _DEBUG
#define _NO_IMPS_LOGGING_
#endif
// ================= MEMBER FUNCTIONS =======================


// ---------------------------------------------------------
// TImpsPackedEntity::TImpsPackedEntity
// ---------------------------------------------------------
//
EXPORT_C TImpsPackedEntity::TImpsPackedEntity( HBufC8*& aBuffer )
: iBuffer( aBuffer )
    {}

// ---------------------------------------------------------
// TImpsPackedEntity::PackEntity
// ---------------------------------------------------------
//
EXPORT_C TInt TImpsPackedEntity::PackEntity( const CImpsFields& aEntity )
    {
#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("TImpsPackedEntity::PackEntityL begins"));
#endif
    // find the start and end of the buffer
    const TUint8* pS = iBuffer->Ptr();
    const TUint8* pE = PtrAdd( pS, iBuffer->Des().MaxSize() );

    TInt error = DoPackEntity( pS, pE, aEntity );
    if ( error==KErrNone )
        {
        // update the length of the buffer
        iBuffer->Des().SetLength( pS-iBuffer->Ptr() );
        }

#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("TImpsPackedEntity::PackEntityL ends with %d"), error);
#endif
    return error;
    }

// ---------------------------------------------------------
// TImpsPackedEntity::UnpackEntityL
// ---------------------------------------------------------
//
EXPORT_C void TImpsPackedEntity::UnpackEntityL( CImpsFields& aEntity )
    {
#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("TImpsPackedEntity::UnPackEntityL begins"));
#endif

    TUint8* pS = CONST_CAST(TUint8*, iBuffer->Ptr());
    DoUnpackEntityL( pS, aEntity );

#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("TImpsPackedEntity::UnPackEntityL ends"));
#endif
    }

// ---------------------------------------------------------
// TImpsPackedEntity::DoUnpackEntityL
// ---------------------------------------------------------
void TImpsPackedEntity::DoUnpackEntityL( 
    TUint8*& aPtr, 
    CImpsFields& aEntity )
    {
    TInt sizePackedCont = Align4( KImpsPackedCopyData );
    
    // Get the entry from the start of the buffer
    Mem::Copy( &aEntity, aPtr, sizePackedCont);
    aPtr = aPtr + sizePackedCont;

    CImpsData* data = aEntity.Data( );
    DoUnpackDataL( aPtr, *data );
    }



// ---------------------------------------------------------
// TImpsPackedEntity::DoUnpackDataL
// ---------------------------------------------------------
void TImpsPackedEntity::DoUnpackDataL(
    TUint8*& aPtr, 
    CImpsData& aEntity )
    {
    TInt mySize = 0;
    Mem::Copy( &mySize, aPtr, sizeof( mySize ) );
    aPtr += sizeof( mySize );
    aEntity.UnPackL( aPtr );
    }

// ---------------------------------------------------------
// TImpsPackedEntity::DoPackEntity
// Format is
//   fundamental types copied 
//   plus each descriptor: size + 8-bit data
// NOTICE: This must be modified always when CImpsFields members is changed!!!
// ---------------------------------------------------------
TInt TImpsPackedEntity::DoPackEntity(
    const TUint8*& aPtrStart, 
    const TUint8* aPtrEnd, 
    const CImpsFields& aEntity )
//
// Fails with KErrOverflow if the packed entry is too large
// aPtrStart is always returned pointing to the end of the packed entry (even if too large)
//
    {
    // make sure the entry can fit into the memory area defined by the two pointers

    TInt size =  aEntity.Size();
    if ( ( aPtrStart + size ) > aPtrEnd )
        {
        aPtrStart += size;
        return KErrOverflow;
        }

    size = Align4( KImpsPackedCopyData );
    // copy the entry and descriptors into the memory area
    Mem::Copy((void*)aPtrStart, &aEntity, size );
    aPtrStart += size;

    // Notice: Login data is not packed at the very moment

    TInt ret = DoPackData( aPtrStart, aPtrEnd, *aEntity.Data( ) );

    return ret;
    }



// ---------------------------------------------------------
// TImpsPackedEntity::DoPackData
// ---------------------------------------------------------
TInt TImpsPackedEntity::DoPackData(
    const TUint8*& aPtrStart, 
    const TUint8* aPtrEnd, 
    const CImpsData& aEntity )
    {
    TInt size = aEntity.Size(); 
    size += (2 * sizeof (TInt));		//size,count
    if ( ( aPtrStart + size ) > aPtrEnd )
        {
        aPtrStart += size;
        return KErrOverflow;
        }
    // write the size first.
    Mem::Copy( (void*)aPtrStart, &size, sizeof( size ) );
    aPtrStart = aPtrStart + sizeof( size );

    TInt ret = aEntity.Pack( aPtrStart );
    return ret;
    }

// ---------------------------------------------------------
// TImpsPackedEntity::DoPackDescriptor
// ---------------------------------------------------------
void TImpsPackedEntity::DoPackDescriptor(
    const TUint8*& aPtrStart, 
    const TDesC& /*HBufC* */ aDescriptor )
    {

    TInt32 tempSize = 0;
    tempSize = aDescriptor.Size();
    Mem::Copy( (void*)aPtrStart, &tempSize, sizeof( tempSize) );
    aPtrStart = aPtrStart + sizeof( tempSize );
    if ( tempSize )
        {
        Mem::Copy( (void*)aPtrStart, aDescriptor.Ptr(), tempSize);
        aPtrStart = aPtrStart + tempSize ;
        }
    }

// ---------------------------------------------------------
// TImpsPackedEntity::DoUnpackDescriptorLC
// ---------------------------------------------------------
void TImpsPackedEntity::DoUnpackDescriptorLC(
    const TUint8*& aPtrStart, 
    HBufC*& aDescriptor )
    {

    const TUint8* textPtr = aPtrStart;
    TInt32 tempSize = 0;

    Mem::Copy( &tempSize, textPtr, sizeof( tempSize) );
    textPtr = textPtr + sizeof( tempSize );
    if ( tempSize > 0 )
        {
        // put and leave this to the CleanupStack because of other the
        // calling method can leave
        aDescriptor = HBufC::NewL( tempSize / 2 );  
        CleanupStack::PushL( aDescriptor );
        Mem::Copy( (void*)aDescriptor->Ptr(), textPtr, tempSize );
        aDescriptor->Des().SetLength( tempSize / 2 ); 
        textPtr = textPtr + tempSize; 
        }
    else
        {
        aDescriptor = NULL;
        }
    if ( tempSize < 0 )
        {
#ifndef _NO_IMPS_LOGGING_
    CImpsClientLogger::Log(_L("TImpsPackedEntity: Descriptor Length 0"));
#endif
        }

    aPtrStart = (TUint8*) textPtr;
    
    }

// ---------------------------------------------------------
// TImpsPackedEntity::DoPackArray
// ---------------------------------------------------------
EXPORT_C void TImpsPackedEntity::DoPackArray(
            const TUint8*& aPtrStart,
            const MDesCArray* aArray )
    {

    // First count nbr of elements
    TInt32 nbrElements = 0;

    if ( aArray != NULL )
        {
        nbrElements = aArray->MdcaCount();
        }
    Mem::Copy( (void*)aPtrStart, &nbrElements, sizeof( nbrElements ) );
    aPtrStart = aPtrStart + sizeof( nbrElements );

    // Store each array element
    for ( TInt i = 0; i < nbrElements; i++ )
        {
        TPtrC element = aArray->MdcaPoint(i);
        DoPackDescriptor( aPtrStart, element );
        }

    }

// ---------------------------------------------------------
// TImpsPackedEntity::DoUnpackArrayL
// ---------------------------------------------------------
EXPORT_C void TImpsPackedEntity::DoUnpackArrayL(
            const TUint8*& aPtrStart,
            CDesCArray* aArray )
    {

    const TUint8* textPtr = aPtrStart;
    TInt32 tempSize = 0;

    // Get the number of elements
    Mem::Copy( &tempSize, textPtr, sizeof( tempSize) );
    textPtr = textPtr + sizeof( tempSize );

    if ( tempSize == 0 )
        {
        // There are no elements in array
        aPtrStart = (TUint8*) textPtr;
        return;
        }

    // Unpack each element and add to the array
    HBufC* myPtr;
    HBufC*& descriptor = myPtr;
    for (  TInt i = 0; i < tempSize; i++ )
        {
        // This allocates memory for each element
        DoUnpackDescriptorLC( textPtr, descriptor );  
        // Array may contain zero length descriptor
        if ( descriptor != NULL )
            {
            aArray->AppendL( descriptor->Des() );
            //delete myPtr;
            CleanupStack::PopAndDestroy();
            }
        else
            {
            aArray->AppendL( KNullDesC );
            }
        myPtr = NULL;
        }

    // Increase the packed data pointer
    aPtrStart = (TUint8*) textPtr;
    }


// ================= OTHER EXPORTED FUNCTIONS ==============

//  End of File