/*

* Copyright (c) 2008-2009 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:    Item ordered for traversing lists

*

*/

#include "mglxmedialist.h"

#include "glxlistutils.h"

#include "glxmedialistiterator.h"

#include <glxtracer.h>

#include <glxlog.h>

#include <hal.h>

const TInt KSequentialIteratorInitialValue = -1;

// Default granularity of items to request for

const TUint KGlxBlockyIteratorDefaultGranularity = 15;

const TInt KGlxLowerMemoryLimitForCacheSize = 31500000; // 30 MB

const TInt KGlxUpperMemoryLimitForCacheSize = 52500000; // 50 MB

const TInt KMaxLowMemOffsetValue = 3;

const TInt KMinLowMemOffsetValue = 1;

EXPORT_C TGlxSequentialIterator::TGlxSequentialIterator()

    {

    TRACER("TGlxSequentialIterator::TGlxSequentialIterator");

    iList = NULL;

    iCurrentItem = KSequentialIteratorInitialValue;

    iRange = KMaxTInt;      // To support full list length iteration,if range is not set                         

    }

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

// Set to first item

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

//

void TGlxSequentialIterator::SetToFirst(const MGlxMediaList* aList)

    {

    TRACER("TGlxSequentialIterator::SetToFirst");

    __ASSERT_DEBUG(aList != NULL, Panic(EGlxPanicNullPointer));

    iList = aList;

    iCurrentItem = KSequentialIteratorInitialValue;

    }

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

// Return the next item index or KErrNotFound

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

//

TInt TGlxSequentialIterator::operator++(TInt) 

    {

    TRACER("TGlxSequentialIterator::operator++");

    iCurrentItem++;

    if (iCurrentItem < iList->Count() && iCurrentItem < iRange )

        {

        return iCurrentItem;

        }

    else

        {

        return KErrNotFound;

        }

    }

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

// Return ETrue if index is within range, EFalse otherwise

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

//

TBool TGlxSequentialIterator::InRange(TInt aIndex) const

    {

    TRACER("TGlxSequentialIterator::InRange");

    return (aIndex < iRange && aIndex < iList->Count() && aIndex >= 0);

    }

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

// SetRange

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

//

EXPORT_C void TGlxSequentialIterator::SetRange( TInt aRange )

    {

    TRACER("TGlxSequentialIterator::SetRange");

    iRange = aRange; 

    }

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

// Constructor

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

//

EXPORT_C TGlxSpecificIdIterator::TGlxSpecificIdIterator(const TGlxIdSpaceId& aIdSpaceId, TGlxMediaId aMediaId)

    : iMediaId(aMediaId), iIdSpaceId(aIdSpaceId), iFinished(EFalse)

    {

    TRACER("TGlxSpecificIdIterator::TGlxSpecificIdIterator");

    }

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

// Set to first item

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

//

void TGlxSpecificIdIterator::SetToFirst(const MGlxMediaList* aList)

    {

    TRACER("TGlxSpecificIdIterator::SetToFirst");

    __ASSERT_DEBUG(aList != NULL, Panic(EGlxPanicNullPointer));

    iList = aList;

    iFinished = EFalse;

    }

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

// Return the next item index or KErrNotFound

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

//

TInt TGlxSpecificIdIterator::operator++(TInt) 

    {

    TRACER("TGlxSpecificIdIterator::operator++");

    if (iFinished)

        {

        return KErrNotFound;

        }

    else

        {

        iFinished = ETrue;        

        return iList->Index(iIdSpaceId, iMediaId);

        }

    }

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

// Return ETrue if index is within range, EFalse otherwise

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

//

TBool TGlxSpecificIdIterator::InRange(TInt aIndex) const

    {

    TRACER("TGlxSpecificIdIterator::InRange");

    return (aIndex == iList->Index(iIdSpaceId, iMediaId));

    }

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

// Constructor

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

//

EXPORT_C TGlxFirstThenLastIterator::TGlxFirstThenLastIterator()

    {

    TRACER("TGlxFirstThenLastIterator::TGlxFirstThenLastIterator");

    iCurrentItem = 0;

    iList = NULL;

  }

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

// Destructor

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

//

EXPORT_C TGlxFirstThenLastIterator::~TGlxFirstThenLastIterator()

    {

    TRACER("TGlxFirstThenLastIterator::~TGlxFirstThenLastIterator");

    }

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

// Set to first item

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

//

void TGlxFirstThenLastIterator::SetToFirst(const MGlxMediaList* aList) 

    {

    TRACER("TGlxFirstThenLastIterator::SetToFirst");    

    __ASSERT_DEBUG(aList, Panic(EGlxPanicNullPointer));

    iList = aList;

    iCurrentItem = 0;

  }

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

// Return the next item index or KErrNotFound

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

//

TInt TGlxFirstThenLastIterator::operator++(TInt) 

    {

    TRACER("TGlxFirstThenLastIterator::operator++");    

    __ASSERT_DEBUG(iList != NULL, Panic(EGlxPanicNullPointer));

    TInt count = iList->Count();

    if (count <= 0)

        {

        return KErrNotFound;

        }

    if (iCurrentItem == 0) 

        {

        // Return first item index

       iCurrentItem++;

       return 0; 

        }

    if (iCurrentItem == 1) 

        {

        // Return last item index

        iCurrentItem++;

        return count - 1;

        }

  // At last item already

    return KErrNotFound; 

    }

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

