King_DuckZ/Sprout
1
0
Fork 0
mirror of https://github.com/bolero-MURAKAMI/Sprout synced 2025-08-03 12:49:50 +00:00
Code Issues Releases Wiki Activity

fix template-parameter name: Iterator, Range

Browse source
This commit is contained in:
bolero-MURAKAMI 2013-08-07 22:13:03 +09:00
parent ddccff51e6
commit 21cefe8a67
62 changed files with 809 additions and 784 deletions
Download patch file Download diff file Expand all files Collapse all files

56
sprout/range/algorithm/adjacent_find.hpp
View file

@ -12,53 +12,53 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.8 Adjacent find
template<typename Range>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
adjacent_find(Range&& range) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
adjacent_find(ForwardRange&& range) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::adjacent_find(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range))
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range))
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<typename Range, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
adjacent_find(Range&& range, BinaryPredicate pred) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
adjacent_find(ForwardRange&& range, BinaryPredicate pred) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::adjacent_find(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
pred
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
adjacent_find(Range&& range) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
adjacent_find(ForwardRange&& range) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::adjacent_find(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range))
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range))
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
adjacent_find(Range&& range, BinaryPredicate pred) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
adjacent_find(ForwardRange&& range, BinaryPredicate pred) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::adjacent_find(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
pred
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
} // namespace range

4
sprout/range/algorithm/all_of.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.1 All of
template<typename Range, typename Predicate>
template<typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR bool
all_of(Range const& range, Predicate pred) {
all_of(InputRange const& range, Predicate pred) {
return sprout::all_of(sprout::begin(range), sprout::end(range), pred);
}
} // namespace range

4
sprout/range/algorithm/all_of_equal.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
//
// all_of_equal
//
template<typename Range, typename T>
template<typename InputRange, typename T>
inline SPROUT_CONSTEXPR bool
all_of_equal(Range const& range, T const& value) {
all_of_equal(InputRange const& range, T const& value) {
return sprout::all_of_equal(sprout::begin(range), sprout::end(range), value);
}
} // namespace range

4
sprout/range/algorithm/any_of.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.2 Any of
template<typename Range, typename Predicate>
template<typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR bool
any_of(Range const& range, Predicate pred) {
any_of(InputRange const& range, Predicate pred) {
return sprout::any_of(sprout::begin(range), sprout::end(range), pred);
}
} // namespace range

4
sprout/range/algorithm/any_of_equal.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
//
// any_of_equal
//
template<typename Range, typename T>
template<typename InputRange, typename T>
inline SPROUT_CONSTEXPR bool
any_of_equal(Range const& range, T const& value) {
any_of_equal(InputRange const& range, T const& value) {
return sprout::any_of_equal(sprout::begin(range), sprout::end(range), value);
}
} // namespace range

8
sprout/range/algorithm/binary_search.hpp
View file

