/*

* 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: Container class for stored IMPS engine inner classes

* 

*/

// INCLUDE FILES

#include    <e32base.h>

#include    "impsdata.h"

// LOCAL CONSTANTS AND MACROS

const TInt KDefaultNumberOfPairs = 10;

// C++ default constructor can NOT contain any code, that

// might leave.

//

CImpsElement::CImpsElement( ) :

iBool(EFalse),

iValueType(EImpsDataTypeNone),

iIsEmpty(EFalse)

    {

    }

// Symbian OS default constructor can leave.

void CImpsElement::ConstructL( )

    {

    }

// Two-phased constructor.

CImpsElement* CImpsElement::NewL( )

    {

    CImpsElement* self = new (ELeave) CImpsElement;

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( );

    return self;

    }

// Destructor

CImpsElement::~CImpsElement( )

    {

    delete iKey;

    delete iString;

    delete iString8;

    }

// ---------------------------------------------------------

// CImpsElement::SetStringL

// Stores string with given key

// ---------------------------------------------------------

//

void CImpsElement::SetStringL(

    const CImpsKey* aKey, 

    const TDesC& aBuf )

    {

    iKey = aKey->CopyL(  );

    HBufC* newString = aBuf.AllocL( );

    iString = newString;

    iValueType = EImpsDataTypeDesc;

    }

// ---------------------------------------------------------

// CImpsElement::SetString8L

// Stores string8 with given key

// ---------------------------------------------------------

//

void CImpsElement::SetString8L(

    const CImpsKey* aKey, 

    const TDesC8& aBuf )

    {

    iKey = aKey->CopyL(  );

    HBufC8* newString = aBuf.AllocL( );

    iString8 = newString;

    iValueType = EImpsDataTypeDesc8;

    }

// ---------------------------------------------------------

// CImpsElement::SetIntL

// Stores integervalue with given key

// ---------------------------------------------------------

//

void CImpsElement::SetIntL(

    const CImpsKey* aKey, 

    TInt aInt )

    {

    iKey = aKey->CopyL(  );

    iInt = aInt;

    iValueType = EImpsDataTypeInt;

    }

// ---------------------------------------------------------

// CImpsElement::SetBooleanL

// Stores boolean value with given key

// ---------------------------------------------------------

//

void CImpsElement::SetBooleanL(

    const CImpsKey* aKey, 

    TBool aBool )

    {

    iKey = aKey->CopyL(  );

    iBool = aBool;

    iValueType = EImpsDataTypeBoolean;

    }

// ---------------------------------------------------------

// CImpsElement::SetEmptyL

// Stores Empty value with given key

// ---------------------------------------------------------

//

void CImpsElement::SetEmptyL(

    const CImpsKey* aKey )

    {

    iKey = aKey->CopyL(  );

    iIsEmpty = ETrue;

    iValueType = EImpsDataTypeNone;

    }

// ---------------------------------------------------------

// CImpsElement::Size

// Calculates the size of the element

// ---------------------------------------------------------

//

TInt CImpsElement::Size( ) const

    {

    TInt size = 4 * sizeof (TInt); // iInt, iBool, iIsEmpty, iValueType

    size += iKey->Size( );

    if( iString )

        size += iString->Size( ) + sizeof (TInt32);

    if( iString8 ) 

        size += iString8->Size( ) + sizeof (TInt32);

    return size;

    }

// ---------------------------------------------------------

// CImpsElement::Pack

// ---------------------------------------------------------

//

TInt CImpsElement::Pack(

    const TUint8*& aPtrStart ) const

    {

    Mem::Copy( (void*)aPtrStart, &iInt, sizeof( iInt ) );

    aPtrStart = aPtrStart + sizeof( iInt );

    Mem::Copy( (void*)aPtrStart, &iBool, sizeof( iBool ) );

    aPtrStart = aPtrStart + sizeof( iBool );

    Mem::Copy( (void*)aPtrStart, &iValueType, sizeof( iValueType ) );

    aPtrStart = aPtrStart + sizeof( iValueType );

    Mem::Copy( (void*)aPtrStart, &iIsEmpty, sizeof( iIsEmpty ) );

    aPtrStart = aPtrStart + sizeof( iIsEmpty );

    if( iValueType == EImpsDataTypeDesc )

        {

        TInt32 tempSize = 0;

        tempSize = iString->Size();

        Mem::Copy( (void*)aPtrStart, &tempSize, sizeof( tempSize) );

        aPtrStart = aPtrStart + sizeof( tempSize );

        if ( tempSize )

            {

            Mem::Copy( (void*)aPtrStart, iString->Ptr(), tempSize);

            aPtrStart = aPtrStart + tempSize;

            }

        }

    if( iValueType == EImpsDataTypeDesc8 )

        {

        TInt32 tempSize = 0;

        tempSize = iString8->Size();

        Mem::Copy( (void*)aPtrStart, &tempSize, sizeof( tempSize) );

        aPtrStart = aPtrStart + sizeof( tempSize );

        if ( tempSize )

            {

            Mem::Copy( (void*)aPtrStart, iString8->Ptr(), tempSize);

            aPtrStart = aPtrStart + tempSize ;

            }

        }

    TInt ret = iKey->Pack( aPtrStart );

    return ret;

    }