// Return ETrue if index is within range, EFalse otherwise

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

//

TBool TGlxFirstThenLastIterator::InRange(TInt aIndex) const

    {

    TRACER("TGlxFirstThenLastIterator::InRange");

    __ASSERT_DEBUG(aIndex >= 0 && aIndex < iList->Count(), Panic(EGlxPanicIllegalArgument));

    // Return ETrue if first or last item

    return (aIndex == 0) || (aIndex == iList->Count() - 1);

    }

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

// Constructor

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

//

EXPORT_C TGlxFromFocusOutwardIterator::TGlxFromFocusOutwardIterator()

    {

    TRACER("TGlxFromFocusOutwardIterator::TGlxFromFocusOutwardIterator");

    iCurrentItem = 0;

    iFrontOffset = 0;

    iRearOffset = 0;

    iList = NULL;

  }

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

// Destructor

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

//

EXPORT_C TGlxFromFocusOutwardIterator::~TGlxFromFocusOutwardIterator()

    {

    TRACER("TGlxFromFocusOutwardIterator::~TGlxFromFocusOutwardIterator");

    } 

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

// Set range offsets

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

//

EXPORT_C void TGlxFromFocusOutwardIterator::SetRangeOffsets(TInt aRearOffset,

    TInt aFrontOffset)

    { 

    TRACER("TGlxFromFocusOutwardIterator::SetRangeOffsets");

    __ASSERT_DEBUG(aRearOffset >= 0 && aFrontOffset >= 0, Panic(EGlxPanicIllegalArgument)); 

    iFrontOffset = aFrontOffset;

    iRearOffset = aRearOffset;

    iOriginalFrontOffset = iFrontOffset;

    iOriginalRearOffset = iRearOffset;    

    }

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

// Set to first item

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

//

void TGlxFromFocusOutwardIterator::SetToFirst(const MGlxMediaList* aList) 

    {

    TRACER("TGlxFromFocusOutwardIterator::SetToFirst");

    __ASSERT_DEBUG(aList != NULL, Panic(EGlxPanicNullPointer));

    iList = aList;

    iCurrentItem = 0;

    }

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

// Return the item index or KErrNotFound, and goes to next

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

//

TInt TGlxFromFocusOutwardIterator::operator++(TInt) 

    {

    TRACER("TGlxFromFocusOutwardIterator::operator++");

    __ASSERT_DEBUG(iList != NULL, Panic(EGlxPanicNullPointer));

    TInt count = iList->Count();

    if (count <= 0)

        {

        return KErrNotFound;

        }

    if (iOriginalFrontOffset > KMaxLowMemOffsetValue && 

        iOriginalRearOffset > KMaxLowMemOffsetValue)

        {

        TInt freeMemory = 0;

        HAL::Get( HALData::EMemoryRAMFree, freeMemory );    

        if ( freeMemory < KGlxUpperMemoryLimitForCacheSize &&

             freeMemory > KGlxLowerMemoryLimitForCacheSize )

            {

            iFrontOffset = KMaxLowMemOffsetValue;

            iRearOffset = KMaxLowMemOffsetValue;

            }

        else if ( freeMemory < KGlxLowerMemoryLimitForCacheSize )

            {

            iFrontOffset = KMinLowMemOffsetValue;

            iRearOffset = KMinLowMemOffsetValue;

            }

        else if (iFrontOffset != iOriginalFrontOffset 

                 && iRearOffset!= iOriginalRearOffset)

            {

            iFrontOffset = Max(iFrontOffset, iOriginalFrontOffset );

            iRearOffset = Max(iRearOffset, iOriginalRearOffset );

            }

        }

   // Check if out of bounds

    if (iFrontOffset + iRearOffset < iCurrentItem || count <= iCurrentItem)

        {

        return KErrNotFound;

        }

    // The ranges may be inequal, which means there won't be any jumping between

    // front and rear. 

    // |-------F----------------------|

    // |< jumping zone>|

    TInt index = iList->FocusIndex();

    TInt min = Min(iFrontOffset, iRearOffset);

    TInt jumpingZoneLength = min * 2;

    if (iCurrentItem <= jumpingZoneLength) 

        {

        // Still within the (rear-front-rear-front) jumping zone

        TInt distanceFromFocus = (iCurrentItem + 1) / 2;

        TBool rear = !(iCurrentItem & 1); // Rear if number is even

        if (rear) 

             {

             index -= distanceFromFocus; 

             }

        else 

             {

             index += distanceFromFocus; 

             }

        }

     else 

         {

         __ASSERT_DEBUG(iFrontOffset != iRearOffset, Panic(EGlxPanicLogicError));

         // index is currently focus index. Figure out how much need to move.

         TInt indexesFromFocus = iCurrentItem - min; 

         if (iRearOffset < iFrontOffset)

             {

             // Front range is longer than rear, so the item is on the front side

             index += indexesFromFocus;

             }

         else 

             {

             // Rear range is longer than front, so the item is on the rear side

             index -= indexesFromFocus;

             }

         }

      iCurrentItem++;

      // The index may be below 0 or above count. Normalise back to list indexes.

      return GlxListUtils::NormalizedIndex(index, count); 

      } 

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

