/*

* 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:  Container for individual key-value pairs

*

*/

// INCLUDE FILES

#include    "CIMPSSAPKeyValuePairs.h"

#include    "CIMPSSAPKeyValuePair.h"

#include    "CIMPSSAPLookupKeyValuePair.h"

#include    "IMPSSAPSettingsStorePanics.h"

#include    <e32std.h>

//CONSTANTS

const TInt KKeyValuePairGranurality = 5;

// LOCAL CONSTANTS AND MACROS

#define KEYWORD_ORDER TLinearOrder< CIMPSSAPKeyValuePair > ( CompareKeys )

// ============================ LOCAL FUNCTIONS ===============================

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

// CompareKeys()

// Comparison function for TLinearOrder

//

// @param aLhs The left hand side in comparison.

// @param aRhs The right hand side in comparison.

// @return Result from compare

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

//

TInt CompareKeys( const CIMPSSAPKeyValuePair& aLhs, const CIMPSSAPKeyValuePair& aRhs )

    {

    return aLhs.Key().Compare( aRhs.Key() );

    }

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

// SetValueToPairs()

// Templated algorithm to set or update new value to list of key values.

//

// @param aPairs The list of key-value pairs.

// @param aLookupKey The lookup key to use in searching.

// @param aKey The key for which to assign the value.

// @param aValue Templated data type to assign to key.

// @return Error code.

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

//

template< typename T >

TInt SetValueToPairs( RPointerArray< CIMPSSAPKeyValuePair >& aPairs,

                      CIMPSSAPLookupKeyValuePair& aLookupKey,

                      const TDesC& aKey,

                      const T& aValue )

    {

    aLookupKey.SetLookupKey( aKey );

    TInt err = KErrNone;

    TInt index = aPairs.FindInOrder( &aLookupKey, KEYWORD_ORDER );

    if ( index != KErrNotFound )

        {

        //Update existing

        err = aPairs[ index ]->SetValue( aValue );

        }

    else

        {

        //create new

        CIMPSSAPKeyValuePair* newPair = CIMPSSAPKeyValuePair::New( aKey );

        if ( !newPair )

            {

            err = KErrNoMemory;

            }

        else

            {

            //Insert new

            err = newPair->SetValue( aValue );

            if ( err == KErrNone )

                {

                err = aPairs.InsertInOrderAllowRepeats( newPair, KEYWORD_ORDER );

                }

            if ( err != KErrNone )

                {

                delete newPair;

                }

            }

        }

    aLookupKey.ResetLookupKey();

    return err;

    }

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

// GetValueFromPairs()

//

// Templated algorithm to get value from list of key values.

//

// @param aPairs The list of key-value pairs.

// @param aLookupKey The lookup key to use in searching.

// @param aKey The key for which to get the value.

// @param aValue Templated data type to get.

// @return Error code.

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

//

template< typename T >

TInt GetValueFromPairs( const RPointerArray< CIMPSSAPKeyValuePair >& aPairs,

                        CIMPSSAPLookupKeyValuePair& aLookupKey,

                        const TDesC& aKey,

                        T& aValue )

    {

    aLookupKey.SetLookupKey( aKey );

    TInt index = aPairs.FindInOrder( &aLookupKey, KEYWORD_ORDER );

    if ( index != KErrNotFound )

        {

        index = aPairs[ index ]->GetValue( aValue );

        }

    aLookupKey.ResetLookupKey();

    return index;

    }

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

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

// CIMPSSAPKeyValuePairs::NewL()

// Two-phased constructor.

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

//

CIMPSSAPKeyValuePairs* CIMPSSAPKeyValuePairs::NewL()

    {

    CIMPSSAPKeyValuePairs* self = new ( ELeave ) CIMPSSAPKeyValuePairs;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); //self

    return self;

    }

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

// CIMPSSAPKeyValuePairs::~CIMPSSAPKeyValuePairs()

// Destructor

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

//

CIMPSSAPKeyValuePairs::~CIMPSSAPKeyValuePairs()

    {

    iPairs.ResetAndDestroy();

    delete iLookupKey;

    }

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

// CIMPSSAPKeyValuePairs::CIMPSSAPKeyValuePairs()

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

// might leave.

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

//

CIMPSSAPKeyValuePairs::CIMPSSAPKeyValuePairs()

        : iPairs( KKeyValuePairGranurality )

    {

    }

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

// CIMPSSAPKeyValuePairs::ConstructL)

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

//

void CIMPSSAPKeyValuePairs::ConstructL()

    {

    iLookupKey = CIMPSSAPLookupKeyValuePair::NewL();

    }

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

// CIMPSSAPKeyValuePairs::ObjectID()

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

//

TIMPSSapObjectID CIMPSSAPKeyValuePairs::ObjectID() const

    {

    return EIMPSSapObjKeyValuePairs;

    }

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

// CIMPSSAPKeyValuePairs::ObjectVersion()

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

//

TInt CIMPSSAPKeyValuePairs::ObjectVersion() const

    {

    return KIMPSSapObjVersionInitial;

    }

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

