/*

* Copyright (c) 2004 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:  Key - value container.

*

*/

// INCLUDE FILES

#include	<utf.h> // for unicode character conversions

#include	<centralrepository.h>

#include    "e32std.h"

#include    "CIMPSSAPKeyValuePair.h"

#include	"IMPSSAPSettingsStoreDefinitions.h"

#include	"IMPSSAPSettingsStorePanics.h"

//MACROS

//Helper macro to check value type in data set

#define REQUIRE_SET_VALUE_TYPE( aType ) \

        { \

        TBool _settable = ( iValueType == EValueTypeNone ) || \

                          ( iValueType == aType ); \

        if( !_settable )\

            {\

            return KErrGeneral;\

            }\

        } \

//Helper macro to check value type in data get

#define REQUIRE_GET_VALUE_TYPE( aType ) \

        { \

        if( iValueType == EValueTypeNone ) \

            { \

            return KErrNotFound; \

            } \

        TBool _readable = ( iValueType == aType ); \

        if( !_readable ) \

            { \

            return KErrGeneral; \

            } \

        } \

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

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

// CIMPSSAPKeyValuePair::New()

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

//

CIMPSSAPKeyValuePair* CIMPSSAPKeyValuePair::New( const TDesC16& aKey )

    {

    //Non leaving two phased constructor!!!

    CIMPSSAPKeyValuePair* self = new CIMPSSAPKeyValuePair;	// CSI: 62 #

    if ( self )

        {

        self->iKey = aKey.Alloc();

        if ( !self->iKey )

            {

            delete self;

            self = NULL;

            }

        }

    return self;

    }

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

// CIMPSSAPKeyValuePair::NewLC()

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

//

CIMPSSAPKeyValuePair* CIMPSSAPKeyValuePair::NewLC( RReadStream& aStream )

    {

    CIMPSSAPKeyValuePair* self = new ( ELeave ) CIMPSSAPKeyValuePair;

    CleanupStack::PushL( self );

    self->ConstructL( aStream );

    return self;

    }

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

// CIMPSSAPKeyValuePair::NewLC()

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

//

CIMPSSAPKeyValuePair* CIMPSSAPKeyValuePair::NewLC( const TDesC& aKeyValuePairFlat )

    {

    CIMPSSAPKeyValuePair* self = new ( ELeave ) CIMPSSAPKeyValuePair;

    CleanupStack::PushL( self );

    self->ParseFlatKeyValuePairL( aKeyValuePairFlat );

    return self;

    }

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

// CIMPSSAPKeyValuePair::~CIMPSSAPKeyValuePair()

// Destructor

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

//

CIMPSSAPKeyValuePair::~CIMPSSAPKeyValuePair()

    {

    Reset();

    }

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

// CIMPSSAPKeyValuePair::CIMPSSAPKeyValuePair()

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

// might leave.

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

//

CIMPSSAPKeyValuePair::CIMPSSAPKeyValuePair()

        : iValueType( EValueTypeNone )

    {

    }

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

// CIMPSSAPKeyValuePair::ConstructL()

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

//

void CIMPSSAPKeyValuePair::ConstructL( RReadStream& aStream )

    {

    //Note! This implementation must be in sync with

    //ExternalizeL()

    //Extension space

    aStream.ReadInt32L();

    //Default data

    TInt keyLength = aStream.ReadInt32L();

    iKey = HBufC::NewL( keyLength );

    TPtr keyPtr( iKey->Des() );

    aStream.ReadL( keyPtr, keyLength );

    iValueType = static_cast< TValueType > ( aStream.ReadInt8L() );

    switch ( iValueType )

        {

        case EValueTypeInt:

            {

            iInt = aStream.ReadInt32L();

            break;

            }

        case EValueTypeDesC8:

            {

            TInt descLength = aStream.ReadInt32L();

            iBuf8 = HBufC8::NewL( descLength );

            TPtr8 descPtr8( iBuf8->Des() );

            aStream.ReadL( descPtr8, descLength );

            break;

            }

        case EValueTypeDesC16:

            {

            TInt descLength = aStream.ReadInt32L();

            iBuf16 = HBufC16::NewL( descLength );

            TPtr16 descPtr16( iBuf16->Des() );

            aStream.ReadL( descPtr16, descLength );

            break;

            }

        //FLOW THROUGH

        case EValueTypeNone:

        default:

            {

            break;

            }

        };

    }

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