// Return ETrue if index is within range, EFalse otherwise

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

//

TBool TGlxFromFocusOutwardIterator::InRange(TInt aIndex) const

    {

    TRACER("TGlxFromFocusOutwardIterator::InRange");

    TInt count = iList->Count();

    // Handle the case where range is longer than count separately, because looping will

    // confuse otherwise

    if (count <= iRearOffset + iFrontOffset) 

        {

        // Range is longer than count, must be in range

        return ETrue;

        }

    TInt focusIndex = iList->FocusIndex();

    TInt firstInRange = GlxListUtils::NormalizedIndex(focusIndex - iRearOffset, count);

    TInt lastInRange = GlxListUtils::NormalizedIndex(focusIndex + iFrontOffset, count);

    if (firstInRange <= lastInRange)

        {

        // Normal case:  |    F-------L   |

        return aIndex >= firstInRange && aIndex <= lastInRange;

        }

    else 

        {

        // Looping case: |----L      F----|

        return aIndex <= lastInRange || aIndex >= firstInRange;

        }

    }

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

// Constructor

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

//

EXPORT_C TGlxFromIndexOutwardBlockyIterator::TGlxFromIndexOutwardBlockyIterator(

    const MGlxIndex& aIndexFunctor ) 

        : iIndexFunctor( aIndexFunctor )

    {

    TRACER("TGlxFromIndexOutwardBlockyIterator::TGlxFromIndexOutwardBlockyIterator");

    iCurrentItem = 0;

    iFrontOffset = 2 * KGlxBlockyIteratorDefaultGranularity;

    iRearOffset = 2 * KGlxBlockyIteratorDefaultGranularity;

    iList = NULL;

  }

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

// Destructor

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

//

EXPORT_C TGlxFromIndexOutwardBlockyIterator::~TGlxFromIndexOutwardBlockyIterator()

    {

    TRACER("TGlxFromIndexOutwardBlockyIterator::~TGlxFromIndexOutwardBlockyIterator");

    } 

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

// Set range offsets

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

//

EXPORT_C void TGlxFromIndexOutwardBlockyIterator::SetRangeOffsets(TInt aRearOffset,

    TInt aFrontOffset)

    { 

    TRACER("TGlxFromIndexOutwardBlockyIterator::SetRangeOffsets");

    __ASSERT_DEBUG(aRearOffset >= 0 && aFrontOffset >= 0, Panic(EGlxPanicIllegalArgument)); 

    iFrontOffset = Max(aFrontOffset, KGlxBlockyIteratorDefaultGranularity );

    iRearOffset = Max(aRearOffset, KGlxBlockyIteratorDefaultGranularity );

    }

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

// Set to first item

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

//

void TGlxFromIndexOutwardBlockyIterator::SetToFirst(const MGlxMediaList* aList) 

    {

    TRACER("TGlxFromIndexOutwardBlockyIterator::SetToFirst");

    __ASSERT_DEBUG(aList != NULL, Panic(EGlxPanicNullPointer));

    iList = aList;

    iCurrentItem = 0;

    }

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

// Return the item index or KErrNotFound, and goes to next

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

//

TInt TGlxFromIndexOutwardBlockyIterator::operator++(TInt) 

    {

    TRACER("TGlxFromIndexOutwardBlockyIterator::operator++");

    __ASSERT_DEBUG(iList != NULL, Panic(EGlxPanicNullPointer));

    TInt count = iList->Count();

    if (count <= 0)

        {

        return KErrNotFound;

        }

   // Check if out of bounds

    if (iFrontOffset + iRearOffset < iCurrentItem || count <= iCurrentItem)

        {

        return KErrNotFound;

        }

    // The ranges may be inequal, which means there won't be any jumping between

    // front and rear. 

    // |-------F----------------------|

    // |< jumping zone>|

    index -= index % KGlxBlockyIteratorDefaultGranularity;

    TInt min = Min(iFrontOffset, iRearOffset);

    TInt jumpingZoneLength = min * 2;

    if (iCurrentItem <= jumpingZoneLength) 

        {

        // Still within the (rear-front-rear-front) jumping zone

        TInt distanceFromFocus = (iCurrentItem + 1) / 2;

        TBool rear = !(iCurrentItem & 1); // Rear if number is even

        if (rear) 

             {

             index -= distanceFromFocus; 

             }

        else 

             {

             index += distanceFromFocus; 

             }

        }

     else 

         {

         __ASSERT_DEBUG(iFrontOffset != iRearOffset, Panic(EGlxPanicLogicError));

         // index is currently focus index. Figure out how much need to move.

         TInt indexesFromFocus = iCurrentItem - min; 

         if (iRearOffset < iFrontOffset)

             {

             // Front range is longer than rear, so the item is on the front side

             index += indexesFromFocus;

             }

         else