@ -10,15 +10,15 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.3.4 binary_search
template<typename Range, typename T>
template<typename ForwardRange, typename T>
inline SPROUT_CONSTEXPR bool
binary_search(Range const& range, T const& value) {
binary_search(ForwardRange const& range, T const& value) {
return sprout::binary_search(sprout::begin(range), sprout::end(range), value);
}
template<typename Range, typename T, typename Compare>
template<typename ForwardRange, typename T, typename Compare>
inline SPROUT_CONSTEXPR bool
binary_search(Range const& range, T const& value, Compare comp) {
binary_search(ForwardRange const& range, T const& value, Compare comp) {
return sprout::binary_search(sprout::begin(range), sprout::end(range), value, comp);
}
} // namespace range

6
sprout/range/algorithm/count.hpp
View file

@ -11,9 +11,9 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.9 Count
template<typename Range, typename T>
inline SPROUT_CONSTEXPR typename sprout::container_traits<Range const>::difference_type
count(Range const& range, T const& value) {
template<typename InputRange, typename T>
inline SPROUT_CONSTEXPR typename sprout::container_traits<InputRange const>::difference_type
count(InputRange const& range, T const& value) {
return sprout::count(sprout::begin(range), sprout::end(range), value);
}
} // namespace range

6
sprout/range/algorithm/count_if.hpp
View file

@ -11,9 +11,9 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.9 Count
template<typename Range, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::container_traits<Range const>::difference_type
count_if(Range const& range, Predicate pred) {
template<typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::container_traits<InputRange const>::difference_type
count_if(InputRange const& range, Predicate pred) {
return sprout::count_if(sprout::begin(range), sprout::end(range), pred);
}
} // namespace range

8
sprout/range/algorithm/equal.hpp
View file

@ -10,15 +10,15 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.11 Equal
template<typename Range1, typename Range2>
template<typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR bool
equal(Range1 const& range1, Range2 const& range2) {
equal(InputRange1 const& range1, InputRange2 const& range2) {
return sprout::equal(sprout::begin(range1), sprout::end(range1), sprout::begin(range2));
}
template<typename Range1, typename Range2, typename BinaryPredicate>
template<typename InputRange1, typename InputRange2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR bool
equal(Range1 const& range1, Range2 const& range2, BinaryPredicate pred) {
equal(InputRange1 const& range1, InputRange2 const& range2, BinaryPredicate pred) {
return sprout::equal(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), pred);
}
} // namespace range

28
sprout/range/algorithm/equal_range.hpp
View file

@ -10,8 +10,8 @@
namespace sprout {
namespace range {
namespace detail {
template<typename Range, typename Pair>
inline SPROUT_CONSTEXPR typename sprout::range::lvalue_range<Range>::type
template<typename ForwardRange, typename Pair>
inline SPROUT_CONSTEXPR typename sprout::range::lvalue_range<ForwardRange>::type
pair_to_range(Pair const& pair) {
return {pair.first, pair.second};
}
@ -20,25 +20,25 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.3.3 equal_range
template<typename Range, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::lvalue_range<Range>::type
equal_range(Range&& range, T const& value) {
return sprout::range::detail::pair_to_range<Range>(
template<typename ForwardRange, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::lvalue_range<ForwardRange>::type
equal_range(ForwardRange&& range, T const& value) {
return sprout::range::detail::pair_to_range<ForwardRange>(
sprout::equal_range(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
value
)
);
}
template<typename Range, typename T, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::lvalue_range<Range>::type
equal_range(Range&& range, T const& value, Compare comp) {
return sprout::range::detail::pair_to_range<Range>(
template<typename ForwardRange, typename T, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::lvalue_range<ForwardRange>::type
equal_range(ForwardRange&& range, T const& value, Compare comp) {
return sprout::range::detail::pair_to_range<ForwardRange>(
sprout::equal_range(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
value,
comp
)

28
sprout/range/algorithm/find.hpp
View file

@ -12,29 +12,29 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.5 Find
template<typename Range, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
find(Range&& range, T const& value) {
return sprout::range::range_return<Range>::pack(
template<typename InputRange, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<InputRange>::type
find(InputRange&& range, T const& value) {
return sprout::range::range_return<InputRange>::pack(
sprout::find(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<InputRange>(range)),
sprout::end(sprout::forward<InputRange>(range)),
value
),
sprout::forward<Range>(range)
sprout::forward<InputRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
find(Range&& range, T const& value) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename InputRange, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<InputRange, RetV>::type
find(InputRange&& range, T const& value) {
return sprout::range::range_return<InputRange, RetV>::pack(
sprout::find(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<InputRange>(range)),
sprout::end(sprout::forward<InputRange>(range)),
value
),
sprout::forward<Range>(range)
sprout::forward<InputRange>(range)
);
}
} // namespace range

32
sprout/range/algorithm/find_difference.hpp
View file

@ -13,32 +13,32 @@ namespace sprout {
//
// find_difference
//
template<typename Range1, typename Range2, typename Compare>
template<typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
find_difference(Range1&& range1, Range2&& range2, Compare comp) {
find_difference(InputRange1&& range1, InputRange2&& range2, Compare comp) {
return sprout::find_difference(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2)),
comp
);
}
template<typename Range1, typename Range2>
template<typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
find_difference(Range1&& range1, Range2&& range2) {
find_difference(InputRange1&& range1, InputRange2&& range2) {
return sprout::find_difference(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2))
);
}
} // namespace range

72
sprout/range/algorithm/find_end.hpp
View file

@ -12,61 +12,61 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.6 Find end
template<typename Range1, typename Range2>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range1>::type
find_end(Range1&& range1, Range2&& range2) {
return sprout::range::range_return<Range1>::pack(
template<typename ForwardRange1, typename ForwardRange2>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange1>::type
find_end(ForwardRange1&& range1, ForwardRange2&& range2) {
return sprout::range::range_return<ForwardRange1>::pack(
sprout::find_end(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<ForwardRange1>(range1)),
sprout::end(sprout::forward<ForwardRange1>(range1)),
sprout::begin(sprout::forward<ForwardRange2>(range2)),
sprout::end(sprout::forward<ForwardRange2>(range2))
),
sprout::forward<Range1>(range1)
sprout::forward<ForwardRange1>(range1)
);
}
template<typename Range1, typename Range2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range1>::type
find_end(Range1&& range1, Range2&& range2, BinaryPredicate pred) {
return sprout::range::range_return<Range1>::pack(
template<typename ForwardRange1, typename ForwardRange2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange1>::type
find_end(ForwardRange1&& range1, ForwardRange2&& range2, BinaryPredicate pred) {
return sprout::range::range_return<ForwardRange1>::pack(
sprout::find_end(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<ForwardRange1>(range1)),
sprout::end(sprout::forward<ForwardRange1>(range1)),
sprout::begin(sprout::forward<ForwardRange2>(range2)),
sprout::end(sprout::forward<ForwardRange2>(range2)),
pred
),
sprout::forward<Range1>(range1)
sprout::forward<ForwardRange1>(range1)
);
}
template<sprout::range::range_return_value RetV, typename Range1, typename Range2>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range1, RetV>::type
find_end(Range1&& range1, Range2&& range2) {
return sprout::range::range_return<Range1, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange1, typename ForwardRange2>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange1, RetV>::type
find_end(ForwardRange1&& range1, ForwardRange2&& range2) {
return sprout::range::range_return<ForwardRange1, RetV>::pack(
sprout::find_end(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<ForwardRange1>(range1)),
sprout::end(sprout::forward<ForwardRange1>(range1)),
sprout::begin(sprout::forward<ForwardRange2>(range2)),
sprout::end(sprout::forward<ForwardRange2>(range2))
),
sprout::forward<Range1>(range1)
sprout::forward<ForwardRange1>(range1)
);
}
template<sprout::range::range_return_value RetV, typename Range1, typename Range2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range1, RetV>::type
find_end(Range1&& range1, Range2&& range2, BinaryPredicate pred) {
return sprout::range::range_return<Range1, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange1, typename ForwardRange2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange1, RetV>::type
find_end(ForwardRange1&& range1, ForwardRange2&& range2, BinaryPredicate pred) {
return sprout::range::range_return<ForwardRange1, RetV>::pack(
sprout::find_end(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<ForwardRange1>(range1)),
sprout::end(sprout::forward<ForwardRange1>(range1)),
sprout::begin(sprout::forward<ForwardRange2>(range2)),
sprout::end(sprout::forward<ForwardRange2>(range2)),
pred
),
sprout::forward<Range1>(range1)
sprout::forward<ForwardRange1>(range1)
);
}
} // namespace range

72
sprout/range/algorithm/find_first_of.hpp
View file

@ -12,61 +12,61 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.7 Find first
template<typename Range1, typename Range2>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range1>::type
find_first_of(Range1&& range1, Range2&& range2) {
return sprout::range::range_return<Range1>::pack(
template<typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<InputRange1>::type
find_first_of(InputRange1&& range1, InputRange2&& range2) {
return sprout::range::range_return<InputRange1>::pack(
sprout::find_first_of(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2))
),
sprout::forward<Range1>(range1)
sprout::forward<InputRange1>(range1)
);
}
template<typename Range1, typename Range2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range1>::type
find_first_of(Range1&& range1, Range2&& range2, BinaryPredicate pred) {
return sprout::range::range_return<Range1>::pack(
template<typename InputRange1, typename InputRange2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<InputRange1>::type
find_first_of(InputRange1&& range1, InputRange2&& range2, BinaryPredicate pred) {
return sprout::range::range_return<InputRange1>::pack(
sprout::find_first_of(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2)),
pred
),
sprout::forward<Range1>(range1)
sprout::forward<InputRange1>(range1)
);
}
template<sprout::range::range_return_value RetV, typename Range1, typename Range2>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range1, RetV>::type
find_first_of(Range1&& range1, Range2&& range2) {
return sprout::range::range_return<Range1, RetV>::pack(
template<sprout::range::range_return_value RetV, typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<InputRange1, RetV>::type
find_first_of(InputRange1&& range1, InputRange2&& range2) {
return sprout::range::range_return<InputRange1, RetV>::pack(
sprout::find_first_of(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2))
),
sprout::forward<Range1>(range1)
sprout::forward<InputRange1>(range1)
);
}
template<sprout::range::range_return_value RetV, typename Range1, typename Range2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range1, RetV>::type
find_first_of(Range1&& range1, Range2&& range2, BinaryPredicate pred) {
return sprout::range::range_return<Range1, RetV>::pack(
template<sprout::range::range_return_value RetV, typename InputRange1, typename InputRange2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<InputRange1, RetV>::type
find_first_of(InputRange1&& range1, InputRange2&& range2, BinaryPredicate pred) {
return sprout::range::range_return<InputRange1, RetV>::pack(
sprout::find_first_of(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2)),
pred
),
sprout::forward<Range1>(range1)
sprout::forward<InputRange1>(range1)
);
}
} // namespace range

28
sprout/range/algorithm/find_if.hpp
View file

@ -12,29 +12,29 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.5 Find
template<typename Range, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
find_if(Range&& range, Predicate pred) {
return sprout::range::range_return<Range>::pack(
template<typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<InputRange>::type
find_if(InputRange&& range, Predicate pred) {
return sprout::range::range_return<InputRange>::pack(
sprout::find_if(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<InputRange>(range)),
sprout::end(sprout::forward<InputRange>(range)),
pred
),
sprout::forward<Range>(range)
sprout::forward<InputRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
find_if(Range&& range, Predicate pred) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<InputRange, RetV>::type
find_if(InputRange&& range, Predicate pred) {
return sprout::range::range_return<InputRange, RetV>::pack(
sprout::find_if(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<InputRange>(range)),
sprout::end(sprout::forward<InputRange>(range)),
pred
),
sprout::forward<Range>(range)
sprout::forward<InputRange>(range)
);
}
} // namespace range

28
sprout/range/algorithm/find_if_not.hpp
View file

@ -12,29 +12,29 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.5 Find
template<typename Range, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
find_if_not(Range&& range, Predicate pred) {
return sprout::range::range_return<Range>::pack(
template<typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<InputRange>::type
find_if_not(InputRange&& range, Predicate pred) {
return sprout::range::range_return<InputRange>::pack(
sprout::find_if_not(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<InputRange>(range)),
sprout::end(sprout::forward<InputRange>(range)),
pred
),
sprout::forward<Range>(range)
sprout::forward<InputRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
find_if_not(Range&& range, Predicate pred) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<InputRange, RetV>::type
find_if_not(InputRange&& range, Predicate pred) {
return sprout::range::range_return<InputRange, RetV>::pack(
sprout::find_if_not(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<InputRange>(range)),
sprout::end(sprout::forward<InputRange>(range)),
pred
),
sprout::forward<Range>(range)
sprout::forward<InputRange>(range)
);
}
} // namespace range

32
sprout/range/algorithm/find_intersection.hpp
View file

@ -13,32 +13,32 @@ namespace sprout {
//
// find_intersection
//
template<typename Range1, typename Range2, typename Compare>
template<typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
find_intersection(Range1&& range1, Range2&& range2, Compare comp) {
find_intersection(InputRange1&& range1, InputRange2&& range2, Compare comp) {
return sprout::find_intersection(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2)),
comp
);
}
template<typename Range1, typename Range2>
template<typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
find_intersection(Range1&& range1, Range2&& range2) {
find_intersection(InputRange1&& range1, InputRange2&& range2) {
return sprout::find_intersection(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2))
);
}
} // namespace range

32
sprout/range/algorithm/find_symmetric_difference.hpp
View file

@ -13,32 +13,32 @@ namespace sprout {
//
// find_symmetric_difference
//
template<typename Range1, typename Range2, typename Compare>
template<typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
find_symmetric_difference(Range1&& range1, Range2&& range2, Compare comp) {
find_symmetric_difference(InputRange1&& range1, InputRange2&& range2, Compare comp) {
return sprout::find_symmetric_difference(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2)),
comp
);
}
template<typename Range1, typename Range2>
template<typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
find_symmetric_difference(Range1&& range1, Range2&& range2) {
find_symmetric_difference(InputRange1&& range1, InputRange2&& range2) {
return sprout::find_symmetric_difference(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2))
);
}
} // namespace range

8
sprout/range/algorithm/includes.hpp
View file

@ -10,15 +10,15 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.5.1 includes
template<typename Range1, typename Range2>
template<typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR bool
includes(Range1 const& range1, Range2 const& range2) {
includes(InputRange1 const& range1, InputRange2 const& range2) {
return sprout::includes(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2));
}
template<typename Range1, typename Range2, typename Compare>
template<typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR bool
includes(Range1 const& range1, Range2 const& range2, Compare comp) {
includes(InputRange1 const& range1, InputRange2 const& range2, Compare comp) {
return sprout::includes(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2), comp);
}
} // namespace range

4
sprout/range/algorithm/is_decreasing.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
//
// is_decreasing
//
template<typename Range>
template<typename ForwardRange>
inline SPROUT_CONSTEXPR bool
is_decreasing(Range const& range) {
is_decreasing(ForwardRange const& range) {
return sprout::is_decreasing(sprout::begin(range), sprout::end(range));
}
} // namespace range

8
sprout/range/algorithm/is_heap.hpp
View file

@ -10,15 +10,15 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.6.5 is_heap
template<typename Range>
template<typename RandomAccessRange>
inline SPROUT_CONSTEXPR bool
is_heap(Range const& range) {
is_heap(RandomAccessRange const& range) {
return sprout::is_heap(sprout::begin(range), sprout::end(range));
}
template<typename Range, typename Compare>
template<typename RandomAccessRange, typename Compare>
inline SPROUT_CONSTEXPR bool
is_heap(Range const& range, Compare comp) {
is_heap(RandomAccessRange const& range, Compare comp) {
return sprout::is_heap(sprout::begin(range), sprout::end(range), comp);
}
} // namespace range

56
sprout/range/algorithm/is_heap_until.hpp
View file

@ -12,53 +12,53 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.6.5 is_heap
template<typename Range>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
is_heap_until(Range&& range) {
return sprout::range::range_return<Range>::pack(
template<typename RandomAccessRange>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<RandomAccessRange>::type
is_heap_until(RandomAccessRange&& range) {
return sprout::range::range_return<RandomAccessRange>::pack(
sprout::is_heap_until(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range))
sprout::begin(sprout::forward<RandomAccessRange>(range)),
sprout::end(sprout::forward<RandomAccessRange>(range))
),
sprout::forward<Range>(range)
sprout::forward<RandomAccessRange>(range)
);
}
template<typename Range, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
is_heap_until(Range&& range, Compare comp) {
return sprout::range::range_return<Range>::pack(
template<typename RandomAccessRange, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<RandomAccessRange>::type
is_heap_until(RandomAccessRange&& range, Compare comp) {
return sprout::range::range_return<RandomAccessRange>::pack(
sprout::is_heap_until(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<RandomAccessRange>(range)),
sprout::end(sprout::forward<RandomAccessRange>(range)),
comp
),
sprout::forward<Range>(range)
sprout::forward<RandomAccessRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
is_heap_until(Range&& range) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename RandomAccessRange>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<RandomAccessRange, RetV>::type
is_heap_until(RandomAccessRange&& range) {
return sprout::range::range_return<RandomAccessRange, RetV>::pack(
sprout::is_heap_until(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range))
sprout::begin(sprout::forward<RandomAccessRange>(range)),
sprout::end(sprout::forward<RandomAccessRange>(range))
),
sprout::forward<Range>(range)
sprout::forward<RandomAccessRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
is_heap_until(Range&& range, Compare comp) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename RandomAccessRange, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<RandomAccessRange, RetV>::type
is_heap_until(RandomAccessRange&& range, Compare comp) {
return sprout::range::range_return<RandomAccessRange, RetV>::pack(
sprout::is_heap_until(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<RandomAccessRange>(range)),
sprout::end(sprout::forward<RandomAccessRange>(range)),
comp
),
sprout::forward<Range>(range)
sprout::forward<RandomAccessRange>(range)
);
}
} // namespace range

4
sprout/range/algorithm/is_increasing.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
//
// is_increasing
//
template<typename Range>
template<typename ForwardRange>
inline SPROUT_CONSTEXPR bool
is_increasing(Range const& range) {
is_increasing(ForwardRange const& range) {
return sprout::is_increasing(sprout::begin(range), sprout::end(range));
}
} // namespace range

4
sprout/range/algorithm/is_partitioned.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.3.13 partitions
template<typename Range, typename Predicate>
template<typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR bool
is_partitioned(Range const& range, Predicate pred) {
is_partitioned(InputRange const& range, Predicate pred) {
return sprout::is_partitioned(sprout::begin(range), sprout::end(range), pred);
}
} // namespace range

8
sprout/range/algorithm/is_permutation.hpp
View file

@ -10,15 +10,15 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.12 Is permutation
template<typename Range1, typename Range2>
template<typename ForwardRange1, typename ForwardRange2>
inline SPROUT_CONSTEXPR bool
is_permutation(Range1 const& range1, Range2 const& range2) {
is_permutation(ForwardRange1 const& range1, ForwardRange2 const& range2) {
return sprout::is_permutation(sprout::begin(range1), sprout::end(range1), sprout::begin(range2));
}
template<typename Range1, typename Range2, typename BinaryPredicate>
template<typename ForwardRange1, typename ForwardRange2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR bool
is_permutation(Range1 const& range1, Range2 const& range2, BinaryPredicate pred) {
is_permutation(ForwardRange1 const& range1, ForwardRange2 const& range2, BinaryPredicate pred) {
return sprout::is_permutation(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), pred);
}
} // namespace range

8
sprout/range/algorithm/is_sorted.hpp
View file

@ -10,15 +10,15 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.1.5 is_sorted
template<typename Range>
template<typename ForwardRange>
inline SPROUT_CONSTEXPR bool
is_sorted(Range const& range) {
is_sorted(ForwardRange const& range) {
return sprout::is_sorted(sprout::begin(range), sprout::end(range));
}
template<typename Range, typename Compare>
template<typename ForwardRange, typename Compare>
inline SPROUT_CONSTEXPR bool
is_sorted(Range const& range, Compare comp) {
is_sorted(ForwardRange const& range, Compare comp) {
return sprout::is_sorted(sprout::begin(range), sprout::end(range), comp);
}
} // namespace range

56
sprout/range/algorithm/is_sorted_until.hpp
View file

@ -12,53 +12,53 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.1.5 is_sorted
template<typename Range>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
is_sorted_until(Range&& range) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
is_sorted_until(ForwardRange&& range) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::is_sorted_until(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range))
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range))
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<typename Range, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
is_sorted_until(Range&& range, Compare comp) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
is_sorted_until(ForwardRange&& range, Compare comp) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::is_sorted_until(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
comp
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
is_sorted_until(Range&& range) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
is_sorted_until(ForwardRange&& range) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::is_sorted_until(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range))
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range))
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
is_sorted_until(Range&& range, Compare comp) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
is_sorted_until(ForwardRange&& range, Compare comp) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::is_sorted_until(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
comp
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
} // namespace range

4
sprout/range/algorithm/is_strictly_decreasing.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
//
// is_strictly_decreasing
//
template<typename Range>
template<typename ForwardRange>
inline SPROUT_CONSTEXPR bool
is_strictly_decreasing(Range const& range) {
is_strictly_decreasing(ForwardRange const& range) {
return sprout::is_strictly_decreasing(sprout::begin(range), sprout::end(range));
}
} // namespace range

4
sprout/range/algorithm/is_strictly_increasing.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
//
// is_strictly_increasing
//
template<typename Range>
template<typename ForwardRange>
inline SPROUT_CONSTEXPR bool
is_strictly_increasing(Range const& range) {
is_strictly_increasing(ForwardRange const& range) {
return sprout::is_strictly_increasing(sprout::begin(range), sprout::end(range));
}
} // namespace range

8
sprout/range/algorithm/lexicographical_compare.hpp
View file

@ -10,17 +10,17 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.8 Lexicographical comparison
template<typename Range1, typename Range2>
template<typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR bool
lexicographical_compare(Range1 const& range1, Range2 const& range2) {
lexicographical_compare(InputRange1 const& range1, InputRange2 const& range2) {
return sprout::lexicographical_compare(
sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2)
);
}
template<typename Range1, typename Range2, typename Compare>
template<typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR bool
lexicographical_compare(Range1 const& range1, Range2 const& range2, Compare comp) {
lexicographical_compare(InputRange1 const& range1, InputRange2 const& range2, Compare comp) {
return sprout::lexicographical_compare(
sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2), comp
);

56
sprout/range/algorithm/lower_bound.hpp
View file

@ -12,57 +12,57 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.3.1 lower_bound
template<typename Range, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
lower_bound(Range&& range, T const& value) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
lower_bound(ForwardRange&& range, T const& value) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::lower_bound(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
value
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<typename Range, typename T, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
lower_bound(Range&& range, T const& value, Compare comp) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange, typename T, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
lower_bound(ForwardRange&& range, T const& value, Compare comp) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::lower_bound(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
value,
comp
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
lower_bound(Range&& range, T const& value) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
lower_bound(ForwardRange&& range, T const& value) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::lower_bound(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
value
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename T, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
lower_bound(Range&& range, T const& value, Compare comp) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange, typename T, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
lower_bound(ForwardRange&& range, T const& value, Compare comp) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::lower_bound(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
value,
comp
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
} // namespace range

56
sprout/range/algorithm/max_element.hpp
View file

@ -12,53 +12,53 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.7 Minimum and maximum
template<typename Range>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
max_element(Range&& range) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
max_element(ForwardRange&& range) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::max_element(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range))
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range))
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<typename Range, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
max_element(Range&& range, Compare comp) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
max_element(ForwardRange&& range, Compare comp) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::max_element(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
comp
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
max_element(Range&& range) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
max_element(ForwardRange&& range) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::max_element(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range))
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range))
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
max_element(Range&& range, Compare comp) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
max_element(ForwardRange&& range, Compare comp) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::max_element(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
comp
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
} // namespace range

56
sprout/range/algorithm/min_element.hpp
View file

@ -12,53 +12,53 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.7 Minimum and maximum
template<typename Range>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
min_element(Range&& range) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
min_element(ForwardRange&& range) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::min_element(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range))
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range))
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<typename Range, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
min_element(Range&& range, Compare comp) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
min_element(ForwardRange&& range, Compare comp) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::min_element(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
comp
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
min_element(Range&& range) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
min_element(ForwardRange&& range) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::min_element(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range))
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range))
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
min_element(Range&& range, Compare comp) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
min_element(ForwardRange&& range, Compare comp) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::min_element(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
comp
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
} // namespace range