// CIMPSSAPKeyValuePair::Reset()

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

//

void CIMPSSAPKeyValuePair::Reset()

    {

    switch ( iValueType )

        {

        case EValueTypeDesC8:

            {

            delete iBuf8;

            iBuf8 = NULL;

            break;

            }

        case EValueTypeDesC16:

            {

            delete iBuf16;

            iBuf16 = NULL;

            break;

            }

        //FLOW THROUGH

        case EValueTypeInt:

        case EValueTypeNone:

        default:

            {

            break;

            }

        };

    iValueType = EValueTypeNone;

    delete iKey;

    iKey = NULL;

    }

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

// CIMPSSAPKeyValuePair::SetValue()

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

//

TInt CIMPSSAPKeyValuePair::SetValue( TInt aValue )

    {

    REQUIRE_SET_VALUE_TYPE( EValueTypeInt )

    TInt oldValue( iInt );

    iInt = aValue;

    iValueType = EValueTypeInt;

    TBool dataTooBig( IsDataTooBig() );

    TInt err( KErrNone );

    if ( dataTooBig )

        {

        iInt = oldValue;

        err = KErrTooBig;

        }

    __ASSERT_DEBUG( !err, Panic( EIMPSInvalidKeyValue ) );

    return err;

    }

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

// CIMPSSAPKeyValuePair::Key()

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

//

const TDesC& CIMPSSAPKeyValuePair::Key() const

    {

    return *iKey;

    }

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

// CIMPSSAPKeyValuePair::SetValue()

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

//

TInt CIMPSSAPKeyValuePair::SetValue( const TDesC8& aValue )

    {

    REQUIRE_SET_VALUE_TYPE( EValueTypeDesC8 )

    // Allocate memory for the new value

    HBufC8* tmp = aValue.Alloc();

    if ( !tmp )

        {

        return KErrNoMemory;

        }

    // Swap pointers

    HBufC8* tmp2( NULL );

    tmp2 = iBuf8;

    iBuf8 = tmp;

    iValueType = EValueTypeDesC8;

    TBool dataTooBig( IsDataTooBig() );

    TInt err( KErrNone );

    // Rollback if data too bog

    if ( dataTooBig )

        {

        iBuf8 = tmp2;

        delete tmp;

        err = KErrTooBig;

        }

    // Otherwise delete the old value

    else

        {

        delete tmp2;

        }

    __ASSERT_DEBUG( !err, Panic( EIMPSInvalidKeyValue ) );

    return err;

    }

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

// CIMPSSAPKeyValuePair::SetValue()

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

//

TInt CIMPSSAPKeyValuePair::SetValue( const TDesC16& aValue )

    {

    REQUIRE_SET_VALUE_TYPE( EValueTypeDesC16 )

    // Allocate memory for the new value

    HBufC16* tmp = aValue.Alloc();

    if ( !tmp )

        {

        return KErrNoMemory;

        }

    // Swap pointers

    HBufC16* tmp2( NULL );

    tmp2 = iBuf16;

    iBuf16 = tmp;

    iValueType = EValueTypeDesC16;

    TBool dataTooBig( IsDataTooBig() );

    TInt err( KErrNone );

    // Rollback if data too bog

    if ( dataTooBig )

        {

        iBuf16 = tmp2;

        delete tmp;

        err = KErrTooBig;

        }

    // Otherwise delete the old value

    else

        {

        delete tmp2;

        }

    __ASSERT_DEBUG( !err, Panic( EIMPSInvalidKeyValue ) );

    return err;

    }

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

// CIMPSSAPKeyValuePair::GetValue()

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

