ceph/src/boost/libs/range/include/boost/range/algorithm/upper_bound.hpp

   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_UPPER_BOUND_HPP_INCLUDED
  10 #define BOOST_RANGE_ALGORITHM_UPPER_BOUND_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 <boost/range/detail/range_return.hpp>
  17 #include <algorithm>
  18
  19 namespace boost
  20 {
  21     namespace range
  22     {
  23
  24 /// \brief template function upper_bound
  25 ///
  26 /// range-based version of the upper_bound std algorithm
  27 ///
  28 /// \pre ForwardRange is a model of the ForwardRangeConcept
  29 template< class ForwardRange, class Value >
  30 inline
  31 BOOST_DEDUCED_TYPENAME disable_if<
  32     is_const<ForwardRange>,
  33     BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
  34 >::type
  35 upper_bound( ForwardRange& rng, Value val )
  36 {
  37     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
  38     return std::upper_bound(boost::begin(rng), boost::end(rng), val);
  39 }
  40
  41 /// \overload
  42 template< class ForwardRange, class Value >
  43 BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
  44 upper_bound( const ForwardRange& rng, Value val )
  45 {
  46     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
  47     return std::upper_bound(boost::begin(rng), boost::end(rng), val);
  48 }
  49
  50 /// \overload
  51 template< class ForwardRange, class Value, class SortPredicate >
  52 inline BOOST_DEDUCED_TYPENAME disable_if<
  53     is_const<ForwardRange>,
  54     BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
  55 >::type
  56 upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
  57 {
  58     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
  59     return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
  60 }
  61
  62 /// \overload
  63 template< class ForwardRange, class Value, class SortPredicate >
  64 inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
  65 upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
  66 {
  67     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
  68     return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
  69 }
  70
  71 /// \overload
  72 template< range_return_value re, class ForwardRange, class Value >
  73 inline BOOST_DEDUCED_TYPENAME disable_if<
  74     is_const<ForwardRange>,
  75     BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
  76 >::type
  77 upper_bound( ForwardRange& rng, Value val )
  78 {
  79     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
  80     return range_return<ForwardRange,re>::
  81         pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
  82              rng);
  83 }
  84
  85 /// \overload
  86 template< range_return_value re, class ForwardRange, class Value >
  87 inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
  88 upper_bound( const ForwardRange& rng, Value val )
  89 {
  90     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
  91     return range_return<const ForwardRange,re>::
  92         pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
  93              rng);
  94 }
  95
  96 /// \overload
  97 template< range_return_value re, class ForwardRange, class Value,
  98           class SortPredicate >
  99 inline BOOST_DEDUCED_TYPENAME disable_if<
 100     is_const<ForwardRange>,
 101     BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
 102 >::type
 103 upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
 104 {
 105     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
 106     return range_return<ForwardRange,re>::
 107         pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
 108              rng);
 109 }
 110
 111 /// \overload
 112 template< range_return_value re, class ForwardRange, class Value,
 113           class SortPredicate >
 114 inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
 115 upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
 116 {
 117     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
 118     return range_return<const ForwardRange,re>::
 119         pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
 120              rng);
 121 }
 122
 123     } // namespace range
 124     using range::upper_bound;
 125 } // namespace boost
 126
 127 #endif // include guard