smbmusicaplibalgorithm.inl

索爱手机代码

//  For_each()
// ----------------------------------------------------------------------------
template<typename InputIterator, typename Function>
inline Function For_each( InputIterator aFirst, InputIterator aLast, Function aFunc )
    {
    for (/*none*/; aFirst != aLast; ++aFirst)
        aFunc( *aFirst );
    return aFunc;
    }

// ----------------------------------------------------------------------------
//  For_each_if()
// ----------------------------------------------------------------------------
template<typename InputIterator, typename Function, typename Predicate>
inline Function For_each_if( InputIterator aFirst, InputIterator aLast, Function aFunc, Predicate aPred )
    {
    for (/*none*/; aFirst != aLast; ++aFirst)
        {
        if (aPred( *aFirst ))
            aFunc( *aFirst );
        }
    return aFunc;
    }

// ----------------------------------------------------------------------------
//  Transform()
// ----------------------------------------------------------------------------
template<typename InputIterator, typename OutputIterator, typename UnaryOperation>
inline OutputIterator Transform( InputIterator aFirst, InputIterator aLast, OutputIterator aResult, UnaryOperation aUnaryOp )
    {
    for (/*none*/; aFirst != aLast; ++aFirst, ++aResult)
        *aResult = aUnaryOp( *aFirst );
    return aResult;
    }

// ----------------------------------------------------------------------------
//  Transform()
// ----------------------------------------------------------------------------
template<typename InputIterator1, typename InputIterator2, typename OutputIterator, typename BinaryOperation>
inline OutputIterator Transform( InputIterator1 aFirst1, InputIterator1 aLast1, InputIterator2 aFirst2, OutputIterator aResult, BinaryOperation aBinaryOp )
    {
    for (/*none*/; aFirst1 != aLast1; ++aFirst1, ++aFirst2, ++aResult)
        *aResult = aBinaryOp( *aFirst1, *aFirst2 );
    return aResult;
    }

// ----------------------------------------------------------------------------
//  Remove()
// ----------------------------------------------------------------------------
template<typename ForwardIterator, typename T>
inline ForwardIterator Remove( ForwardIterator aFirst, ForwardIterator aLast, const T& aVal )
    {
    aFirst = Find( aFirst, aLast, aVal );
    ForwardIterator i = aFirst;
    return aFirst == aLast ? aFirst : Remove_copy( ++i, aLast, aFirst, aVal );
    }

// ----------------------------------------------------------------------------
//  Remove_if()
// ----------------------------------------------------------------------------
template<typename ForwardIterator, typename Predicate>
inline ForwardIterator Remove_if( ForwardIterator aFirst, ForwardIterator aLast, Predicate aPred )
    {
    aFirst = Find_if( aFirst, aLast, aPred );
    ForwardIterator i = aFirst;
    return aFirst == aLast ? aFirst : Remove_copy_if( ++i, aLast, aFirst, aPred );
    }

// ----------------------------------------------------------------------------
//  Remove_copy()
// ----------------------------------------------------------------------------
template<typename InputIterator, typename OutputIterator, typename T>
inline OutputIterator Remove_copy( InputIterator aFirst, InputIterator aLast, OutputIterator aResult, const T& aVal )
    {
    return Remove_copy_if( aFirst, aLast, aResult, Bind1st(TSmbMusicAPLib_equal_to<T>(), aVal) );
    }

// ----------------------------------------------------------------------------
//  Remove_copy_if()
// ----------------------------------------------------------------------------
template<typename InputIterator, typename OutputIterator, typename Predicate>
inline OutputIterator Remove_copy_if( InputIterator aFirst, InputIterator aLast, OutputIterator aResult, Predicate aPred )
    {
    for (/*none*/; aFirst != aLast; ++aFirst)
        {
        if (!aPred(*aFirst))
            {
            *aResult = *aFirst;
            ++aResult;
            }
        }
    return aResult;
    }

// ----------------------------------------------------------------------------
//  Lower_bound()
// ----------------------------------------------------------------------------
template<typename ForwardIterator, typename T>
inline ForwardIterator Lower_bound( ForwardIterator aFirst, ForwardIterator aLast, const T& aVal )
    {
    return Lower_bound( aFirst, aLast, aVal, TSmbMusicAPLib_less<T>() );
    }

// ----------------------------------------------------------------------------
//  Lower_bound()
// ----------------------------------------------------------------------------
template<typename ForwardIterator, typename T, typename Compare>
inline ForwardIterator Lower_bound( ForwardIterator aFirst, ForwardIterator aLast, const T& aVal, Compare aCmp )
    {
    typedef TInt    DistanceType;

    DistanceType len = Distance( aFirst, aLast );
    while (len > 0)
        {
        DistanceType half = len >> 1;
        ForwardIterator middle = aFirst;
        Advance( middle, half );
        if (aCmp(*middle, aVal))
            {
            aFirst = middle;
            ++aFirst;
            len = len - half - 1;
            }
        else
            len = half;
        }
    return aFirst;
    }

