/*

* Copyright (c) 2007 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:    Represents ICE valid list.

*

*/

#include "natfwcredentials.h"

#include "natfwcandidatepair.h"

#include "natfwcandidate.h"

#include "cicevalidlist.h"

#include "icecandidatehandlerlogs.h"

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

CIceValidList::CIceValidList( TUint aCollectionId )

    :

    iCollectionId( aCollectionId )

    {

    __ICEDP( "CIceValidList::CIceValidList" )

    }

CIceValidList* CIceValidList::NewL( TUint aCollectionId )

    {

    __ICEDP( "CIceValidList::NewL" )

    CIceValidList* self 

        = CIceValidList::NewLC( aCollectionId );

    CleanupStack::Pop( self );

    return self;

    }

CIceValidList* CIceValidList::NewLC( TUint aCollectionId )

    {

    __ICEDP( "CIceValidList::NewLC" )

    CIceValidList* self 

        = new( ELeave ) CIceValidList( aCollectionId );

    CleanupStack::PushL( self );

    return self;

    }

CIceValidList::~CIceValidList()

    {

    __ICEDP( "CIceValidList::~CIceValidList" )

    iValidList.ResetAndDestroy();

    }

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

// CIceValidList::StreamCollectionId

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

//

TUint CIceValidList::StreamCollectionId() const

    {

    __ICEDP( "CIceValidList::StreamCollectionId" )

    return iCollectionId;

    }

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

// CIceValidList::AddValidPairL

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

//

void CIceValidList::AddValidPairL( const CNATFWCandidatePair& aPair )

    {

    __ICEDP( "CIceValidList::AddValidPairL" )

    // check if existing pair needs to be updated

    TBool existingPairFound( EFalse );

    TInt validPairInd( iValidList.Count() - 1 );

    while ( !existingPairFound && 0 <= validPairInd )

        {

        if ( aPair.LocalCandidate().ComponentId() 

                == iValidList[validPairInd]->LocalCandidate().ComponentId()

            && aPair.Priority() == iValidList[validPairInd]->Priority() )

            {

            existingPairFound = ETrue;

            iValidList[ validPairInd ]->CopyL( aPair );

            }

        validPairInd--;

        }

    if ( !existingPairFound )

        {

        // add new pair to the valid list

        CNATFWCandidatePair* newPair = CNATFWCandidatePair::NewLC( aPair );

        iValidList.InsertInOrderL( 

            newPair, CNATFWCandidatePair::PriorityOrder );

        CleanupStack::Pop( newPair );

        }

    }

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

// CIceValidList::HasPair

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

//

TBool CIceValidList::HasPair( const CNATFWCandidatePair& aPair ) const

    {

    __ICEDP( "CIceValidList::HasPair" )

    TInt ind = iValidList.Find( &aPair, CNATFWCandidatePair::MatchAddresses );

    return ( KErrNotFound != ind );

    }

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

// CIceValidList::HasPairForComponents

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

//

TBool CIceValidList::HasPairForComponents( 

        RArray<TUint>& aComponentIds ) const

    {

    __ICEDP( "CIceValidList::HasPairForComponents" )

    TInt numOfComponents( aComponentIds.Count() );

    ASSERT( numOfComponents );

    TInt numOfValidPairs( iValidList.Count() );

    for ( TInt i( 0 ); i < numOfComponents; ++i )

        {

        TUint compId( aComponentIds[i] );

        TBool validPairExists( EFalse );

        for ( TInt j( 0 ); j < numOfValidPairs; j++ )

            {

            if ( iValidList[j]->LocalCandidate().ComponentId() == compId )

                {

                validPairExists = ETrue;

                }

            }

        if ( !validPairExists )

            {

            __ICEDP( "CIceValidList::HasPairForComponents, EFalse" )

            return EFalse;

            }

        }

    __ICEDP( "CIceValidList::HasPairForComponents, ETrue" )

    return ETrue;

    }

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

// CIceValidList::SetPairNominatedL

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

//

void CIceValidList::SetPairNominatedL( const CNATFWCandidatePair& aPair )

    {

    __ICEDP( "CIceValidList::SetPairNominatedL" )

    TInt ind = iValidList.Find( &aPair, CNATFWCandidatePair::MatchAddresses );

    User::LeaveIfError( ind );

    iValidList[ind]->SetSelected( ETrue );

    }

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

// CIceValidList::NominatedPairsExist

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

//

TBool CIceValidList::NominatedPairsExist( 

        RArray<TUint>& aComponentIds ) const

    {

    __ICEDP( "CIceValidList::NominatedPairsExist" )

    TInt ind( aComponentIds.Count() );

    ASSERT( aComponentIds.Count() );

    while ( ind-- )

        {

        if ( NULL == SelectedPair( aComponentIds[ind] ) )

            {

            return EFalse;

            }

        }

    return ETrue;

    }

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

// CIceValidList::SelectedPair

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

//

const CNATFWCandidatePair* 

    CIceValidList::SelectedPair( TUint aComponentId ) const

    {

    __ICEDP( "CIceValidList::SelectedPair" )

    TInt count( iValidList.Count() );

    for ( TInt i( 0 ); i < count; ++i )

        {

        CNATFWCandidatePair* item( iValidList[i] );

        if ( item->Selected() 

            && item->LocalCandidate().ComponentId() == aComponentId )

            {

            return item;

            }

        }

    return NULL;

    }

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

// CIceValidList::HighestPriorityPair

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

//

const CNATFWCandidatePair* CIceValidList::HighestPriorityPair( 

        TUint aComponentId ) const

    {

    __ICEDP( "CIceValidList::HighestPriorityPair" )

    TInt count( iValidList.Count() );

    for ( TInt i( 0 ); i < count; ++i )

        {

        CNATFWCandidatePair* item( iValidList[i] );

        if ( item->LocalCandidate().ComponentId() == aComponentId )

            {

            return item;

            }

        }

    return NULL;

    }

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

// CIceValidList::FlushValidList

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

//

void CIceValidList::FlushValidList()

    {

    __ICEDP( "CIceValidList::FlushValidList" )

    iValidList.ResetAndDestroy();

    }