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