//

TInt CIMPSSAPKeyValuePair::GetValue( TInt& aValue ) const

    {

    REQUIRE_GET_VALUE_TYPE( EValueTypeInt )

    aValue = iInt;

    return KErrNone;

    }

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

// CIMPSSAPKeyValuePair::GetValue()

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

//

TInt CIMPSSAPKeyValuePair::GetValue( TPtrC8& aValue ) const

    {

    REQUIRE_GET_VALUE_TYPE( EValueTypeDesC8 )

    aValue.Set( *iBuf8 );

    return KErrNone;

    }

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

// CIMPSSAPKeyValuePair::GetValue()

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

//

TInt CIMPSSAPKeyValuePair::GetValue( TPtrC16& aValue ) const

    {

    REQUIRE_GET_VALUE_TYPE( EValueTypeDesC16 )

    aValue.Set( *iBuf16 );

    return KErrNone;

    }

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

// CIMPSSAPKeyValuePair::ExternalizeL()

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

//

void CIMPSSAPKeyValuePair::ExternalizeL( RWriteStream& aStream ) const

    {

    //Extension space

    aStream.WriteInt32L( 0 );

    //Default data

    aStream.WriteInt32L( iKey->Length() );

    aStream.WriteL( *iKey );

    aStream.WriteInt8L( iValueType );

    switch ( iValueType )

        {

        case EValueTypeInt:

            {

            aStream.WriteInt32L( iInt );

            break;

            }

        case EValueTypeDesC8:

            {

            aStream.WriteInt32L( iBuf8->Length() );

            aStream.WriteL( *iBuf8 );

            break;

            }

        case EValueTypeDesC16:

            {

            aStream.WriteInt32L( iBuf16->Length() );

            aStream.WriteL( *iBuf16 );

            break;

            }

        //FLOW THROUGH

        case EValueTypeNone:

        default:

            {

            break;

            }

        };

    }

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

// CIMPSSAPKeyValuePair::DataSize()

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

//

TInt CIMPSSAPKeyValuePair::DataSize() const

    {

    // extension space == 4 bytes

    // keyLength == 4 bytes

    // valueType == 1 bytes

    // ==> 9 bytes

    TInt dataSize = 9;

    dataSize += iKey->Length();

    switch ( iValueType )

        {

        case EValueTypeInt:

            {

            //Integer == 4 bytes

            dataSize += 4;

            break;

            }

        case EValueTypeDesC8:

            {

            //desc8 length == 4 bytes

            dataSize += 4;

            dataSize += iBuf8->Size();

            break;

            }

        case EValueTypeDesC16:

            {

            //desc16 length == 4 bytes

            dataSize += 4;

            dataSize += iBuf16->Size();

            break;

            }

        //FLOW THROUGH

        case EValueTypeNone:

        default:

            {

            break;

            }

        };

    return dataSize;

    }

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

// CIMPSSAPKeyValuePair::DataSizeDec()

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

//

TInt CIMPSSAPKeyValuePair::DataSizeDec() const

    {

    TInt dataSize( iKey->Length() );

    switch ( iValueType )

        {

        case EValueTypeInt:

            {

            dataSize += KTIntMaxLengthTextual;

            break;

            }

        case EValueTypeDesC8:

            {

            dataSize += iBuf8->Length();

            break;

            }

        case EValueTypeDesC16:

            {

            dataSize += iBuf16->Length();

            break;

            }

        //FLOW THROUGH

        case EValueTypeNone:

        default:

            {

            break;

            }

        };

    return dataSize;

    }

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

// CIMPSSAPKeyValuePair::IsDataTooBig()

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

//

TBool CIMPSSAPKeyValuePair::IsDataTooBig() const

    {

    return ( DataSizeDec() > ( NCentralRepositoryConstants::KMaxUnicodeStringLength -

                               2*KKeyValuePairFieldSeparator().Length() - 1 ) );

    }

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

// CIMPSSAPKeyValuePair::KeyValuePairFlatLC()