tsmbmusicaplibiterator.h

索爱手机代码

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

/** @file TSmbMusicAPLibIterator.h
 *  STL 偺 @<iterator@> 憡摉丅
 *
 *  $Revision: 1.3 $ $Date: 2006/05/13 09:47:40 $
 */

#ifndef __TSMBMUSICAPLIB_ITERATOR_H__
#define __TSMBMUSICAPLIB_ITERATOR_H__

#include    "SmbMusicAPLibConfig.h"
#include    "SmbMusicAPLibStddef.h"     // for size_t, ptrdiff_t

SEMCJ_NAMESPACE_BEGIN
MUSICAPLIB_NAMESPACE_BEGIN

// ----------------------------------------------------------------------------
//  斀暅巕偺庬椶傪昞偡僞僌孮丅
//
//  宆忣曬偩偗偑堄枴傪帩偮儅乕僇乕偱偁傝丄拞恎偼嬻偭傐丅
// ----------------------------------------------------------------------------
/** 擖椡斀暅巕傪昞偡僞僌丅 */
struct TSmbMusicAPLib_input_iterator_tag {};
/** 弌椡斀暅巕傪昞偡僞僌丅 */
struct TSmbMusicAPLib_output_iterator_tag {};
/** 慜曽岦斀暅巕傪昞偡僞僌丅 */
struct TSmbMusicAPLib_forward_iterator_tag : public TSmbMusicAPLib_input_iterator_tag {};
/** 憃曽岦斀暅巕傪昞偡僞僌丅 */
struct TSmbMusicAPLib_bidirectional_iterator_tag : public TSmbMusicAPLib_forward_iterator_tag {};
/** 儔儞僟儉傾僋僙僗斀暅巕傪昞偡僞僌丅 */
struct TSmbMusicAPLib_random_access_iterator_tag : public TSmbMusicAPLib_bidirectional_iterator_tag {};

/**
 *  斀暅巕偺婎掙僋儔僗丅
 *
 *  偙偺僋儔僗偼壗傕偣偢丄嫟捠偺 typedef 傪嫙媼偡傞偺傒丅
 *  偙傟傜偺 typedef 偼丄摿庩壔傗僆乕僶乕儘乕僪偵巊傢傟傞丅
 */
template<typename Category, typename T, typename Distance = size_t, typename Pointer = T*, typename Reference = T&>
struct TSmbMusicAPLib_iterator
    {
    typedef Category    iterator_category;  /**< 斀暅巕偺庬椶傪昞偡僇僥僑儕丅   */
    typedef T           value_type;         /**< 斀暅巕偑埖偆梫慺偺宆丅         */
    typedef Distance    difference_type;    /**< 斀暅巕娫偺嵎(嫍棧)傪昞偡宆丅   */
    typedef Pointer     pointer;            /**< 斀暅巕偑埖偆梫慺偺億僀儞僞宆丅 */
    typedef Reference   reference;          /**< 斀暅巕偑埖偆梫慺偺嶲徠宆丅     */
    };

/**
 *  斀暅巕偺摿惈丅
 *
 *  偙偺僋儔僗傕壗傕偣偢丄摿庩壔偺偨傔偺 nested typedef 傪掕媊偡傞偺傒丅
 */
template<typename Iterator>
struct TSmbMusicAPLib_iterator_traits
    {
    typedef typename Iterator::iterator_category    iterator_category;  /**< 斀暅巕偺庬椶傪昞偡僇僥僑儕丅   */
    typedef typename Iterator::value_type           value_type;         /**< 斀暅巕偑埖偆梫慺偺宆丅         */
    typedef typename Iterator::difference_type      difference_type;    /**< 斀暅巕娫偺嵎(嫍棧)傪昞偡宆丅   */
    typedef typename Iterator::pointer              pointer;            /**< 斀暅巕偑埖偆梫慺偺億僀儞僞宆丅 */
    typedef typename Iterator::reference            reference;          /**< 斀暅巕偑埖偆梫慺偺嶲徠宆丅     */
    };