88
sprout/range/algorithm/minmax_element.hpp
View file

@ -11,27 +11,27 @@
namespace sprout {
namespace range {
namespace detail {
template<typename Range, typename Pair>
template<typename ForwardRange, typename Pair>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::range_return<Range>::type,
typename sprout::range::range_return<Range>::type
typename sprout::range::range_return<ForwardRange>::type,
typename sprout::range::range_return<ForwardRange>::type
>
pack_pair(Pair const& pair, Range&& range) {
pack_pair(Pair const& pair, ForwardRange&& range) {
return {
sprout::range::range_return<Range>::pack(pair.first, sprout::forward<Range>(range)),
sprout::range::range_return<Range>::pack(pair.second, sprout::forward<Range>(range))
sprout::range::range_return<ForwardRange>::pack(pair.first, sprout::forward<ForwardRange>(range)),
sprout::range::range_return<ForwardRange>::pack(pair.second, sprout::forward<ForwardRange>(range))
};
}
template<sprout::range::range_return_value RetV, typename Range, typename Pair>
template<sprout::range::range_return_value RetV, typename ForwardRange, typename Pair>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::range_return<Range, RetV>::type,
typename sprout::range::range_return<Range, RetV>::type
typename sprout::range::range_return<ForwardRange, RetV>::type,
typename sprout::range::range_return<ForwardRange, RetV>::type
>
pack_pair(Pair const& pair, Range&& range) {
pack_pair(Pair const& pair, ForwardRange&& range) {
return {
sprout::range::range_return<Range, RetV>::pack(pair.first, sprout::forward<Range>(range)),
sprout::range::range_return<Range, RetV>::pack(pair.second, sprout::forward<Range>(range))
sprout::range::range_return<ForwardRange, RetV>::pack(pair.first, sprout::forward<ForwardRange>(range)),
sprout::range::range_return<ForwardRange, RetV>::pack(pair.second, sprout::forward<ForwardRange>(range))
};
}
} // namespace detail
@ -39,65 +39,65 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.7 Minimum and maximum
template<typename Range>
template<typename ForwardRange>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::range_return<Range>::type,
typename sprout::range::range_return<Range>::type
typename sprout::range::range_return<ForwardRange>::type,
typename sprout::range::range_return<ForwardRange>::type
>
minmax_element(Range&& range) {
return sprout::range::detail::pack_pair<Range>(
minmax_element(ForwardRange&& range) {
return sprout::range::detail::pack_pair<ForwardRange>(
sprout::minmax_element(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range))
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range))
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<typename Range, typename Compare>
template<typename ForwardRange, typename Compare>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::range_return<Range>::type,
typename sprout::range::range_return<Range>::type
typename sprout::range::range_return<ForwardRange>::type,
typename sprout::range::range_return<ForwardRange>::type
>
minmax_element(Range&& range, Compare comp) {
return sprout::range::detail::pack_pair<Range>(
minmax_element(ForwardRange&& range, Compare comp) {
return sprout::range::detail::pack_pair<ForwardRange>(
sprout::minmax_element(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
comp
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range>
template<sprout::range::range_return_value RetV, typename ForwardRange>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::range_return<Range, RetV>::type,
typename sprout::range::range_return<Range, RetV>::type
typename sprout::range::range_return<ForwardRange, RetV>::type,
typename sprout::range::range_return<ForwardRange, RetV>::type
>
minmax_element(Range&& range) {
return sprout::range::detail::pack_pair<RetV, Range>(
minmax_element(ForwardRange&& range) {
return sprout::range::detail::pack_pair<RetV, ForwardRange>(
sprout::minmax_element(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range))
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range))
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename Compare>
template<sprout::range::range_return_value RetV, typename ForwardRange, typename Compare>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::range_return<Range, RetV>::type,
typename sprout::range::range_return<Range, RetV>::type
typename sprout::range::range_return<ForwardRange, RetV>::type,
typename sprout::range::range_return<ForwardRange, RetV>::type
>
minmax_element(Range&& range, Compare comp) {
return sprout::range::detail::pack_pair<RetV, Range>(
minmax_element(ForwardRange&& range, Compare comp) {
return sprout::range::detail::pack_pair<RetV, ForwardRange>(
sprout::minmax_element(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
comp
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
} // namespace range

28
sprout/range/algorithm/mismatch.hpp
View file

@ -13,29 +13,29 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.10 Mismatch
template<typename Range1, typename Range2>
template<typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
mismatch(Range1&& range1, Range2&& range2) {
mismatch(InputRange1&& range1, InputRange2&& range2) {
return sprout::mismatch(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2))
);
}
template<typename Range1, typename Range2, typename BinaryPredicate>
template<typename InputRange1, typename InputRange2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
mismatch(Range1&& range1, Range2&& range2, BinaryPredicate pred) {
mismatch(InputRange1&& range1, InputRange2&& range2, BinaryPredicate pred) {
return sprout::mismatch(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
pred
);
}

32
sprout/range/algorithm/next_difference.hpp
View file

@ -13,32 +13,32 @@ namespace sprout {
//
// next_difference
//
template<typename Range1, typename Range2, typename Compare>
template<typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
next_difference(Range1&& range1, Range2&& range2, Compare comp) {
next_difference(InputRange1&& range1, InputRange2&& range2, Compare comp) {
return sprout::next_difference(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2)),
comp
);
}
template<typename Range1, typename Range2>
template<typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
next_difference(Range1&& range1, Range2&& range2) {
next_difference(InputRange1&& range1, InputRange2&& range2) {
return sprout::next_difference(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2))
);
}
} // namespace range

32
sprout/range/algorithm/next_intersection.hpp
View file

@ -13,32 +13,32 @@ namespace sprout {
//
// next_intersection
//
template<typename Range1, typename Range2, typename Compare>
template<typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
next_intersection(Range1&& range1, Range2&& range2, Compare comp) {
next_intersection(InputRange1&& range1, InputRange2&& range2, Compare comp) {
return sprout::next_intersection(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2)),
comp
);
}
template<typename Range1, typename Range2>
template<typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
next_intersection(Range1&& range1, Range2&& range2) {
next_intersection(InputRange1&& range1, InputRange2&& range2) {
return sprout::next_intersection(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2))
);
}
} // namespace range

32
sprout/range/algorithm/next_union.hpp
View file

@ -13,32 +13,32 @@ namespace sprout {
//
// next_union
//
template<typename Range1, typename Range2, typename Compare>
template<typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
next_union(Range1&& range1, Range2&& range2, Compare comp) {
next_union(InputRange1&& range1, InputRange2&& range2, Compare comp) {
return sprout::next_union(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2)),
comp
);
}
template<typename Range1, typename Range2>
template<typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR sprout::pair<
typename sprout::range::lvalue_iterator<Range1>::type,
typename sprout::range::lvalue_iterator<Range2>::type
typename sprout::range::lvalue_iterator<InputRange1>::type,
typename sprout::range::lvalue_iterator<InputRange2>::type
>
next_union(Range1&& range1, Range2&& range2) {
next_union(InputRange1&& range1, InputRange2&& range2) {
return sprout::next_union(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<InputRange1>(range1)),
sprout::end(sprout::forward<InputRange1>(range1)),
sprout::begin(sprout::forward<InputRange2>(range2)),
sprout::end(sprout::forward<InputRange2>(range2))
);
}
} // namespace range

4
sprout/range/algorithm/none_of.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.3 None of
template<typename Range, typename Predicate>
template<typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR bool
none_of(Range const& range, Predicate pred) {
none_of(InputRange const& range, Predicate pred) {
return sprout::none_of(sprout::begin(range), sprout::end(range), pred);
}
} // namespace range

4
sprout/range/algorithm/none_of_equal.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
//
// none_of_equal
//
template<typename Range, typename T>
template<typename InputRange, typename T>
inline SPROUT_CONSTEXPR bool
none_of_equal(Range const& range, T const& value) {
none_of_equal(InputRange const& range, T const& value) {
return sprout::none_of_equal(sprout::begin(range), sprout::end(range), value);
}
} // namespace range

4
sprout/range/algorithm/one_of.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
//
// one_of
//
template<typename Range, typename Predicate>
template<typename InputRange, typename Predicate>
inline SPROUT_CONSTEXPR bool
one_of(Range const& range, Predicate pred) {
one_of(InputRange const& range, Predicate pred) {
return sprout::one_of(sprout::begin(range), sprout::end(range), pred);
}
} // namespace range

4
sprout/range/algorithm/one_of_equal.hpp
View file

@ -10,9 +10,9 @@ namespace sprout {
//
// one_of_equal
//
template<typename Range, typename T>
template<typename InputRange, typename T>
inline SPROUT_CONSTEXPR bool
one_of_equal(Range const& range, T const& value) {
one_of_equal(InputRange const& range, T const& value) {
return sprout::one_of_equal(sprout::begin(range), sprout::end(range), value);
}
} // namespace range

14
sprout/range/algorithm/partition_point.hpp
View file

@ -12,16 +12,16 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.3.13 partitions
template<typename Range, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
partition_point(Range&& range, Predicate pred) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange, typename Predicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
partition_point(ForwardRange&& range, Predicate pred) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::partition_point(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
pred
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
} // namespace range

72
sprout/range/algorithm/search.hpp
View file

@ -12,61 +12,61 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.13 Search
template<typename Range1, typename Range2>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range1>::type
search(Range1&& range1, Range2&& range2) {
return sprout::range::range_return<Range1>::pack(
template<typename ForwardRange1, typename ForwardRange2>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange1>::type
search(ForwardRange1&& range1, ForwardRange2&& range2) {
return sprout::range::range_return<ForwardRange1>::pack(
sprout::search(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<ForwardRange1>(range1)),
sprout::end(sprout::forward<ForwardRange1>(range1)),
sprout::begin(sprout::forward<ForwardRange2>(range2)),
sprout::end(sprout::forward<ForwardRange2>(range2))
),
sprout::forward<Range1>(range1)
sprout::forward<ForwardRange1>(range1)
);
}
template<typename Range1, typename Range2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range1>::type
search(Range1&& range1, Range2&& range2, BinaryPredicate pred) {
return sprout::range::range_return<Range1>::pack(
template<typename ForwardRange1, typename ForwardRange2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange1>::type
search(ForwardRange1&& range1, ForwardRange2&& range2, BinaryPredicate pred) {
return sprout::range::range_return<ForwardRange1>::pack(
sprout::search(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<ForwardRange1>(range1)),
sprout::end(sprout::forward<ForwardRange1>(range1)),
sprout::begin(sprout::forward<ForwardRange2>(range2)),
sprout::end(sprout::forward<ForwardRange2>(range2)),
pred
),
sprout::forward<Range1>(range1)
sprout::forward<ForwardRange1>(range1)
);
}
template<sprout::range::range_return_value RetV, typename Range1, typename Range2>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range1, RetV>::type
search(Range1&& range1, Range2&& range2) {
return sprout::range::range_return<Range1, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange1, typename ForwardRange2>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange1, RetV>::type
search(ForwardRange1&& range1, ForwardRange2&& range2) {
return sprout::range::range_return<ForwardRange1, RetV>::pack(
sprout::search(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2))
sprout::begin(sprout::forward<ForwardRange1>(range1)),
sprout::end(sprout::forward<ForwardRange1>(range1)),
sprout::begin(sprout::forward<ForwardRange2>(range2)),
sprout::end(sprout::forward<ForwardRange2>(range2))
),
sprout::forward<Range1>(range1)
sprout::forward<ForwardRange1>(range1)
);
}
template<sprout::range::range_return_value RetV, typename Range1, typename Range2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range1, RetV>::type
search(Range1&& range1, Range2&& range2, BinaryPredicate pred) {
return sprout::range::range_return<Range1, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange1, typename ForwardRange2, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange1, RetV>::type
search(ForwardRange1&& range1, ForwardRange2&& range2, BinaryPredicate pred) {
return sprout::range::range_return<ForwardRange1, RetV>::pack(
sprout::search(
sprout::begin(sprout::forward<Range1>(range1)),
sprout::end(sprout::forward<Range1>(range1)),
sprout::begin(sprout::forward<Range2>(range2)),
sprout::end(sprout::forward<Range2>(range2)),
sprout::begin(sprout::forward<ForwardRange1>(range1)),
sprout::end(sprout::forward<ForwardRange1>(range1)),
sprout::begin(sprout::forward<ForwardRange2>(range2)),
sprout::end(sprout::forward<ForwardRange2>(range2)),
pred
),
sprout::forward<Range1>(range1)
sprout::forward<ForwardRange1>(range1)
);
}
} // namespace range

56
sprout/range/algorithm/search_n.hpp
View file

@ -12,61 +12,61 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.2.13 Search
template<typename Range, typename Size, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
search_n(Range&& range, Size count, T const& value) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange, typename Size, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
search_n(ForwardRange&& range, Size count, T const& value) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::search_n(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
count,
value
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<typename Range, typename Size, typename T, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
search_n(Range&& range, Size count, T const& value, BinaryPredicate pred) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange, typename Size, typename T, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
search_n(ForwardRange&& range, Size count, T const& value, BinaryPredicate pred) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::search_n(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
count,
value,
pred
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename Size, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
search_n(Range&& range, Size count, T const& value) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange, typename Size, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
search_n(ForwardRange&& range, Size count, T const& value) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::search_n(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
count,
value
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename Size, typename T, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
search_n(Range&& range, Size count, T const& value, BinaryPredicate pred) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange, typename Size, typename T, typename BinaryPredicate>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
search_n(ForwardRange&& range, Size count, T const& value, BinaryPredicate pred) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::search_n(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
count,
value,
pred
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
} // namespace range

16
sprout/range/algorithm/tristate_lexicographical_compare.hpp
View file

@ -10,33 +10,33 @@ namespace sprout {
//
// tristate_lexicographical_compare
//
template<typename Range1, typename Range2>
template<typename InputRange1, typename InputRange2>
inline SPROUT_CONSTEXPR int
tristate_lexicographical_compare(Range1 const& range1, Range2 const& range2) {
tristate_lexicographical_compare(InputRange1 const& range1, InputRange2 const& range2) {
return sprout::tristate_lexicographical_compare(
sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2)
);
}
template<typename Range1, typename Range2, typename Compare>
template<typename InputRange1, typename InputRange2, typename Compare>
inline SPROUT_CONSTEXPR int
tristate_lexicographical_compare(Range1 const& range1, Range2 const& range2, Compare comp) {
tristate_lexicographical_compare(InputRange1 const& range1, InputRange2 const& range2, Compare comp) {
return sprout::tristate_lexicographical_compare(
sprout::begin(range1), sprout::end(range1), sprout::begin(range2), sprout::end(range2), comp
);
}
template<typename Range1, typename T1, typename Range2, typename T2>
template<typename InputRange1, typename T1, typename InputRange2, typename T2>
inline SPROUT_CONSTEXPR int
tristate_lexicographical_compare(Range1 const& range1, T1 const& delim1, Range2 const& range2, T2 const& delim2) {
tristate_lexicographical_compare(InputRange1 const& range1, T1 const& delim1, InputRange2 const& range2, T2 const& delim2) {
return sprout::tristate_lexicographical_compare(
sprout::begin(range1), sprout::end(range1), delim1, sprout::begin(range2), sprout::end(range2), delim2
);
}
template<typename Range1, typename T1, typename Range2, typename T2, typename Compare>
template<typename InputRange1, typename T1, typename InputRange2, typename T2, typename Compare>
inline SPROUT_CONSTEXPR int
tristate_lexicographical_compare(Range1 const& range1, T1 const& delim1, Range2 const& range2, T2 const& delim2, Compare comp) {
tristate_lexicographical_compare(InputRange1 const& range1, T1 const& delim1, InputRange2 const& range2, T2 const& delim2, Compare comp) {
return sprout::tristate_lexicographical_compare(
sprout::begin(range1), sprout::end(range1), delim1, sprout::begin(range2), sprout::end(range2), delim2, comp
);

56
sprout/range/algorithm/upper_bound.hpp
View file

@ -12,57 +12,57 @@ namespace sprout {
// Copyright (C) 2011 RiSK (sscrisk)
// 25.4.3.2 upper_bound
template<typename Range, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
upper_bound(Range&& range, T const& value) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
upper_bound(ForwardRange&& range, T const& value) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::upper_bound(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
value
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<typename Range, typename T, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range>::type
upper_bound(Range&& range, T const& value, Compare comp) {
return sprout::range::range_return<Range>::pack(
template<typename ForwardRange, typename T, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange>::type
upper_bound(ForwardRange&& range, T const& value, Compare comp) {
return sprout::range::range_return<ForwardRange>::pack(
sprout::upper_bound(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
value,
comp
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
upper_bound(Range&& range, T const& value) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange, typename T>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
upper_bound(ForwardRange&& range, T const& value) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::upper_bound(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
value
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
template<sprout::range::range_return_value RetV, typename Range, typename T, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<Range, RetV>::type
upper_bound(Range&& range, T const& value, Compare comp) {
return sprout::range::range_return<Range, RetV>::pack(
template<sprout::range::range_return_value RetV, typename ForwardRange, typename T, typename Compare>
inline SPROUT_CONSTEXPR typename sprout::range::range_return<ForwardRange, RetV>::type
upper_bound(ForwardRange&& range, T const& value, Compare comp) {
return sprout::range::range_return<ForwardRange, RetV>::pack(
sprout::upper_bound(
sprout::begin(sprout::forward<Range>(range)),
sprout::end(sprout::forward<Range>(range)),
sprout::begin(sprout::forward<ForwardRange>(range)),
sprout::end(sprout::forward<ForwardRange>(range)),
value,
comp
),
sprout::forward<Range>(range)
sprout::forward<ForwardRange>(range)
);
}
} // namespace range

8
sprout/range/numeric/accumulate.hpp
View file

@ -7,15 +7,15 @@
namespace sprout {
namespace range {
// 26.7.2 Accumulate
template<typename Range, typename T, typename BinaryOperation>
template<typename InputRange, typename T, typename BinaryOperation>
inline SPROUT_CONSTEXPR T
accumulate(Range const& range, T init, BinaryOperation binary_op) {
accumulate(InputRange const& range, T init, BinaryOperation binary_op) {
return sprout::accumulate(sprout::begin(range), sprout::end(range), init, binary_op);
}
template<typename Range, typename T>
template<typename InputRange, typename T>
inline SPROUT_CONSTEXPR T
accumulate(Range const& range, T init) {
accumulate(InputRange const& range, T init) {
return sprout::accumulate(sprout::begin(range), sprout::end(range), init);
}
} // namespace range

8
sprout/range/numeric/inner_product.hpp
View file

@ -7,19 +7,19 @@
namespace sprout {
namespace range {
// 26.7.3 Inner product
template<typename Range1, typename Range2, typename T, typename BinaryOperation1, typename BinaryOperation2>
template<typename InputRange1, typename InputRange2, typename T, typename BinaryOperation1, typename BinaryOperation2>
inline SPROUT_CONSTEXPR T
inner_product(
Range1 const& range1, Range2 const& range2, T init,
InputRange1 const& range1, InputRange2 const& range2, T init,
BinaryOperation1 binary_op1, BinaryOperation2 binary_op2
)
{
return sprout::inner_product(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), init, binary_op1, binary_op2);
}
template<typename Range1, typename Range2, typename T>
template<typename InputRange1, typename InputRange2, typename T>
inline SPROUT_CONSTEXPR T
inner_product(Range1 const& range1, Range2 const& range2, T init) {
inner_product(InputRange1 const& range1, InputRange2 const& range2, T init) {
return sprout::inner_product(sprout::begin(range1), sprout::end(range1), sprout::begin(range2), init);
}
} // namespace range