smbmusicaplibalgorithm.inl

索爱手机代码

/* Copyright (C) 2006 Sony Ericsson Mobile Communications Japan, Inc. */
/*--------------------------------------------------------------------*/
// FileName:
//	SmbMusicAPLibAlgorithm.inl
//
// Description:
//	PTX810 Music傾僾儕 儈儏乕僕僢僋嫟捠儔僀僽儔儕
/*--------------------------------------------------------------------*/
//曄峏棜楌
//擔晅			|曄峏幰			|撪梕
//--------------+---------------+--------------------------------------
//2006/09/23	|SEMC崃绮		|僼傽僀儖僔僗僥儉嫟捠儔僀僽儔儕偐傜愗傝弌偟

/**
 *  $Revision: 1.3 $ $Date: 2006/04/05 17:21:27 $
 */

#include    "TSmbMusicAPLibFunctional.h"  // for TSmbMusicAPLib_less<T>, TSmbMusicAPLib_equal_to<T>, Bind1st()
#include    "TSmbMusicAPLibIterator.h"      		// for Distance(), Advance()




SEMCJ_NAMESPACE_BEGIN
MUSICAPLIB_NAMESPACE_BEGIN

// ----------------------------------------------------------------------------
//  Swap()
// ----------------------------------------------------------------------------
template<typename T>
inline void Swap( T& a1, T& a2 )
    {
    const T tmp(a1);
    a1 = a2;
    a2 = tmp;
    }

// ----------------------------------------------------------------------------
//  MyMin()
// ----------------------------------------------------------------------------
template<typename T>
inline const T& MyMin( const T& a1, const T& a2 )
    {
    return MyMin( a1, a2, TSmbMusicAPLib_less<T>() );
    }

// ----------------------------------------------------------------------------
//  MyMin()
// ----------------------------------------------------------------------------
template<typename T, typename Compare>
inline const T& MyMin( const T& a1, const T& a2, Compare aCmp )
    {
    return aCmp(a1, a2) ? a1 : a2;
    }

// ----------------------------------------------------------------------------
//  MyMax()
// ----------------------------------------------------------------------------
template<typename T>
inline const T& MyMax( const T& a1, const T& a2 )
    {
    return MyMax( a1, a2, TSmbMusicAPLib_less<T>() );
    }

// ----------------------------------------------------------------------------
//  MyMax()
// ----------------------------------------------------------------------------
template<typename T, typename Compare>
inline const T& MyMax( const T& a1, const T& a2, Compare aCmp )
    {
    return aCmp(a1, a2) ? a2 : a1;
    }

// ----------------------------------------------------------------------------
//  Equal()
// ----------------------------------------------------------------------------
template<typename InputIterator1, typename InputIterator2>
inline TBool Equal( InputIterator1 aFirst1, InputIterator1 aLast1, InputIterator2 aFirst2 )
    {
    for (/*none*/; aFirst1 != aLast1; ++aFirst1, ++aFirst2)
        {
        if (!(*aFirst1 == *aFirst2))
            return EFalse;
        }
    return ETrue;
    }

// ----------------------------------------------------------------------------
//  Equal()
// ----------------------------------------------------------------------------
template<typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
inline TBool Equal( InputIterator1 aFirst1, InputIterator1 aLast1, InputIterator2 aFirst2, BinaryPredicate aBinPred )
    {
    for (/*none*/; aFirst1 != aLast1; ++aFirst1, ++aFirst2)
        {
        if (!aBinPred(*aFirst1, *aFirst2))
            return EFalse;
        }
    return ETrue;
    }

// ----------------------------------------------------------------------------
//  Lexicographical_compare()
// ----------------------------------------------------------------------------
template<typename InputIterator1, typename InputIterator2>
inline TBool Lexicographical_compare( InputIterator1 aFirst1, InputIterator1 aLast1, InputIterator2 aFirst2, InputIterator2 aLast2 )
    {
    for (/*none*/; aFirst1 != aLast1  &&  aFirst2 != aLast2; ++aFirst1, ++aFirst2)
        {
        if (*aFirst1 < *aFirst2)
            return ETrue;
        if (*aFirst2 < *aFirst1)
            return EFalse;
        }
    return aFirst1 == aLast1  &&  aFirst2 != aLast2;
    }