// ---------------------------------------------------------

// CImpsData::UnPack

// ---------------------------------------------------------

//

void CImpsElement::UnPackL(

    TUint8*& aPtr )

    { 

    Mem::Copy( &iInt, aPtr, sizeof( iInt ) );

    aPtr += sizeof( iInt );

    Mem::Copy( &iBool, aPtr, sizeof( iBool ) );

    aPtr += sizeof( iBool );

    Mem::Copy( &iValueType, aPtr, sizeof( iValueType ) );

    aPtr += sizeof( iValueType );

    Mem::Copy( &iIsEmpty, aPtr, sizeof( iIsEmpty ) );

    aPtr += sizeof( iIsEmpty );

    if( iValueType == EImpsDataTypeDesc )

        {

        const TUint8* textPtr = aPtr;

        TInt32 tempSize = 0;

        Mem::Copy( &tempSize, textPtr, sizeof( tempSize) );

        textPtr = textPtr + sizeof( tempSize );

        if ( tempSize > 0 )

            {

            // No need to put CleanupStack because of other methods do not leave.

            iString  = HBufC::NewL( tempSize / 2 );  

            Mem::Copy( (void*)iString->Ptr(), textPtr, tempSize );

            iString->Des().SetLength( tempSize / 2 ); 

            textPtr = textPtr + tempSize; 

            }

        if ( tempSize < 0 )

            {

            User::Leave( KErrCorrupt );

            }

        aPtr = (TUint8*) textPtr;

        }

    if( iValueType == EImpsDataTypeDesc8 )

        {

        const TUint8* textPtr = aPtr;

        TInt32 tempSize = 0;

        Mem::Copy( &tempSize, textPtr, sizeof( tempSize) );

        textPtr = textPtr + sizeof( tempSize );

        if ( tempSize > 0 )

            {

            iString8 = HBufC8::NewL( tempSize );  

            Mem::Copy( (void*)iString8->Ptr(), textPtr, tempSize );

            iString8->Des().SetLength( tempSize ); 

            textPtr = textPtr + tempSize; 

            }

        if ( tempSize < 0 )

            {

            User::Leave( KErrCorrupt );

            }

        aPtr = (TUint8*) textPtr;

        }

    iKey = CImpsKey::NewL( );

    iKey->UnPackL( aPtr );

    }

#ifdef _DEBUG

// ---------------------------------------------------------

// CImpsElement::DumpToFile

// ---------------------------------------------------------

//

void CImpsElement::DumpToFileL( RFile& aFile ) const

    {

    _LIT8( KImpsElementDumpBegin, "  Element dump begin\r\n");

    aFile.Write( KImpsElementDumpBegin );

    _LIT8(KIntegerValue,"    Integer value = %d\r\n");

    _LIT8(KDescStart,"    ");

    _LIT8(KDescEnd,"\r\n");

    TBuf8<256> message; 

    HBufC8* messageString;

    switch ( iValueType )

        {

        case EImpsDataTypeNone:

            aFile.Write( _L8( "    Impselement type is EImpsDataTypeNone\r\n" ));

            break;

        case EImpsDataTypeInt:

            aFile.Write( _L8( "    Impselement type is EImpsDataTypeInt\r\n" ));

            message.Format( KIntegerValue, iInt );

            aFile.Write( message );

            break;

        case EImpsDataTypeDesc:

            aFile.Write( _L8( "    Impselement type is EImpsDataTypeDesc\r\n" ));

            aFile.Write( KDescStart );

//            message.Copy( iString->Des() );

            messageString = HBufC8::NewL(iString->Length());

            messageString->Des().Copy(iString->Des());

            aFile.Write( _L8( "Value: " )  );

            aFile.Write(messageString->Des());

            aFile.Write( KDescEnd );

            delete messageString;

            break;

        case EImpsDataTypeDesc8:

            aFile.Write( _L8( "    Impselement type is EImpsDataTypeDesc8\r\n" ));

            aFile.Write( KDescStart );

//            message.Copy( iString8->Des() );

            aFile.Write( _L8( "Value: " ) );

//            aFile.Write( message );

            aFile.Write( iString8->Des() );

            aFile.Write( KDescEnd );

            break;

        case EImpsDataTypeBoolean:

            aFile.Write( _L8( "    Impselement type is EImpsDataTypeBoolean\r\n" ));

            if( iBool )

                aFile.Write( _L8( "    iBool = ETrue\r\n" ));

            else

                aFile.Write( _L8( "    iBool = EFalse\r\n" ));

            break;

        case EImpsDataTypeNotSupported:

            aFile.Write( _L8( "    Impselement type is EImpsDataTypeNotSupported\r\n" ));

            break;

        default:

            aFile.Write( _L8( "    Impselement type is unknown\r\n" ));

          break;

        }

    iKey->DumpToFileL( aFile );

    _LIT8( KImpsElementDumpEnd, "  Element dump end\r\n");

    aFile.Write( KImpsElementDumpEnd );

    }