/**
 *  尵岅慻傒崬傒偺億僀儞僞(旕const)梡偺摿庩壔僶乕僕儑儞丅
 */
template<typename T>
struct TSmbMusicAPLib_iterator_traits<T*>
    {
    typedef TSmbMusicAPLib_random_access_iterator_tag   iterator_category;  /**< 斀暅巕偺庬椶傪昞偡僇僥僑儕丅   */
    typedef T                                   value_type;         /**< 斀暅巕偑埖偆梫慺偺宆丅         */
    typedef ptrdiff_t                           difference_type;    /**< 斀暅巕娫偺嵎(嫍棧)傪昞偡宆丅   */
    typedef T*                                  pointer;            /**< 斀暅巕偑埖偆梫慺偺億僀儞僞宆丅 */
    typedef T&                                  reference;          /**< 斀暅巕偑埖偆梫慺偺嶲徠宆丅     */
    };
/**
 *  尵岅慻傒崬傒偺億僀儞僞(const)梡偺摿庩壔僶乕僕儑儞丅
 */
template<typename T>
struct TSmbMusicAPLib_iterator_traits<const T*>
    {
    typedef TSmbMusicAPLib_random_access_iterator_tag   iterator_category;  /**< 斀暅巕偺庬椶傪昞偡僇僥僑儕丅   */
    typedef T                                   value_type;         /**< 斀暅巕偑埖偆梫慺偺宆丅         */
    typedef ptrdiff_t                           difference_type;    /**< 斀暅巕娫偺嵎(嫍棧)傪昞偡宆丅   */
    typedef const T*                            pointer;            /**< 斀暅巕偑埖偆梫慺偺億僀儞僞宆丅 */
    typedef const T&                            reference;          /**< 斀暅巕偑埖偆梫慺偺嶲徠宆丅     */
    };

namespace detail {

// ----------------------------------------------------------------------------
//  Iterator_category()
// ----------------------------------------------------------------------------
template<typename Iterator>
inline typename TSmbMusicAPLib_iterator_traits<Iterator>::iterator_category Iterator_category( const Iterator& )
    {
    return typename TSmbMusicAPLib_iterator_traits<Iterator>::iterator_category();
    }

// ----------------------------------------------------------------------------
//  Distance()
// ----------------------------------------------------------------------------
template<typename InputIterator>
inline typename TSmbMusicAPLib_iterator_traits<InputIterator>::difference_type Distance( InputIterator aFirst, InputIterator aLast, TSmbMusicAPLib_input_iterator_tag )
    {
    typename TSmbMusicAPLib_iterator_traits<InputIterator>::difference_type n = 0;
    while (aFirst != aLast)
        {
        ++aFirst;
        ++n;
        }
    return n;
    }

template<typename RandomAccessIterator>
inline typename TSmbMusicAPLib_iterator_traits<RandomAccessIterator>::difference_type Distance( RandomAccessIterator aFirst, RandomAccessIterator aLast, TSmbMusicAPLib_random_access_iterator_tag )
    {
    return aLast - aFirst;
    }

// ----------------------------------------------------------------------------
//  Advance()
// ----------------------------------------------------------------------------
template<typename InputIterator, typename Distance>
inline void Advance( InputIterator& aIter, Distance aDist, TSmbMusicAPLib_input_iterator_tag )
    {
    while (aDist--)
        ++aIter;
    }

template<typename BidirectionalIterator, typename Distance>
inline void Advance( BidirectionalIterator& aIter, Distance aDist, TSmbMusicAPLib_bidirectional_iterator_tag )
    {
    if (aDist > 0)
        {
        while (aDist--)
            ++aIter;
        }
    else
        {
        while (aDist++)
            --aIter;
        }
    }

template<typename RandomAccessIterator, typename Distance>
inline void Advance( RandomAccessIterator& aIter, Distance aDist, TSmbMusicAPLib_random_access_iterator_tag )
    {
    aIter += aDist;
    }

}   // end of namespace detail

