source: XIOS/dev/dev_olga/src/extern/boost/include/boost/range/algorithm/heap_algorithm.hpp @ 1022

Last change on this file since 1022 was 1022, checked in by mhnguyen, 7 years ago
File size: 6.3 KB
Line 
1//  Copyright Neil Groves 2009. Use, modification and
2//  distribution is subject to the Boost Software License, Version
3//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
4//  http://www.boost.org/LICENSE_1_0.txt)
5//
6//
7// For more information, see http://www.boost.org/libs/range/
8//
9#ifndef BOOST_RANGE_ALGORITHM_HEAP_ALGORITHM_HPP_INCLUDED
10#define BOOST_RANGE_ALGORITHM_HEAP_ALGORITHM_HPP_INCLUDED
11
12#include <boost/concept_check.hpp>
13#include <boost/range/begin.hpp>
14#include <boost/range/end.hpp>
15#include <boost/range/concepts.hpp>
16#include <algorithm>
17
18namespace boost
19{
20    namespace range
21    {
22
23/// \brief template function push_heap
24///
25/// range-based version of the push_heap std algorithm
26///
27/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
28/// \pre Compare is a model of the BinaryPredicateConcept
29template<class RandomAccessRange>
30inline RandomAccessRange& push_heap(RandomAccessRange& rng)
31{
32    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
33    std::push_heap(boost::begin(rng), boost::end(rng));
34    return rng;
35}
36
37/// \overload
38template<class RandomAccessRange>
39inline const RandomAccessRange& push_heap(const RandomAccessRange& rng)
40{
41    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
42    std::push_heap(boost::begin(rng), boost::end(rng));
43    return rng;
44}
45
46/// \overload
47template<class RandomAccessRange, class Compare>
48inline RandomAccessRange& push_heap(RandomAccessRange& rng, Compare comp_pred)
49{
50    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
51    std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
52    return rng;
53}
54
55/// \overload
56template<class RandomAccessRange, class Compare>
57inline const RandomAccessRange& push_heap(const RandomAccessRange& rng, Compare comp_pred)
58{
59    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
60    std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
61    return rng;
62}
63
64/// \brief template function pop_heap
65///
66/// range-based version of the pop_heap std algorithm
67///
68/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
69/// \pre Compare is a model of the BinaryPredicateConcept
70template<class RandomAccessRange>
71inline RandomAccessRange& pop_heap(RandomAccessRange& rng)
72{
73    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
74    std::pop_heap(boost::begin(rng), boost::end(rng));
75    return rng;
76}
77
78/// \overload
79template<class RandomAccessRange>
80inline const RandomAccessRange& pop_heap(const RandomAccessRange& rng)
81{
82    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
83    std::pop_heap(boost::begin(rng), boost::end(rng));
84    return rng;
85}
86
87/// \overload
88template<class RandomAccessRange, class Compare>
89inline RandomAccessRange& pop_heap(RandomAccessRange& rng, Compare comp_pred)
90{
91    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
92    std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
93    return rng;
94}
95
96/// \overload
97template<class RandomAccessRange, class Compare>
98inline const RandomAccessRange& pop_heap(const RandomAccessRange& rng, Compare comp_pred)
99{
100    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
101    std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
102    return rng;
103}
104
105/// \brief template function make_heap
106///
107/// range-based version of the make_heap std algorithm
108///
109/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
110/// \pre Compare is a model of the BinaryPredicateConcept
111template<class RandomAccessRange>
112inline RandomAccessRange& make_heap(RandomAccessRange& rng)
113{
114    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
115    std::make_heap(boost::begin(rng), boost::end(rng));
116    return rng;
117}
118
119/// \overload
120template<class RandomAccessRange>
121inline const RandomAccessRange& make_heap(const RandomAccessRange& rng)
122{
123    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
124    std::make_heap(boost::begin(rng), boost::end(rng));
125    return rng;
126}
127
128/// \overload
129template<class RandomAccessRange, class Compare>
130inline RandomAccessRange& make_heap(RandomAccessRange& rng, Compare comp_pred)
131{
132    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
133    std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
134    return rng;
135}
136
137/// \overload
138template<class RandomAccessRange, class Compare>
139inline const RandomAccessRange& make_heap(const RandomAccessRange& rng, Compare comp_pred)
140{
141    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
142    std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
143    return rng;
144}
145
146/// \brief template function sort_heap
147///
148/// range-based version of the sort_heap std algorithm
149///
150/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
151/// \pre Compare is a model of the BinaryPredicateConcept
152template<class RandomAccessRange>
153inline RandomAccessRange& sort_heap(RandomAccessRange& rng)
154{
155    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
156    std::sort_heap(boost::begin(rng), boost::end(rng));
157    return rng;
158}
159
160/// \overload
161template<class RandomAccessRange>
162inline const RandomAccessRange& sort_heap(const RandomAccessRange& rng)
163{
164    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
165    std::sort_heap(boost::begin(rng), boost::end(rng));
166    return rng;
167}
168
169/// \overload
170template<class RandomAccessRange, class Compare>
171inline RandomAccessRange& sort_heap(RandomAccessRange& rng, Compare comp_pred)
172{
173    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
174    std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
175    return rng;
176}
177
178/// \overload
179template<class RandomAccessRange, class Compare>
180inline const RandomAccessRange& sort_heap(const RandomAccessRange& rng, Compare comp_pred)
181{
182    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
183    std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
184    return rng;
185}
186
187    } // namespace range
188    using range::push_heap;
189    using range::pop_heap;
190    using range::make_heap;
191    using range::sort_heap;
192} // namespace boost
193
194#endif // include guard
Note: See TracBrowser for help on using the repository browser.