/*

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

*

*/

#include "natfwcandidate.h"

#include "natfwcandidatepair.h"

#include "cicecheckprioritizer.h"

#include "ciceconnectivitycheck.h"

#include "icecandidatehandlerlogs.h"

/** variables used in priority calculation */

const TUint64 K2ToPowerOf32 = 2^32;

const TUint64 KNumValTwo = 2;

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

CIceCheckPrioritizer::CIceCheckPrioritizer()

    {

    __ICEDP( "CIceCheckPrioritizer::CIceCheckPrioritizer" )

    }

CIceCheckPrioritizer* CIceCheckPrioritizer::NewL()

    {

    __ICEDP( "CIceCheckPrioritizer::NewL" )

    CIceCheckPrioritizer* self = CIceCheckPrioritizer::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

CIceCheckPrioritizer* CIceCheckPrioritizer::NewLC()

    {

    __ICEDP( "CIceCheckPrioritizer::NewLC" )

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

    CleanupStack::PushL( self );

    return self;

    }

CIceCheckPrioritizer::~CIceCheckPrioritizer()

    {  

    __ICEDP( "CIceCheckPrioritizer::~CIceCheckPrioritizer" )

    }   

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

// CIceCheckPrioritizer::PrioritizePair

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

//  

void CIceCheckPrioritizer::PrioritizePair( CNATFWCandidatePair& aPair,

        TNATFWIceRole aCurrentRole ) const

    {

    __ICEDP( "CIceCheckPrioritizer::PrioritizePair" )

    /*

    ICE-17, section 5.7.2.

    Let G be the priority for the candidate provided by the controlling

    agent. Let D be the priority for the candidate provided by the

    controlled agent. The priority for a pair is computed as:

      pair priority = 2^32*MIN(G,D) + 2*MAX(G,D) + (G>D?1:0)

    Where G>D?1:0 is an expression whose value is 1 if G is greater than

    D, and 0 otherwise.  This formula ensures a unique priority for each

    pair.

    */

    TUint64 controllingPri( 0 );

    TUint64 controlledPri( 0 );

    if ( EIceRoleControlling == aCurrentRole )

        {

        controllingPri = aPair.LocalCandidate().Priority();

        controlledPri = aPair.RemoteCandidate().Priority();

        }

    else

        {

        controlledPri = aPair.LocalCandidate().Priority();

        controllingPri = aPair.RemoteCandidate().Priority();

        }

    TUint64 pairPri = K2ToPowerOf32 * Min( controllingPri, controlledPri )

        + KNumValTwo * Max( controllingPri, controlledPri )

        + ( 

            ( controllingPri > controlledPri ) ? TUint64( 1 ) : TUint64( 0 )

          );

    aPair.SetPriority( pairPri );

    }

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

// CIceCheckPrioritizer::PrioritizePairs

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

//  

void CIceCheckPrioritizer::PrioritizePairs( 

        RPointerArray<CNATFWCandidatePair>& aPairs,

        TNATFWIceRole aCurrentRole ) const

    {

    __ICEDP( "CIceCheckPrioritizer::PrioritizePairs" )

    TInt ind( aPairs.Count() );

    while ( ind-- )

        {

        PrioritizePair( *aPairs[ind], aCurrentRole );

        }

    }

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

// CIceCheckPrioritizer::PrioritizeCheck

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

//  

void CIceCheckPrioritizer::PrioritizeCheck( 

        CIceConnectivityCheck& aCheck, TNATFWIceRole aCurrentRole ) const

    {

    __ICEDP( "CIceCheckPrioritizer::PrioritizeCheck" )

    PrioritizePair( 

        const_cast<CNATFWCandidatePair&>( aCheck.CandidatePair() ), 

        aCurrentRole );

    }

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

// CIceCheckPrioritizer::PrioritizeChecks

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

//  

void CIceCheckPrioritizer::PrioritizeChecks( 

        RPointerArray<CIceConnectivityCheck>& aChecks,

        TNATFWIceRole aCurrentRole ) const

    {

    __ICEDP( "CIceCheckPrioritizer::PrioritizeChecks" )

    TInt ind( aChecks.Count() );

    while ( ind-- )

        {

        PrioritizeCheck( *aChecks[ind], aCurrentRole );

        }

    }