range<I>
operator()(I begin, iterator_difference_t<I> dist, V const & val, R pred_ = R{},
P proj_ = P{}) const
{
RANGES_ASSERT(0 <= dist);
auto &&pred = invokable(pred_);
auto &&proj = invokable(proj_);
while(0 != dist)
{
auto half = dist / 2;
auto middle = next(begin, half);
if(pred(proj(*middle), val))
{
begin = std::move(++middle);
dist -= half + 1;
}
else if(pred(val, proj(*middle)))
{
dist = half;
}
else
return {lower_bound_n(std::move(begin), half, val, std::ref(pred)),
upper_bound_n(next(middle), dist - half - 1, val, std::ref(pred))};
}
return {begin, begin};
}
std::pair<I, O>
operator()(I begin, S end, O result, S2 end_result, BOp bop_ = BOp{},
P proj_ = P{}) const
{
auto &&bop = invokable(bop_);
auto &&proj = invokable(proj_);
using V = iterator_value_t<I>;
using X = concepts::Invokable::result_t<P, V>;
coerce<V> v;
coerce<X> x;
if(begin != end && result != end_result)
{
auto t1(x(proj(v(*begin))));
*result = t1;
for(++begin, ++result; begin != end && result != end_result;
++begin, ++result)
{
auto t2(x(proj(v(*begin))));
*result = bop(t2, t1);
t1 = std::move(t2);
}
}
return {begin, result};
}
O operator()(I begin, SI end, O out_begin, SO out_end, C pred_ = C{}, PI in_proj_ = PI{},
PO out_proj_ = PO{}) const
{
auto && pred = invokable(pred_);
auto && in_proj = invokable(in_proj_);
auto && out_proj = invokable(out_proj_);
O r = out_begin;
if(r != out_end)
{
for(; begin != end && r != out_end; ++begin, ++r)
*r = *begin;
make_heap(out_begin, r, std::ref(pred), std::ref(out_proj));
auto len = r - out_begin;
for(; begin != end; ++begin)
{
if(pred(in_proj(*begin), out_proj(*out_begin)))
{
*out_begin = *begin;
detail::sift_down_n(out_begin, len, out_begin, std::ref(pred), std::ref(out_proj));
}
}
sort_heap(out_begin, r, std::ref(pred), std::ref(out_proj));
}
return r;
}
T operator()(I begin, S end, T init, Op op_ = Op{}, P proj_ = P{}) const
{
auto &&op = invokable(op_);
auto &&proj = invokable(proj_);
for(; begin != end; ++begin)
init = op(init, proj(*begin));
return init;
}
I operator()(I begin, S end, F pred_, P proj_ = P{}) const
{
auto &&pred = invokable(pred_);
auto &&proj = invokable(proj_);
for(; begin != end; ++begin)
if(pred(proj(*begin)))
break;
return begin;
}
I operator()(I begin, S end, C pred_, T const & new_value, P proj_ = P{}) const
{
auto &&pred = invokable(pred_);
auto &&proj = invokable(proj_);
for(; begin != end; ++begin)
if(pred(proj(*begin)))
*begin = new_value;
return begin;
}
I operator()(I begin, S end, F fun_, P proj_ = P{}) const
{
auto &&fun = invokable(fun_);
auto &&proj = invokable(proj_);
for(; begin != end; ++begin)
{
fun(proj(*begin));
}
return begin;
}
bool
operator()(I first, S last, F pred, P proj = P{}) const
{
auto &&ipred = invokable(pred);
auto &&iproj = invokable(proj);
for(; first != last; ++first)
if(!ipred(iproj(*first)))
break;
return first == last;
}
bool
operator()(I first, S last, F pred, P proj = P{}) const
{
auto &&ipred = invokable(pred);
auto &&iproj = invokable(proj);
for(; first != last; ++first)
if(ipred(iproj(*first)))
return true;
return false;
}
I operator()(I begin, S end, C pred_ = C{}, P proj_ = P{}) const
{
auto && pred = invokable(pred_);
auto && proj = invokable(proj_);
if(begin != end)
for(auto tmp = next(begin); tmp != end; ++tmp)
if(pred(proj(*begin), proj(*tmp)))
begin = tmp;
return begin;
}
iterator_difference_t<I>
operator()(I begin, S end, R pred_, P proj_ = P{}) const
{
auto &&pred = invokable(pred_);
auto &&proj = invokable(proj_);
iterator_difference_t<I> n = 0;
for(; begin != end; ++begin)
if(pred(proj(*begin)))
++n;
return n;
}
T operator()(I1 begin1, S1 end1, I2 begin2, S2 end2, T init, BOp1 bop1_ = BOp1{},
BOp2 bop2_ = BOp2{}, P1 proj1_ = P1{}, P2 proj2_ = P2{}) const
{
auto &&bop1 = invokable(bop1_);
auto &&bop2 = invokable(bop2_);
auto &&proj1 = invokable(proj1_);
auto &&proj2 = invokable(proj2_);
for (; begin1 != end1 && begin2 != end2; ++begin1, ++begin2)
init = bop1(init, bop2(proj1(*begin1), proj2(*begin2)));
return init;
}
I
operator()(I begin, S end, C pred_ = C{}, P proj_ = P{}) const
{
auto &&pred = invokable(pred_);
auto &&proj = invokable(proj_);
if(begin == end)
return begin;
auto next = begin;
for(; ++next != end; begin = next)
if(pred(proj(*begin), proj(*next)))
return begin;
return next;
}
std::pair<I, O> operator()(I begin, S end, O out, C pred_, P proj_ = P{}) const
{
auto &&pred = invokable(pred_);
auto &&proj = invokable(proj_);
for(; begin != end; ++begin)
{
auto &&v = save(proj(*begin));
if(!(pred(v)))
{
*out = (decltype(v)) v;
++out;
}
}
return {begin, out};
}
bool operator()(I0 begin0, S0 end0, I1 begin1, S1 end1, C pred_ = C{}, P0 proj0_ = P0{},
P1 proj1_ = P1{}) const
{
auto &&pred = invokable(pred_);
auto &&proj0 = invokable(proj0_);
auto &&proj1 = invokable(proj1_);
for(; begin1 != end1; ++begin0, ++begin1)
{
if(begin0 == end0 || pred(proj0(*begin0), proj1(*begin1)))
return true;
if(pred(proj1(*begin1), proj1(*begin0)))
return false;
}
return false;
}
static std::pair<I, O> impl(I begin, S end, O out, C pred_, P proj_,
concepts::InputIterator*, std::true_type)
{
auto &&pred = invokable(pred_);
auto &&proj = invokable(proj_);
if(begin != end)
{
*out = *begin;
while(++begin != end)
if(!pred(proj(*out), proj(*begin)))
*++out = *begin;
++out;
}
return {begin, out};
}
std::pair<I, O>
operator()(I begin, S end, O out, F pred_, P proj_ = P{}) const
{
auto &&pred = invokable(pred_);
auto &&proj = invokable(proj_);
for(; begin != end; ++begin)
{
if(pred(proj(*begin)))
{
*out = proj(*begin);
++out;
}
}
return {begin, out};
}
I operator()(I begin, S end, C pred_ = C{}, P proj_ = P{}) const
{
auto &&pred = invokable(pred_);
auto &&proj = invokable(proj_);
begin = adjacent_find(std::move(begin), end, std::ref(pred), std::ref(proj));
if(begin != end)
{
for(I i = next(begin); ++i != end;)
if(!pred(proj(*begin), proj(*i)))
*++begin = std::move(*i);
++begin;
}
return begin;
}
std::pair<I, O> operator()(I begin, S end, O out, P proj_ = P{}) const
{
auto &&proj = invokable(proj_);
for(; begin != end; ++begin, ++out)
*out = std::move(proj(*begin));
return {begin, out};
}
I operator()(I begin, S end, R rel = R{}, P proj_ = P{}) const
{
auto &&irel = invokable(rel);
auto &&iproj = invokable(proj_);
auto i = begin;
if(begin != end)
{
while(++i != end)
{
if(irel(iproj(*i), iproj(*begin)))
return i;
begin = i;
}
}
return i;
}
std::pair<I, O> operator()(I begin, S end_, O out, P proj = P{}) const
{
auto &&iproj = invokable(proj);
I i = next_to(begin, end_), end = i;
while(begin != i)
*--out = iproj(*--i);
return {end, out};
}
I operator()(I begin, S end, V const &val, P proj_ = P{}) const
{
auto &&proj = invokable(proj_);
for(; begin != end; ++begin)
if(proj(*begin) == val)
break;
return begin;
}
I operator()(I begin, S end, C pred_, P proj_ = P{}) const
{
auto &&pred = invokable(pred_);
auto &&proj = invokable(proj_);
begin = find_if(std::move(begin), end, std::ref(pred), std::ref(proj));
if(begin != end)
{
for(I i = next(begin); i != end; ++i)
{
if(!(pred(proj(*i))))
{
*begin = iter_move(i);
++begin;
}
}
}
return begin;
}
I operator()(I begin, I middle, S end, C pred_ = C{}, P proj_ = P{}) const
{
auto && pred = invokable(pred_);
auto && proj = invokable(proj_);
make_heap(begin, middle, std::ref(pred), std::ref(proj));
auto const len = middle - begin;
I i = middle;
for(; i != end; ++i)
{
if(pred(proj(*i), proj(*begin)))
{
iter_swap(i, begin);
detail::sift_down_n(begin, len, begin, std::ref(pred), std::ref(proj));
}
}
sort_heap(begin, middle, std::ref(pred), std::ref(proj));
return i;
}
I operator()(I begin, S end, C pred_, P proj_ = P{}) const
{
auto && pred = invokable(pred_);
auto && proj = invokable(proj_);
auto len = distance(begin, end);
while(len != 0)
{
auto const half = len / 2;
auto middle = next(uncounted(begin), half);
if(pred(proj(*middle)))
{
begin = recounted(begin, std::move(++middle), half + 1);
len -= half + 1;
}
else
len = half;
}
return begin;
}
std::pair<I, O> operator()(I begin, S end, O out, T0 const & old_value, T1 const & new_value, P proj_ = {}) const
{
auto &&proj = invokable(proj_);
for(; begin != end; ++begin, ++out)
if(proj(*begin) == old_value)
*out = new_value;
else
*out = *begin;
return {begin, out};
}
std::pair<I, O>
operator()(I begin, iterator_difference_t<I> n, O out, P proj_ = P{}) const
{
RANGES_ASSERT(0 <= n);
auto &&proj = invokable(proj_);
auto norig = n;
auto b = uncounted(begin);
for(; n != 0; ++b, ++out, --n)
*out = proj(*b);
return {recounted(begin, b, norig), out};
}
std::tuple<I0, I1, O>
operator()(I0 begin0, iterator_difference_t<I0> n0,
I1 begin1, iterator_difference_t<I1> n1,
O out, C r = C{}, P0 p0 = P0{}, P1 p1 = P1{}) const
{
using T = std::tuple<I0, I1, O>;
auto &&ir = invokable(r);
auto &&ip0 = invokable(p0);
auto &&ip1 = invokable(p1);
auto n0orig = n0;
auto n1orig = n1;
auto b0 = uncounted(begin0);
auto b1 = uncounted(begin1);
while(true)
{
if(0 == n0)
{
auto res = copy_n(b1, n1, out);
begin0 = recounted(begin0, b0, n0orig);
begin1 = recounted(begin1, res.first, n1orig);
return T{begin0, begin1, res.second};
}
if(0 == n1)
{
auto res = copy_n(b0, n0, out);
begin0 = recounted(begin0, res.first, n0orig);
begin1 = recounted(begin1, b1, n1orig);
return T{begin0, begin1, res.second};
}
if(ir(ip1(*b1), ip0(*b0)))
{
*out = *b1;
++b1; ++out; --n1;
}
else
{
*out = *b0;
++b0; ++out; --n0;
}
}
}
std::pair<I, O> operator()(I begin, S end_, O out, P proj_ = P{}) const
{
auto &&proj = invokable(proj_);
I i = next_to(begin, end_), end = i;
while(begin != i)
{
// BUGBUG should the projection be applied *before* the move?
auto &&x = iter_move(--i);
*--out = proj((decltype(x) &&) x);
}
return {end, out};
}
static I impl(I begin, S end, C pred_, P proj_, concepts::ForwardIterator*)
{
auto && pred = invokable(pred_);
auto && proj = invokable(proj_);
while(true)
{
if(begin == end)
return begin;
if(!pred(proj(*begin)))
break;
++begin;
}
for(I p = begin; ++p != end;)
{
if(pred(proj(*p)))
{
ranges::iter_swap(begin, p);
++begin;
}
}
return begin;
}
