stl_algo.h

来自「symbian上STL模板库的实现」· C头文件 代码 · 共 1,620 行 · 第 1/5 页

// Algorithm implementation -*- C++ -*-

// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 *
 * Copyright (c) 1996
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 */

/** @file stl_algo.h
 *  This is an internal header file, included by other library headers.
 *  You should not attempt to use it directly.
 */

#ifndef _ALGO_H
#define _ALGO_H 1

#include <bits/stl_heap.h>
#include <bits/stl_tempbuf.h>     // for _Temporary_buffer
#include <debug/debug.h>

// See concept_check.h for the __glibcxx_*_requires macros.

namespace std
{
    /**
     *  @brief Find the median of three values.
     *  @param  a  A value.
     *  @param  b  A value.
     *  @param  c  A value.
     *  @return One of @p a, @p b or @p c.
     *
     *  If @c {l,m,n} is some convolution of @p {a,b,c} such that @c l<=m<=n
     *  then the value returned will be @c m.
     *  This is an SGI extension.
     *  @ingroup SGIextensions
     */
    template<typename _Tp>
        inline const _Tp&
        __median(const _Tp& __a, const _Tp& __b, const _Tp& __c)
        {
            // concept requirements
#ifndef NO__GLIBCXX_FUNCTION_REQUIRES
            __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
#endif
                if (__a < __b)
                    if (__b < __c)
                        return __b;
                    else if (__a < __c)
                        return __c;
                    else
                        return __a;
                else if (__a < __c)
                    return __a;
                else if (__b < __c)
                    return __c;
                else
                    return __b;
        }

    /**
     *  @brief Find the median of three values using a predicate for comparison.
     *  @param  a     A value.
     *  @param  b     A value.
     *  @param  c     A value.
     *  @param  comp  A binary predicate.
     *  @return One of @p a, @p b or @p c.
     *
     *  If @c {l,m,n} is some convolution of @p {a,b,c} such that @p comp(l,m)
     *  and @p comp(m,n) are both true then the value returned will be @c m.
     *  This is an SGI extension.
     *  @ingroup SGIextensions
     */
    template<typename _Tp, typename _Compare>
        inline const _Tp&
        __median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp)
        {
            // concept requirements
#ifndef NO__GLIBCXX_FUNCTION_REQUIRES
            __glibcxx_function_requires(_BinaryFunctionConcept<_Compare,bool,_Tp,_Tp>)
#endif
                if (__comp(__a, __b))
                    if (__comp(__b, __c))
                        return __b;
                    else if (__comp(__a, __c))
                        return __c;
                    else
                        return __a;
                else if (__comp(__a, __c))
                    return __a;
                else if (__comp(__b, __c))
                    return __c;
                else
                    return __b;
        }

    /**
     *  @brief Apply a function to every element of a sequence.
     *  @param  first  An input iterator.
     *  @param  last   An input iterator.
     *  @param  f      A unary function object.
     *  @return   @p f.
     *
     *  Applies the function object @p f to each element in the range
     *  @p [first,last).  @p f must not modify the order of the sequence.
     *  If @p f has a return value it is ignored.
     */
    template<typename _InputIterator, typename _Function>
        _Function
        for_each(_InputIterator __first, _InputIterator __last, _Function __f)
        {
            // concept requirements
#ifndef NO__GLIBCXX_FUNCTION_REQUIRES
            __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
#endif
                __glibcxx_requires_valid_range(__first, __last);
            for ( ; __first != __last; ++__first)
                __f(*__first);
            return __f;
        }

    /**
     *  @if maint
     *  This is an overload used by find() for the Input Iterator case.
     *  @endif
     */
    template<typename _InputIterator, typename _Tp>
        inline _InputIterator
        find(_InputIterator __first, _InputIterator __last,
                const _Tp& __val, input_iterator_tag)
        {
            while (__first != __last && !(*__first == __val))
                ++__first;
            return __first;
        }

    /**
     *  @if maint
     *  This is an overload used by find_if() for the Input Iterator case.
     *  @endif
     */
    template<typename _InputIterator, typename _Predicate>
        inline _InputIterator
        find_if(_InputIterator __first, _InputIterator __last,
                _Predicate __pred, input_iterator_tag)
        {
            while (__first != __last && !__pred(*__first))
                ++__first;
            return __first;
        }

    /**
     *  @if maint
     *  This is an overload used by find() for the RAI case.
     *  @endif
     */
    template<typename _RandomAccessIterator, typename _Tp>
        _RandomAccessIterator
        find(_RandomAccessIterator __first, _RandomAccessIterator __last,
                const _Tp& __val, random_access_iterator_tag)
        {
            typename iterator_traits<_RandomAccessIterator>::difference_type
                __trip_count = (__last - __first) >> 2;

            for ( ; __trip_count > 0 ; --__trip_count)
            {
                if (*__first == __val)
                    return __first;
                ++__first;

                if (*__first == __val)
                    return __first;
                ++__first;

                if (*__first == __val)
                    return __first;
                ++__first;

                if (*__first == __val)
                    return __first;
                ++__first;
            }

            switch (__last - __first)
            {
                case 3:
                    if (*__first == __val)
                        return __first;
                    ++__first;
                case 2:
                    if (*__first == __val)
                        return __first;
                    ++__first;
                case 1:
                    if (*__first == __val)
                        return __first;
                    ++__first;
                case 0:
                default:
                    return __last;
            }
        }

    /**
     *  @if maint
     *  This is an overload used by find_if() for the RAI case.
     *  @endif
     */
    template<typename _RandomAccessIterator, typename _Predicate>
        _RandomAccessIterator
        find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
                _Predicate __pred, random_access_iterator_tag)
        {
            typename iterator_traits<_RandomAccessIterator>::difference_type
                __trip_count = (__last - __first) >> 2;

            for ( ; __trip_count > 0 ; --__trip_count)
            {
                if (__pred(*__first))
                    return __first;
                ++__first;

                if (__pred(*__first))
                    return __first;
                ++__first;

                if (__pred(*__first))
                    return __first;
                ++__first;

                if (__pred(*__first))
                    return __first;
                ++__first;
            }

            switch (__last - __first)
            {
                case 3:
                    if (__pred(*__first))
                        return __first;
                    ++__first;
                case 2:
                    if (__pred(*__first))
                        return __first;
                    ++__first;
                case 1:
                    if (__pred(*__first))
                        return __first;
                    ++__first;
                case 0:
                default:
                    return __last;
            }
        }

    /**
     *  @brief Find the first occurrence of a value in a sequence.
     *  @param  first  An input iterator.
     *  @param  last   An input iterator.
     *  @param  val    The value to find.
     *  @return   The first iterator @c i in the range @p [first,last)
     *  such that @c *i == @p val, or @p last if no such iterator exists.
     */
    template<typename _InputIterator, typename _Tp>
        inline _InputIterator
        find(_InputIterator __first, _InputIterator __last,
                const _Tp& __val)
        {
            // concept requirements
#ifndef NO__GLIBCXX_FUNCTION_REQUIRES
            __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
                __glibcxx_function_requires(_EqualOpConcept<
                        typename iterator_traits<_InputIterator>::value_type, _Tp>)
#endif
                __glibcxx_requires_valid_range(__first, __last);
            return std::find(__first, __last, __val,
                    std::__iterator_category(__first));
        }