/*

* 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:  sorting routine. uses Symbian services: User::QuickSort

*

*/

//INCLUDES

#include <e32std.h>

#include <alf/ialfmap.h>

#include <alf/alfvarianttype.h>

#include <alf/ialfsortfunction.h>

//#include "alf/alfperf.h"

#include "alfsort.h"

using namespace Alf;

/**

*  Defines the characteristics of a key used

*  to access the elements of an array. Used for sort.

*  @since S60 ?S60_version

*/

NONSHARABLE_CLASS(AlfSortKey) : public TKey

    {

public:

    /**

     * constructor

     *

     * @since S60 ?S60_version

     * @param aSortFunction callback interface for sort.

     * @param aArr array to sort.

     * @param aCount. count of items in the array.

     */

    AlfSortKey( const IAlfSortFunction& aSortFunction,

    IAlfVariantType** aArr, uint aCount );

    /**

     * returns data from array

     *

     * @since S60 ?S60_version

     * @param anIndex index to element to return

     * @return element at index anIndex.

     */

    TAny *At(TInt anIndex) const;

    /**

     * compares two items.

     *

     * @since S60 ?S60_version

     * @param aLeft index to the array for left parameter.

     * @return the value returned from sort function:

     *  < 0, if aFirst is less than aSecond,

     *  > 0 if aFirst is more than aSecond,

     *  0, if aFirst equals aSecond.

     */

    TInt Compare(TInt aLeft, TInt aRight) const;

private:

    //sort function not owned.

    const IAlfSortFunction& iSortFunction;

    //array to sort. not owned

    IAlfVariantType** iArr;

    //count of items in array.

    uint iCount;

    };

/**

*  Defines the basic behaviour for swapping two elements of an array.

*  Used for sort

*  @since S60 ?S60_version

*/

NONSHARABLE_CLASS(AlfSortSwap) : public TSwap

    {

public:

    /**

     * constructor

     *

     * @since S60 ?S60_version

     * @param aArr array, which elements are to be swapped.

     * @param aCount. count of items in the array.

     */

    AlfSortSwap( IAlfVariantType** aArr, uint aCount );

    /**

     * swaps two items in the array.

     *

     * @since S60 ?S60_version

     * @param aLeft  left index

     * @param aRight right index.

     */

    void Swap(TInt aLeft, TInt aRight) const;

private:

    //array, which elements are to be swapped. Not owned.

    IAlfVariantType** iArr;

    //count of items in the array.

    uint iCount;

    };

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

// Description : constructor

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

//

AlfSortKey::AlfSortKey( const IAlfSortFunction& aSortFunction,

                        IAlfVariantType** aArr, uint aCount ) :

        iSortFunction(aSortFunction), iArr(aArr), iCount(aCount)

    {

    }

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

// Description : return element from index anIndex.

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

//

TAny *AlfSortKey::At(TInt anIndex) const

    {

    return iArr[anIndex];

    }

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

// Description : compares two items.

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

//

TInt AlfSortKey::Compare(TInt aLeft, TInt aRight) const

    {

    const IAlfMap* leftMap = iArr[aLeft]->map();

    const IAlfMap* rightMap = iArr[aRight]->map();

    return iSortFunction.compareLeafs( leftMap, rightMap );

    }

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

// Description : constructor

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

//

AlfSortSwap::AlfSortSwap( IAlfVariantType** aArr, uint aCount ) :

        iArr(aArr), iCount(aCount)

    {

    }

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

// Description : swaps two items

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

//

void AlfSortSwap::Swap(TInt aLeft, TInt aRight) const

    {

    IAlfVariantType* tmp = iArr[aLeft];

    iArr[aLeft] = iArr[aRight];

    iArr[aRight] = tmp;

    }

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

// Description : The sorting routine.

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

//

void AlfSort::sort(IAlfVariantType** aArr, uint aCount,

                   const IAlfSortFunction& aSortFunction )

    {

    //ALF_PERF_START( perfdata, "AlfSort-Sort-Sorting")

    AlfSortKey key(aSortFunction, aArr, aCount);

    AlfSortSwap swap(aArr, aCount);

    User::QuickSort( aCount, key, swap );

    //ALF_PERF_STOP( perfdata, "AlfSort-Sort-Sorting")

    }