/**
 *  斀暅巕娫偺嫍棧傪寁嶼丅
 *
 *  斀暅巕 @a aFirst 偲 @a aLast 偺娫偺嫍棧傪寁嶼偟偰曉偡丅
 *
 *  @param[in]  aFirst  婎弨偲偡傞斀暅巕丅
 *  @param[in]  aLast   寁嶼偺懳徾偲偡傞斀暅巕丅
 *  @return @a aFirst 偐傜 @a aLast 傑偱偺嫍棧丅
 */
template<typename InputIterator>
inline typename TSmbMusicAPLib_iterator_traits<InputIterator>::difference_type Distance( InputIterator aFirst, InputIterator aLast )
    {
    return detail::Distance( aFirst, aLast, detail::Iterator_category(aFirst) );
    }

/**
 *  斀暅巕偺堏摦丅
 *
 *  斀暅巕 @a aIter 傪丄嫍棧 @a aDist 偩偗堏摦偝偣傞丅
 *
 *  @param[in]  aIter   懳徾斀暅巕丅
 *  @param[in]  aDist   堏摦偝偣傞嫍棧丅
 */
template<typename InputIterator, typename Distance>
inline void Advance( InputIterator& aIter, Distance aDist )
    {
    detail::Advance( aIter, aDist, detail::Iterator_category(aIter) );
    }

/**
 *  媡峴斀暅巕丅
 *
 *  梫慺偺弴彉斀揮傾僋僙僗傪峴偆偨傔偺斀暅巕丅++偱屻曽偵丄--偱慜曽偵恑傓丅
 *  晛捠偺儔儞僟儉傾僋僙僗斀暅巕傪丄媡峴斀暅巕偲偟偰巊偆偨傔偺丄傾僟僾僞丅
 */
template<typename Iterator>
class TSmbMusicAPLib_reverse_iterator
    : public TSmbMusicAPLib_iterator
            <
                typename TSmbMusicAPLib_iterator_traits<Iterator>::iterator_category,
                typename TSmbMusicAPLib_iterator_traits<Iterator>::value_type,
                typename TSmbMusicAPLib_iterator_traits<Iterator>::difference_type,
                typename TSmbMusicAPLib_iterator_traits<Iterator>::pointer,
                typename TSmbMusicAPLib_iterator_traits<Iterator>::reference
            >
    {
public:
    typedef Iterator                                                    iterator_type;      /**< 斀暅巕偺宆丅                   */
    typedef typename TSmbMusicAPLib_iterator_traits<Iterator>::difference_type  difference_type;    /**< 斀暅巕娫偺嵎(嫍棧)傪昞偡宆丅   */
    typedef typename TSmbMusicAPLib_iterator_traits<Iterator>::pointer          pointer;            /**< 斀暅巕偑埖偆梫慺偺億僀儞僞宆丅 */
    typedef typename TSmbMusicAPLib_iterator_traits<Iterator>::reference        reference;          /**< 斀暅巕偑埖偆梫慺偺嶲徠宆丅     */

public:
    TSmbMusicAPLib_reverse_iterator() : iCurrent() {}
    explicit TSmbMusicAPLib_reverse_iterator( iterator_type aIter ) : iCurrent(aIter) {}
    TSmbMusicAPLib_reverse_iterator( const TSmbMusicAPLib_reverse_iterator& aRhs ) : iCurrent(aRhs.iCurrent) {}
    template<typename Iter>
    TSmbMusicAPLib_reverse_iterator( const TSmbMusicAPLib_reverse_iterator<Iter>& aRhs ) : iCurrent(aRhs.Base()) {}
    iterator_type Base() const
        {
        return iCurrent;
        }
    reference operator*() const
        {
        Iterator tmp = iCurrent;
        return *--tmp;
        }
    pointer operator->() const
        {
        return &(operator*());
        }
    TSmbMusicAPLib_reverse_iterator& operator++()
        {
        --iCurrent;
        return *this;
        }
    TSmbMusicAPLib_reverse_iterator operator++( int )
        {
        TSmbMusicAPLib_reverse_iterator tmp = *this;
        --iCurrent;
        return tmp;
        }
    TSmbMusicAPLib_reverse_iterator& operator--()
        {
        ++iCurrent;
        return *this;
        }
    TSmbMusicAPLib_reverse_iterator operator--( int )
        {
        TSmbMusicAPLib_reverse_iterator tmp = *this;
        ++iCurrent;
        return tmp;
        }
    TSmbMusicAPLib_reverse_iterator operator+( difference_type aDiffer ) const
        {
        return TSmbMusicAPLib_reverse_iterator( iCurrent - aDiffer );
        }
    TSmbMusicAPLib_reverse_iterator& operator+=( difference_type aDiffer )
        {
        iCurrent -= aDiffer;
        return *this;
        }
    TSmbMusicAPLib_reverse_iterator operator-( difference_type aDiffer ) const
        {
        return TSmbMusicAPLib_reverse_iterator( iCurrent + aDiffer );
        }
    TSmbMusicAPLib_reverse_iterator& operator-=( difference_type aDiffer )
        {
        iCurrent += aDiffer;
        return *this;
        }
    reference operator[]( difference_type aDiffer ) const
        {
        return *( *this + aDiffer );
        }

protected:
    Iterator iCurrent;
    };  // end of TSmbMusicAPLib_reverse_iterator

