/*
* 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:   CNcdKeyValueMap implementation
*
*/


#include <s32strm.h>
#include <s32mem.h>

#include "ncdkeyvaluemap.h"
#include "ncdkeyvaluepair.h"

#include "catalogsdebug.h"
#include "ncdutils.h"

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

// ---------------------------------------------------------------------------
// Creator
// ---------------------------------------------------------------------------
//	
CNcdKeyValueMap* CNcdKeyValueMap::NewL()
    {
    CNcdKeyValueMap* self = CNcdKeyValueMap::NewLC();
    CleanupStack::Pop();
    return self;
    }


// ---------------------------------------------------------------------------
// Creator
// ---------------------------------------------------------------------------
//	
CNcdKeyValueMap* CNcdKeyValueMap::NewLC()
    {
    CNcdKeyValueMap* self = new ( ELeave ) CNcdKeyValueMap();
    CleanupStack::PushL( self );
    return self;
    }


// ---------------------------------------------------------------------------
// Copy creator
// ---------------------------------------------------------------------------
//	    
CNcdKeyValueMap* CNcdKeyValueMap::NewL( const 
    CNcdKeyValueMap& aOther )
    {
    CNcdKeyValueMap* self = new ( ELeave )
        CNcdKeyValueMap( aOther );
    CleanupStack::PushL( self );
    self->ConstructL( aOther );
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// Cloner
// ---------------------------------------------------------------------------
//	        
CNcdKeyValueMap* CNcdKeyValueMap::CloneL() const
    {
    return NewL( *this );    
    }
  

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//	
CNcdKeyValueMap::~CNcdKeyValueMap()
    { 
    iPairs.ResetAndDestroy();
    }
    
    
// ---------------------------------------------------------------------------
// Pair adder
// ---------------------------------------------------------------------------
//	
void CNcdKeyValueMap::AddL( const TDesC& aKey, const TDesC& aValue )
    {    
    DLTRACEIN( ( "" ) );
    
    // Add the replacement
    CNcdKeyValuePair* pair = CNcdKeyValuePair::NewLC( 
        aKey, aValue );
    User::LeaveIfError( iPairs.Append( pair ) );
    CleanupStack::Pop( pair );    
    DLTRACEOUT( ( "" ) );
    }


// ---------------------------------------------------------------------------
// Pair adder
// ---------------------------------------------------------------------------
//	
void CNcdKeyValueMap::AddL( CNcdKeyValuePair* aPair )
    {    
    DLTRACEIN((""));
        
    // Add the replacement
    iPairs.AppendL( aPair );    
    }



// ---------------------------------------------------------------------------
// Pair replacer
// ---------------------------------------------------------------------------
//	
void CNcdKeyValueMap::ReplaceL( CNcdKeyValuePair* aPair )
    {
    DLTRACEIN((""));    
    // Remove existing pair with the same key if any
    TInt err = Remove( aPair->Key() );
    if ( err != KErrNone && err != KErrNotFound )
        {
        User::Leave( err );
        }
    AddL( aPair );    
    }
    

// ---------------------------------------------------------------------------
// Pair remover
// ---------------------------------------------------------------------------
//	
TInt CNcdKeyValueMap::Remove( const TDesC& aKey )
    {
    DLTRACEIN((""));
    TRAPD(err,
        {        
        err = KErrNotFound;
        TIdentityRelation<CNcdKeyValuePair> match( 
            CNcdKeyValuePair::MatchByKey );

        CNcdKeyValuePair* pair = CNcdKeyValuePair::NewLC( aKey, 
            KNullDesC );    

        TInt index = iPairs.Find( pair, match );

        if ( index != KErrNotFound )
            {
            CNcdKeyValuePair* removed = iPairs[index];
            iPairs.Remove( index );
            delete removed;

            err = KErrNone;
            }

        CleanupStack::PopAndDestroy( pair );
        
        } ); //TRAPD    
    return err;        
    }
           

// ---------------------------------------------------------------------------
// Pair list getter
// ---------------------------------------------------------------------------
//	            
RPointerArray<CNcdKeyValuePair>& CNcdKeyValueMap::Pairs()
    {
    return iPairs;
    }


// ---------------------------------------------------------------------------
// Pair list getter
// ---------------------------------------------------------------------------
//	            
const RPointerArray<CNcdKeyValuePair>& CNcdKeyValueMap::Pairs() 
    const
    {
    return iPairs;
    }


// ---------------------------------------------------------------------------
// Search for a value by key
// ---------------------------------------------------------------------------
//	            
const TDesC& CNcdKeyValueMap::ValueByKeyL( const TDesC& aKey ) const
    {
    CNcdKeyValuePair* pair = CNcdKeyValuePair::NewLC( aKey, 
        KNullDesC );
    return FindValueL( pair );
    }


// ---------------------------------------------------------------------------
// Value exists
// ---------------------------------------------------------------------------
//	
CNcdKeyValueMap::KeyValueIndex CNcdKeyValueMap::KeyExists( 
    const TDesC& aKey ) const
    {
    DLTRACEIN(( _L("Key: %S"), &aKey ));
    
    for ( TInt i = 0; i < iPairs.Count(); ++i ) 
        {
        if ( iPairs[i]->Key().Compare( aKey ) == 0 ) 
            {
            DLTRACEOUT(("index: %d", i));
            return i;
            }
        }
        
    DLTRACEOUT(("Key not found"));
    return KErrNotFound;    
    }

// ---------------------------------------------------------------------------
// Returns a value by index
// ---------------------------------------------------------------------------
//	
const TDesC& CNcdKeyValueMap::ValueByIndex( const KeyValueIndex& aIndex ) const
    {
    DASSERT( aIndex >= 0 && aIndex < iPairs.Count() );
    return iPairs[aIndex]->Value();
    }
        

// ---------------------------------------------------------------------------
// Pair exists
// ---------------------------------------------------------------------------
//	
CNcdKeyValueMap::KeyValueIndex CNcdKeyValueMap::PairExists( 
    const CNcdKeyValuePair& aPair ) const
    {
    DLTRACEIN((""));
    for ( TInt i = 0; i < iPairs.Count(); ++i )
        {
        if ( iPairs[i]->Key().Compare( aPair.Key() ) == 0 && 
             iPairs[i]->Value().Compare( aPair.Value() ) == 0 )
            {
            return i;
            }        
        }
    
    DLTRACEOUT(("Key not found"));
    return KErrNotFound;            
    }


// ---------------------------------------------------------------------------
// Reset and destroy
// ---------------------------------------------------------------------------
//	
void CNcdKeyValueMap::ResetAndDestroy()
    {
    iPairs.ResetAndDestroy();
    }


// ---------------------------------------------------------------------------
// Reset
// ---------------------------------------------------------------------------
//	
void CNcdKeyValueMap::Reset()
    {
    iPairs.Reset();
    }


// ---------------------------------------------------------------------------
// Reset
// ---------------------------------------------------------------------------
//	
void CNcdKeyValueMap::AppendL( const CNcdKeyValueMap& aMap )
    {
    DLTRACEIN((""));
    const RPointerArray<CNcdKeyValuePair>& pairs( aMap.Pairs() );
    TInt count = pairs.Count();
    iPairs.ReserveL( iPairs.Count() + count );
    for ( TInt i = 0; i < count; ++i )
        {
        CNcdKeyValuePair* pair = CNcdKeyValuePair::NewLC( 
            *aMap.iPairs[i] );        
        iPairs.Append( pair );
        CleanupStack::Pop( pair );        
        }
    }


// ---------------------------------------------------------------------------
// ExternalizeL
// ---------------------------------------------------------------------------
//	
void CNcdKeyValueMap::ExternalizeL( RWriteStream& aStream ) const
    {
    aStream.WriteInt32L( iPairs.Count() );
    for ( TInt i = 0; i < iPairs.Count(); ++i )
        {
        iPairs[i]->ExternalizeL( aStream );
        }
    
    }


// ---------------------------------------------------------------------------
// ExternalizeL
// ---------------------------------------------------------------------------
//	    
void CNcdKeyValueMap::ExternalizeL( RBuf8& aTarget ) const
    {
    DLTRACEIN((""));
    TInt totalLength = 0;
    
    // Calculate total needed memory    
    for ( TInt i = 0; i < iPairs.Count(); ++i ) 
        {
        totalLength += iPairs[i]->Key().Length() + iPairs[i]->Value().Length() 
            + 2*sizeof(TInt32);
        }
    
    // 16bits = 2 * 8bits
    totalLength *= 2;
    aTarget.Close();
    
    // Total length of pairs + length of pair count
    aTarget.CreateL( totalLength + sizeof(TInt32) );
    
    // Open a write stream to the buffer
    RDesWriteStream stream( aTarget );
    CleanupClosePushL( stream );
    
    // Write count
    stream.WriteInt32L( iPairs.Count() );
    
    DLTRACE(("Externalize pairs"));
    for ( TInt i = 0; i < iPairs.Count(); ++i ) 
        {
        iPairs[i]->ExternalizeL( stream );
        }
    CleanupStack::PopAndDestroy( &stream );
    DLTRACEOUT((""));
    }
    
    
// ---------------------------------------------------------------------------
// InternalizeL
// ---------------------------------------------------------------------------
//	    
void CNcdKeyValueMap::InternalizeL( RReadStream& aStream )
    {
    DLTRACEIN((""));
    TInt count = aStream.ReadInt32L();
    DLTRACE(("Reading %d pairs", count));
    
    iPairs.ResetAndDestroy();
    if ( count ) 
        {   
        DLTRACE(("Internalizing pairs"));             
        iPairs.ReserveL( count );
        CNcdKeyValuePair* pair = NULL;
        
        // Internalize pairs
        for ( TInt i = 0; i < count; ++i ) 
            {            
            pair = CNcdKeyValuePair::NewL( aStream );
            DLTRACE( ( _L("Key: %S, value: %S"), &pair->Key(), &pair->Value() ));
            // Append cannot fail
            iPairs.Append( pair );
            }
        }
                    
    DLTRACEOUT((""));
    }

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//	
CNcdKeyValueMap::CNcdKeyValueMap()
    {
    }

// ---------------------------------------------------------------------------
// Copy constructor
// ---------------------------------------------------------------------------
//	
CNcdKeyValueMap::CNcdKeyValueMap( 
    const CNcdKeyValueMap& /*aOther*/ )
    {
    // The actual copying is done in ConstructL( aOther )
    }


// ---------------------------------------------------------------------------
// 2nd phase constructor
// ---------------------------------------------------------------------------
//	
void CNcdKeyValueMap::ConstructL( const CNcdKeyValueMap& aOther )
    {
    DLTRACEIN( ( _L("") ) );
    for( TInt i = 0; i < aOther.iPairs.Count(); ++i ) 
        {
        // Create a copy of the header and add it to the new header list
        CNcdKeyValuePair* pair = CNcdKeyValuePair::NewLC( 
            *aOther.iPairs[i] );        
        iPairs.AppendL( pair );
        CleanupStack::Pop( pair );
        }
    DLTRACEOUT( ( _L("") ) );
    }


// ---------------------------------------------------------------------------
// Searches for the given key and returns the matching value
// ---------------------------------------------------------------------------
//	
const TDesC& CNcdKeyValueMap::FindValueL( 
    CNcdKeyValuePair* aPair ) const
    {
    TIdentityRelation<CNcdKeyValuePair> match( 
        CNcdKeyValuePair::MatchByKey );
    
    TInt index = iPairs.Find( aPair, match );

    if ( index == KErrNotFound )
        {
        User::Leave( KErrNotFound );
        }
    CleanupStack::PopAndDestroy( aPair );
    return iPairs[index]->Value();        
    }