// CIMPSSAPKeyValuePairs::ExternalizeVersionDataL()

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

//

void CIMPSSAPKeyValuePairs::ExternalizeVersionDataL( TInt aVersion,

                                                     RWriteStream& aStream ) const

    {

    switch ( aVersion )

        {

        case  KIMPSSapObjVersionInitial:

            {

            //Phase 1 key value objects

            const TInt count = iPairs.Count();

            aStream.WriteInt32L( count );

            for ( TInt ii = 0; ii < count; ii++ )

                {

                iPairs[ ii ]->ExternalizeL( aStream );

                }

            break;

            }

        default:

            {

            //Unknown version ID in externalization.

            Panic( EIMPSSetStoreUnknownObjectVersionExternalize );

            break;

            }

        };

    }

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

// CIMPSSAPKeyValuePairs::InternalizeVersionDataL()

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

//

void CIMPSSAPKeyValuePairs::InternalizeVersionDataL( TInt aVersion,

                                                     RReadStream& aStream )

    {

    switch ( aVersion )

        {

        case  KIMPSSapObjVersionInitial:

            {

            //Phase 1 key value objects

            const TInt count = aStream.ReadInt32L();

            for ( TInt ii = 0; ii < count; ii++ )

                {

                CIMPSSAPKeyValuePair* pair = CIMPSSAPKeyValuePair::NewLC( aStream );

                User::LeaveIfError( iPairs.Append( pair ) );

                CleanupStack::Pop( pair );

                }

            break;

            }

        default:

            {

            //Unknown version ID in internalization.

            Panic( EIMPSSetStoreUnknownObjectVersionInternalize );

            break;

            }

        };

    }

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

// CIMPSSAPKeyValuePairs::DataSize()

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

//

TInt CIMPSSAPKeyValuePairs::DataSize() const

    {

    //pairs count == 4 bytes

    TInt dataSize = 4;

    const TInt count = iPairs.Count();

    for ( TInt ii = 0; ii < count; ii++ )

        {

        dataSize += iPairs[ ii ]->DataSize();

        }

    return dataSize;

    }

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

// CIMPSSAPKeyValuePairs::Reset()

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

//

void CIMPSSAPKeyValuePairs::Reset()

    {

    iPairs.ResetAndDestroy();

    }

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

// CIMPSSAPKeyValuePairs::SetValueInt()

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

//

TInt CIMPSSAPKeyValuePairs::SetValueInt( const TDesC& aKey, TInt aValue )

    {

    return SetValueToPairs( iPairs, *iLookupKey, aKey, aValue );

    }

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

// CIMPSSAPKeyValuePairs::SetValueDesC8()

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

//

TInt CIMPSSAPKeyValuePairs::SetValueDesC8( const TDesC& aKey, const TDesC8& aValue )

    {

    return SetValueToPairs( iPairs, *iLookupKey, aKey, aValue );

    }

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

// CIMPSSAPKeyValuePairs::SetValueDesC16()

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

//

TInt CIMPSSAPKeyValuePairs::SetValueDesC16( const TDesC& aKey, const TDesC16& aValue )

    {

    return SetValueToPairs( iPairs, *iLookupKey, aKey, aValue );

    }

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

// CIMPSSAPKeyValuePairs::GetValueInt()

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

//

TInt CIMPSSAPKeyValuePairs::GetValueInt( const TDesC& aKey, TInt& aValue )

    {

    return GetValueFromPairs( iPairs, *iLookupKey, aKey, aValue );

    }

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

// CIMPSSAPKeyValuePairs::GetValueDesC8()

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

//

TInt CIMPSSAPKeyValuePairs::GetValueDesC8( const TDesC& aKey, TPtrC8& aValue )

    {

    return GetValueFromPairs( iPairs, *iLookupKey, aKey, aValue );

    }

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

// CIMPSSAPKeyValuePairs::GetValueDesC16()

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

//

TInt CIMPSSAPKeyValuePairs::GetValueDesC16( const TDesC& aKey, TPtrC16& aValue )

    {

    return GetValueFromPairs( iPairs, *iLookupKey, aKey, aValue );

    }

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

// CIMPSSAPKeyValuePairs::DeletePair()

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

//

TInt CIMPSSAPKeyValuePairs::DeletePair( const TDesC& aKey )

    {

    iLookupKey->SetLookupKey( aKey );

    TInt index = iPairs.FindInOrder( iLookupKey, KEYWORD_ORDER );

    if ( index != KErrNotFound )

        {

        delete iPairs[ index ];

        iPairs.Remove( index );

        index = KErrNone;

        }

    iLookupKey->ResetLookupKey();

    return index;

    }

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

// CIMPSSAPKeyValuePairs::Pairs()

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

//

const RPointerArray< CIMPSSAPKeyValuePair >& CIMPSSAPKeyValuePairs::Pairs() const

    {

    return iPairs;

    }

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

// CIMPSSAPKeyValuePairs::Pairs()

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

//

RPointerArray< CIMPSSAPKeyValuePair >& CIMPSSAPKeyValuePairs::Pairs()

    {

    return iPairs;

    }

//  End of File