template<typename Iterator>
inline TBool operator==( const TSmbMusicAPLib_reverse_iterator<Iterator>& aLhs, const TSmbMusicAPLib_reverse_iterator<Iterator>& aRhs )
    {
    return aLhs.Base() == aRhs.Base();
    }

template<typename Iterator>
inline TBool operator<( const TSmbMusicAPLib_reverse_iterator<Iterator>& aLhs, const TSmbMusicAPLib_reverse_iterator<Iterator>& aRhs )
    {
    return aRhs.Base() < aLhs.Base();
    }

template<typename Iterator>
inline TBool operator!=( const TSmbMusicAPLib_reverse_iterator<Iterator>& aLhs, const TSmbMusicAPLib_reverse_iterator<Iterator>& aRhs )
    {
    return !(aLhs == aRhs);
    }

template<typename Iterator>
inline TBool operator>( const TSmbMusicAPLib_reverse_iterator<Iterator>& aLhs, const TSmbMusicAPLib_reverse_iterator<Iterator>& aRhs )
    {
    return aRhs < aLhs;
    }

template<typename Iterator>
inline TBool operator<=( const TSmbMusicAPLib_reverse_iterator<Iterator>& aLhs, const TSmbMusicAPLib_reverse_iterator<Iterator>& aRhs )
    {
    return !(aRhs < aLhs);
    }

template<typename Iterator>
inline TBool operator>=( const TSmbMusicAPLib_reverse_iterator<Iterator>& aLhs, const TSmbMusicAPLib_reverse_iterator<Iterator>& aRhs )
    {
    return !(aLhs < aRhs);
    }

template<typename Iterator>
inline typename TSmbMusicAPLib_reverse_iterator<Iterator>::difference_type operator-( const TSmbMusicAPLib_reverse_iterator<Iterator>& aLhs, const TSmbMusicAPLib_reverse_iterator<Iterator>& aRhs )
    {
    return aRhs.Base() - aLhs.Base();
    }

template<typename Iterator>
inline TSmbMusicAPLib_reverse_iterator<Iterator> operator+( typename TSmbMusicAPLib_reverse_iterator<Iterator>::difference_type aDiffer, const TSmbMusicAPLib_reverse_iterator<Iterator>& aIter )
    {
    return TSmbMusicAPLib_reverse_iterator<Iterator>( aIter.Base() - aDiffer );
    }




/**
 *  憓擖斀暅巕丅
 *