// ----------------------------------------------------------------------------
//  Lexicographical_compare()
// ----------------------------------------------------------------------------
template<typename InputIterator1, typename InputIterator2, typename BinaryPredicate>
inline TBool Lexicographical_compare( InputIterator1 aFirst1, InputIterator1 aLast1, InputIterator2 aFirst2, InputIterator2 aLast2, BinaryPredicate aBinPred )
    {
    for (/*none*/; aFirst1 != aLast1  &&  aFirst2 != aLast2; ++aFirst1, ++aFirst2)
        {
        if (aBinPred(*aFirst1, *aFirst2))
            return ETrue;
        if (aBinPred(*aFirst2, *aFirst1))
            return EFalse;
        }
    return aFirst1 == aLast1  &&  aFirst2 != aLast2;
    }

// ----------------------------------------------------------------------------
//  Find()
// ----------------------------------------------------------------------------
template <typename InputIterator, typename T>
inline InputIterator Find( InputIterator aFirst, InputIterator aLast, const T& aVal )
    {
    while (aFirst != aLast  &&  !(*aFirst == aVal))
        ++aFirst;
    return aFirst;
    }

// ----------------------------------------------------------------------------
//  Find_if()
// ----------------------------------------------------------------------------
template <typename InputIterator, typename Predicate>
inline InputIterator Find_if( InputIterator aFirst, InputIterator aLast, Predicate aPred )
    {
    while (aFirst != aLast  &&  !aPred(*aFirst))
        ++aFirst;
    return aFirst;
    }

// ----------------------------------------------------------------------------
//  Find_first_of()
// ----------------------------------------------------------------------------
template <typename InputIterator, typename ForwardIterator>
inline InputIterator Find_first_of( InputIterator aFirst1, InputIterator aLast1, ForwardIterator aFirst2, ForwardIterator aLast2 )
    {
    for (/*none*/; aFirst1 != aLast1; ++aFirst1)
        for (ForwardIterator i = aFirst2; i != aLast2; ++i)
            if (*aFirst1 == *i)
                return aFirst1;
    return aLast1;
    }

// ----------------------------------------------------------------------------
//  Find_first_of()
// ----------------------------------------------------------------------------
template <typename InputIterator, typename ForwardIterator, typename BinaryPredicate>
inline InputIterator Find_first_of( InputIterator aFirst1, InputIterator aLast1, ForwardIterator aFirst2, ForwardIterator aLast2, BinaryPredicate aPred )
    {
    for (/*none*/ ; aFirst1 != aLast1; ++aFirst1)
        for (ForwardIterator i = aFirst2; i != aLast2; ++i)
            if (aPred( *aFirst1, *i ))
                return aFirst1;
    return aLast1;
    }

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

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

// ----------------------------------------------------------------------------
//  Fill()
// ----------------------------------------------------------------------------
template<typename ForwardIterator, typename T>
inline void Fill( ForwardIterator aFirst, ForwardIterator aLast, const T& aVal )
    {
    for (/*none*/; aFirst != aLast; ++aFirst)
        *aFirst = aVal;
    }

// ----------------------------------------------------------------------------
//  Fill_n()
// ----------------------------------------------------------------------------
template<typename OutputIterator, typename Size, typename T>
inline OutputIterator Fill_n( OutputIterator aFirst, Size aNum, const T& aVal )
    {
    for ( ; aNum > 0; --aNum, ++aFirst)
        *aFirst = aVal;
    return aFirst;
    }

// ----------------------------------------------------------------------------
//  Generate()
// ----------------------------------------------------------------------------
template<typename ForwardIterator, typename Generator>
inline void Generate( ForwardIterator aFirst, ForwardIterator aLast, Generator aGen )
    {
    for (/*none*/; aFirst != aLast; ++aFirst)
        *aFirst = aGen();
    }

// ----------------------------------------------------------------------------
//  Generate_n()
// ----------------------------------------------------------------------------
template<typename OutputIterator, typename Size, typename Generator>
inline OutputIterator Generate_n( OutputIterator aFirst, Size aNum, Generator aGen )
    {
    for (/*none*/; aNum > 0; --aNum, ++aFirst)
        *aFirst = aGen();
    return aFirst;
    }

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