// ----------------------------------------------------------------------------
//  Upper_bound()
// ----------------------------------------------------------------------------
template<typename ForwardIterator, typename T>
inline ForwardIterator Upper_bound( ForwardIterator aFirst, ForwardIterator aLast, const T& aVal )
    {
    return Upper_bound( aFirst, aLast, aVal, TSmbMusicAPLib_less<T>() );
    }

// ----------------------------------------------------------------------------
//  Upper_bound()
// ----------------------------------------------------------------------------
template<typename ForwardIterator, typename T, typename Compare>
inline ForwardIterator Upper_bound( ForwardIterator aFirst, ForwardIterator aLast, const T& aVal, Compare aCmp )
    {
    typedef TInt    DistanceType;

    DistanceType len = Distance( aFirst, aLast );
    while (len > 0)
        {
        DistanceType half = len >> 1;
        ForwardIterator middle = aFirst;
        Advance( middle, half );
        if (aCmp(aVal, *middle))
            len = half;
        else
            {
            aFirst = middle;
            ++aFirst;
            len = len - half - 1;
            }
        }
    return aFirst;
    }

// ----------------------------------------------------------------------------
//  Equal_range()
// ----------------------------------------------------------------------------
template<typename ForwardIterator, typename T>
inline TSmbMusicAPLibPair<ForwardIterator, ForwardIterator> Equal_range( ForwardIterator aFirst, ForwardIterator aLast, const T& aVal )
    {
    return Equal_range( aFirst, aLast, aVal, TSmbMusicAPLib_less<T>() );
    }

// ----------------------------------------------------------------------------
//  Equal_range()
// ----------------------------------------------------------------------------
template<typename ForwardIterator, typename T, typename Compare>
inline TSmbMusicAPLibPair<ForwardIterator, ForwardIterator> Equal_range( ForwardIterator aFirst, ForwardIterator aLast, const T& aVal, Compare aCmp )
    {
    typedef TInt    DistanceType;

    DistanceType len = Distance( aFirst, aLast );
    while (len > 0)
        {
        DistanceType half = len >> 1;
        ForwardIterator middle = aFirst;
        Advance( middle, half );
        if (aCmp(*middle, aVal))
            {
            aFirst = middle;
            ++aFirst;
            len = len - half - 1;
            }
        else if (aCmp(aVal, *middle))
            len = half;
        else
            {
            ForwardIterator left = Lower_bound( aFirst, middle, aVal, aCmp );
            Advance( aFirst, len );
            ForwardIterator right = Upper_bound( ++middle, aFirst, aVal, aCmp );
            return Make_pair( left, right );
            }
        }
    return Make_pair( aFirst, aFirst );
    }

// ----------------------------------------------------------------------------
//  Sort()
// ----------------------------------------------------------------------------
template<typename RandomAccessIterator>
inline void Sort( RandomAccessIterator aFirst, RandomAccessIterator aLast )
    {
    Sort( aFirst, aLast, TSmbMusicAPLib_less<typename TSmbMusicAPLib_iterator_traits<RandomAccessIterator>::value_type>() );
    }

// ----------------------------------------------------------------------------
//  Sort()
// ----------------------------------------------------------------------------
template<typename RandomAccessIterator, typename Compare>
inline void Sort( RandomAccessIterator aFirst, RandomAccessIterator aLast, Compare aCmp )
    {
    if (aFirst >= aLast)
        return;

    RandomAccessIterator pivot = aFirst;    // 愭摢傪悤幉偲偡傞丅
    RandomAccessIterator i = aFirst, j = aLast - 1;
    for (;;)
        {
        while (aCmp(*i, *pivot))   ++i;     // 悤幉埲忋偺抣偑尒偮偐傞傑偱塃偵恑傔傞丅
        while (aCmp(*pivot, *j))   --j;     // 悤幉埲壓偺抣偑尒偮偐傞傑偱嵍偵恑傔傞丅
        if (i >= j)
            break;
        Swap( *i, *j );
        ++i, --j;
        }

    if( aFirst < i - 1 )
        Sort( aFirst, i, aCmp );
    if( j + 2 < aLast )
        Sort( j + 1, aLast, aCmp );
    }

MUSICAPLIB_NAMESPACE_END
SEMCJ_NAMESPACE_END

/* Copyright (C) 2006 Sony Ericsson Mobile Communications Japan, Inc. */