Skip to content

Modernize ranges::all_of and friends #1061

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
CaseyCarter merged 2 commits into from
Jul 27, 2020
Merged

Modernize ranges::all_of and friends #1061

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
57a56d6
Modernize ranges::all_of and friends
miscco Jul 20, 2020
3003096
Apply review comments from Casey
miscco Jul 21, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
84 changes: 57 additions & 27 deletions stl/inc/algorithm
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1417,21 +1417,31 @@ namespace ranges {
indirect_unary_predicate<projected<_It, _Pj>> _Pr>
_NODISCARD constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
_Adl_verify_range(_First, _Last);
auto _UFirst = _Get_unwrapped(_STD move(_First));
const auto _ULast = _Get_unwrapped(_STD move(_Last));
for (; _UFirst != _ULast; ++_UFirst) {
if (!_STD invoke(_Pred, _STD invoke(_Proj, *_UFirst))) {
return false;
}
}

return true;
return _All_of_unchecked(
_Get_unwrapped(_STD move(_First)), _Get_unwrapped(_STD move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));
}

template <input_range _Rng, class _Pj = identity,
indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
_NODISCARD constexpr bool operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
return (*this)(_RANGES begin(_Range), _RANGES end(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
return _All_of_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
}

private:
template <class _It, class _Se, class _Pj, class _Pr>
_NODISCARD static constexpr bool _All_of_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
_STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
_STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
_STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);

for (; _First != _Last; ++_First) {
if (!_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
return false;
}
}

return true;
}
};

Expand Down Expand Up @@ -1471,21 +1481,31 @@ namespace ranges {
indirect_unary_predicate<projected<_It, _Pj>> _Pr>
_NODISCARD constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
_Adl_verify_range(_First, _Last);
auto _UFirst = _Get_unwrapped(_STD move(_First));
const auto _ULast = _Get_unwrapped(_STD move(_Last));
for (; _UFirst != _ULast; ++_UFirst) {
if (_STD invoke(_Pred, _STD invoke(_Proj, *_UFirst))) {
return true;
}
}

return false;
return _Any_of_unchecked(
_Get_unwrapped(_STD move(_First)), _Get_unwrapped(_STD move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));
}

template <input_range _Rng, class _Pj = identity,
indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
_NODISCARD constexpr bool operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
return (*this)(_RANGES begin(_Range), _RANGES end(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
return _Any_of_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
}

private:
template <class _It, class _Se, class _Pj, class _Pr>
_NODISCARD static constexpr bool _Any_of_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
_STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
_STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
_STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);

for (; _First != _Last; ++_First) {
if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
return true;
}
}

return false;
}
};

Expand Down Expand Up @@ -1525,21 +1545,31 @@ namespace ranges {
indirect_unary_predicate<projected<_It, _Pj>> _Pr>
_NODISCARD constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
_Adl_verify_range(_First, _Last);
auto _UFirst = _Get_unwrapped(_STD move(_First));
const auto _ULast = _Get_unwrapped(_STD move(_Last));
for (; _UFirst != _ULast; ++_UFirst) {
if (_STD invoke(_Pred, _STD invoke(_Proj, *_UFirst))) {
return false;
}
}

return true;
return _None_of_unchecked(
_Get_unwrapped(_STD move(_First)), _Get_unwrapped(_STD move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));
}

template <input_range _Rng, class _Pj = identity,
indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
_NODISCARD constexpr bool operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
return (*this)(_RANGES begin(_Range), _RANGES end(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
return _None_of_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
}

private:
template <class _It, class _Se, class _Pj, class _Pr>
_NODISCARD static constexpr bool _None_of_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
_STL_INTERNAL_STATIC_ASSERT(input_iterator<_It>);
_STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se, _It>);
_STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);

for (; _First != _Last; ++_First) {
if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
return false;
}
}

return true;
}
};

Expand Down
77 changes: 38 additions & 39 deletions tests/std/tests/P0896R4_ranges_alg_all_of/test.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,55 +2,54 @@
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#include <algorithm>
#include <array>
#include <cassert>
#include <concepts>
#include <ranges>
#include <utility>

#include <range_algorithm_support.hpp>
using namespace std;
using P = pair<int, int>;

constexpr auto is_even = [](auto const& x) { return x % 2 == 0; };
constexpr auto is_odd = [](auto const& x) { return x % 2 != 0; };

using R = std::array<std::pair<int, int>, 3>;

constexpr void smoke_test() {
using ranges::all_of;
constexpr R pairs = {{{0, 13}, {2, 13}, {4, 13}}};

assert(all_of(basic_borrowed_range{pairs}, is_even, get_first));
assert(!all_of(basic_borrowed_range{pairs}, is_even, get_second));
assert(!all_of(basic_borrowed_range{pairs}, is_odd, get_first));
assert(all_of(basic_borrowed_range{pairs}, is_odd, get_second));
{
basic_borrowed_range wrapped_pairs{pairs};
assert(all_of(wrapped_pairs.begin(), wrapped_pairs.end(), is_even, get_first));
}
{
basic_borrowed_range wrapped_pairs{pairs};
assert(!all_of(wrapped_pairs.begin(), wrapped_pairs.end(), is_even, get_second));
}
{
basic_borrowed_range wrapped_pairs{pairs};
assert(!all_of(wrapped_pairs.begin(), wrapped_pairs.end(), is_odd, get_first));
}
{
basic_borrowed_range wrapped_pairs{pairs};
assert(all_of(wrapped_pairs.begin(), wrapped_pairs.end(), is_odd, get_second));
}
}

