LTP GCOV extension - code coverage report
Current view: directory - usr/include/c++/4.3/bits - stl_heap.h
Test: lcov.info
Date: 2008-08-14 Instrumented lines: 92
Code covered: 0.0 % Executed lines: 0

       1                 : // Heap implementation -*- C++ -*-
       2                 : 
       3                 : // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007
       4                 : // Free Software Foundation, Inc.
       5                 : //
       6                 : // This file is part of the GNU ISO C++ Library.  This library is free
       7                 : // software; you can redistribute it and/or modify it under the
       8                 : // terms of the GNU General Public License as published by the
       9                 : // Free Software Foundation; either version 2, or (at your option)
      10                 : // any later version.
      11                 : 
      12                 : // This library is distributed in the hope that it will be useful,
      13                 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 : // GNU General Public License for more details.
      16                 : 
      17                 : // You should have received a copy of the GNU General Public License along
      18                 : // with this library; see the file COPYING.  If not, write to the Free
      19                 : // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
      20                 : // USA.
      21                 : 
      22                 : // As a special exception, you may use this file as part of a free software
      23                 : // library without restriction.  Specifically, if other files instantiate
      24                 : // templates or use macros or inline functions from this file, or you compile
      25                 : // this file and link it with other files to produce an executable, this
      26                 : // file does not by itself cause the resulting executable to be covered by
      27                 : // the GNU General Public License.  This exception does not however
      28                 : // invalidate any other reasons why the executable file might be covered by
      29                 : // the GNU General Public License.
      30                 : 
      31                 : /*
      32                 :  *
      33                 :  * Copyright (c) 1994
      34                 :  * Hewlett-Packard Company
      35                 :  *
      36                 :  * Permission to use, copy, modify, distribute and sell this software
      37                 :  * and its documentation for any purpose is hereby granted without fee,
      38                 :  * provided that the above copyright notice appear in all copies and
      39                 :  * that both that copyright notice and this permission notice appear
      40                 :  * in supporting documentation.  Hewlett-Packard Company makes no
      41                 :  * representations about the suitability of this software for any
      42                 :  * purpose.  It is provided "as is" without express or implied warranty.
      43                 :  *
      44                 :  * Copyright (c) 1997
      45                 :  * Silicon Graphics Computer Systems, Inc.
      46                 :  *
      47                 :  * Permission to use, copy, modify, distribute and sell this software
      48                 :  * and its documentation for any purpose is hereby granted without fee,
      49                 :  * provided that the above copyright notice appear in all copies and
      50                 :  * that both that copyright notice and this permission notice appear
      51                 :  * in supporting documentation.  Silicon Graphics makes no
      52                 :  * representations about the suitability of this software for any
      53                 :  * purpose.  It is provided "as is" without express or implied warranty.
      54                 :  */
      55                 : 
      56                 : /** @file stl_heap.h
      57                 :  *  This is an internal header file, included by other library headers.
      58                 :  *  You should not attempt to use it directly.
      59                 :  */
      60                 : 
      61                 : #ifndef _STL_HEAP_H
      62                 : #define _STL_HEAP_H 1
      63                 : 
      64                 : #include <debug/debug.h>
      65                 : #include <bits/stl_move.h>
      66                 : 
      67                 : _GLIBCXX_BEGIN_NAMESPACE(std)
      68                 : 
      69                 :   template<typename _RandomAccessIterator, typename _Distance>
      70                 :     _Distance
      71                 :     __is_heap_until(_RandomAccessIterator __first, _Distance __n)
      72                 :     {
      73                 :       _Distance __parent = 0;
      74                 :       for (_Distance __child = 1; __child < __n; ++__child)
      75                 :         {
      76                 :           if (__first[__parent] < __first[__child])
      77                 :             return __child;
      78                 :           if ((__child & 1) == 0)
      79                 :             ++__parent;
      80                 :         }
      81                 :       return __n;
      82                 :     }
      83                 : 
      84                 :   template<typename _RandomAccessIterator, typename _Distance,
      85                 :            typename _Compare>
      86                 :     _Distance
      87                 :     __is_heap_until(_RandomAccessIterator __first, _Distance __n,
      88                 :                     _Compare __comp)
      89                 :     {
      90                 :       _Distance __parent = 0;
      91                 :       for (_Distance __child = 1; __child < __n; ++__child)
      92                 :         {
      93                 :           if (__comp(__first[__parent], __first[__child]))
      94                 :             return __child;
      95                 :           if ((__child & 1) == 0)
      96                 :             ++__parent;
      97                 :         }
      98                 :       return __n;
      99                 :     }
     100                 : 
     101                 :   // __is_heap, a predicate testing whether or not a range is a heap.
     102                 :   // This function is an extension, not part of the C++ standard.
     103                 :   template<typename _RandomAccessIterator, typename _Distance>
     104                 :     inline bool
     105                 :     __is_heap(_RandomAccessIterator __first, _Distance __n)
     106                 :     { return std::__is_heap_until(__first, __n) == __n; }
     107                 : 
     108                 :   template<typename _RandomAccessIterator, typename _Compare,
     109                 :            typename _Distance>
     110                 :     inline bool
     111                 :     __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
     112                 :     { return std::__is_heap_until(__first, __n, __comp) == __n; }
     113                 : 
     114                 :   template<typename _RandomAccessIterator>
     115                 :     inline bool
     116                 :     __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
     117                 :     { return std::__is_heap(__first, std::distance(__first, __last)); }
     118                 : 
     119                 :   template<typename _RandomAccessIterator, typename _Compare>
     120                 :     inline bool
     121                 :     __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
     122                 :               _Compare __comp)
     123                 :     { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
     124                 : 
     125                 :   // Heap-manipulation functions: push_heap, pop_heap, make_heap, sort_heap,
     126                 :   // + is_heap and is_heap_until in C++0x.
     127                 : 
     128                 :   template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
     129                 :     void
     130                 :     __push_heap(_RandomAccessIterator __first,
     131               0 :                 _Distance __holeIndex, _Distance __topIndex, _Tp __value)
     132                 :     {
     133               0 :       _Distance __parent = (__holeIndex - 1) / 2;
     134               0 :       while (__holeIndex > __topIndex && *(__first + __parent) < __value)
     135                 :         {
     136               0 :           *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent));
     137               0 :           __holeIndex = __parent;
     138               0 :           __parent = (__holeIndex - 1) / 2;
     139                 :         }
     140               0 :       *(__first + __holeIndex) = _GLIBCXX_MOVE(__value);
     141               0 :     }
     142                 : 
     143                 :   /**
     144                 :    *  @brief  Push an element onto a heap.
     145                 :    *  @param  first  Start of heap.
     146                 :    *  @param  last   End of heap + element.
     147                 :    *  @ingroup heap
     148                 :    *
     149                 :    *  This operation pushes the element at last-1 onto the valid heap over the
     150                 :    *  range [first,last-1).  After completion, [first,last) is a valid heap.
     151                 :   */
     152                 :   template<typename _RandomAccessIterator>
     153                 :     inline void
     154                 :     push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
     155                 :     {
     156                 :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
     157                 :           _ValueType;
     158                 :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
     159                 :           _DistanceType;
     160                 : 
     161                 :       // concept requirements
     162                 :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
     163                 :             _RandomAccessIterator>)
     164                 :       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
     165                 :       __glibcxx_requires_valid_range(__first, __last);
     166                 :       __glibcxx_requires_heap(__first, __last - 1);
     167                 : 
     168                 :       _ValueType __value = _GLIBCXX_MOVE(*(__last - 1));
     169                 :       std::__push_heap(__first, _DistanceType((__last - __first) - 1),
     170                 :                        _DistanceType(0), _GLIBCXX_MOVE(__value));
     171                 :     }
     172                 : 
     173                 :   template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
     174                 :            typename _Compare>
     175                 :     void
     176                 :     __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
     177               0 :                 _Distance __topIndex, _Tp __value, _Compare __comp)
     178                 :     {
     179               0 :       _Distance __parent = (__holeIndex - 1) / 2;
     180               0 :       while (__holeIndex > __topIndex
     181                 :              && __comp(*(__first + __parent), __value))
     182                 :         {
     183               0 :           *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent));
     184               0 :           __holeIndex = __parent;
     185               0 :           __parent = (__holeIndex - 1) / 2;
     186                 :         }
     187               0 :       *(__first + __holeIndex) = _GLIBCXX_MOVE(__value);
     188               0 :     }
     189                 : 
     190                 :   /**
     191                 :    *  @brief  Push an element onto a heap using comparison functor.
     192                 :    *  @param  first  Start of heap.
     193                 :    *  @param  last   End of heap + element.
     194                 :    *  @param  comp   Comparison functor.
     195                 :    *  @ingroup heap
     196                 :    *
     197                 :    *  This operation pushes the element at last-1 onto the valid heap over the
     198                 :    *  range [first,last-1).  After completion, [first,last) is a valid heap.
     199                 :    *  Compare operations are performed using comp.
     200                 :   */
     201                 :   template<typename _RandomAccessIterator, typename _Compare>
     202                 :     inline void
     203                 :     push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
     204                 :               _Compare __comp)
     205                 :     {
     206                 :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
     207                 :           _ValueType;
     208                 :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
     209                 :           _DistanceType;
     210                 : 
     211                 :       // concept requirements
     212                 :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
     213                 :             _RandomAccessIterator>)
     214                 :       __glibcxx_requires_valid_range(__first, __last);
     215                 :       __glibcxx_requires_heap_pred(__first, __last - 1, __comp);
     216                 : 
     217                 :       _ValueType __value = _GLIBCXX_MOVE(*(__last - 1));
     218                 :       std::__push_heap(__first, _DistanceType((__last - __first) - 1),
     219                 :                        _DistanceType(0), _GLIBCXX_MOVE(__value), __comp);
     220                 :     }
     221                 : 
     222                 :   template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
     223                 :     void
     224                 :     __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
     225               0 :                   _Distance __len, _Tp __value)
     226                 :     {
     227               0 :       const _Distance __topIndex = __holeIndex;
     228               0 :       _Distance __secondChild = __holeIndex;
     229               0 :       while (__secondChild < (__len - 1) / 2)
     230                 :         {
     231               0 :           __secondChild = 2 * (__secondChild + 1);
     232               0 :           if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
     233               0 :             __secondChild--;
     234               0 :           *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __secondChild));
     235               0 :           __holeIndex = __secondChild;
     236                 :         }
     237               0 :       if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
     238                 :         {
     239               0 :           __secondChild = 2 * (__secondChild + 1);
     240               0 :           *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first
     241                 :                                                      + (__secondChild - 1)));
     242               0 :           __holeIndex = __secondChild - 1;
     243                 :         }
     244               0 :       std::__push_heap(__first, __holeIndex, __topIndex,
     245                 :                        _GLIBCXX_MOVE(__value));
     246               0 :     }
     247                 : 
     248                 :   template<typename _RandomAccessIterator>
     249                 :     inline void
     250                 :     __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
     251               0 :                _RandomAccessIterator __result)
     252                 :     {
     253                 :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
     254                 :         _ValueType;
     255                 :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
     256                 :         _DistanceType;
     257                 : 
     258               0 :       _ValueType __value = _GLIBCXX_MOVE(*__result);
     259               0 :       *__result = _GLIBCXX_MOVE(*__first);
     260               0 :       std::__adjust_heap(__first, _DistanceType(0),
     261                 :                          _DistanceType(__last - __first),
     262                 :                          _GLIBCXX_MOVE(__value));
     263               0 :     }
     264                 : 
     265                 :   /**
     266                 :    *  @brief  Pop an element off a heap.
     267                 :    *  @param  first  Start of heap.
     268                 :    *  @param  last   End of heap.
     269                 :    *  @ingroup heap
     270                 :    *
     271                 :    *  This operation pops the top of the heap.  The elements first and last-1
     272                 :    *  are swapped and [first,last-1) is made into a heap.
     273                 :   */
     274                 :   template<typename _RandomAccessIterator>
     275                 :     inline void
     276               0 :     pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
     277                 :     {
     278                 :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
     279                 :         _ValueType;
     280                 : 
     281                 :       // concept requirements
     282                 :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
     283                 :             _RandomAccessIterator>)
     284                 :       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
     285                 :       __glibcxx_requires_valid_range(__first, __last);
     286                 :       __glibcxx_requires_heap(__first, __last);
     287                 : 
     288               0 :       std::__pop_heap(__first, __last - 1, __last - 1);
     289               0 :     }
     290                 : 
     291                 :   template<typename _RandomAccessIterator, typename _Distance,
     292                 :            typename _Tp, typename _Compare>
     293                 :     void
     294                 :     __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
     295               0 :                   _Distance __len, _Tp __value, _Compare __comp)
     296                 :     {
     297               0 :       const _Distance __topIndex = __holeIndex;
     298               0 :       _Distance __secondChild = __holeIndex;
     299               0 :       while (__secondChild < (__len - 1) / 2)
     300                 :         {
     301               0 :           __secondChild = 2 * (__secondChild + 1);
     302               0 :           if (__comp(*(__first + __secondChild),
     303                 :                      *(__first + (__secondChild - 1))))
     304               0 :             __secondChild--;
     305               0 :           *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __secondChild));
     306               0 :           __holeIndex = __secondChild;
     307                 :         }
     308               0 :       if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
     309                 :         {
     310               0 :           __secondChild = 2 * (__secondChild + 1);
     311               0 :           *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first
     312                 :                                                      + (__secondChild - 1)));
     313               0 :           __holeIndex = __secondChild - 1;
     314                 :         }
     315               0 :       std::__push_heap(__first, __holeIndex, __topIndex, 
     316                 :                        _GLIBCXX_MOVE(__value), __comp);      
     317               0 :     }
     318                 : 
     319                 :   template<typename _RandomAccessIterator, typename _Compare>
     320                 :     inline void
     321                 :     __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
     322               0 :                _RandomAccessIterator __result, _Compare __comp)
     323                 :     {
     324                 :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
     325                 :         _ValueType;
     326                 :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
     327                 :         _DistanceType;
     328                 : 
     329               0 :       _ValueType __value = _GLIBCXX_MOVE(*__result);
     330               0 :       *__result = _GLIBCXX_MOVE(*__first);
     331               0 :       std::__adjust_heap(__first, _DistanceType(0),
     332                 :                          _DistanceType(__last - __first),
     333                 :                          _GLIBCXX_MOVE(__value), __comp);
     334               0 :     }
     335                 : 
     336                 :   /**
     337                 :    *  @brief  Pop an element off a heap using comparison functor.
     338                 :    *  @param  first  Start of heap.
     339                 :    *  @param  last   End of heap.
     340                 :    *  @param  comp   Comparison functor to use.
     341                 :    *  @ingroup heap
     342                 :    *
     343                 :    *  This operation pops the top of the heap.  The elements first and last-1
     344                 :    *  are swapped and [first,last-1) is made into a heap.  Comparisons are
     345                 :    *  made using comp.
     346                 :   */
     347                 :   template<typename _RandomAccessIterator, typename _Compare>
     348                 :     inline void
     349                 :     pop_heap(_RandomAccessIterator __first,
     350               0 :              _RandomAccessIterator __last, _Compare __comp)
     351                 :     {
     352                 :       // concept requirements
     353                 :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
     354                 :             _RandomAccessIterator>)
     355                 :       __glibcxx_requires_valid_range(__first, __last);
     356                 :       __glibcxx_requires_heap_pred(__first, __last, __comp);
     357                 : 
     358               0 :       std::__pop_heap(__first, __last - 1, __last - 1, __comp);
     359               0 :     }
     360                 : 
     361                 :   /**
     362                 :    *  @brief  Construct a heap over a range.
     363                 :    *  @param  first  Start of heap.
     364                 :    *  @param  last   End of heap.
     365                 :    *  @ingroup heap
     366                 :    *
     367                 :    *  This operation makes the elements in [first,last) into a heap.
     368                 :   */
     369                 :   template<typename _RandomAccessIterator>
     370                 :     void
     371               0 :     make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
     372                 :     {
     373                 :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
     374                 :           _ValueType;
     375                 :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
     376                 :           _DistanceType;
     377                 : 
     378                 :       // concept requirements
     379                 :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
     380                 :             _RandomAccessIterator>)
     381                 :       __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
     382                 :       __glibcxx_requires_valid_range(__first, __last);
     383                 : 
     384               0 :       if (__last - __first < 2)
     385               0 :         return;
     386                 : 
     387               0 :       const _DistanceType __len = __last - __first;
     388               0 :       _DistanceType __parent = (__len - 2) / 2;
     389               0 :       while (true)
     390                 :         {
     391               0 :           _ValueType __value = _GLIBCXX_MOVE(*(__first + __parent));
     392               0 :           std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value));
     393               0 :           if (__parent == 0)
     394               0 :             return;
     395               0 :           __parent--;
     396                 :         }
     397                 :     }
     398                 : 
     399                 :   /**
     400                 :    *  @brief  Construct a heap over a range using comparison functor.
     401                 :    *  @param  first  Start of heap.
     402                 :    *  @param  last   End of heap.
     403                 :    *  @param  comp   Comparison functor to use.
     404                 :    *  @ingroup heap
     405                 :    *
     406                 :    *  This operation makes the elements in [first,last) into a heap.
     407                 :    *  Comparisons are made using comp.
     408                 :   */
     409                 :   template<typename _RandomAccessIterator, typename _Compare>
     410                 :     void
     411                 :     make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
     412               0 :               _Compare __comp)
     413                 :     {
     414                 :       typedef typename iterator_traits<_RandomAccessIterator>::value_type
     415                 :           _ValueType;
     416                 :       typedef typename iterator_traits<_RandomAccessIterator>::difference_type
     417                 :           _DistanceType;
     418                 : 
     419                 :       // concept requirements
     420                 :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
     421                 :             _RandomAccessIterator>)
     422                 :       __glibcxx_requires_valid_range(__first, __last);
     423                 : 
     424               0 :       if (__last - __first < 2)
     425               0 :         return;
     426                 : 
     427               0 :       const _DistanceType __len = __last - __first;
     428               0 :       _DistanceType __parent = (__len - 2) / 2;
     429               0 :       while (true)
     430                 :         {
     431               0 :           _ValueType __value = _GLIBCXX_MOVE(*(__first + __parent));
     432               0 :           std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value),
     433                 :                              __comp);
     434               0 :           if (__parent == 0)
     435               0 :             return;
     436               0 :           __parent--;
     437                 :         }
     438                 :     }
     439                 : 
     440                 :   /**
     441                 :    *  @brief  Sort a heap.
     442                 :    *  @param  first  Start of heap.
     443                 :    *  @param  last   End of heap.
     444                 :    *  @ingroup heap
     445                 :    *
     446                 :    *  This operation sorts the valid heap in the range [first,last).
     447                 :   */
     448                 :   template<typename _RandomAccessIterator>
     449                 :     void
     450               0 :     sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
     451                 :     {
     452                 :       // concept requirements
     453                 :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
     454                 :             _RandomAccessIterator>)
     455                 :       __glibcxx_function_requires(_LessThanComparableConcept<
     456                 :             typename iterator_traits<_RandomAccessIterator>::value_type>)
     457                 :       __glibcxx_requires_valid_range(__first, __last);
     458                 :       __glibcxx_requires_heap(__first, __last);
     459                 : 
     460               0 :       while (__last - __first > 1)
     461               0 :         std::pop_heap(__first, _RandomAccessIterator(__last--));
     462               0 :     }
     463                 : 
     464                 :   /**
     465                 :    *  @brief  Sort a heap using comparison functor.
     466                 :    *  @param  first  Start of heap.
     467                 :    *  @param  last   End of heap.
     468                 :    *  @param  comp   Comparison functor to use.
     469                 :    *  @ingroup heap
     470                 :    *
     471                 :    *  This operation sorts the valid heap in the range [first,last).
     472                 :    *  Comparisons are made using comp.
     473                 :   */
     474                 :   template<typename _RandomAccessIterator, typename _Compare>
     475                 :     void
     476                 :     sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
     477               0 :               _Compare __comp)
     478                 :     {
     479                 :       // concept requirements
     480                 :       __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
     481                 :             _RandomAccessIterator>)
     482                 :       __glibcxx_requires_valid_range(__first, __last);
     483                 :       __glibcxx_requires_heap_pred(__first, __last, __comp);
     484                 : 
     485               0 :       while (__last - __first > 1)
     486               0 :         std::pop_heap(__first, _RandomAccessIterator(__last--), __comp);
     487               0 :     }
     488                 : 
     489                 : #ifdef __GXX_EXPERIMENTAL_CXX0X__
     490                 :   /**
     491                 :    *  @brief  Search the end of a heap.
     492                 :    *  @param  first  Start of range.
     493                 :    *  @param  last   End of range.
     494                 :    *  @return  An iterator pointing to the first element not in the heap.
     495                 :    *  @ingroup heap
     496                 :    *
     497                 :    *  This operation returns the last iterator i in [first, last) for which
     498                 :    *  the range [first, i) is a heap.
     499                 :   */
     500                 :   template<typename _RandomAccessIterator>
     501                 :     inline _RandomAccessIterator
     502                 :     is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
     503                 :     {
     504                 :       // concept requirements
     505                 :       __glibcxx_function_requires(_RandomAccessIteratorConcept<
     506                 :             _RandomAccessIterator>)
     507                 :       __glibcxx_function_requires(_LessThanComparableConcept<
     508                 :             typename iterator_traits<_RandomAccessIterator>::value_type>)
     509                 :       __glibcxx_requires_valid_range(__first, __last);
     510                 : 
     511                 :       return __first + std::__is_heap_until(__first, std::distance(__first,
     512                 :                                                                    __last));
     513                 :     }
     514                 : 
     515                 :   /**
     516                 :    *  @brief  Search the end of a heap using comparison functor.
     517                 :    *  @param  first  Start of range.
     518                 :    *  @param  last   End of range.
     519                 :    *  @param  comp   Comparison functor to use.
     520                 :    *  @return  An iterator pointing to the first element not in the heap.
     521                 :    *  @ingroup heap
     522                 :    *
     523                 :    *  This operation returns the last iterator i in [first, last) for which
     524                 :    *  the range [first, i) is a heap.  Comparisons are made using comp.
     525                 :   */
     526                 :   template<typename _RandomAccessIterator, typename _Compare>
     527                 :     inline _RandomAccessIterator
     528                 :     is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
     529                 :                   _Compare __comp)
     530                 :     {
     531                 :       // concept requirements
     532                 :       __glibcxx_function_requires(_RandomAccessIteratorConcept<
     533                 :             _RandomAccessIterator>)
     534                 :       __glibcxx_requires_valid_range(__first, __last);
     535                 : 
     536                 :       return __first + std::__is_heap_until(__first, std::distance(__first,
     537                 :                                                                    __last),
     538                 :                                             __comp);
     539                 :     }
     540                 : 
     541                 :   /**
     542                 :    *  @brief  Determines whether a range is a heap.
     543                 :    *  @param  first  Start of range.
     544                 :    *  @param  last   End of range.
     545                 :    *  @return  True if range is a heap, false otherwise.
     546                 :    *  @ingroup heap
     547                 :   */
     548                 :   template<typename _RandomAccessIterator>
     549                 :     inline bool
     550                 :     is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
     551                 :     { return std::is_heap_until(__first, __last) == __last; }
     552                 : 
     553                 :   /**
     554                 :    *  @brief  Determines whether a range is a heap using comparison functor.
     555                 :    *  @param  first  Start of range.
     556                 :    *  @param  last   End of range.
     557                 :    *  @param  comp   Comparison functor to use.
     558                 :    *  @return  True if range is a heap, false otherwise.
     559                 :    *  @ingroup heap
     560                 :   */
     561                 :   template<typename _RandomAccessIterator, typename _Compare>
     562                 :     inline bool
     563                 :     is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
     564                 :             _Compare __comp)
     565                 :     { return std::is_heap_until(__first, __last, __comp) == __last; }
     566                 : #endif
     567                 : 
     568                 : _GLIBCXX_END_NAMESPACE
     569                 : 
     570                 : #endif /* _STL_HEAP_H */

Generated by: LTP GCOV extension version 1.6