#endif

// ---------------------------------------------------------

// CImpsElement::CopyL

// ---------------------------------------------------------

//

CImpsElement* CImpsElement::CopyL( ) const

    {

    CImpsElement* elem = CImpsElement::NewL( );

    CleanupStack::PushL( elem );

    elem->iBool = iBool;

    elem->iInt = iInt;

    elem->iValueType = iValueType;

    elem->iIsEmpty = iIsEmpty;

    elem->iKey = iKey->CopyL( );

    if( iString )

        elem->iString = iString->AllocL( );

    if( iString8 )

        elem->iString8 = iString8->AllocL( );

    CleanupStack::Pop( );

    return elem;

    }

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor can NOT contain any code, that

// might leave.

//

CImpsData::CImpsData()

    {

    }

// Symbian OS default constructor can leave.

void CImpsData::ConstructL( )

    {

    iElements = new (ELeave) CImpsElements( KDefaultNumberOfPairs );

    }

// Two-phased constructor.

CImpsData* CImpsData::NewL( )

    {

    CImpsData* self = new (ELeave) CImpsData;

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( );

    return self;

    }

// Destructor

CImpsData::~CImpsData( )

    {

    if ( iElements )

        {

        iElements->ResetAndDestroy( );

        delete iElements;

        }

    iElements = NULL;

    }

// ---------------------------------------------------------

// CImpsData::StoreStringL

// Stores string with given key

// ---------------------------------------------------------

//

void CImpsData::StoreStringL(

    const CImpsKey *aKey, 

    const TDesC& aBuff )

    {

    CImpsElement* aElement = CImpsElement::NewL( );

    CleanupStack::PushL( aElement );

    aElement->SetStringL( aKey, aBuff );

    iElements->AppendL( aElement );

    CleanupStack::Pop( );

    }

// ---------------------------------------------------------

// CImpsData::StoreString8L

// Stores string with given key

// ---------------------------------------------------------

//

void CImpsData::StoreString8L(

    const CImpsKey *aKey, 

    const TDesC8& aBuff )

    {

    CImpsElement* aElement = CImpsElement::NewL( );

    CleanupStack::PushL( aElement );

    aElement->SetString8L( aKey,aBuff );

    iElements->AppendL( aElement );

    CleanupStack::Pop( );

    }

// ---------------------------------------------------------

// CImpsData::StoreInt

// Stores interger value with given key

// ---------------------------------------------------------

//

void CImpsData::StoreIntL(

    const CImpsKey *aKey, 

    TInt aInt )

    {

    CImpsElement* aElement = CImpsElement::NewL( );

    CleanupStack::PushL( aElement );

    aElement->SetIntL( aKey,aInt );

    iElements->AppendL( aElement );

    CleanupStack::Pop( );

    }

// ---------------------------------------------------------

// CImpsData::StoreBooleanL

// Stores boolean value with given key

// ---------------------------------------------------------

//

void CImpsData::StoreBooleanL(

    const CImpsKey *aKey, 

    TBool aBool )

    {

    CImpsElement* aElement = CImpsElement::NewL( );

    CleanupStack::PushL( aElement );

    aElement->SetBooleanL( aKey,aBool );

    iElements->AppendL( aElement );

    CleanupStack::Pop( );

    }

// ---------------------------------------------------------

// CImpsData::StoreEmptyL

// Stores empty value with given key

// ---------------------------------------------------------

//

void CImpsData::StoreEmptyL(

    const CImpsKey *aKey )

    {

    CImpsElement* aElement = CImpsElement::NewL( );

    CleanupStack::PushL( aElement );

    aElement->SetEmptyL( aKey );

    iElements->AppendL( aElement );

    CleanupStack::Pop( );

    }

// ---------------------------------------------------------

// CImpsData::RestoreString

// Restores the string with given key

// Return EFalse if not found

// ---------------------------------------------------------

//

TBool CImpsData::RestoreString(

    const CImpsKey *aKey,

    TDesC*& aBuff ) const

    {

    const CImpsElement* aElement = Find( aKey, EImpsDataTypeDesc );

    if( aElement )

        {

        aBuff = aElement->GetString();

        return ETrue;

        }

    return EFalse;

    }

// ---------------------------------------------------------

// CImpsData::RestoreString8

// Restores the string with given key

// Return EFalse if not found

// ---------------------------------------------------------

//

TBool CImpsData::RestoreString8(

    const CImpsKey *aKey,

    TDesC8*& aBuff )

    {

    const CImpsElement* aElement = Find( aKey, EImpsDataTypeDesc8 );

    if( aElement )

        {

        aBuff = aElement->GetString8();

        return ETrue;

        }

    return EFalse;

    }

// ---------------------------------------------------------

// CImpsData::RestoreInt

// Restores the integer value with given key

// Return EFalse if not found

// ---------------------------------------------------------

//

TBool CImpsData::RestoreInt(

    const CImpsKey *aKey,

    TInt& aInt )

    {

    const CImpsElement* aElement = Find( aKey, EImpsDataTypeInt );

    if( aElement )

        {