RANGES_CXX14_CONSTEXPR
void set_offset(range_difference_type_t<Rng> const delta) noexcept
{
RANGES_EXPECT(0 <= delta && delta < stride_);
if(0 > offset_) offset_ = delta;
else RANGES_EXPECT(offset_ == delta);
}
std::pair<T *, std::ptrdiff_t> get_temporary_buffer_impl(
std::size_t count) noexcept
{
RANGES_EXPECT(count >= 0);
std::size_t n = static_cast<std::size_t>(count);
if(n > PTRDIFF_MAX / sizeof(T))
n = PTRDIFF_MAX / sizeof(T);
void * ptr = nullptr;
for(; ptr == nullptr && n > 0; n /= 2)
{
#if RANGES_CXX_ALIGNED_NEW < RANGES_CXX_ALIGNED_NEW_17
static_assert(alignof(T) <= alignof(std::max_align_t),
"Sorry: over-aligned types are supported only with C++17.");
#else // RANGES_CXX_ALIGNED_NEW
if(RANGES_CONSTEXPR_IF(alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__))
ptr = ::operator new(
sizeof(T) * n, std::align_val_t{alignof(T)}, std::nothrow);
else
#endif // RANGES_CXX_ALIGNED_NEW
ptr = ::operator new(sizeof(T) * n, std::nothrow);
}
return {static_cast<T *>(ptr), static_cast<std::ptrdiff_t>(n)};
}
iterator_t<Rng> pos_at_(Rng && rng, Int i, input_range_tag, std::false_type)
{
RANGES_EXPECT(i >= 0 || (bool)SizedRange<Rng> || (bool)ForwardRange<Rng>);
if(0 > i)
return next(ranges::begin(rng), distance(rng) + i);
return next(ranges::begin(rng), i);
}
safe_iterator_t<Rng>
operator()(Rng &&rng, range_difference_type_t<Rng> n, F fun, P proj = P{}) const
{
if (SizedRange<Rng>())
RANGES_EXPECT(n <= distance(rng));
return (*this)(begin(rng), n, detail::move(fun), detail::move(proj));
}
RANGES_CXX14_CONSTEXPR
stride_view_base(Rng &&rng, range_difference_type_t<Rng> const stride)
noexcept(std::is_nothrow_constructible<stride_view_adaptor<Rng>, Rng>::value &&
noexcept(std::declval<stride_view_base &>().calc_offset(SizedRange<Rng>())))
: stride_view_adaptor<Rng>{std::move(rng)},
stride_{(RANGES_EXPECT(0 < stride), stride)},
offset_{calc_offset(SizedRange<Rng>())}
{}
slice_view_(Rng rng, range_difference_t<Rng> from,
range_difference_t<Rng> count)
: rng_(std::move(rng))
, from_(from)
, count_(count)
{
RANGES_EXPECT(0 <= count_);
}
T &construct_from(Args &&... args)
noexcept(std::is_nothrow_constructible<T, Args...>::value)
{
RANGES_EXPECT(!engaged_);
auto const address = static_cast<void *>(std::addressof(data_));
::new (address) T(static_cast<Args &&>(args)...);
engaged_ = true;
return data_;
}
I operator()(I begin, difference_type_t<I> n, F fun, P proj = P{}) const
{
RANGES_EXPECT(0 <= n);
auto norig = n;
auto b = uncounted(begin);
for(; 0 < n; ++b, --n)
invoke(fun, invoke(proj, *b));
return recounted(begin, b, norig);
}
tagged_pair<tag::out(O), tag::fun(F)>
operator()(O begin, difference_type_t<O> n, F fun) const
{
RANGES_EXPECT(n >= 0);
auto norig = n;
auto b = uncounted(begin);
for(; 0 != n; ++b, --n)
*b = invoke(fun);
return {recounted(begin, b, norig), detail::move(fun)};
}
RANGES_CXX14_CONSTEXPR void next() noexcept
{
RANGES_EXPECT(n_ > 0);
--n_;
if(n_ == 0)
{
from_ = to_;
}
else
{
from_ += (to_ - from_) / T(n_);
}
}
constexpr void next() noexcept
{
RANGES_EXPECT(n_ > 0);
--n_;
if(n_ == 0)
{
from_ = to_;
}
else
{
from_ += (to_ - from_) / T(n_);
}
}
RANGES_CXX14_CONSTEXPR V operator()(Rng &&rng, C pred = C{}, P proj = P{}) const
{
auto begin = ranges::begin(rng);
auto end = ranges::end(rng);
RANGES_EXPECT(begin != end);
V result = *begin;
while(++begin != end)
{
auto && tmp = *begin;
if(invoke(pred, invoke(proj, result), invoke(proj, tmp)))
result = (decltype(tmp) &&) tmp;
}
return result;
}
void next()
{
RANGES_EXPECT(cur_ != last_);
// If the last match consumed zero elements, bump the position.
advance(cur_, (int)zero_, last_);
zero_ = false;
for(; cur_ != last_; ++cur_)
{
auto p = invoke(fun_, cur_, last_);
if(p.first)
{
zero_ = (cur_ == p.second);
cur_ = p.second;
return;
}
}
}
RANGES_CXX14_CONSTEXPR
range_difference_type_t<Rng> get_offset(bool check = true) const noexcept
{
RANGES_EXPECT(!check || 0 <= offset_);
return offset_;
}
take_exactly_view_(Rng rng, difference_type_ n)
: rng_(std::move(rng)), n_(n)
{
RANGES_EXPECT(n >= 0);
RANGES_EXPECT(!SizedRange<Rng>() || n <= ranges::distance(rng_));
}
take_exactly_view_(Rng rng, difference_type_ n)
: rng_(std::move(rng)), n_(n)
{
RANGES_EXPECT(n >= 0);
}
constexpr stride_view_base(Rng &&rng, range_difference_type_t<Rng> const stride)
noexcept(std::is_nothrow_constructible<stride_view_adaptor<Rng>, Rng>::value)
: stride_view_adaptor<Rng>{std::move(rng)},
stride_{(RANGES_EXPECT(0 < stride), stride)}
{}
T const & get() const
{
RANGES_EXPECT(t_);
return *t_;
}
T const &operator*() const noexcept
{
RANGES_EXPECT(*this);
return ranges::get<1>(data_);
}
constexpr repeat_n_view(Val value, std::ptrdiff_t n)
: value_(detail::move(value)), n_((RANGES_EXPECT(0 <= n), n))
{}
std::pair<T *, std::ptrdiff_t> get_temporary_buffer(D count) noexcept
{
RANGES_EXPECT(count >= 0);
return detail::get_temporary_buffer_impl<T>(static_cast<std::size_t>(count));
}
iterator_t<Rng> pos_at_(Rng && rng, Int i, input_range_tag, std::true_type)
{
RANGES_EXPECT(0 <= i);
return next(ranges::begin(rng), i);
}
constexpr chunk_view(Rng rng, range_difference_type_t<Rng> n)
: chunk_view::view_adaptor(detail::move(rng))
, n_((RANGES_EXPECT(0 < n), n))
{}
Rng operator()(Rng && rng, range_difference_type_t<Rng> n) const
{
RANGES_EXPECT(n >= 0);
ranges::action::erase(rng, begin(rng), ranges::next(begin(rng), n, end(rng)));
return static_cast<Rng&&>(rng);
}
counted_view(I it, difference_type_t<I> n)
: it_(it), n_(n)
{
RANGES_EXPECT(0 <= n_);
}
T & get()
{
RANGES_EXPECT(t_);
return *t_;
}
[[noreturn]]
common_type_t<decay_t<unwrap_reference_t<Val2 const &>>, value_type_t<I>> &
operator()(copy_tag, I const &) const
{
RANGES_EXPECT(false);
}
void next()
{
RANGES_EXPECT(0 != n_);
--n_;
}