int main() {
STATIC_ASSERT((smoke_test(), true));
smoke_test();
}

struct instantiator {
template <class In>
static void call(In&& in = {}) {
(void) ranges::all_of(in, UnaryPredicateFor<ranges::iterator_t<In>>{});
(void) ranges::all_of(in, ProjectedUnaryPredicate<>{}, ProjectionFor<ranges::iterator_t<In>>{});
static constexpr P input[3] = {{0, 13}, {2, 13}, {4, 13}};

template <ranges::input_range Read>
static constexpr void call() {
using ranges::all_of;
{ // Validate iterator + sentinel overload
Read wrapped_input1{input};
Read wrapped_input2{input};
Read wrapped_input3{input};
Read wrapped_input4{input};

auto result = all_of(wrapped_input1.begin(), wrapped_input1.end(), is_even, get_first);
STATIC_ASSERT(same_as<decltype(result), bool>);
assert(result);
assert(!all_of(wrapped_input2.begin(), wrapped_input2.end(), is_even, get_second));
assert(!all_of(wrapped_input3.begin(), wrapped_input3.end(), is_odd, get_first));
assert(all_of(wrapped_input4.begin(), wrapped_input4.end(), is_odd, get_second));
}
{ // Validate range overload
Read wrapped_input1{input};
Read wrapped_input2{input};
Read wrapped_input3{input};
Read wrapped_input4{input};

auto result = all_of(wrapped_input1, is_even, get_first);
STATIC_ASSERT(same_as<decltype(result), bool>);
assert(result);
assert(!all_of(wrapped_input2, is_even, get_second));
assert(!all_of(wrapped_input3, is_odd, get_first));
assert(all_of(wrapped_input4, is_odd, get_second));
}
}
};

template void test_in<instantiator, const int>();
int main() {
STATIC_ASSERT((test_in<instantiator, const P>(), true));
test_in<instantiator, const P>();
}
75 changes: 38 additions & 37 deletions tests/std/tests/P0896R4_ranges_alg_any_of/test.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,53 +2,54 @@
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#include <algorithm>
#include <array>
#include <cassert>
#include <concepts>
#include <ranges>
#include <utility>

#include <range_algorithm_support.hpp>
using namespace std;
using P = pair<int, int>;

constexpr auto is_even = [](auto const& x) { return x % 2 == 0; };
constexpr auto is_odd = [](auto const& x) { return x % 2 != 0; };

constexpr void smoke_test() {
using ranges::any_of;
constexpr std::array<std::pair<int, int>, 3> pairs = {{{0, 13}, {7, 13}, {4, 13}}};

assert(any_of(basic_borrowed_range{pairs}, is_even, get_first));
assert(!any_of(basic_borrowed_range{pairs}, is_even, get_second));
assert(any_of(basic_borrowed_range{pairs}, is_odd, get_first));
assert(any_of(basic_borrowed_range{pairs}, is_odd, get_second));
{
basic_borrowed_range wrapped_pairs{pairs};
assert(any_of(wrapped_pairs.begin(), wrapped_pairs.end(), is_even, get_first));
}
{
basic_borrowed_range wrapped_pairs{pairs};
assert(!any_of(wrapped_pairs.begin(), wrapped_pairs.end(), is_even, get_second));
}
{
basic_borrowed_range wrapped_pairs{pairs};
assert(any_of(wrapped_pairs.begin(), wrapped_pairs.end(), is_odd, get_first));
}
{
basic_borrowed_range wrapped_pairs{pairs};
assert(any_of(wrapped_pairs.begin(), wrapped_pairs.end(), is_odd, get_second));
}
}

int main() {
STATIC_ASSERT((smoke_test(), true));
smoke_test();
}

struct instantiator {
template <class In>
static void call(In&& in = {}) {
(void) ranges::any_of(in, UnaryPredicateFor<ranges::iterator_t<In>>{});
(void) ranges::any_of(in, ProjectedUnaryPredicate<>{}, ProjectionFor<ranges::iterator_t<In>>{});
static constexpr P input[3] = {{0, 13}, {7, 13}, {4, 13}};

template <ranges::input_range Read>
static constexpr void call() {
using ranges::any_of;
{ // Validate iterator + sentinel overload
Read wrapped_input1{input};
Read wrapped_input2{input};
Read wrapped_input3{input};
Read wrapped_input4{input};

auto result = any_of(wrapped_input1.begin(), wrapped_input1.end(), is_even, get_first);
STATIC_ASSERT(same_as<decltype(result), bool>);
assert(result);
assert(!any_of(wrapped_input2.begin(), wrapped_input2.end(), is_even, get_second));
assert(any_of(wrapped_input3.begin(), wrapped_input3.end(), is_odd, get_first));
assert(any_of(wrapped_input4.begin(), wrapped_input4.end(), is_odd, get_second));
}
{ // Validate range overload
Read wrapped_input1{input};
Read wrapped_input2{input};
Read wrapped_input3{input};
Read wrapped_input4{input};

auto result = any_of(wrapped_input1, is_even, get_first);
STATIC_ASSERT(same_as<decltype(result), bool>);
assert(result);
assert(!any_of(wrapped_input2, is_even, get_second));
assert(any_of(wrapped_input3, is_odd, get_first));
assert(any_of(wrapped_input4, is_odd, get_second));
}
}
};

template void test_in<instantiator, const int>();
int main() {
STATIC_ASSERT((test_in<instantiator, const P>(), true));
test_in<instantiator, const P>();
}
Loading