/*

* Copyright (c) 2006 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:   Implementation of CNcdKeyValuePair

*

*/

#include <s32strm.h> 

#include <s32mem.h>

#include "ncdutils.h"

#include "catalogsutils.h"

#include "catalogsdebug.h"

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

// NewL

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

//    

EXPORT_C CNcdKeyValuePair* CNcdKeyValuePair::NewL( const TDesC& aKey,

    const TDesC& aValue )

    {

    CNcdKeyValuePair* self = CNcdKeyValuePair::NewLC( aKey, aValue );

    CleanupStack::Pop();

    return self;

    }

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

// NewLC

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

//    

EXPORT_C CNcdKeyValuePair* CNcdKeyValuePair::NewLC( const TDesC& aKey, 

    const TDesC& aValue )

    {

    CNcdKeyValuePair* self = new( ELeave ) CNcdKeyValuePair;

    CleanupStack::PushL( self );

    self->ConstructL( aKey, aValue );

    return self;

    }

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

// Copy creator

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

//	

EXPORT_C CNcdKeyValuePair* CNcdKeyValuePair::NewL( 

    const MNcdKeyValuePair& aOther )

    {

    // Using normal constructor

    CNcdKeyValuePair* self = CNcdKeyValuePair::NewLC( aOther );

    CleanupStack::Pop( self );

    return self;

    }    

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

// Copy creator

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

//	

EXPORT_C CNcdKeyValuePair* CNcdKeyValuePair::NewLC( 

    const MNcdKeyValuePair& aOther )

    {

    // Using normal constructor

    CNcdKeyValuePair* self = new ( ELeave ) CNcdKeyValuePair();

    CleanupStack::PushL( self );

    self->ConstructL( aOther.Key(), aOther.Value() );

    return self;

    }    

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

// NewL

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

//	

EXPORT_C CNcdKeyValuePair* CNcdKeyValuePair::NewL( RReadStream& aStream )

    {

    CNcdKeyValuePair* self = CNcdKeyValuePair::NewLC( aStream );

    CleanupStack::Pop();

    return self;

    }

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

// NewLC

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

//	

EXPORT_C CNcdKeyValuePair* CNcdKeyValuePair::NewLC( RReadStream& aStream )

    {

    CNcdKeyValuePair* self = new( ELeave ) CNcdKeyValuePair;

    CleanupStack::PushL( self );

    self->InternalizeL( aStream );

    return self;

    }

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

// Destructor

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

//    

CNcdKeyValuePair::~CNcdKeyValuePair()

    {

    delete iKey;

    delete iValue;

    }

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

// Key

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

//    

const TDesC& CNcdKeyValuePair::Key() const

    {

    DASSERT( iKey );

    return *iKey;

    }

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

// SetKeyL

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

//    

EXPORT_C void CNcdKeyValuePair::SetKeyL( const TDesC& aKey )

    {

    if ( !aKey.Length() ) 

        {

        User::Leave( KErrArgument );

        }

    HBufC* temp = aKey.AllocL();

    delete iKey;

    iKey = temp;

    }

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

// Value

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

//    

const TDesC& CNcdKeyValuePair::Value() const

    {

    DASSERT( iValue );

    return *iValue;        

    }

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

// SetValueL

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

//    

EXPORT_C void CNcdKeyValuePair::SetValueL( const TDesC& aValue )

    {

    HBufC* temp = aValue.AllocL();

    delete iValue;

    iValue = temp;

    }

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

// Matcher

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

//	

EXPORT_C TBool CNcdKeyValuePair::MatchByKey( const CNcdKeyValuePair& aFirst, 

    const CNcdKeyValuePair& aSecond )

    {

    return ( aFirst.Key().Compare( aSecond.Key() ) == 0 );

    }

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

// ExternalizeL

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

//    

EXPORT_C void CNcdKeyValuePair::ExternalizeL( RWriteStream& aStream ) const

    {

    ExternalizeDesL( *iKey, aStream );

    ExternalizeDesL( *iValue, aStream );

    }

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

// ExternalizeL

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

//    

EXPORT_C HBufC8* CNcdKeyValuePair::ExternalizeToDesLC() const

    {

    HBufC8* ext = HBufC8::NewLC( 2 * ( sizeof(TInt) + iKey->Length() + 

        iValue->Length() ) );

    TPtr8 ptr( ext->Des() );

    RDesWriteStream stream( ptr );        

    CleanupClosePushL( stream );

    ExternalizeDesL( *iKey, stream );

    ExternalizeDesL( *iValue, stream );    

    CleanupStack::PopAndDestroy( &stream );

    return ext;

    }

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

// InternalizeL

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

//    

EXPORT_C void CNcdKeyValuePair::InternalizeL( RReadStream& aStream )

    {

    InternalizeDesL( iKey, aStream );

    InternalizeDesL( iValue, aStream );

    }

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

// ConstructL

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

//    

void CNcdKeyValuePair::ConstructL( const TDesC& aKey, const TDesC& aValue )

    {

    if ( !aKey.Length() ) 

        {

        User::Leave( KErrArgument );

        }

    iKey = aKey.AllocL();

    iValue = aValue.AllocL();

    }

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

// Constructor

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

//    

CNcdKeyValuePair::CNcdKeyValuePair()

    {

    }