Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/traits.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_TRAITS_HPP
#define RANGES_V3_ITERATOR_TRAITS_HPP
#include <iterator>
#include <type_traits>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/access.hpp> // for iter_move, iter_swap
#include <range/v3/utility/common_type.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-iterator
/// @{
/// \cond
using input_iterator_tag RANGES_DEPRECATED(
"Please switch to the standard iterator tags") = std::input_iterator_tag;
using forward_iterator_tag RANGES_DEPRECATED(
"Please switch to the standard iterator tags") = std::forward_iterator_tag;
using bidirectional_iterator_tag RANGES_DEPRECATED(
"Please switch to the standard iterator tags") = std::bidirectional_iterator_tag;
using random_access_iterator_tag RANGES_DEPRECATED(
"Please switch to the standard iterator tags") = std::random_access_iterator_tag;
/// \endcond
struct contiguous_iterator_tag : std::random_access_iterator_tag
{};
/// \cond
namespace detail
{
template<typename I, typename = iter_reference_t<I>,
typename R = decltype(iter_move(std::declval<I &>())), typename = R &>
using iter_rvalue_reference_t = R;
template<typename I>
RANGES_INLINE_VAR constexpr bool has_nothrow_iter_move_v =
noexcept(iter_rvalue_reference_t<I>(ranges::iter_move(std::declval<I &>())));
} // namespace detail
/// \endcond
template<typename I>
using iter_rvalue_reference_t = detail::iter_rvalue_reference_t<I>;
template<typename I>
using iter_common_reference_t =
common_reference_t<iter_reference_t<I>, iter_value_t<I> &>;
#if defined(RANGES_DEEP_STL_INTEGRATION) && RANGES_DEEP_STL_INTEGRATION && \
!defined(RANGES_DOXYGEN_INVOKED)
template<typename T>
using iter_difference_t =
typename meta::conditional_t<detail::is_std_iterator_traits_specialized_v<T>,
std::iterator_traits<uncvref_t<T>>,
incrementable_traits<uncvref_t<T>>>::difference_type;
#else
template<typename T>
using iter_difference_t =
typename incrementable_traits<uncvref_t<T>>::difference_type;
#endif
// Defined in <range/v3/iterator/access.hpp>
// template<typename T>
// using iter_value_t = ...
// Defined in <range/v3/iterator/access.hpp>
// template<typename R>
// using iter_reference_t = detail::iter_reference_t_<R>;
// Defined in <range/v3/range_fwd.hpp>:
// template<typename S, typename I>
// inline constexpr bool disable_sized_sentinel = false;
/// \cond
namespace detail
{
template<typename I>
using iter_size_t =
meta::_t<meta::conditional_t<std::is_integral<iter_difference_t<I>>::value,
std::make_unsigned<iter_difference_t<I>>,
meta::id<iter_difference_t<I>>>>;
template<typename I>
using iter_arrow_t = decltype(std::declval<I &>().operator->());
template<typename I>
using iter_pointer_t =
meta::_t<meta::conditional_t<
meta::is_trait<meta::defer<iter_arrow_t, I>>::value,
meta::defer<iter_arrow_t, I>,
std::add_pointer<iter_reference_t<I>>>>;
template<typename T>
struct difference_type_ : meta::defer<iter_difference_t, T>
{};
template<typename T>
struct value_type_ : meta::defer<iter_value_t, T>
{};
template<typename T>
struct size_type_ : meta::defer<iter_size_t, T>
{};
} // namespace detail
template<typename T>
using difference_type_t RANGES_DEPRECATED(
"ranges::difference_type_t is deprecated. Please use "
"ranges::iter_difference_t instead.") = iter_difference_t<T>;
template<typename T>
using value_type_t RANGES_DEPRECATED(
"ranges::value_type_t is deprecated. Please use "
"ranges::iter_value_t instead.") = iter_value_t<T>;
template<typename R>
using reference_t RANGES_DEPRECATED(
"ranges::reference_t is deprecated. Use ranges::iter_reference_t "
"instead.") = iter_reference_t<R>;
template<typename I>
using rvalue_reference_t RANGES_DEPRECATED(
"rvalue_reference_t is deprecated; "
"use iter_rvalue_reference_t instead") = iter_rvalue_reference_t<I>;
template<typename T>
struct RANGES_DEPRECATED(
"ranges::size_type is deprecated. Iterators do not have an associated "
"size_type.") size_type : detail::size_type_<T>
{};
template<typename I>
using size_type_t RANGES_DEPRECATED("size_type_t is deprecated.") =
detail::iter_size_t<I>;
/// \endcond
namespace cpp20
{
using ranges::iter_common_reference_t;
using ranges::iter_difference_t;
using ranges::iter_reference_t;
using ranges::iter_rvalue_reference_t;
using ranges::iter_value_t;
// Specialize these in the ranges:: namespace
using ranges::disable_sized_sentinel;
template<typename T>
using incrementable_traits = ranges::incrementable_traits<T>;
template<typename T>
using indirectly_readable_traits = ranges::indirectly_readable_traits<T>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_ITERATOR_TRAITS_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/common_iterator.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
// Copyright Casey Carter 2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_COMMON_ITERATOR_HPP
#define RANGES_V3_ITERATOR_COMMON_ITERATOR_HPP
#include <cstdint>
#include <iterator>
#include <type_traits>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/detail/variant.hpp>
#include <range/v3/iterator/basic_iterator.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/utility/common_tuple.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-iterator
/// @{
/// \cond
namespace detail
{
template<typename I, typename S>
variant<I, S> & cidata(common_iterator<I, S> & that)
{
return that.data_;
}
template<typename I, typename S>
variant<I, S> const & cidata(common_iterator<I, S> const & that)
{
return that.data_;
}
} // namespace detail
#if RANGES_BROKEN_CPO_LOOKUP
namespace _common_iterator_
{
struct adl_hook
{};
} // namespace _common_iterator_
#endif
/// \endcond
template<typename I, typename S>
struct common_iterator
#if RANGES_BROKEN_CPO_LOOKUP
: private _common_iterator_::adl_hook
#endif
{
private:
CPP_assert(input_or_output_iterator<I>);
CPP_assert(sentinel_for<S, I>);
CPP_assert(!same_as<I, S>);
variant<I, S> data_;
friend variant<I, S> & detail::cidata<>(common_iterator<I, S> &);
friend variant<I, S> const & detail::cidata<>(common_iterator<I, S> const &);
struct emplace_fn
{
variant<I, S> * data_;
template<typename T, std::size_t N>
void operator()(indexed_element<T, N> t) const
{
ranges::emplace<N>(*data_, t.get());
}
};
struct arrow_proxy_
{
private:
friend common_iterator;
iter_value_t<I> keep_;
arrow_proxy_(iter_reference_t<I> && x)
: keep_(std::move(x))
{}
public:
const iter_value_t<I> * operator->() const noexcept
{
return std::addressof(keep_);
}
};
template<typename T>
static T * operator_arrow_(T * p, int) noexcept
{
return p;
}
template<typename J, typename = detail::iter_arrow_t<J const>>
static J operator_arrow_(J const & j, int) noexcept(noexcept(J(j)))
{
return j;
}
template(typename J, typename R = iter_reference_t<J>)(
requires std::is_reference<R>::value) //
static meta::_t<std::add_pointer<R>> operator_arrow_(J const & j, long) noexcept
{
auto && r = *j;
return std::addressof(r);
}
template(typename J, typename V = iter_value_t<J>)(
requires constructible_from<V, iter_reference_t<J>>)
static arrow_proxy_ operator_arrow_(J const & j, ...) noexcept(noexcept(V(V(*j))))
{
return arrow_proxy_(*j);
}
public:
using difference_type = iter_difference_t<I>;
common_iterator() = default;
common_iterator(I i)
: data_(emplaced_index<0>, std::move(i))
{}
common_iterator(S s)
: data_(emplaced_index<1>, std::move(s))
{}
template(typename I2, typename S2)(
requires convertible_to<I2, I> AND convertible_to<S2, S>)
common_iterator(common_iterator<I2, S2> const & that)
: data_(detail::variant_core_access::make_empty<I, S>())
{
detail::cidata(that).visit_i(emplace_fn{&data_});
}
template(typename I2, typename S2)(
requires convertible_to<I2, I> AND convertible_to<S2, S>)
common_iterator & operator=(common_iterator<I2, S2> const & that)
{
detail::cidata(that).visit_i(emplace_fn{&data_});
return *this;
}
iter_reference_t<I> operator*() //
noexcept(noexcept(iter_reference_t<I>(*std::declval<I &>())))
{
return *ranges::get<0>(data_);
}
CPP_member
auto operator*() const //
noexcept(noexcept(iter_reference_t<I>(*std::declval<I const &>())))
-> CPP_ret(iter_reference_t<I>)(
requires indirectly_readable<I const>)
{
return *ranges::get<0>(data_);
}
template(typename J = I)(
requires indirectly_readable<J>)
auto operator->() const //
noexcept(
noexcept(common_iterator::operator_arrow_(std::declval<I const &>(), 42)))
-> decltype(common_iterator::operator_arrow_(std::declval<J const &>(), 42))
{
return common_iterator::operator_arrow_(ranges::get<0>(data_), 42);
}
common_iterator & operator++()
{
++ranges::get<0>(data_);
return *this;
}
#ifdef RANGES_WORKAROUND_MSVC_677925
template(typename I2 = I)(
requires (!forward_iterator<I2>)) //
auto operator++(int) //
-> decltype(std::declval<I2 &>()++)
{
return ranges::get<0>(data_)++;
}
#else // ^^^ workaround ^^^ / vvv no workaround vvv
CPP_member
auto operator++(int) //
-> CPP_ret(decltype(std::declval<I &>()++))(
requires (!forward_iterator<I>))
{
return ranges::get<0>(data_)++;
}
#endif // RANGES_WORKAROUND_MSVC_677925
CPP_member
auto operator++(int) //
-> CPP_ret(common_iterator)(
requires forward_iterator<I>)
{
return common_iterator(ranges::get<0>(data_)++);
}
#if !RANGES_BROKEN_CPO_LOOKUP
template<typename I_ = I>
friend constexpr auto iter_move(common_iterator const & i) //
noexcept(detail::has_nothrow_iter_move_v<I>)
-> CPP_broken_friend_ret(iter_rvalue_reference_t<I>)(
requires input_iterator<I_>)
{
return ranges::iter_move(ranges::get<0>(detail::cidata(i)));
}
template<typename I2, typename S2>
friend auto iter_swap(
common_iterator const & x,
common_iterator<I2, S2> const &
y) noexcept(is_nothrow_indirectly_swappable<I, I2>::value)
-> CPP_broken_friend_ret(void)(
requires indirectly_swappable<I2, I>)
{
return ranges::iter_swap(ranges::get<0>(detail::cidata(x)),
ranges::get<0>(detail::cidata(y)));
}
#endif
};
/// \cond
#if RANGES_BROKEN_CPO_LOOKUP
namespace _common_iterator_
{
template<typename I, typename S>
constexpr auto iter_move(common_iterator<I, S> const & i) noexcept(
detail::has_nothrow_iter_move_v<I>)
-> CPP_broken_friend_ret(iter_rvalue_reference_t<I>)(
requires input_iterator<I>)
{
return ranges::iter_move(ranges::get<0>(detail::cidata(i)));
}
template<typename I1, typename S1, typename I2, typename S2>
auto iter_swap(common_iterator<I1, S1> const & x,
common_iterator<I2, S2> const & y) //
noexcept(is_nothrow_indirectly_swappable<I1, I2>::value)
-> CPP_broken_friend_ret(void)(
requires indirectly_swappable<I1, I2>)
{
return ranges::iter_swap(ranges::get<0>(detail::cidata(x)),
ranges::get<0>(detail::cidata(y)));
}
} // namespace _common_iterator_
#endif
/// \endcond
template(typename I1, typename I2, typename S1, typename S2)(
requires sentinel_for<S1, I2> AND sentinel_for<S2, I1> AND
(!equality_comparable_with<I1, I2>)) //
bool operator==(common_iterator<I1, S1> const & x, common_iterator<I2, S2> const & y)
{
return detail::cidata(x).index() == 1u ? (detail::cidata(y).index() == 1u ||
ranges::get<0>(detail::cidata(y)) ==
ranges::get<1>(detail::cidata(x)))
: (detail::cidata(y).index() != 1u ||
ranges::get<0>(detail::cidata(x)) ==
ranges::get<1>(detail::cidata(y)));
}
template(typename I1, typename I2, typename S1, typename S2)(
requires sentinel_for<S1, I2> AND sentinel_for<S2, I1> AND
equality_comparable_with<I1, I2>)
bool operator==(common_iterator<I1, S1> const & x, common_iterator<I2, S2> const & y)
{
return detail::cidata(x).index() == 1u
? (detail::cidata(y).index() == 1u ||
ranges::get<0>(detail::cidata(y)) ==
ranges::get<1>(detail::cidata(x)))
: (detail::cidata(y).index() == 1u
? ranges::get<0>(detail::cidata(x)) ==
ranges::get<1>(detail::cidata(y))
: ranges::get<0>(detail::cidata(x)) ==
ranges::get<0>(detail::cidata(y)));
}
template(typename I1, typename I2, typename S1, typename S2)(
requires sentinel_for<S1, I2> AND sentinel_for<S2, I1>)
bool operator!=(common_iterator<I1, S1> const & x, common_iterator<I2, S2> const & y)
{
return !(x == y);
}
template(typename I1, typename I2, typename S1, typename S2)(
requires sized_sentinel_for<I1, I2> AND sized_sentinel_for<S1, I2> AND
sized_sentinel_for<S2, I1>)
iter_difference_t<I2> operator-(common_iterator<I1, S1> const & x,
common_iterator<I2, S2> const & y)
{
return detail::cidata(x).index() == 1u
? (detail::cidata(y).index() == 1u
? 0
: ranges::get<1>(detail::cidata(x)) -
ranges::get<0>(detail::cidata(y)))
: (detail::cidata(y).index() == 1u
? ranges::get<0>(detail::cidata(x)) -
ranges::get<1>(detail::cidata(y))
: ranges::get<0>(detail::cidata(x)) -
ranges::get<0>(detail::cidata(y)));
}
template<typename I, typename S>
struct indirectly_readable_traits<common_iterator<I, S>>
: meta::if_c<
(bool)indirectly_readable<I>,
indirectly_readable_traits<I>,
meta::nil_>
{};
/// \cond
namespace detail
{
template<typename I>
auto demote_common_iter_cat(...) -> nil_;
template<typename I>
auto demote_common_iter_cat(long)
-> with_iterator_category<std::input_iterator_tag>;
template(typename I)(
requires derived_from<typename std::iterator_traits<I>::iterator_category,
std::forward_iterator_tag>)
auto demote_common_iter_cat(int)
-> with_iterator_category<std::forward_iterator_tag>;
template<typename I, bool = (bool)input_iterator<I>>
struct common_iterator_std_traits : decltype(detail::demote_common_iter_cat<I>(0))
{
using difference_type = iter_difference_t<I>;
using value_type = iter_value_t<I>;
using reference = iter_reference_t<I>;
using pointer = detail::iter_pointer_t<I>;
using iterator_concept =
meta::conditional_t<(bool)forward_iterator<I>, std::forward_iterator_tag,
std::input_iterator_tag>;
};
template<typename I>
struct common_iterator_std_traits<I, false>
{
using difference_type = iter_difference_t<I>;
using value_type = void;
using reference = void;
using pointer = void;
using iterator_category = std::output_iterator_tag;
};
// An iterator adaptor that demotes a user-defined difference_type to
// std::intmax_t, for use when constructing containers from such
// iterators.
template<typename I>
struct cpp17_iterator_cursor
{
private:
friend range_access;
I it_;
struct mixin : basic_mixin<cpp17_iterator_cursor>
{
mixin() = default;
#ifndef _MSC_VER
using basic_mixin<cpp17_iterator_cursor>::basic_mixin;
#else
constexpr explicit mixin(cpp17_iterator_cursor && cur)
: basic_mixin<cpp17_iterator_cursor>(
static_cast<cpp17_iterator_cursor &&>(cur))
{}
constexpr explicit mixin(cpp17_iterator_cursor const & cur)
: basic_mixin<cpp17_iterator_cursor>(cur)
{}
#endif
explicit mixin(I it)
: mixin{cpp17_iterator_cursor{std::move(it)}}
{}
I base() const
{
return this->get().it_;
}
};
public:
using single_pass = meta::bool_<!forward_iterator<I>>;
using difference_type = std::ptrdiff_t;
using value_type = iter_value_t<I>;
cpp17_iterator_cursor() = default;
constexpr explicit cpp17_iterator_cursor(I i)
: it_(static_cast<I &&>(i))
{}
I arrow() const
{
return it_;
}
decltype(auto) read()
{
return *it_;
}
decltype(auto) read() const
{
return *it_;
}
void next()
{
++it_;
}
bool equal(cpp17_iterator_cursor const & that) const
{
return it_ == that.it_;
}
CPP_member
auto prev() //
-> CPP_ret(void)(
requires bidirectional_iterator<I>)
{
--it_;
}
CPP_member
auto advance(std::ptrdiff_t n) //
-> CPP_ret(void)(
requires random_access_iterator<I>)
{
it_ += static_cast<iter_difference_t<I>>(n);
}
CPP_member
auto distance_to(cpp17_iterator_cursor const & that) //
-> CPP_ret(std::ptrdiff_t)(
requires random_access_iterator<I>)
{
auto d = that.it_ - it_;
RANGES_EXPECT(d <= PTRDIFF_MAX);
return static_cast<std::ptrdiff_t>(d);
}
};
} // namespace detail
/// \endcond
namespace cpp20
{
using ranges::common_iterator;
}
/// @}
} // namespace ranges
/// \cond
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
namespace std
{
template<typename I, typename S>
struct iterator_traits<::ranges::common_iterator<I, S>>
: ::ranges::detail::common_iterator_std_traits<I>
{};
} // namespace std
RANGES_DIAGNOSTIC_POP
/// \endcond
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/access.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
// Copyright Casey Carter 2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_ACCESS_HPP
#define RANGES_V3_ITERATOR_ACCESS_HPP
#include <iterator>
#include <type_traits>
#include <utility>
#include <std/detail/associated_types.hpp>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/utility/move.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/utility/swap.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-iterator
/// @{
/// \cond
namespace detail
{
template<typename I,
#ifdef RANGES_WORKAROUND_MSVC_683388
typename R = meta::conditional_t<
std::is_pointer<uncvref_t<I>>::value &&
std::is_array<std::remove_pointer_t<uncvref_t<I>>>::value,
std::add_lvalue_reference_t<std::remove_pointer_t<uncvref_t<I>>>,
decltype(*std::declval<I &>())>,
#else
typename R = decltype(*std::declval<I &>()),
#endif
typename = R &>
using iter_reference_t_ = R;
#if defined(RANGES_DEEP_STL_INTEGRATION) && RANGES_DEEP_STL_INTEGRATION && \
!defined(RANGES_DOXYGEN_INVOKED)
template<typename T>
using iter_value_t_ =
typename meta::conditional_t<
is_std_iterator_traits_specialized_v<T>,
std::iterator_traits<T>,
indirectly_readable_traits<T>>::value_type;
#else
template<typename T>
using iter_value_t_ = typename indirectly_readable_traits<T>::value_type;
#endif
} // namespace detail
/// \endcond
template<typename R>
using iter_reference_t = detail::iter_reference_t_<R>;
template<typename R>
using iter_value_t = detail::iter_value_t_<uncvref_t<R>>;
/// \cond
namespace _iter_move_
{
#if RANGES_BROKEN_CPO_LOOKUP
void iter_move(); // unqualified name lookup block
#endif
template<typename T>
decltype(iter_move(std::declval<T>())) try_adl_iter_move_(int);
template<typename T>
void try_adl_iter_move_(long);
template<typename T>
RANGES_INLINE_VAR constexpr bool is_adl_indirectly_movable_v =
!RANGES_IS_SAME(void, decltype(_iter_move_::try_adl_iter_move_<T>(42)));
struct fn
{
// clang-format off
template<typename I,
typename = detail::enable_if_t<is_adl_indirectly_movable_v<I &>>>
#ifndef RANGES_WORKAROUND_CLANG_23135
constexpr
#endif // RANGES_WORKAROUND_CLANG_23135
auto CPP_auto_fun(operator())(I &&i)(const)
(
return iter_move(i)
)
template<
typename I,
typename = detail::enable_if_t<!is_adl_indirectly_movable_v<I &>>,
typename R = iter_reference_t<I>>
#ifndef RANGES_WORKAROUND_CLANG_23135
constexpr
#endif // RANGES_WORKAROUND_CLANG_23135
auto CPP_auto_fun(operator())(I &&i)(const)
(
return static_cast<aux::move_t<R>>(aux::move(*i))
)
// clang-format on
};
} // namespace _iter_move_
/// \endcond
RANGES_DEFINE_CPO(_iter_move_::fn, iter_move)
/// \cond
namespace detail
{
template<typename I, typename O>
auto is_indirectly_movable_(I & (*i)(), O & (*o)(), iter_value_t<I> * v = nullptr)
-> always_<std::true_type,
decltype(iter_value_t<I>(iter_move(i()))),
decltype(*v = iter_move(i())),
decltype(*o() = (iter_value_t<I> &&) * v),
decltype(*o() = iter_move(i()))>;
template<typename I, typename O>
auto is_indirectly_movable_(...) -> std::false_type;
template<typename I, typename O>
auto is_nothrow_indirectly_movable_(iter_value_t<I> * v) -> meta::bool_<
noexcept(iter_value_t<I>(iter_move(std::declval<I &>()))) &&
noexcept(*v = iter_move(std::declval<I &>())) &&
noexcept(*std::declval<O &>() = (iter_value_t<I> &&) * v) &&
noexcept(*std::declval<O &>() = iter_move(std::declval<I &>()))>;
template<typename I, typename O>
auto is_nothrow_indirectly_movable_(...) -> std::false_type;
} // namespace detail
/// \endcond
template<typename I, typename O>
RANGES_INLINE_VAR constexpr bool is_indirectly_movable_v =
decltype(detail::is_indirectly_movable_<I, O>(nullptr, nullptr))::value;
template<typename I, typename O>
RANGES_INLINE_VAR constexpr bool is_nothrow_indirectly_movable_v =
decltype(detail::is_nothrow_indirectly_movable_<I, O>(nullptr))::value;
template<typename I, typename O>
struct is_indirectly_movable : meta::bool_<is_indirectly_movable_v<I, O>>
{};
template<typename I, typename O>
struct is_nothrow_indirectly_movable
: meta::bool_<is_nothrow_indirectly_movable_v<I, O>>
{};
/// \cond
namespace _iter_swap_
{
struct nope
{};
// Q: Should std::reference_wrapper be considered a proxy wrt swapping rvalues?
// A: No. Its operator= is currently defined to reseat the references, so
// std::swap(ra, rb) already means something when ra and rb are (lvalue)
// reference_wrappers. That reseats the reference wrappers but leaves the
// referents unmodified. Treating rvalue reference_wrappers differently would
// be confusing.
// Q: Then why is it OK to "re"-define swap for pairs and tuples of references?
// A: Because as defined above, swapping an rvalue tuple of references has the
// same semantics as swapping an lvalue tuple of references. Rather than
// reseat the references, assignment happens *through* the references.
// Q: But I have an iterator whose operator* returns an rvalue
// std::reference_wrapper<T>. How do I make it model indirectly_swappable?
// A: With an overload of iter_swap.
// Intentionally create an ambiguity with std::iter_swap, which is
// unconstrained.
template<typename T, typename U>
nope iter_swap(T, U) = delete;
#ifdef RANGES_WORKAROUND_MSVC_895622
nope iter_swap();
#endif
template<typename T, typename U>
decltype(iter_swap(std::declval<T>(), std::declval<U>())) try_adl_iter_swap_(int);
template<typename T, typename U>
nope try_adl_iter_swap_(long);
// Test whether an overload of iter_swap for a T and a U can be found
// via ADL with the iter_swap overload above participating in the
// overload set. This depends on user-defined iter_swap overloads
// being a better match than the overload in namespace std.
template<typename T, typename U>
RANGES_INLINE_VAR constexpr bool is_adl_indirectly_swappable_v =
!RANGES_IS_SAME(nope, decltype(_iter_swap_::try_adl_iter_swap_<T, U>(42)));
struct fn
{
// *If* a user-defined iter_swap is found via ADL, call that:
template<typename T, typename U>
constexpr detail::enable_if_t<is_adl_indirectly_swappable_v<T, U>> operator()(
T && t, U && u) const noexcept(noexcept(iter_swap((T &&) t, (U &&) u)))
{
(void)iter_swap((T &&) t, (U &&) u);
}
// *Otherwise*, for readable types with swappable reference
// types, call ranges::swap(*a, *b)
template<typename I0, typename I1>
constexpr detail::enable_if_t<
!is_adl_indirectly_swappable_v<I0, I1> &&
is_swappable_with<iter_reference_t<I0>, iter_reference_t<I1>>::value>
operator()(I0 && a, I1 && b) const noexcept(noexcept(ranges::swap(*a, *b)))
{
ranges::swap(*a, *b);
}
// *Otherwise*, for readable types that are mutually
// indirectly_movable_storable, implement as:
// iter_value_t<T0> tmp = iter_move(a);
// *a = iter_move(b);
// *b = std::move(tmp);
template<typename I0, typename I1>
constexpr detail::enable_if_t<
!is_adl_indirectly_swappable_v<I0, I1> &&
!is_swappable_with<iter_reference_t<I0>, iter_reference_t<I1>>::value &&
is_indirectly_movable_v<I0, I1> && is_indirectly_movable_v<I1, I0>>
operator()(I0 && a, I1 && b) const
noexcept(is_nothrow_indirectly_movable_v<I0, I1> &&
is_nothrow_indirectly_movable_v<I1, I0>)
{
iter_value_t<I0> v0 = iter_move(a);
*a = iter_move(b);
*b = detail::move(v0);
}
};
} // namespace _iter_swap_
/// \endcond
/// \relates _iter_swap_::fn
RANGES_DEFINE_CPO(_iter_swap_::fn, iter_swap)
/// \cond
namespace detail
{
template<typename T, typename U>
auto is_indirectly_swappable_(T & (*t)(), U & (*u)())
-> detail::always_<std::true_type, decltype(iter_swap(t(), u()))>;
template<typename T, typename U>
auto is_indirectly_swappable_(...) -> std::false_type;
template<typename T, typename U>
auto is_nothrow_indirectly_swappable_(int)
-> meta::bool_<noexcept(iter_swap(std::declval<T &>(), std::declval<U &>()))>;
template<typename T, typename U>
auto is_nothrow_indirectly_swappable_(long) -> std::false_type;
} // namespace detail
/// \endcond
template<typename T, typename U>
RANGES_INLINE_VAR constexpr bool is_indirectly_swappable_v =
decltype(detail::is_indirectly_swappable_<T, U>(nullptr, nullptr))::value;
template<typename T, typename U>
RANGES_INLINE_VAR constexpr bool is_nothrow_indirectly_swappable_v =
decltype(detail::is_nothrow_indirectly_swappable_<T, U>(0))::value;
template<typename T, typename U>
struct is_indirectly_swappable : meta::bool_<is_indirectly_swappable_v<T, U>>
{};
template<typename T, typename U>
struct is_nothrow_indirectly_swappable
: meta::bool_<is_nothrow_indirectly_swappable_v<T, U>>
{};
namespace cpp20
{
using ranges::iter_move;
using ranges::iter_reference_t;
using ranges::iter_swap;
using ranges::iter_value_t;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_ITERATOR_ACCESS_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/default_sentinel.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_DEFAULT_SENTINEL_HPP
#define RANGES_V3_ITERATOR_DEFAULT_SENTINEL_HPP
#include <range/v3/detail/config.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-iterator
/// @{
struct default_sentinel_t
{};
// Default sentinel
RANGES_INLINE_VARIABLE(default_sentinel_t, default_sentinel)
namespace cpp20
{
using ranges::default_sentinel;
using ranges::default_sentinel_t;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/reverse_iterator.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_REVERSE_ITERATOR_HPP
#define RANGES_V3_ITERATOR_REVERSE_ITERATOR_HPP
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/basic_iterator.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-iterator
/// @{
/// \cond
namespace detail
{
template<typename I>
struct reverse_cursor
{
private:
CPP_assert(bidirectional_iterator<I>);
friend range_access;
using value_type = iter_value_t<I>;
template<typename OtherI>
friend struct reverse_cursor;
struct mixin : basic_mixin<reverse_cursor>
{
mixin() = default;
#ifndef _MSC_VER
using basic_mixin<reverse_cursor>::basic_mixin;
#else
constexpr explicit mixin(reverse_cursor && cur)
: basic_mixin<reverse_cursor>(static_cast<reverse_cursor &&>(cur))
{}
constexpr explicit mixin(reverse_cursor const & cur)
: basic_mixin<reverse_cursor>(cur)
{}
#endif
constexpr mixin(I it)
: mixin{reverse_cursor{it}}
{}
constexpr I base() const
{
return this->get().base();
}
};
I it_;
constexpr reverse_cursor(I it)
: it_(std::move(it))
{}
constexpr iter_reference_t<I> read() const
{
return *arrow();
}
constexpr I arrow() const
{
auto tmp = it_;
--tmp;
return tmp;
}
constexpr I base() const
{
return it_;
}
template(typename J)(
requires sentinel_for<J, I>)
constexpr bool equal(reverse_cursor<J> const & that) const
{
return it_ == that.it_;
}
constexpr void next()
{
--it_;
}
constexpr void prev()
{
++it_;
}
CPP_member
constexpr auto advance(iter_difference_t<I> n) //
-> CPP_ret(void)(
requires random_access_iterator<I>)
{
it_ -= n;
}
template(typename J)(
requires sized_sentinel_for<J, I>)
constexpr iter_difference_t<I> distance_to(reverse_cursor<J> const & that) //
const
{
return it_ - that.base();
}
constexpr iter_rvalue_reference_t<I> move() const
noexcept(noexcept((void)I(I(it_)), (void)--const_cast<I &>(it_),
iter_move(it_)))
{
auto tmp = it_;
--tmp;
return iter_move(tmp);
}
public:
reverse_cursor() = default;
template(typename U)(
requires convertible_to<U, I>)
constexpr reverse_cursor(reverse_cursor<U> const & u)
: it_(u.base())
{}
};
} // namespace detail
/// \endcond
struct make_reverse_iterator_fn
{
template(typename I)(
requires bidirectional_iterator<I>)
constexpr reverse_iterator<I> operator()(I i) const
{
return reverse_iterator<I>(i);
}
};
RANGES_INLINE_VARIABLE(make_reverse_iterator_fn, make_reverse_iterator)
namespace cpp20
{
using ranges::make_reverse_iterator;
using ranges::reverse_iterator;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_ITERATOR_REVERSE_ITERATOR_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/concepts.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_CONCEPTS_HPP
#define RANGES_V3_ITERATOR_CONCEPTS_HPP
#include <iterator>
#include <type_traits>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/comparisons.hpp>
#include <range/v3/functional/concepts.hpp>
#include <range/v3/functional/identity.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/access.hpp>
#include <range/v3/iterator/traits.hpp>
#ifdef _GLIBCXX_DEBUG
#include <debug/safe_iterator.h>
#endif
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-iterator-concepts
/// @{
/// \cond
namespace detail
{
template<typename I>
using iter_traits_t = meta::conditional_t<is_std_iterator_traits_specialized_v<I>,
std::iterator_traits<I>, I>;
#if defined(_GLIBCXX_DEBUG)
template(typename I, typename T, typename Seq)(
requires same_as<I, __gnu_debug::_Safe_iterator<T *, Seq>>)
auto iter_concept_(__gnu_debug::_Safe_iterator<T *, Seq>, priority_tag<3>)
-> ranges::contiguous_iterator_tag;
#endif
#if defined(__GLIBCXX__)
template(typename I, typename T, typename Seq)(
requires same_as<I, __gnu_cxx::__normal_iterator<T *, Seq>>)
auto iter_concept_(__gnu_cxx::__normal_iterator<T *, Seq>, priority_tag<3>)
-> ranges::contiguous_iterator_tag;
#endif
#if defined(_LIBCPP_VERSION)
template(typename I, typename T)(
requires same_as<I, std::__wrap_iter<T *>>)
auto iter_concept_(std::__wrap_iter<T *>, priority_tag<3>)
-> ranges::contiguous_iterator_tag;
#endif
#if defined(_MSVC_STL_VERSION) || defined(_IS_WRS)
template(typename I)(
requires same_as<I, class I::_Array_iterator>)
auto iter_concept_(I, priority_tag<3>)
-> ranges::contiguous_iterator_tag;
template(typename I)(
requires same_as<I, class I::_Array_const_iterator>)
auto iter_concept_(I, priority_tag<3>)
-> ranges::contiguous_iterator_tag;
template(typename I)(
requires same_as<I, class I::_Vector_iterator>)
auto iter_concept_(I, priority_tag<3>)
-> ranges::contiguous_iterator_tag;
template(typename I)(
requires same_as<I, class I::_Vector_const_iterator>)
auto iter_concept_(I, priority_tag<3>)
-> ranges::contiguous_iterator_tag;
template(typename I)(
requires same_as<I, class I::_String_iterator>)
auto iter_concept_(I, priority_tag<3>)
-> ranges::contiguous_iterator_tag;
template(typename I)(
requires same_as<I, class I::_String_const_iterator>)
auto iter_concept_(I, priority_tag<3>)
-> ranges::contiguous_iterator_tag;
template(typename I)(
requires same_as<I, class I::_String_view_iterator>)
auto iter_concept_(I, priority_tag<3>)
-> ranges::contiguous_iterator_tag;
template(typename I)(
requires same_as<I, class I::_Span_iterator>)
auto iter_concept_(I, priority_tag<3>)
-> ranges::contiguous_iterator_tag;
#endif
template(typename I, typename T)(
requires same_as<I, T *>)
auto iter_concept_(T *, priority_tag<3>)
-> ranges::contiguous_iterator_tag;
template<typename I>
auto iter_concept_(I, priority_tag<2>) ->
typename iter_traits_t<I>::iterator_concept;
template<typename I>
auto iter_concept_(I, priority_tag<1>) ->
typename iter_traits_t<I>::iterator_category;
template<typename I>
auto iter_concept_(I, priority_tag<0>)
-> enable_if_t<!is_std_iterator_traits_specialized_v<I>,
std::random_access_iterator_tag>;
template<typename I>
using iter_concept_t =
decltype(iter_concept_<I>(std::declval<I>(), priority_tag<3>{}));
using ::concepts::detail::weakly_equality_comparable_with_;
template<typename I>
using readable_types_t =
meta::list<iter_value_t<I>, iter_reference_t<I>, iter_rvalue_reference_t<I>>;
} // namespace detail
/// \endcond
// clang-format off
/// \concept readable_
/// \brief The \c readable_ concept
template(typename I)(
concept (readable_)(I),
// requires (I const i)
// (
// { *i } -> same_as<iter_reference_t<I>>;
// { iter_move(i) } -> same_as<iter_rvalue_reference_t<I>>;
// ) &&
same_as<iter_reference_t<I const>, iter_reference_t<I>> AND
same_as<iter_rvalue_reference_t<I const>, iter_rvalue_reference_t<I>> AND
common_reference_with<iter_reference_t<I> &&, iter_value_t<I> &> AND
common_reference_with<iter_reference_t<I> &&,
iter_rvalue_reference_t<I> &&> AND
common_reference_with<iter_rvalue_reference_t<I> &&, iter_value_t<I> const &>
);
/// \concept indirectly_readable
/// \brief The \c indirectly_readable concept
template<typename I>
CPP_concept indirectly_readable = //
CPP_concept_ref(ranges::readable_, uncvref_t<I>);
template<typename I>
RANGES_DEPRECATED("Please use ranges::indirectly_readable instead")
RANGES_INLINE_VAR constexpr bool readable = //
indirectly_readable<I>;
/// \concept writable_
/// \brief The \c writable_ concept
template<typename O, typename T>
CPP_requires(writable_,
requires(O && o, T && t) //
(
*o = (T &&) t,
*(O &&) o = (T &&) t,
const_cast<iter_reference_t<O> const &&>(*o) = (T &&) t,
const_cast<iter_reference_t<O> const &&>(*(O &&) o) = (T &&) t
));
/// \concept indirectly_writable
/// \brief The \c indirectly_writable concept
template<typename O, typename T>
CPP_concept indirectly_writable = //
CPP_requires_ref(ranges::writable_, O, T);
template<typename O, typename T>
RANGES_DEPRECATED("Please use ranges::indirectly_writable instead")
RANGES_INLINE_VAR constexpr bool writable = //
indirectly_writable<O, T>;
// clang-format on
/// \cond
namespace detail
{
#if RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17
template<typename D>
inline constexpr bool _is_integer_like_ = std::is_integral<D>::value;
#else
template<typename D, typename = void>
constexpr bool _is_integer_like_ = std::is_integral<D>::value;
#endif
// gcc10 uses for std::ranges::range_difference_t<
// std::ranges::iota_view<size_t, size_t>> == __int128
#if __SIZEOF_INT128__
__extension__ typedef __int128 int128_t;
#if RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17
template<>
inline constexpr bool _is_integer_like_<int128_t> = true;
#else
template<typename Enable>
constexpr bool _is_integer_like_<int128_t, Enable> = true;
#endif
#endif // __SIZEOF_INT128__
// clang-format off
/// \concept integer_like_
/// \brief The \c integer_like_ concept
template<typename D>
CPP_concept integer_like_ = _is_integer_like_<D>;
// TODO additional syntactic and semantic requirements
#ifdef RANGES_WORKAROUND_MSVC_792338
template<typename D, bool Signed = (D(-1) < D(0))>
constexpr bool _is_signed_(D *)
{
return Signed;
}
constexpr bool _is_signed_(void *)
{
return false;
}
/// \concept signed_integer_like_
/// \brief The \c signed_integer_like_ concept
template<typename D>
CPP_concept signed_integer_like_ =
integer_like_<D> && detail::_is_signed_((D*) nullptr);
#else // ^^^ workaround / no workaround vvv
/// \concept signed_integer_like_impl_
/// \brief The \c signed_integer_like_impl_ concept
template(typename D)(
concept (signed_integer_like_impl_)(D),
integer_like_<D> AND
concepts::type<std::integral_constant<bool, (D(-1) < D(0))>> AND
std::integral_constant<bool, (D(-1) < D(0))>::value
);
/// \concept signed_integer_like_
/// \brief The \c signed_integer_like_ concept
template<typename D>
CPP_concept signed_integer_like_ =
integer_like_<D> &&
CPP_concept_ref(detail::signed_integer_like_impl_, D);
#endif // RANGES_WORKAROUND_MSVC_792338
// clang-format on
} // namespace detail
/// \endcond
// clang-format off
/// \concept weakly_incrementable_
/// \brief The \c weakly_incrementable_ concept
template<typename I>
CPP_requires(weakly_incrementable_,
requires(I i) //
(
++i,
i++,
concepts::requires_<same_as<I&, decltype(++i)>>
));
/// \concept weakly_incrementable_
/// \brief The \c weakly_incrementable_ concept
template(typename I)(
concept (weakly_incrementable_)(I),
concepts::type<iter_difference_t<I>> AND
detail::signed_integer_like_<iter_difference_t<I>>);
/// \concept weakly_incrementable
/// \brief The \c weakly_incrementable concept
template<typename I>
CPP_concept weakly_incrementable =
copyable<I> &&
CPP_requires_ref(ranges::weakly_incrementable_, I) &&
CPP_concept_ref(ranges::weakly_incrementable_, I);
/// \concept incrementable_
/// \brief The \c incrementable_ concept
template<typename I>
CPP_requires(incrementable_,
requires(I i) //
(
concepts::requires_<same_as<I, decltype(i++)>>
));
/// \concept incrementable
/// \brief The \c incrementable concept
template<typename I>
CPP_concept incrementable =
regular<I> &&
weakly_incrementable<I> &&
CPP_requires_ref(ranges::incrementable_, I);
/// \concept input_or_output_iterator_
/// \brief The \c input_or_output_iterator_ concept
template(typename I)(
concept (input_or_output_iterator_)(I),
detail::dereferenceable_<I&>
);
/// \concept input_or_output_iterator
/// \brief The \c input_or_output_iterator concept
template<typename I>
CPP_concept input_or_output_iterator =
weakly_incrementable<I> &&
CPP_concept_ref(ranges::input_or_output_iterator_, I);
/// \concept sentinel_for
/// \brief The \c sentinel_for concept
template<typename S, typename I>
CPP_concept sentinel_for =
semiregular<S> &&
input_or_output_iterator<I> &&
detail::weakly_equality_comparable_with_<S, I>;
/// \concept sized_sentinel_for_
/// \brief The \c sized_sentinel_for_ concept
template<typename S, typename I>
CPP_requires(sized_sentinel_for_,
requires(S const & s, I const & i) //
(
s - i,
i - s,
concepts::requires_<same_as<iter_difference_t<I>, decltype(s - i)>>,
concepts::requires_<same_as<iter_difference_t<I>, decltype(i - s)>>
));
/// \concept sized_sentinel_for_
/// \brief The \c sized_sentinel_for_ concept
template(typename S, typename I)(
concept (sized_sentinel_for_)(S, I),
(!disable_sized_sentinel<std::remove_cv_t<S>, std::remove_cv_t<I>>) AND
sentinel_for<S, I>);
/// \concept sized_sentinel_for
/// \brief The \c sized_sentinel_for concept
template<typename S, typename I>
CPP_concept sized_sentinel_for =
CPP_concept_ref(sized_sentinel_for_, S, I) &&
CPP_requires_ref(ranges::sized_sentinel_for_, S, I);
/// \concept output_iterator_
/// \brief The \c output_iterator_ concept
template<typename Out, typename T>
CPP_requires(output_iterator_,
requires(Out o, T && t) //
(
*o++ = (T &&) t
));
/// \concept output_iterator
/// \brief The \c output_iterator concept
template<typename Out, typename T>
CPP_concept output_iterator =
input_or_output_iterator<Out> &&
indirectly_writable<Out, T> &&
CPP_requires_ref(ranges::output_iterator_, Out, T);
/// \concept with_category_
/// \brief The \c with_category_ concept
template(typename I, typename Tag)(
concept (with_category_)(I, Tag),
derived_from<detail::iter_concept_t<I>, Tag>
);
/// \concept input_iterator
/// \brief The \c input_iterator concept
template<typename I>
CPP_concept input_iterator =
input_or_output_iterator<I> &&
indirectly_readable<I> &&
CPP_concept_ref(ranges::with_category_, I, std::input_iterator_tag);
/// \concept forward_iterator
/// \brief The \c forward_iterator concept
template<typename I>
CPP_concept forward_iterator =
input_iterator<I> &&
incrementable<I> &&
sentinel_for<I, I> &&
CPP_concept_ref(ranges::with_category_, I, std::forward_iterator_tag);
/// \concept bidirectional_iterator_
/// \brief The \c bidirectional_iterator_ concept
template<typename I>
CPP_requires(bidirectional_iterator_,
requires(I i) //
(
--i,
i--,
concepts::requires_<same_as<I&, decltype(--i)>>,
concepts::requires_<same_as<I, decltype(i--)>>
));
/// \concept bidirectional_iterator
/// \brief The \c bidirectional_iterator concept
template<typename I>
CPP_concept bidirectional_iterator =
forward_iterator<I> &&
CPP_requires_ref(ranges::bidirectional_iterator_, I) &&
CPP_concept_ref(ranges::with_category_, I, std::bidirectional_iterator_tag);
/// \concept random_access_iterator_
/// \brief The \c random_access_iterator_ concept
template<typename I>
CPP_requires(random_access_iterator_,
requires(I i, iter_difference_t<I> n)
(
i + n,
n + i,
i - n,
i += n,
i -= n,
concepts::requires_<same_as<decltype(i + n), I>>,
concepts::requires_<same_as<decltype(n + i), I>>,
concepts::requires_<same_as<decltype(i - n), I>>,
concepts::requires_<same_as<decltype(i += n), I&>>,
concepts::requires_<same_as<decltype(i -= n), I&>>,
concepts::requires_<same_as<decltype(i[n]), iter_reference_t<I>>>
));
/// \concept random_access_iterator
/// \brief The \c random_access_iterator concept
template<typename I>
CPP_concept random_access_iterator =
bidirectional_iterator<I> &&
totally_ordered<I> &&
sized_sentinel_for<I, I> &&
CPP_requires_ref(ranges::random_access_iterator_, I) &&
CPP_concept_ref(ranges::with_category_, I, std::random_access_iterator_tag);
/// \concept contiguous_iterator_
/// \brief The \c contiguous_iterator_ concept
template(typename I)(
concept (contiguous_iterator_)(I),
std::is_lvalue_reference<iter_reference_t<I>>::value AND
same_as<iter_value_t<I>, uncvref_t<iter_reference_t<I>>> AND
derived_from<detail::iter_concept_t<I>, ranges::contiguous_iterator_tag>
);
/// \concept contiguous_iterator
/// \brief The \c contiguous_iterator concept
template<typename I>
CPP_concept contiguous_iterator =
random_access_iterator<I> &&
CPP_concept_ref(ranges::contiguous_iterator_, I);
// clang-format on
/////////////////////////////////////////////////////////////////////////////////////
// iterator_tag_of
template<typename Rng>
using iterator_tag_of = //
std::enable_if_t< //
input_iterator<Rng>, //
meta::conditional_t< //
contiguous_iterator<Rng>, //
ranges::contiguous_iterator_tag, //
meta::conditional_t< //
random_access_iterator<Rng>, //
std::random_access_iterator_tag, //
meta::conditional_t< //
bidirectional_iterator<Rng>, //
std::bidirectional_iterator_tag, //
meta::conditional_t< //
forward_iterator<Rng>, //
std::forward_iterator_tag, //
std::input_iterator_tag>>>>>;
/// \cond
namespace detail
{
template<typename, bool>
struct iterator_category_
{};
template<typename I>
struct iterator_category_<I, true>
{
using type = iterator_tag_of<I>;
};
template<typename T, typename U = meta::_t<std::remove_const<T>>>
using iterator_category = iterator_category_<U, (bool)input_iterator<U>>;
} // namespace detail
/// \endcond
/// \cond
// Generally useful to know if an iterator is single-pass or not:
// clang-format off
/// \concept single_pass_iterator_
/// \brief The \c single_pass_iterator_ concept
template<typename I>
CPP_concept single_pass_iterator_ =
input_or_output_iterator<I> && !forward_iterator<I>;
// clang-format on
/// \endcond
//////////////////////////////////////////////////////////////////////////////////////
// indirect_result_t
template<typename Fun, typename... Is>
using indirect_result_t =
detail::enable_if_t<(bool)and_v<(bool)indirectly_readable<Is>...>,
invoke_result_t<Fun, iter_reference_t<Is>...>>;
/// \cond
namespace detail
{
// clang-format off
/// \concept common_reference_with_4_impl_
/// \brief The \c common_reference_with_4_impl_ concept
template(typename T1, typename T2, typename T3, typename T4)(
concept (common_reference_with_4_impl_)(T1, T2, T3, T4),
concepts::type<common_reference_t<T1, T2, T3, T4>> AND
convertible_to<T1, common_reference_t<T1, T2, T3, T4>> AND
convertible_to<T2, common_reference_t<T1, T2, T3, T4>> AND
convertible_to<T3, common_reference_t<T1, T2, T3, T4>> AND
convertible_to<T4, common_reference_t<T1, T2, T3, T4>>
);
/// \concept common_reference_with_4_
/// \brief The \c common_reference_with_4_ concept
template<typename T1, typename T2, typename T3, typename T4>
CPP_concept common_reference_with_4_ =
CPP_concept_ref(detail::common_reference_with_4_impl_, T1, T2, T3, T4);
// axiom: all permutations of T1,T2,T3,T4 have the same
// common reference type.
/// \concept indirectly_unary_invocable_impl_
/// \brief The \c indirectly_unary_invocable_impl_ concept
template(typename F, typename I)(
concept (indirectly_unary_invocable_impl_)(F, I),
invocable<F &, iter_value_t<I> &> AND
invocable<F &, iter_reference_t<I>> AND
invocable<F &, iter_common_reference_t<I>> AND
common_reference_with<
invoke_result_t<F &, iter_value_t<I> &>,
invoke_result_t<F &, iter_reference_t<I>>>
);
/// \concept indirectly_unary_invocable_
/// \brief The \c indirectly_unary_invocable_ concept
template<typename F, typename I>
CPP_concept indirectly_unary_invocable_ =
indirectly_readable<I> &&
CPP_concept_ref(detail::indirectly_unary_invocable_impl_, F, I);
// clang-format on
} // namespace detail
/// \endcond
// clang-format off
/// \concept indirectly_unary_invocable
/// \brief The \c indirectly_unary_invocable concept
template<typename F, typename I>
CPP_concept indirectly_unary_invocable =
detail::indirectly_unary_invocable_<F, I> &&
copy_constructible<F>;
/// \concept indirectly_regular_unary_invocable_
/// \brief The \c indirectly_regular_unary_invocable_ concept
template(typename F, typename I)(
concept (indirectly_regular_unary_invocable_)(F, I),
regular_invocable<F &, iter_value_t<I> &> AND
regular_invocable<F &, iter_reference_t<I>> AND
regular_invocable<F &, iter_common_reference_t<I>> AND
common_reference_with<
invoke_result_t<F &, iter_value_t<I> &>,
invoke_result_t<F &, iter_reference_t<I>>>
);
/// \concept indirectly_regular_unary_invocable
/// \brief The \c indirectly_regular_unary_invocable concept
template<typename F, typename I>
CPP_concept indirectly_regular_unary_invocable =
indirectly_readable<I> &&
copy_constructible<F> &&
CPP_concept_ref(ranges::indirectly_regular_unary_invocable_, F, I);
/// \cond
// Non-standard indirect invocable concepts
/// \concept indirectly_binary_invocable_impl_
/// \brief The \c indirectly_binary_invocable_impl_ concept
template(typename F, typename I1, typename I2)(
concept (indirectly_binary_invocable_impl_)(F, I1, I2),
invocable<F &, iter_value_t<I1> &, iter_value_t<I2> &> AND
invocable<F &, iter_value_t<I1> &, iter_reference_t<I2>> AND
invocable<F &, iter_reference_t<I1>, iter_value_t<I2> &> AND
invocable<F &, iter_reference_t<I1>, iter_reference_t<I2>> AND
invocable<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>> AND
detail::common_reference_with_4_<
invoke_result_t<F &, iter_value_t<I1> &, iter_value_t<I2> &>,
invoke_result_t<F &, iter_value_t<I1> &, iter_reference_t<I2>>,
invoke_result_t<F &, iter_reference_t<I1>, iter_value_t<I2> &>,
invoke_result_t<F &, iter_reference_t<I1>, iter_reference_t<I2>>>
);
/// \concept indirectly_binary_invocable_
/// \brief The \c indirectly_binary_invocable_ concept
template<typename F, typename I1, typename I2>
CPP_concept indirectly_binary_invocable_ =
indirectly_readable<I1> && indirectly_readable<I2> &&
copy_constructible<F> &&
CPP_concept_ref(ranges::indirectly_binary_invocable_impl_, F, I1, I2);
/// \concept indirectly_regular_binary_invocable_impl_
/// \brief The \c indirectly_regular_binary_invocable_impl_ concept
template(typename F, typename I1, typename I2)(
concept (indirectly_regular_binary_invocable_impl_)(F, I1, I2),
regular_invocable<F &, iter_value_t<I1> &, iter_value_t<I2> &> AND
regular_invocable<F &, iter_value_t<I1> &, iter_reference_t<I2>> AND
regular_invocable<F &, iter_reference_t<I1>, iter_value_t<I2> &> AND
regular_invocable<F &, iter_reference_t<I1>, iter_reference_t<I2>> AND
regular_invocable<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>> AND
detail::common_reference_with_4_<
invoke_result_t<F &, iter_value_t<I1> &, iter_value_t<I2> &>,
invoke_result_t<F &, iter_value_t<I1> &, iter_reference_t<I2>>,
invoke_result_t<F &, iter_reference_t<I1>, iter_value_t<I2> &>,
invoke_result_t<F &, iter_reference_t<I1>, iter_reference_t<I2>>>
);
/// \concept indirectly_regular_binary_invocable_
/// \brief The \c indirectly_regular_binary_invocable_ concept
template<typename F, typename I1, typename I2>
CPP_concept indirectly_regular_binary_invocable_ =
indirectly_readable<I1> && indirectly_readable<I2> &&
copy_constructible<F> &&
CPP_concept_ref(ranges::indirectly_regular_binary_invocable_impl_, F, I1, I2);
/// \endcond
/// \concept indirect_unary_predicate_
/// \brief The \c indirect_unary_predicate_ concept
template(typename F, typename I)(
concept (indirect_unary_predicate_)(F, I),
predicate<F &, iter_value_t<I> &> AND
predicate<F &, iter_reference_t<I>> AND
predicate<F &, iter_common_reference_t<I>>
);
/// \concept indirect_unary_predicate
/// \brief The \c indirect_unary_predicate concept
template<typename F, typename I>
CPP_concept indirect_unary_predicate =
indirectly_readable<I> &&
copy_constructible<F> &&
CPP_concept_ref(ranges::indirect_unary_predicate_, F, I);
/// \concept indirect_binary_predicate_impl_
/// \brief The \c indirect_binary_predicate_impl_ concept
template(typename F, typename I1, typename I2)(
concept (indirect_binary_predicate_impl_)(F, I1, I2),
predicate<F &, iter_value_t<I1> &, iter_value_t<I2> &> AND
predicate<F &, iter_value_t<I1> &, iter_reference_t<I2>> AND
predicate<F &, iter_reference_t<I1>, iter_value_t<I2> &> AND
predicate<F &, iter_reference_t<I1>, iter_reference_t<I2>> AND
predicate<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>
);
/// \concept indirect_binary_predicate_
/// \brief The \c indirect_binary_predicate_ concept
template<typename F, typename I1, typename I2>
CPP_concept indirect_binary_predicate_ =
indirectly_readable<I1> && indirectly_readable<I2> &&
copy_constructible<F> &&
CPP_concept_ref(ranges::indirect_binary_predicate_impl_, F, I1, I2);
/// \concept indirect_relation_
/// \brief The \c indirect_relation_ concept
template(typename F, typename I1, typename I2)(
concept (indirect_relation_)(F, I1, I2),
relation<F &, iter_value_t<I1> &, iter_value_t<I2> &> AND
relation<F &, iter_value_t<I1> &, iter_reference_t<I2>> AND
relation<F &, iter_reference_t<I1>, iter_value_t<I2> &> AND
relation<F &, iter_reference_t<I1>, iter_reference_t<I2>> AND
relation<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>
);
/// \concept indirect_relation
/// \brief The \c indirect_relation concept
template<typename F, typename I1, typename I2 = I1>
CPP_concept indirect_relation =
indirectly_readable<I1> && indirectly_readable<I2> &&
copy_constructible<F> &&
CPP_concept_ref(ranges::indirect_relation_, F, I1, I2);
/// \concept indirect_strict_weak_order_
/// \brief The \c indirect_strict_weak_order_ concept
template(typename F, typename I1, typename I2)(
concept (indirect_strict_weak_order_)(F, I1, I2),
strict_weak_order<F &, iter_value_t<I1> &, iter_value_t<I2> &> AND
strict_weak_order<F &, iter_value_t<I1> &, iter_reference_t<I2>> AND
strict_weak_order<F &, iter_reference_t<I1>, iter_value_t<I2> &> AND
strict_weak_order<F &, iter_reference_t<I1>, iter_reference_t<I2>> AND
strict_weak_order<F &, iter_common_reference_t<I1>, iter_common_reference_t<I2>>
);
/// \concept indirect_strict_weak_order
/// \brief The \c indirect_strict_weak_order concept
template<typename F, typename I1, typename I2 = I1>
CPP_concept indirect_strict_weak_order =
indirectly_readable<I1> && indirectly_readable<I2> &&
copy_constructible<F> &&
CPP_concept_ref(ranges::indirect_strict_weak_order_, F, I1, I2);
// clang-format on
//////////////////////////////////////////////////////////////////////////////////////
// projected struct, for "projecting" a readable with a unary callable
/// \cond
namespace detail
{
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_INTERNAL
template<typename I, typename Proj>
struct projected_
{
struct type
{
using reference = indirect_result_t<Proj &, I>;
using value_type = uncvref_t<reference>;
reference operator*() const;
};
};
RANGES_DIAGNOSTIC_POP
template<typename Proj>
struct select_projected_
{
template<typename I>
using apply =
meta::_t<
detail::enable_if_t<
(bool)indirectly_regular_unary_invocable<Proj, I>,
detail::projected_<I, Proj>>>;
};
template<>
struct select_projected_<identity>
{
template<typename I>
using apply = detail::enable_if_t<(bool)indirectly_readable<I>, I>;
};
} // namespace detail
/// \endcond
template<typename I, typename Proj>
using projected = typename detail::select_projected_<Proj>::template apply<I>;
template<typename I, typename Proj>
struct incrementable_traits<detail::projected_<I, Proj>> : incrementable_traits<I>
{};
// clang-format off
/// \concept indirectly_movable_
/// \brief The \c indirectly_movable_ concept
template(typename I, typename O)(
concept (indirectly_movable_)(I, O),
indirectly_writable<O, iter_rvalue_reference_t<I>>
);
/// \concept indirectly_movable
/// \brief The \c indirectly_movable concept
template<typename I, typename O>
CPP_concept indirectly_movable =
indirectly_readable<I> && CPP_concept_ref(ranges::indirectly_movable_, I, O);
/// \concept indirectly_movable_storable_
/// \brief The \c indirectly_movable_storable_ concept
template(typename I, typename O)(
concept (indirectly_movable_storable_)(I, O),
indirectly_writable<O, iter_value_t<I>> AND
movable<iter_value_t<I>> AND
constructible_from<iter_value_t<I>, iter_rvalue_reference_t<I>> AND
assignable_from<iter_value_t<I> &, iter_rvalue_reference_t<I>>
);
/// \concept indirectly_movable_storable
/// \brief The \c indirectly_movable_storable concept
template<typename I, typename O>
CPP_concept indirectly_movable_storable =
indirectly_movable<I, O> &&
CPP_concept_ref(ranges::indirectly_movable_storable_, I, O);
/// \concept indirectly_copyable_
/// \brief The \c indirectly_copyable_ concept
template(typename I, typename O)(
concept (indirectly_copyable_)(I, O),
indirectly_writable<O, iter_reference_t<I>>
);
/// \concept indirectly_copyable
/// \brief The \c indirectly_copyable concept
template<typename I, typename O>
CPP_concept indirectly_copyable =
indirectly_readable<I> && CPP_concept_ref(ranges::indirectly_copyable_, I, O);
/// \concept indirectly_copyable_storable_
/// \brief The \c indirectly_copyable_storable_ concept
template(typename I, typename O)(
concept (indirectly_copyable_storable_)(I, O),
indirectly_writable<O, iter_value_t<I> const &> AND
copyable<iter_value_t<I>> AND
constructible_from<iter_value_t<I>, iter_reference_t<I>> AND
assignable_from<iter_value_t<I> &, iter_reference_t<I>>
);
/// \concept indirectly_copyable_storable
/// \brief The \c indirectly_copyable_storable concept
template<typename I, typename O>
CPP_concept indirectly_copyable_storable =
indirectly_copyable<I, O> &&
CPP_concept_ref(ranges::indirectly_copyable_storable_, I, O);
/// \concept indirectly_swappable_
/// \brief The \c indirectly_swappable_ concept
template<typename I1, typename I2>
CPP_requires(indirectly_swappable_,
requires(I1 const i1, I2 const i2) //
(
ranges::iter_swap(i1, i2),
ranges::iter_swap(i1, i1),
ranges::iter_swap(i2, i2),
ranges::iter_swap(i2, i1)
));
/// \concept indirectly_swappable
/// \brief The \c indirectly_swappable concept
template<typename I1, typename I2 = I1>
CPP_concept indirectly_swappable =
indirectly_readable<I1> && //
indirectly_readable<I2> && //
CPP_requires_ref(ranges::indirectly_swappable_, I1, I2);
/// \concept projected_indirect_relation_
/// \brief The \c projected_indirect_relation_ concept
template(typename C, typename I1, typename P1, typename I2, typename P2)(
concept (projected_indirect_relation_)(C, I1, P1, I2, P2),
indirect_relation<C, projected<I1, P1>, projected<I2, P2>>
);
/// \concept indirectly_comparable
/// \brief The \c indirectly_comparable concept
template<typename I1, typename I2, typename C, typename P1 = identity,
typename P2 = identity>
CPP_concept indirectly_comparable =
CPP_concept_ref(ranges::projected_indirect_relation_, C, I1, P1, I2, P2);
//////////////////////////////////////////////////////////////////////////////////////
// Composite concepts for use defining algorithms:
/// \concept permutable
/// \brief The \c permutable concept
template<typename I>
CPP_concept permutable =
forward_iterator<I> &&
indirectly_swappable<I, I> &&
indirectly_movable_storable<I, I>;
/// \concept projected_indirect_strict_weak_order_
/// \brief The \c projected_indirect_strict_weak_order_ concept
template(typename C, typename I1, typename P1, typename I2, typename P2)(
concept (projected_indirect_strict_weak_order_)(C, I1, P1, I2, P2),
indirect_strict_weak_order<C, projected<I1, P1>, projected<I2, P2>>
);
template<typename I1, typename I2, typename Out, typename C = less,
typename P1 = identity, typename P2 = identity>
CPP_concept mergeable =
input_iterator<I1> &&
input_iterator<I2> &&
weakly_incrementable<Out> &&
indirectly_copyable<I1, Out> &&
indirectly_copyable<I2, Out> &&
CPP_concept_ref(ranges::projected_indirect_strict_weak_order_, C, I1, P1, I2, P2);
/// \concept sortable
/// \brief The \c sortable concept
template<typename I, typename C = less, typename P = identity>
CPP_concept sortable =
permutable<I> &&
CPP_concept_ref(ranges::projected_indirect_strict_weak_order_, C, I, P, I, P);
// clang-format on
struct sentinel_tag
{};
struct sized_sentinel_tag : sentinel_tag
{};
template<typename S, typename I>
using sentinel_tag_of = //
std::enable_if_t< //
sentinel_for<S, I>, //
meta::conditional_t< //
sized_sentinel_for<S, I>, //
sized_sentinel_tag, //
sentinel_tag>>;
// Deprecated things:
/// \cond
template<typename I>
using iterator_category RANGES_DEPRECATED(
"iterator_category is deprecated. Use the iterator concepts instead") =
detail::iterator_category<I>;
template<typename I>
using iterator_category_t RANGES_DEPRECATED(
"iterator_category_t is deprecated. Use the iterator concepts instead") =
meta::_t<detail::iterator_category<I>>;
template<typename Fun, typename... Is>
using indirect_invoke_result_t RANGES_DEPRECATED(
"Please switch to indirect_result_t") = indirect_result_t<Fun, Is...>;
template<typename Fun, typename... Is>
struct RANGES_DEPRECATED("Please switch to indirect_result_t") indirect_invoke_result
: meta::defer<indirect_result_t, Fun, Is...>
{};
template<typename Sig>
struct indirect_result_of
{};
template<typename Fun, typename... Is>
struct RANGES_DEPRECATED("Please switch to indirect_result_t")
indirect_result_of<Fun(Is...)> : meta::defer<indirect_result_t, Fun, Is...>
{};
template<typename Sig>
using indirect_result_of_t RANGES_DEPRECATED("Please switch to indirect_result_t") =
meta::_t<indirect_result_of<Sig>>;
/// \endcond
namespace cpp20
{
using ranges::bidirectional_iterator;
using ranges::contiguous_iterator;
using ranges::forward_iterator;
using ranges::incrementable;
using ranges::indirect_relation;
using ranges::indirect_result_t;
using ranges::indirect_strict_weak_order;
using ranges::indirect_unary_predicate;
using ranges::indirectly_comparable;
using ranges::indirectly_copyable;
using ranges::indirectly_copyable_storable;
using ranges::indirectly_movable;
using ranges::indirectly_movable_storable;
using ranges::indirectly_readable;
using ranges::indirectly_regular_unary_invocable;
using ranges::indirectly_swappable;
using ranges::indirectly_unary_invocable;
using ranges::indirectly_writable;
using ranges::input_iterator;
using ranges::input_or_output_iterator;
using ranges::mergeable;
using ranges::output_iterator;
using ranges::permutable;
using ranges::projected;
using ranges::random_access_iterator;
using ranges::sentinel_for;
using ranges::sized_sentinel_for;
using ranges::sortable;
using ranges::weakly_incrementable;
} // namespace cpp20
/// @}
} // namespace ranges
#ifdef _GLIBCXX_DEBUG
// HACKHACK: workaround underconstrained operator- for libstdc++ debug iterator wrapper
// by intentionally creating an ambiguity when the wrapped types don't support the
// necessary operation.
namespace __gnu_debug
{
template(typename I1, typename I2, typename Seq)(
requires (!::ranges::sized_sentinel_for<I1, I2>)) //
void operator-(_Safe_iterator<I1, Seq> const &, _Safe_iterator<I2, Seq> const &) =
delete;
template(typename I1, typename Seq)(
requires (!::ranges::sized_sentinel_for<I1, I1>)) //
void operator-(_Safe_iterator<I1, Seq> const &, _Safe_iterator<I1, Seq> const &) =
delete;
} // namespace __gnu_debug
#endif
#if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 3900)
// HACKHACK: workaround libc++ (https://llvm.org/bugs/show_bug.cgi?id=28421)
// and libstdc++ (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=71771)
// underconstrained operator- for reverse_iterator by disabling sized_sentinel_for
// when the base iterators do not model sized_sentinel_for.
namespace ranges
{
template<typename S, typename I>
/*inline*/ constexpr bool
disable_sized_sentinel<std::reverse_iterator<S>, std::reverse_iterator<I>> =
!static_cast<bool>(sized_sentinel_for<I, S>);
} // namespace ranges
#endif // defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION <= 3900)
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_ITERATOR_CONCEPTS_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/basic_iterator.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
// Copyright Casey Carter 2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_BASIC_ITERATOR_HPP
#define RANGES_V3_ITERATOR_BASIC_ITERATOR_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/detail/range_access.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/utility/addressof.hpp>
#include <range/v3/utility/box.hpp>
#include <range/v3/utility/move.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/detail/prologue.hpp>
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_MULTIPLE_ASSIGNMENT_OPERATORS
namespace ranges
{
/// \addtogroup group-iterator Iterator
/// @{
///
template<typename T>
struct basic_mixin : private box<T>
{
CPP_member
constexpr CPP_ctor(basic_mixin)()( //
noexcept(std::is_nothrow_default_constructible<T>::value) //
requires default_constructible<T>)
: box<T>{}
{}
CPP_member
constexpr explicit CPP_ctor(basic_mixin)(T && t)( //
noexcept(std::is_nothrow_move_constructible<T>::value) //
requires move_constructible<T>)
: box<T>(detail::move(t))
{}
CPP_member
constexpr explicit CPP_ctor(basic_mixin)(T const & t)( //
noexcept(std::is_nothrow_copy_constructible<T>::value) //
requires copy_constructible<T>)
: box<T>(t)
{}
protected:
using box<T>::get;
};
/// \cond
namespace detail
{
template<typename Cur>
using cursor_reference_t =
decltype(range_access::read(std::declval<Cur const &>()));
// Compute the rvalue reference type of a cursor
template<typename Cur>
auto cursor_move(Cur const & cur, int) -> decltype(range_access::move(cur));
template<typename Cur>
auto cursor_move(Cur const & cur, long) -> aux::move_t<cursor_reference_t<Cur>>;
template<typename Cur>
using cursor_rvalue_reference_t =
decltype(detail::cursor_move(std::declval<Cur const &>(), 42));
// Define conversion operators from the proxy reference type
// to the common reference types, so that basic_iterator can model readable
// even with getters/setters.
template<typename Derived, typename Head>
struct proxy_reference_conversion
{
operator Head() const
noexcept(noexcept(Head(Head(std::declval<Derived const &>().read_()))))
{
return Head(static_cast<Derived const *>(this)->read_());
}
};
// Collect the reference types associated with cursors
template<typename Cur, bool IsReadable>
struct cursor_traits_
{
private:
struct private_
{};
public:
using value_t_ = private_;
using reference_t_ = private_;
using rvalue_reference_t_ = private_;
using common_refs = meta::list<>;
};
template<typename Cur>
struct cursor_traits_<Cur, true>
{
using value_t_ = range_access::cursor_value_t<Cur>;
using reference_t_ = cursor_reference_t<Cur>;
using rvalue_reference_t_ = cursor_rvalue_reference_t<Cur>;
private:
using R1 = reference_t_;
using R2 = common_reference_t<reference_t_, value_t_ &>;
using R3 = common_reference_t<reference_t_, rvalue_reference_t_>;
using tmp1 = meta::list<value_t_, R1>;
using tmp2 =
meta::if_<meta::in<tmp1, uncvref_t<R2>>, tmp1, meta::push_back<tmp1, R2>>;
using tmp3 =
meta::if_<meta::in<tmp2, uncvref_t<R3>>, tmp2, meta::push_back<tmp2, R3>>;
public:
using common_refs = meta::unique<meta::pop_front<tmp3>>;
};
template<typename Cur>
using cursor_traits = cursor_traits_<Cur, (bool)readable_cursor<Cur>>;
template<typename Cur>
using cursor_value_t = typename cursor_traits<Cur>::value_t_;
template<typename Cur, bool IsReadable>
struct basic_proxy_reference_;
template<typename Cur>
using basic_proxy_reference =
basic_proxy_reference_<Cur, (bool)readable_cursor<Cur>>;
// The One Proxy Reference type to rule them all. basic_iterator uses this
// as the return type of operator* when the cursor type has a set() member
// function of the correct signature (i.e., if it can accept a value_type &&).
template<typename Cur, bool IsReadable /*= (bool) readable_cursor<Cur>*/>
struct RANGES_EMPTY_BASES basic_proxy_reference_
: cursor_traits<Cur>
// The following adds conversion operators to the common reference
// types, so that basic_proxy_reference can model readable
, meta::inherit<meta::transform<
typename cursor_traits<Cur>::common_refs,
meta::bind_front<meta::quote<proxy_reference_conversion>,
basic_proxy_reference_<Cur, IsReadable>>>>
{
private:
Cur * cur_;
template<typename, bool>
friend struct basic_proxy_reference_;
template<typename, typename>
friend struct proxy_reference_conversion;
using typename cursor_traits<Cur>::value_t_;
using typename cursor_traits<Cur>::reference_t_;
using typename cursor_traits<Cur>::rvalue_reference_t_;
static_assert((bool)common_reference_with<value_t_ &, reference_t_>,
"Your readable and writable cursor must have a value type and "
"a reference type that share a common reference type. See the "
"ranges::common_reference type trait.");
// BUGBUG make these private:
public:
constexpr reference_t_ read_() const noexcept(
noexcept(reference_t_(range_access::read(std::declval<Cur const &>()))))
{
return range_access::read(*cur_);
}
template<typename T>
constexpr void write_(T && t) const
{
range_access::write(*cur_, (T &&) t);
}
// public:
basic_proxy_reference_() = default;
basic_proxy_reference_(basic_proxy_reference_ const &) = default;
template(typename OtherCur)(
requires convertible_to<OtherCur *, Cur *>)
constexpr basic_proxy_reference_(
basic_proxy_reference<OtherCur> const & that) noexcept
: cur_(that.cur_)
{}
constexpr explicit basic_proxy_reference_(Cur & cur) noexcept
: cur_(&cur)
{}
CPP_member
constexpr auto operator=(basic_proxy_reference_ && that)
-> CPP_ret(basic_proxy_reference_ &)(
requires readable_cursor<Cur>)
{
return *this = that;
}
CPP_member
constexpr auto operator=(basic_proxy_reference_ const & that)
-> CPP_ret(basic_proxy_reference_ &)(
requires readable_cursor<Cur>)
{
this->write_(that.read_());
return *this;
}
CPP_member
constexpr auto operator=(basic_proxy_reference_ && that) const
-> CPP_ret(basic_proxy_reference_ const &)(
requires readable_cursor<Cur>)
{
return *this = that;
}
CPP_member
constexpr auto operator=(basic_proxy_reference_ const & that) const
-> CPP_ret(basic_proxy_reference_ const &)(
requires readable_cursor<Cur>)
{
this->write_(that.read_());
return *this;
}
template(typename OtherCur)(
requires readable_cursor<OtherCur> AND
writable_cursor<Cur, cursor_reference_t<OtherCur>>)
constexpr basic_proxy_reference_ & //
operator=(basic_proxy_reference<OtherCur> && that)
{
return *this = that;
}
template(typename OtherCur)(
requires readable_cursor<OtherCur> AND
writable_cursor<Cur, cursor_reference_t<OtherCur>>)
constexpr basic_proxy_reference_ & //
operator=(basic_proxy_reference<OtherCur> const & that)
{
this->write_(that.read_());
return *this;
}
template(typename OtherCur)(
requires readable_cursor<OtherCur> AND
writable_cursor<Cur, cursor_reference_t<OtherCur>>)
constexpr basic_proxy_reference_ const & //
operator=(basic_proxy_reference<OtherCur> && that) const
{
return *this = that;
}
template(typename OtherCur)(
requires readable_cursor<OtherCur> AND
writable_cursor<Cur, cursor_reference_t<OtherCur>>)
constexpr basic_proxy_reference_ const & //
operator=(basic_proxy_reference<OtherCur> const & that) const
{
this->write_(that.read_());
return *this;
}
template(typename T)(
requires writable_cursor<Cur, T>)
constexpr basic_proxy_reference_ & operator=(T && t) //
{
this->write_((T &&) t);
return *this;
}
template(typename T)(
requires writable_cursor<Cur, T>)
constexpr basic_proxy_reference_ const & operator=(T && t) const
{
this->write_((T &&) t);
return *this;
}
};
template(typename Cur, bool IsReadable)(
requires readable_cursor<Cur> AND equality_comparable<cursor_value_t<Cur>>)
constexpr bool operator==(basic_proxy_reference_<Cur, IsReadable> const & x,
cursor_value_t<Cur> const & y)
{
return x.read_() == y;
}
template(typename Cur, bool IsReadable)(
requires readable_cursor<Cur> AND equality_comparable<cursor_value_t<Cur>>)
constexpr bool operator!=(basic_proxy_reference_<Cur, IsReadable> const & x,
cursor_value_t<Cur> const & y)
{
return !(x == y);
}
template(typename Cur, bool IsReadable)(
requires readable_cursor<Cur> AND equality_comparable<cursor_value_t<Cur>>)
constexpr bool operator==(cursor_value_t<Cur> const & x,
basic_proxy_reference_<Cur, IsReadable> const & y)
{
return x == y.read_();
}
template(typename Cur, bool IsReadable)(
requires readable_cursor<Cur> AND equality_comparable<cursor_value_t<Cur>>)
constexpr bool operator!=(cursor_value_t<Cur> const & x,
basic_proxy_reference_<Cur, IsReadable> const & y)
{
return !(x == y);
}
template(typename Cur, bool IsReadable)(
requires readable_cursor<Cur> AND equality_comparable<cursor_value_t<Cur>>)
constexpr bool operator==(basic_proxy_reference_<Cur, IsReadable> const & x,
basic_proxy_reference_<Cur, IsReadable> const & y)
{
return x.read_() == y.read_();
}
template(typename Cur, bool IsReadable)(
requires readable_cursor<Cur> AND equality_comparable<cursor_value_t<Cur>>)
constexpr bool operator!=(basic_proxy_reference_<Cur, IsReadable> const & x,
basic_proxy_reference_<Cur, IsReadable> const & y)
{
return !(x == y);
}
template<typename Cur>
using cpp20_iter_cat_of_t = //
std::enable_if_t< //
input_cursor<Cur>, //
meta::conditional_t< //
contiguous_cursor<Cur>, //
ranges::contiguous_iterator_tag, //
meta::conditional_t< //
random_access_cursor<Cur>, //
std::random_access_iterator_tag, //
meta::conditional_t< //
bidirectional_cursor<Cur>, //
std::bidirectional_iterator_tag, //
meta::conditional_t< //
forward_cursor<Cur>, //
std::forward_iterator_tag, //
std::input_iterator_tag>>>>>;
// clang-format off
/// \concept cpp17_input_cursor_
/// \brief The \c cpp17_input_cursor_ concept
template(typename C)(
concept (cpp17_input_cursor_)(C),
// Either it is not single-pass, or else we can create a
// proxy for postfix increment.
!range_access::single_pass_t<uncvref_t<C>>::value ||
(move_constructible<range_access::cursor_value_t<C>> &&
constructible_from<range_access::cursor_value_t<C>, cursor_reference_t<C>>)
);
/// \concept cpp17_input_cursor
/// \brief The \c cpp17_input_cursor concept
template<typename C>
CPP_concept cpp17_input_cursor =
input_cursor<C> &&
sentinel_for_cursor<C, C> &&
CPP_concept_ref(cpp17_input_cursor_, C);
/// \concept cpp17_forward_cursor_
/// \brief The \c cpp17_forward_cursor_ concept
template(typename C)(
concept (cpp17_forward_cursor_)(C),
std::is_reference<cursor_reference_t<C>>::value
);
/// \concept cpp17_forward_cursor
/// \brief The \c cpp17_forward_cursor concept
template<typename C>
CPP_concept cpp17_forward_cursor =
forward_cursor<C> &&
CPP_concept_ref(cpp17_forward_cursor_, C);
// clang-format on
template<typename Category, typename Base = void>
struct with_iterator_category : Base
{
using iterator_category = Category;
};
template<typename Category>
struct with_iterator_category<Category>
{
using iterator_category = Category;
};
template<typename Cur>
using cpp17_iter_cat_of_t = //
std::enable_if_t< //
cpp17_input_cursor<Cur>, //
meta::conditional_t< //
random_access_cursor<Cur>, //
std::random_access_iterator_tag, //
meta::conditional_t< //
bidirectional_cursor<Cur>, //
std::bidirectional_iterator_tag, //
meta::conditional_t< //
cpp17_forward_cursor<Cur>, //
std::forward_iterator_tag, //
std::input_iterator_tag>>>>;
template<typename Cur, typename = void>
struct readable_iterator_associated_types_base : range_access::mixin_base_t<Cur>
{
readable_iterator_associated_types_base() = default;
using range_access::mixin_base_t<Cur>::mixin_base_t;
readable_iterator_associated_types_base(Cur && cur)
: range_access::mixin_base_t<Cur>(static_cast<Cur &&>(cur))
{}
readable_iterator_associated_types_base(Cur const & cur)
: range_access::mixin_base_t<Cur>(cur)
{}
};
template<typename Cur>
struct readable_iterator_associated_types_base<
Cur, always_<void, cpp17_iter_cat_of_t<Cur>>>
: range_access::mixin_base_t<Cur>
{
using iterator_category = cpp17_iter_cat_of_t<Cur>;
readable_iterator_associated_types_base() = default;
using range_access::mixin_base_t<Cur>::mixin_base_t;
readable_iterator_associated_types_base(Cur && cur)
: range_access::mixin_base_t<Cur>(static_cast<Cur &&>(cur))
{}
readable_iterator_associated_types_base(Cur const & cur)
: range_access::mixin_base_t<Cur>(cur)
{}
};
template<typename Cur, bool IsReadable /*= (bool) readable_cursor<Cur>*/>
struct iterator_associated_types_base_ : range_access::mixin_base_t<Cur>
{
// BUGBUG
// protected:
using iter_reference_t = basic_proxy_reference<Cur>;
using const_reference_t = basic_proxy_reference<Cur const>;
public:
using reference = void;
using difference_type = range_access::cursor_difference_t<Cur>;
iterator_associated_types_base_() = default;
using range_access::mixin_base_t<Cur>::mixin_base_t;
iterator_associated_types_base_(Cur && cur)
: range_access::mixin_base_t<Cur>(static_cast<Cur &&>(cur))
{}
iterator_associated_types_base_(Cur const & cur)
: range_access::mixin_base_t<Cur>(cur)
{}
};
template<typename Cur>
using cursor_arrow_t = decltype(range_access::arrow(std::declval<Cur const &>()));
template<typename Cur>
struct iterator_associated_types_base_<Cur, true>
: readable_iterator_associated_types_base<Cur>
{
// BUGBUG
// protected:
using iter_reference_t =
meta::conditional_t<is_writable_cursor_v<Cur const>,
basic_proxy_reference<Cur const>,
meta::conditional_t<is_writable_cursor_v<Cur>,
basic_proxy_reference<Cur>, cursor_reference_t<Cur>>>;
using const_reference_t =
meta::conditional_t<is_writable_cursor_v<Cur const>,
basic_proxy_reference<Cur const>, cursor_reference_t<Cur>>;
public:
using difference_type = range_access::cursor_difference_t<Cur>;
using value_type = range_access::cursor_value_t<Cur>;
using reference = iter_reference_t;
using iterator_concept = cpp20_iter_cat_of_t<Cur>;
using pointer = meta::_t<
meta::conditional_t<
(bool)has_cursor_arrow<Cur>,
meta::defer<cursor_arrow_t, Cur>,
std::add_pointer<reference>>>;
using common_reference = common_reference_t<reference, value_type &>;
iterator_associated_types_base_() = default;
using readable_iterator_associated_types_base<
Cur>::readable_iterator_associated_types_base;
iterator_associated_types_base_(Cur && cur)
: readable_iterator_associated_types_base<Cur>(static_cast<Cur &&>(cur))
{}
iterator_associated_types_base_(Cur const & cur)
: readable_iterator_associated_types_base<Cur>(cur)
{}
};
template<typename Cur>
using iterator_associated_types_base =
iterator_associated_types_base_<Cur, (bool)readable_cursor<Cur>>;
template<typename Value>
struct postfix_increment_proxy
{
private:
Value cache_;
public:
template<typename T>
constexpr postfix_increment_proxy(T && t)
: cache_(static_cast<T &&>(t))
{}
constexpr Value const & operator*() const noexcept
{
return cache_;
}
};
} // namespace detail
/// \endcond
#if RANGES_BROKEN_CPO_LOOKUP
namespace _basic_iterator_
{
template<typename>
struct adl_hook
{};
} // namespace _basic_iterator_
#endif
template<typename Cur>
struct RANGES_EMPTY_BASES basic_iterator
: detail::iterator_associated_types_base<Cur>
#if RANGES_BROKEN_CPO_LOOKUP
, private _basic_iterator_::adl_hook<basic_iterator<Cur>>
#endif
{
private:
template<typename>
friend struct basic_iterator;
friend range_access;
using base_t = detail::iterator_associated_types_base<Cur>;
using mixin_t = range_access::mixin_base_t<Cur>;
static_assert((bool)detail::cursor<Cur>, "");
using assoc_types_ = detail::iterator_associated_types_base<Cur>;
using typename assoc_types_::const_reference_t;
using typename assoc_types_::iter_reference_t;
constexpr Cur & pos() noexcept
{
return this->mixin_t::basic_mixin::get();
}
constexpr Cur const & pos() const noexcept
{
return this->mixin_t::basic_mixin::get();
}
public:
using typename assoc_types_::difference_type;
constexpr basic_iterator() = default;
template(typename OtherCur)(
requires (!same_as<OtherCur, Cur>) AND convertible_to<OtherCur, Cur> AND
constructible_from<mixin_t, OtherCur>)
constexpr basic_iterator(basic_iterator<OtherCur> that)
: base_t{std::move(that.pos())}
{}
// Mix in any additional constructors provided by the mixin
using base_t::base_t;
explicit basic_iterator(Cur && cur)
: base_t(static_cast<Cur &&>(cur))
{}
explicit basic_iterator(Cur const & cur)
: base_t(cur)
{}
template(typename OtherCur)(
requires (!same_as<OtherCur, Cur>) AND convertible_to<OtherCur, Cur>)
constexpr basic_iterator & operator=(basic_iterator<OtherCur> that)
{
pos() = std::move(that.pos());
return *this;
}
CPP_member
constexpr auto operator*() const
noexcept(noexcept(range_access::read(std::declval<Cur const &>())))
-> CPP_ret(const_reference_t)(
requires detail::readable_cursor<Cur> &&
(!detail::is_writable_cursor_v<Cur>))
{
return range_access::read(pos());
}
CPP_member
constexpr auto operator*() //
noexcept(noexcept(iter_reference_t{std::declval<Cur &>()})) //
-> CPP_ret(iter_reference_t)(
requires detail::has_cursor_next<Cur> &&
detail::is_writable_cursor_v<Cur>)
{
return iter_reference_t{pos()};
}
CPP_member
constexpr auto operator*() const
noexcept(noexcept(const_reference_t{std::declval<Cur const &>()}))
-> CPP_ret(const_reference_t)(
requires detail::has_cursor_next<Cur> &&
detail::is_writable_cursor_v<Cur const>)
{
return const_reference_t{pos()};
}
CPP_member
constexpr auto operator*() noexcept //
-> CPP_ret(basic_iterator &)(
requires (!detail::has_cursor_next<Cur>))
{
return *this;
}
// Use cursor's arrow() member, if any.
template(typename C = Cur)(
requires detail::has_cursor_arrow<C>)
constexpr detail::cursor_arrow_t<C> operator-> () const
noexcept(noexcept(range_access::arrow(std::declval<C const &>())))
{
return range_access::arrow(pos());
}
// Otherwise, if iter_reference_t is an lvalue reference to cv-qualified
// iter_value_t, return the address of **this.
template(typename C = Cur)(
requires (!detail::has_cursor_arrow<C>) AND detail::readable_cursor<C> AND
std::is_lvalue_reference<const_reference_t>::value AND
same_as<typename detail::iterator_associated_types_base<C>::value_type,
uncvref_t<const_reference_t>>)
constexpr std::add_pointer_t<const_reference_t> operator-> () const
noexcept(noexcept(*std::declval<basic_iterator const &>()))
{
return detail::addressof(**this);
}
CPP_member
constexpr auto operator++() //
-> CPP_ret(basic_iterator &)(
requires detail::has_cursor_next<Cur>)
{
range_access::next(pos());
return *this;
}
CPP_member
constexpr auto operator++() noexcept //
-> CPP_ret(basic_iterator &)(
requires (!detail::has_cursor_next<Cur>))
{
return *this;
}
private:
constexpr basic_iterator post_increment_(std::false_type, int)
{
basic_iterator tmp{*this};
++*this;
return tmp;
}
// Attempt to satisfy the C++17 iterator requirements by returning a
// proxy from postfix increment:
template(typename A = assoc_types_, typename V = typename A::value_type)(
requires constructible_from<V, typename A::reference> AND
move_constructible<V>)
constexpr auto post_increment_(std::true_type, int) //
-> detail::postfix_increment_proxy<V>
{
detail::postfix_increment_proxy<V> p{**this};
++*this;
return p;
}
constexpr void post_increment_(std::true_type, long)
{
++*this;
}
public:
CPP_member
constexpr auto operator++(int)
{
return this->post_increment_(meta::bool_ < detail::input_cursor<Cur> &&
!detail::forward_cursor<Cur>> {},
0);
}
CPP_member
constexpr auto operator--()
-> CPP_ret(basic_iterator &)(
requires detail::bidirectional_cursor<Cur>)
{
range_access::prev(pos());
return *this;
}
CPP_member
constexpr auto operator--(int) //
-> CPP_ret(basic_iterator)(
requires detail::bidirectional_cursor<Cur>)
{
basic_iterator tmp(*this);
--*this;
return tmp;
}
CPP_member
constexpr auto operator+=(difference_type n) //
-> CPP_ret(basic_iterator &)(
requires detail::random_access_cursor<Cur>)
{
range_access::advance(pos(), n);
return *this;
}
CPP_member
constexpr auto operator-=(difference_type n) //
-> CPP_ret(basic_iterator &)(
requires detail::random_access_cursor<Cur>)
{
range_access::advance(pos(), (difference_type)-n);
return *this;
}
CPP_member
constexpr auto operator[](difference_type n) const //
-> CPP_ret(const_reference_t)(
requires detail::random_access_cursor<Cur>)
{
return *(*this + n);
}
#if !RANGES_BROKEN_CPO_LOOKUP
// Optionally support hooking iter_move when the cursor sports a
// move() member function.
template<typename C = Cur>
friend constexpr auto iter_move(basic_iterator const & it) noexcept(
noexcept(range_access::move(std::declval<C const &>())))
-> CPP_broken_friend_ret(
decltype(range_access::move(std::declval<C const &>())))(
requires same_as<C, Cur> && detail::input_cursor<Cur>)
{
return range_access::move(it.pos());
}
#endif
};
template(typename Cur, typename Cur2)(
requires detail::sentinel_for_cursor<Cur2, Cur>)
constexpr bool operator==(basic_iterator<Cur> const & left,
basic_iterator<Cur2> const & right)
{
return range_access::equal(range_access::pos(left), range_access::pos(right));
}
template(typename Cur, typename Cur2)(
requires detail::sentinel_for_cursor<Cur2, Cur>)
constexpr bool operator!=(basic_iterator<Cur> const & left,
basic_iterator<Cur2> const & right)
{
return !(left == right);
}
template(typename Cur, typename S)(
requires detail::sentinel_for_cursor<S, Cur>)
constexpr bool operator==(basic_iterator<Cur> const & left,
S const & right)
{
return range_access::equal(range_access::pos(left), right);
}
template(typename Cur, typename S)(
requires detail::sentinel_for_cursor<S, Cur>)
constexpr bool operator!=(basic_iterator<Cur> const & left,
S const & right)
{
return !(left == right);
}
template(typename S, typename Cur)(
requires detail::sentinel_for_cursor<S, Cur>)
constexpr bool operator==(S const & left,
basic_iterator<Cur> const & right)
{
return right == left;
}
template(typename S, typename Cur)(
requires detail::sentinel_for_cursor<S, Cur>)
constexpr bool operator!=(S const & left,
basic_iterator<Cur> const & right)
{
return right != left;
}
template(typename Cur)(
requires detail::random_access_cursor<Cur>)
constexpr basic_iterator<Cur> //
operator+(basic_iterator<Cur> left, typename basic_iterator<Cur>::difference_type n)
{
left += n;
return left;
}
template(typename Cur)(
requires detail::random_access_cursor<Cur>)
constexpr basic_iterator<Cur> //
operator+(typename basic_iterator<Cur>::difference_type n, basic_iterator<Cur> right)
{
right += n;
return right;
}
template(typename Cur)(
requires detail::random_access_cursor<Cur>)
constexpr basic_iterator<Cur> //
operator-(basic_iterator<Cur> left, typename basic_iterator<Cur>::difference_type n)
{
left -= n;
return left;
}
template(typename Cur2, typename Cur)(
requires detail::sized_sentinel_for_cursor<Cur2, Cur>)
constexpr typename basic_iterator<Cur>::difference_type //
operator-(basic_iterator<Cur2> const & left, basic_iterator<Cur> const & right)
{
return range_access::distance_to(range_access::pos(right),
range_access::pos(left));
}
template(typename S, typename Cur)(
requires detail::sized_sentinel_for_cursor<S, Cur>)
constexpr typename basic_iterator<Cur>::difference_type //
operator-(S const & left, basic_iterator<Cur> const & right)
{
return range_access::distance_to(range_access::pos(right), left);
}
template(typename Cur, typename S)(
requires detail::sized_sentinel_for_cursor<S, Cur>)
constexpr typename basic_iterator<Cur>::difference_type //
operator-(basic_iterator<Cur> const & left, S const & right)
{
return -(right - left);
}
// Asymmetric comparisons
template(typename Left, typename Right)(
requires detail::sized_sentinel_for_cursor<Right, Left>)
constexpr bool operator<(basic_iterator<Left> const & left,
basic_iterator<Right> const & right)
{
return 0 < (right - left);
}
template(typename Left, typename Right)(
requires detail::sized_sentinel_for_cursor<Right, Left>)
constexpr bool operator<=(basic_iterator<Left> const & left,
basic_iterator<Right> const & right)
{
return 0 <= (right - left);
}
template(typename Left, typename Right)(
requires detail::sized_sentinel_for_cursor<Right, Left>)
constexpr bool operator>(basic_iterator<Left> const & left,
basic_iterator<Right> const & right)
{
return (right - left) < 0;
}
template(typename Left, typename Right)(
requires detail::sized_sentinel_for_cursor<Right, Left>)
constexpr bool operator>=(basic_iterator<Left> const & left,
basic_iterator<Right> const & right)
{
return (right - left) <= 0;
}
#if RANGES_BROKEN_CPO_LOOKUP
namespace _basic_iterator_
{
// Optionally support hooking iter_move when the cursor sports a
// move() member function.
template<typename Cur>
constexpr auto iter_move(basic_iterator<Cur> const & it) noexcept(
noexcept(range_access::move(std::declval<Cur const &>())))
-> CPP_broken_friend_ret(
decltype(range_access::move(std::declval<Cur const &>())))(
requires detail::input_cursor<Cur>)
{
return range_access::move(range_access::pos(it));
}
} // namespace _basic_iterator_
#endif
/// Get a cursor from a basic_iterator
struct get_cursor_fn
{
template<typename Cur>
constexpr Cur & operator()(basic_iterator<Cur> & it) const noexcept
{
return range_access::pos(it);
}
template<typename Cur>
constexpr Cur const & operator()(basic_iterator<Cur> const & it) const noexcept
{
return range_access::pos(it);
}
template<typename Cur>
constexpr Cur operator()(basic_iterator<Cur> && it) const
noexcept(std::is_nothrow_move_constructible<Cur>::value)
{
return range_access::pos(std::move(it));
}
};
/// \sa `get_cursor_fn`
RANGES_INLINE_VARIABLE(get_cursor_fn, get_cursor)
/// @}
} // namespace ranges
/// \cond
namespace concepts
{
// common_reference specializations for basic_proxy_reference
template<typename Cur, typename U, template<typename> class TQual,
template<typename> class UQual>
struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur, true>, U,
TQual, UQual>
: basic_common_reference<::ranges::detail::cursor_reference_t<Cur>, U, TQual, UQual>
{};
template<typename T, typename Cur, template<typename> class TQual,
template<typename> class UQual>
struct basic_common_reference<T, ::ranges::detail::basic_proxy_reference_<Cur, true>,
TQual, UQual>
: basic_common_reference<T, ::ranges::detail::cursor_reference_t<Cur>, TQual, UQual>
{};
template<typename Cur1, typename Cur2, template<typename> class TQual,
template<typename> class UQual>
struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur1, true>,
::ranges::detail::basic_proxy_reference_<Cur2, true>,
TQual, UQual>
: basic_common_reference<::ranges::detail::cursor_reference_t<Cur1>,
::ranges::detail::cursor_reference_t<Cur2>, TQual, UQual>
{};
// common_type specializations for basic_proxy_reference
template<typename Cur, typename U>
struct common_type<::ranges::detail::basic_proxy_reference_<Cur, true>, U>
: common_type<::ranges::range_access::cursor_value_t<Cur>, U>
{};
template<typename T, typename Cur>
struct common_type<T, ::ranges::detail::basic_proxy_reference_<Cur, true>>
: common_type<T, ::ranges::range_access::cursor_value_t<Cur>>
{};
template<typename Cur1, typename Cur2>
struct common_type<::ranges::detail::basic_proxy_reference_<Cur1, true>,
::ranges::detail::basic_proxy_reference_<Cur2, true>>
: common_type<::ranges::range_access::cursor_value_t<Cur1>,
::ranges::range_access::cursor_value_t<Cur2>>
{};
} // namespace concepts
#if RANGES_CXX_VER > RANGES_CXX_STD_17
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
RANGES_BEGIN_NAMESPACE_STD
RANGES_BEGIN_NAMESPACE_VERSION
template<typename, typename, template <typename> class, template<typename> class>
struct basic_common_reference;
// common_reference specializations for basic_proxy_reference
template<typename Cur, typename U, template<typename> class TQual,
template<typename> class UQual>
struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur, true>, U,
TQual, UQual>
: basic_common_reference<::ranges::detail::cursor_reference_t<Cur>, U, TQual, UQual>
{};
template<typename T, typename Cur, template<typename> class TQual,
template<typename> class UQual>
struct basic_common_reference<T, ::ranges::detail::basic_proxy_reference_<Cur, true>,
TQual, UQual>
: basic_common_reference<T, ::ranges::detail::cursor_reference_t<Cur>, TQual, UQual>
{};
template<typename Cur1, typename Cur2, template<typename> class TQual,
template<typename> class UQual>
struct basic_common_reference<::ranges::detail::basic_proxy_reference_<Cur1, true>,
::ranges::detail::basic_proxy_reference_<Cur2, true>,
TQual, UQual>
: basic_common_reference<::ranges::detail::cursor_reference_t<Cur1>,
::ranges::detail::cursor_reference_t<Cur2>, TQual, UQual>
{};
template<typename...>
struct common_type;
// common_type specializations for basic_proxy_reference
template<typename Cur, typename U>
struct common_type<::ranges::detail::basic_proxy_reference_<Cur, true>, U>
: common_type<::ranges::range_access::cursor_value_t<Cur>, U>
{};
template<typename T, typename Cur>
struct common_type<T, ::ranges::detail::basic_proxy_reference_<Cur, true>>
: common_type<T, ::ranges::range_access::cursor_value_t<Cur>>
{};
template<typename Cur1, typename Cur2>
struct common_type<::ranges::detail::basic_proxy_reference_<Cur1, true>,
::ranges::detail::basic_proxy_reference_<Cur2, true>>
: common_type<::ranges::range_access::cursor_value_t<Cur1>,
::ranges::range_access::cursor_value_t<Cur2>>
{};
RANGES_END_NAMESPACE_VERSION
RANGES_END_NAMESPACE_STD
RANGES_DIAGNOSTIC_POP
#endif // RANGES_CXX_VER > RANGES_CXX_STD_17
namespace ranges
{
/// \cond
namespace detail
{
template<typename Cur, bool IsReadable>
struct std_iterator_traits_
{
using difference_type =
typename iterator_associated_types_base<Cur>::difference_type;
using value_type = void;
using reference = void;
using pointer = void;
using iterator_category = std::output_iterator_tag;
using iterator_concept = std::output_iterator_tag;
};
template<typename Cur>
struct std_iterator_traits_<Cur, true> : iterator_associated_types_base<Cur>
{};
template<typename Cur>
using std_iterator_traits = std_iterator_traits_<Cur, (bool)readable_cursor<Cur>>;
} // namespace detail
/// \endcond
} // namespace ranges
namespace std
{
template<typename Cur>
struct iterator_traits<::ranges::basic_iterator<Cur>>
: ::ranges::detail::std_iterator_traits<Cur>
{};
} // namespace std
/// \endcond
RANGES_DIAGNOSTIC_POP
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/insert_iterators.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_INSERT_ITERATORS_HPP
#define RANGES_V3_ITERATOR_INSERT_ITERATORS_HPP
#include <cstddef>
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/utility/addressof.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-iterator
/// @{
template<typename Container>
struct back_insert_iterator
{
using container_type = Container;
using difference_type = std::ptrdiff_t;
constexpr back_insert_iterator() = default;
constexpr explicit back_insert_iterator(Container & x)
: container_(detail::addressof(x))
{}
back_insert_iterator & operator=(typename Container::value_type const & value)
{
container_->push_back(value);
return *this;
}
back_insert_iterator & operator=(typename Container::value_type && value)
{
container_->push_back(std::move(value));
return *this;
}
back_insert_iterator & operator*()
{
return *this;
}
back_insert_iterator & operator++()
{
return *this;
}
back_insert_iterator operator++(int)
{
return *this;
}
private:
Container * container_ = nullptr;
};
struct back_inserter_fn
{
template<typename Container>
constexpr back_insert_iterator<Container> operator()(Container & x) const
{
return back_insert_iterator<Container>{x};
}
};
/// \sa `back_inserter_fn`
RANGES_INLINE_VARIABLE(back_inserter_fn, back_inserter)
template<typename Container>
struct front_insert_iterator
{
using container_type = Container;
using difference_type = std::ptrdiff_t;
constexpr front_insert_iterator() = default;
constexpr explicit front_insert_iterator(Container & x)
: container_(detail::addressof(x))
{}
front_insert_iterator & operator=(typename Container::value_type const & value)
{
container_->push_front(value);
return *this;
}
front_insert_iterator & operator=(typename Container::value_type && value)
{
container_->push_front(std::move(value));
return *this;
}
front_insert_iterator & operator*()
{
return *this;
}
front_insert_iterator & operator++()
{
return *this;
}
front_insert_iterator operator++(int)
{
return *this;
}
private:
Container * container_ = nullptr;
};
struct front_inserter_fn
{
template<typename Cont>
constexpr front_insert_iterator<Cont> operator()(Cont & cont) const
{
return front_insert_iterator<Cont>{cont};
}
};
/// \sa `front_inserter_fn`
RANGES_INLINE_VARIABLE(front_inserter_fn, front_inserter)
template<typename Container>
struct insert_iterator
{
using container_type = Container;
using difference_type = std::ptrdiff_t;
constexpr insert_iterator() = default;
constexpr explicit insert_iterator(Container & x, typename Container::iterator w)
: container_(detail::addressof(x))
, where_(w)
{}
insert_iterator & operator=(typename Container::value_type const & value)
{
where_ = ranges::next(container_->insert(where_, value));
return *this;
}
insert_iterator & operator=(typename Container::value_type && value)
{
where_ = ranges::next(container_->insert(where_, std::move(value)));
return *this;
}
insert_iterator & operator*()
{
return *this;
}
insert_iterator & operator++()
{
return *this;
}
insert_iterator & operator++(int)
{
return *this;
}
private:
Container * container_ = nullptr;
typename Container::iterator where_ = typename Container::iterator();
};
struct inserter_fn
{
template<typename Cont>
constexpr insert_iterator<Cont> operator()(Cont & cont,
typename Cont::iterator where) const
{
return insert_iterator<Cont>{cont, std::move(where)};
}
};
/// \sa `inserter_fn`
RANGES_INLINE_VARIABLE(inserter_fn, inserter)
namespace cpp20
{
using ranges::back_insert_iterator;
using ranges::back_inserter;
using ranges::front_insert_iterator;
using ranges::front_inserter;
using ranges::insert_iterator;
using ranges::inserter;
} // namespace cpp20
/// @}
} // namespace ranges
/// \cond
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
namespace std
{
template<typename Container>
struct iterator_traits<::ranges::back_insert_iterator<Container>>
: ::ranges::detail::std_output_iterator_traits<>
{};
template<typename Container>
struct iterator_traits<::ranges::front_insert_iterator<Container>>
: ::ranges::detail::std_output_iterator_traits<>
{};
template<typename Container>
struct iterator_traits<::ranges::insert_iterator<Container>>
: ::ranges::detail::std_output_iterator_traits<>
{};
} // namespace std
RANGES_DIAGNOSTIC_POP
/// \endcond
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_ITERATOR_INSERT_ITERATORS_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/counted_iterator.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_COUNTED_ITERATOR_HPP
#define RANGES_V3_ITERATOR_COUNTED_ITERATOR_HPP
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-iterator
/// @{
/// \cond
namespace _counted_iterator_
{
struct access
{
template<typename I>
static constexpr iter_difference_t<counted_iterator<I>> & count(
counted_iterator<I> & ci) noexcept
{
return ci.cnt_;
}
template<typename I>
static constexpr I & current(counted_iterator<I> & ci) noexcept
{
return ci.current_;
}
template<typename I>
static constexpr I const & current(counted_iterator<I> const & ci) noexcept
{
return ci.current_;
}
};
template<bool>
struct contiguous_iterator_concept_base
{};
template<>
struct contiguous_iterator_concept_base<true>
{
using iterator_concept = ranges::contiguous_iterator_tag;
};
} // namespace _counted_iterator_
/// \endcond
template<typename I>
// requires input_or_output_iterator<I>
struct counted_iterator
: _counted_iterator_::contiguous_iterator_concept_base<(bool)contiguous_iterator<I>>
{
private:
friend advance_fn;
CPP_assert(input_or_output_iterator<I>);
friend _counted_iterator_::access;
I current_{};
iter_difference_t<I> cnt_{0};
constexpr void post_increment_(std::true_type)
{
CPP_assert(std::is_void<decltype(current_++)>());
++current_;
--cnt_;
}
constexpr auto post_increment_(std::false_type) -> decltype(current_++)
{
CPP_assert(!std::is_void<decltype(current_++)>());
auto && tmp = current_++;
--cnt_;
return static_cast<decltype(tmp) &&>(tmp);
}
public:
using iterator_type = I;
using difference_type = iter_difference_t<I>;
counted_iterator() = default;
constexpr counted_iterator(I x, iter_difference_t<I> n)
: current_(std::move(x))
, cnt_(n)
{
RANGES_EXPECT(n >= 0);
}
template(typename I2)(
requires convertible_to<I2, I>)
constexpr counted_iterator(counted_iterator<I2> const & i)
: current_(_counted_iterator_::access::current(i))
, cnt_(i.count())
{}
template(typename I2)(
requires convertible_to<I2, I>)
constexpr counted_iterator & operator=(counted_iterator<I2> const & i)
{
current_ = _counted_iterator_::access::current(i);
cnt_ = i.count();
}
constexpr I base() const
{
return current_;
}
constexpr iter_difference_t<I> count() const
{
return cnt_;
}
constexpr iter_reference_t<I> operator*() noexcept(
noexcept(iter_reference_t<I>(*current_)))
{
RANGES_EXPECT(cnt_ > 0);
return *current_;
}
template(typename I2 = I)(
requires indirectly_readable<I2 const>)
constexpr iter_reference_t<I2> operator*() const //
noexcept(noexcept(iter_reference_t<I>(*current_)))
{
RANGES_EXPECT(cnt_ > 0);
return *current_;
}
constexpr counted_iterator & operator++()
{
RANGES_EXPECT(cnt_ > 0);
++current_;
--cnt_;
return *this;
}
#ifdef RANGES_WORKAROUND_MSVC_677925
template(typename I2 = I)(
requires (!forward_iterator<I2>)) //
constexpr auto operator++(int) -> decltype(std::declval<I2 &>()++)
#else // ^^^ workaround ^^^ / vvv no workaround vvv
CPP_member
constexpr auto operator++(int) //
-> CPP_ret(decltype(std::declval<I &>()++))(
requires (!forward_iterator<I>))
#endif // RANGES_WORKAROUND_MSVC_677925
{
RANGES_EXPECT(cnt_ > 0);
return post_increment_(std::is_void<decltype(current_++)>());
}
CPP_member
constexpr auto operator++(int) //
-> CPP_ret(counted_iterator)(
requires forward_iterator<I>)
{
auto tmp(*this);
++*this;
return tmp;
}
CPP_member
constexpr auto operator--() //
-> CPP_ret(counted_iterator &)(
requires bidirectional_iterator<I>)
{
--current_;
++cnt_;
return *this;
}
CPP_member
constexpr auto operator--(int) //
-> CPP_ret(counted_iterator)(
requires bidirectional_iterator<I>)
{
auto tmp(*this);
--*this;
return tmp;
}
CPP_member
constexpr auto operator+=(difference_type n) //
-> CPP_ret(counted_iterator &)(
requires random_access_iterator<I>)
{
RANGES_EXPECT(cnt_ >= n);
current_ += n;
cnt_ -= n;
return *this;
}
CPP_member
constexpr auto operator+(difference_type n) const //
-> CPP_ret(counted_iterator)(
requires random_access_iterator<I>)
{
auto tmp(*this);
tmp += n;
return tmp;
}
CPP_member
constexpr auto operator-=(difference_type n) //
-> CPP_ret(counted_iterator &)(
requires random_access_iterator<I>)
{
RANGES_EXPECT(cnt_ >= -n);
current_ -= n;
cnt_ += n;
return *this;
}
CPP_member
constexpr auto operator-(difference_type n) const //
-> CPP_ret(counted_iterator)(
requires random_access_iterator<I>)
{
auto tmp(*this);
tmp -= n;
return tmp;
}
CPP_member
constexpr auto operator[](difference_type n) const //
-> CPP_ret(iter_reference_t<I>)(
requires random_access_iterator<I>)
{
RANGES_EXPECT(cnt_ >= n);
return current_[n];
}
#if !RANGES_BROKEN_CPO_LOOKUP
CPP_broken_friend_member
friend constexpr auto iter_move(counted_iterator const & i) //
noexcept(detail::has_nothrow_iter_move_v<I>)
-> CPP_broken_friend_ret(iter_rvalue_reference_t<I>)(
requires input_iterator<I>)
{
return ranges::iter_move(i.current_);
}
template<typename I2, typename S2>
friend constexpr auto iter_swap(counted_iterator const & x,
counted_iterator<I2> const & y) //
noexcept(is_nothrow_indirectly_swappable<I, I2>::value)
-> CPP_broken_friend_ret(void)(
requires indirectly_swappable<I2, I>)
{
return ranges::iter_swap(x.current_, _counted_iterator_::access::current(y));
}
#endif
};
/// \cond
#if RANGES_BROKEN_CPO_LOOKUP
namespace _counted_iterator_
{
template<typename I>
constexpr auto iter_move(counted_iterator<I> const & i) noexcept(
detail::has_nothrow_iter_move_v<I>)
-> CPP_broken_friend_ret(iter_rvalue_reference_t<I>)(
requires input_iterator<I>)
{
return ranges::iter_move(_counted_iterator_::access::current(i));
}
template<typename I1, typename I2>
constexpr auto iter_swap(
counted_iterator<I1> const & x,
counted_iterator<I2> const &
y) noexcept(is_nothrow_indirectly_swappable<I1, I2>::value)
-> CPP_broken_friend_ret(void)(
requires indirectly_swappable<I2, I1>)
{
return ranges::iter_swap(_counted_iterator_::access::current(x),
_counted_iterator_::access::current(y));
}
} // namespace _counted_iterator_
#endif
/// endcond
template(typename I1, typename I2)(
requires common_with<I1, I2>)
constexpr bool operator==(counted_iterator<I1> const & x,
counted_iterator<I2> const & y)
{
return x.count() == y.count();
}
template<typename I>
constexpr bool operator==(counted_iterator<I> const & x, default_sentinel_t)
{
return x.count() == 0;
}
template<typename I>
constexpr bool operator==(default_sentinel_t, counted_iterator<I> const & x)
{
return x.count() == 0;
}
template(typename I1, typename I2)(
requires common_with<I1, I2>)
constexpr bool operator!=(counted_iterator<I1> const & x,
counted_iterator<I2> const & y)
{
return !(x == y);
}
template<typename I>
constexpr bool operator!=(counted_iterator<I> const & x, default_sentinel_t y)
{
return !(x == y);
}
template<typename I>
constexpr bool operator!=(default_sentinel_t x, counted_iterator<I> const & y)
{
return !(x == y);
}
template(typename I1, typename I2)(
requires common_with<I1, I2>)
constexpr bool operator<(counted_iterator<I1> const & x,
counted_iterator<I2> const & y)
{
return y.count() < x.count();
}
template(typename I1, typename I2)(
requires common_with<I1, I2>)
constexpr bool operator<=(counted_iterator<I1> const & x,
counted_iterator<I2> const & y)
{
return !(y < x);
}
template(typename I1, typename I2)(
requires common_with<I1, I2>)
constexpr bool operator>(counted_iterator<I1> const & x,
counted_iterator<I2> const & y)
{
return y < x;
}
template(typename I1, typename I2)(
requires common_with<I1, I2>)
constexpr bool operator>=(counted_iterator<I1> const & x,
counted_iterator<I2> const & y)
{
return !(x < y);
}
template(typename I1, typename I2)(
requires common_with<I1, I2>)
constexpr iter_difference_t<I2> operator-(counted_iterator<I1> const & x,
counted_iterator<I2> const & y)
{
return y.count() - x.count();
}
template<typename I>
constexpr iter_difference_t<I> operator-(counted_iterator<I> const & x,
default_sentinel_t)
{
return -x.count();
}
template<typename I>
constexpr iter_difference_t<I> operator-(default_sentinel_t,
counted_iterator<I> const & y)
{
return y.count();
}
template(typename I)(
requires random_access_iterator<I>)
constexpr counted_iterator<I> operator+(iter_difference_t<I> n,
counted_iterator<I> const & x)
{
return x + n;
}
template(typename I)(
requires input_or_output_iterator<I>)
constexpr counted_iterator<I> make_counted_iterator(I i, iter_difference_t<I> n)
{
return {std::move(i), n};
}
template<typename I>
struct indirectly_readable_traits<counted_iterator<I>>
: meta::conditional_t<
(bool)indirectly_readable<I>,
indirectly_readable_traits<I>,
meta::nil_>
{};
CPP_template_def(typename I)(
requires input_or_output_iterator<I>)
constexpr void advance_fn::operator()(counted_iterator<I> & i,
iter_difference_t<I> n) const
{
RANGES_EXPECT(n <= i.cnt_);
advance(i.current_, n);
i.cnt_ -= n;
}
namespace cpp20
{
using ranges::counted_iterator;
}
/// @}
} // namespace ranges
/// \cond
namespace ranges
{
namespace _counted_iterator_
{
template<typename I, typename = void>
struct iterator_traits_
{
using difference_type = iter_difference_t<I>;
using value_type = void;
using reference = void;
using pointer = void;
using iterator_category = std::output_iterator_tag;
};
template<typename I>
struct iterator_traits_<I, meta::if_c<input_iterator<I>>>
: std::iterator_traits<I>
{
using pointer = void;
};
} // namespace _counted_iterator_
} // namespace ranges
namespace std
{
template<typename I>
struct iterator_traits<::ranges::counted_iterator<I>>
: ::ranges::_counted_iterator_::iterator_traits_<I>
{};
} // namespace std
/// \endcond
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/diffmax_t.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2019-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_DIFFMAX_T_HPP
#define RANGES_V3_ITERATOR_DIFFMAX_T_HPP
#include <cstdint>
#include <iosfwd>
#include <limits>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/detail/prologue.hpp>
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_UNSIGNED_MATH
namespace ranges
{
/// \cond
namespace detail
{
struct diffmax_t
{
private:
bool neg_;
std::uintmax_t val_;
struct tag
{};
constexpr diffmax_t(tag, bool neg, std::uintmax_t val)
: neg_(val && neg)
, val_(val)
{}
/// \cond
constexpr void _check()
{
RANGES_ENSURE(!neg_ || val_);
}
static constexpr diffmax_t _normalize(bool neg, std::uintmax_t val)
{
return diffmax_t{tag{}, val && neg, val};
}
/// \endcond
public:
diffmax_t() = default;
template(typename T)(
requires integral<T>)
constexpr diffmax_t(T val) noexcept
: neg_(0 > val)
, val_(0 > val ? static_cast<std::uintmax_t>(-val)
: static_cast<std::uintmax_t>(val))
{}
friend constexpr bool operator<(diffmax_t a, diffmax_t b) noexcept
{
a._check();
b._check();
return a.neg_ ? (b.neg_ ? a.val_ > b.val_ : true)
: (b.neg_ ? false : a.val_ < b.val_);
}
friend constexpr bool operator>(diffmax_t a, diffmax_t b) noexcept
{
return b < a;
}
friend constexpr bool operator<=(diffmax_t a, diffmax_t b) noexcept
{
return !(b < a);
}
friend constexpr bool operator>=(diffmax_t a, diffmax_t b) noexcept
{
return !(a < b);
}
friend constexpr bool operator==(diffmax_t a, diffmax_t b) noexcept
{
a._check();
b._check();
return a.val_ == b.val_ && a.neg_ == b.neg_;
}
friend constexpr bool operator!=(diffmax_t a, diffmax_t b) noexcept
{
return !(a == b);
}
friend constexpr diffmax_t operator+(diffmax_t a) noexcept
{
return a;
}
friend constexpr diffmax_t operator-(diffmax_t a) noexcept
{
return _normalize(!a.neg_, a.val_);
}
friend constexpr diffmax_t operator+(diffmax_t a, diffmax_t b) noexcept
{
return a.neg_ == b.neg_
? diffmax_t{tag{}, a.neg_, a.val_ + b.val_}
: (a.neg_ ? (a.val_ > b.val_
? diffmax_t{tag{}, true, a.val_ - b.val_}
: diffmax_t{tag{}, false, b.val_ - a.val_})
: (b.val_ > a.val_
? diffmax_t{tag{}, true, b.val_ - a.val_}
: diffmax_t{tag{}, false, a.val_ - b.val_}));
}
friend constexpr diffmax_t operator-(diffmax_t a, diffmax_t b) noexcept
{
return a + -b;
}
friend constexpr diffmax_t operator*(diffmax_t a, diffmax_t b) noexcept
{
return _normalize(a.neg_ ^ b.neg_, a.val_ * b.val_);
}
friend constexpr diffmax_t operator/(diffmax_t a, diffmax_t b) noexcept
{
return _normalize(a.neg_ ^ b.neg_, a.val_ / b.val_);
}
friend constexpr diffmax_t operator%(diffmax_t a, diffmax_t b) noexcept
{
return _normalize(a.neg_, a.val_ % b.val_);
}
static constexpr std::uintmax_t compl_if(bool neg,
std::uintmax_t val) noexcept
{
return neg ? ~val + 1 : val;
}
friend constexpr diffmax_t operator&(diffmax_t a, diffmax_t b) noexcept
{
return _normalize(
a.neg_ && b.neg_,
compl_if(a.neg_ && b.neg_,
compl_if(a.neg_, a.val_) & compl_if(b.neg_, b.val_)));
}
friend constexpr diffmax_t operator|(diffmax_t a, diffmax_t b) noexcept
{
return _normalize(
a.neg_ || b.neg_,
compl_if(a.neg_ || b.neg_,
compl_if(a.neg_, a.val_) | compl_if(b.neg_, b.val_)));
}
friend constexpr diffmax_t operator^(diffmax_t a, diffmax_t b) noexcept
{
return _normalize(
bool(a.neg_ ^ b.neg_),
compl_if(bool(a.neg_ ^ b.neg_),
compl_if(a.neg_, a.val_) ^ compl_if(b.neg_, b.val_)));
}
friend constexpr diffmax_t operator<<(diffmax_t a, diffmax_t b) noexcept
{
RANGES_ENSURE(!a.neg_);
return b.neg_ ? diffmax_t{tag{}, false, a.val_ >> b.val_}
: diffmax_t{tag{}, false, a.val_ << b.val_};
}
friend constexpr diffmax_t operator>>(diffmax_t a, diffmax_t b) noexcept
{
return b.neg_ ? diffmax_t{tag{}, a.neg_, a.val_ << b.val_}
: diffmax_t{tag{}, a.neg_, a.val_ >> b.val_};
}
friend constexpr diffmax_t & operator+=(diffmax_t & a, diffmax_t b) noexcept
{
return (a = a + b);
}
friend constexpr diffmax_t & operator-=(diffmax_t & a, diffmax_t b) noexcept
{
return (a = a - b);
}
friend constexpr diffmax_t & operator*=(diffmax_t & a, diffmax_t b) noexcept
{
return (a = a * b);
}
friend constexpr diffmax_t & operator/=(diffmax_t & a, diffmax_t b) noexcept
{
return (a = a / b);
}
friend constexpr diffmax_t & operator%=(diffmax_t & a, diffmax_t b) noexcept
{
return (a = a % b);
}
friend constexpr diffmax_t & operator&=(diffmax_t & a, diffmax_t b) noexcept
{
return (a = a & b);
}
friend constexpr diffmax_t & operator|=(diffmax_t & a, diffmax_t b) noexcept
{
return (a = a | b);
}
friend constexpr diffmax_t & operator^=(diffmax_t & a, diffmax_t b) noexcept
{
return (a = a ^ b);
}
friend constexpr diffmax_t & operator<<=(diffmax_t & a, diffmax_t b) noexcept
{
a = (a << b);
return a;
}
friend constexpr diffmax_t & operator>>=(diffmax_t & a, diffmax_t b) noexcept
{
a = (a >> b);
return a;
}
template<typename T>
friend constexpr auto operator+=(T & a, diffmax_t b) noexcept
-> CPP_broken_friend_ret(T &)(
requires integral<T>)
{
return (a = static_cast<T>(diffmax_t{a} + b));
}
template<typename T>
friend constexpr auto operator-=(T & a, diffmax_t b) noexcept
-> CPP_broken_friend_ret(T &)(
requires integral<T>)
{
return (a = static_cast<T>(diffmax_t{a} - b));
}
template<typename T>
friend constexpr auto operator*=(T & a, diffmax_t b) noexcept
-> CPP_broken_friend_ret(T &)(
requires integral<T>)
{
return (a = static_cast<T>(diffmax_t{a} * b));
}
template<typename T>
friend constexpr auto operator/=(T & a, diffmax_t b) noexcept
-> CPP_broken_friend_ret(T &)(
requires integral<T>)
{
return (a = static_cast<T>(diffmax_t{a} / b));
}
template<typename T>
friend constexpr auto operator%=(T & a, diffmax_t b) noexcept
-> CPP_broken_friend_ret(T &)(
requires integral<T>)
{
return (a = static_cast<T>(diffmax_t{a} % b));
}
template<typename T>
friend constexpr auto operator&=(T & a, diffmax_t b) noexcept
-> CPP_broken_friend_ret(T &)(
requires integral<T>)
{
return (a = static_cast<T>(diffmax_t{a} & b));
}
template<typename T>
friend constexpr auto operator|=(T & a, diffmax_t b) noexcept
-> CPP_broken_friend_ret(T &)(
requires integral<T>)
{
return (a = static_cast<T>(diffmax_t{a} | b));
}
template<typename T>
friend constexpr auto operator^=(T & a, diffmax_t b) noexcept
-> CPP_broken_friend_ret(T &)(
requires integral<T>)
{
return (a = static_cast<T>(diffmax_t{a} ^ b));
}
template<typename T>
friend constexpr auto operator<<=(T & a, diffmax_t b) noexcept
-> CPP_broken_friend_ret(T &)(
requires integral<T>)
{
a = static_cast<T>(diffmax_t{a} << b);
return a;
}
template<typename T>
friend constexpr auto operator>>=(T & a, diffmax_t b) noexcept
-> CPP_broken_friend_ret(T &)(
requires integral<T>)
{
a = static_cast<T>(diffmax_t{a} >> b);
return a;
}
friend constexpr diffmax_t & operator++(diffmax_t & a) noexcept
{
a.neg_ = (a.neg_ ? --a.val_ : ++a.val_) && a.neg_;
return a;
}
friend constexpr diffmax_t & operator--(diffmax_t & a) noexcept
{
a.neg_ = (a.neg_ ? ++a.val_ : --a.val_) && a.neg_;
return a;
}
friend constexpr diffmax_t operator++(diffmax_t & a, int) noexcept
{
auto tmp = a;
++a;
return tmp;
}
friend constexpr diffmax_t operator--(diffmax_t & a, int) noexcept
{
auto tmp = a;
--a;
return tmp;
}
template(typename T)(
requires integral<T>)
constexpr explicit
operator T() const noexcept
{
return neg_ ? -static_cast<T>(val_) : static_cast<T>(val_);
}
constexpr explicit operator bool() const noexcept
{
return val_ != 0;
}
constexpr bool operator!() const noexcept
{
return val_ == 0;
}
template<typename Ostream>
friend auto operator<<(Ostream & sout, diffmax_t a)
-> CPP_broken_friend_ret(std::ostream &)(
requires derived_from<
Ostream, std::basic_ostream<typename Ostream::char_type,
typename Ostream::traits_type>>)
{
return sout << (&"-"[!a.neg_]) << a.val_;
}
};
#if RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17
template<>
inline constexpr bool _is_integer_like_<diffmax_t> = true;
#else
template<typename Enable>
constexpr bool _is_integer_like_<diffmax_t, Enable> = true;
#endif
} // namespace detail
/// \endcond
} // namespace ranges
/// \cond
RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
namespace std
{
template<>
struct numeric_limits<::ranges::detail::diffmax_t>
{
static constexpr bool is_specialized = true;
static constexpr bool is_signed = true;
static constexpr bool is_integer = true;
static constexpr bool is_exact = true;
static constexpr bool has_infinity = false;
static constexpr bool has_quiet_NaN = false;
static constexpr bool has_signaling_NaN = false;
static constexpr bool has_denorm = false;
static constexpr bool has_denorm_loss = false;
static constexpr std::float_round_style round_style = std::round_toward_zero;
static constexpr bool is_iec559 = false;
static constexpr bool is_bounded = true;
static constexpr bool is_modulo = false;
static constexpr int digits = CHAR_BIT * sizeof(std::uintmax_t) + 1;
static constexpr int digits10 =
static_cast<int>(digits * 0.301029996); // digits * std::log10(2)
static constexpr int max_digits10 = 0;
static constexpr int radix = 2;
static constexpr int min_exponent = 0;
static constexpr int min_exponent10 = 0;
static constexpr int max_exponent = 0;
static constexpr int max_exponent10 = 0;
static constexpr bool traps = true;
static constexpr bool tinyness_before = false;
static constexpr ::ranges::detail::diffmax_t max() noexcept
{
return std::uintmax_t(-1);
}
static constexpr ::ranges::detail::diffmax_t min() noexcept
{
return -max();
}
static constexpr ::ranges::detail::diffmax_t lowest() noexcept
{
return min();
}
static constexpr ::ranges::detail::diffmax_t epsilon() noexcept
{
return 0;
}
static constexpr ::ranges::detail::diffmax_t round_error() noexcept
{
return 0;
}
static constexpr ::ranges::detail::diffmax_t infinity() noexcept
{
return 0;
}
static constexpr ::ranges::detail::diffmax_t quiet_NaN() noexcept
{
return 0;
}
static constexpr ::ranges::detail::diffmax_t signaling_NaN() noexcept
{
return 0;
}
static constexpr ::ranges::detail::diffmax_t denorm_min() noexcept
{
return 0;
}
};
template<>
struct numeric_limits<::ranges::detail::diffmax_t const>
: numeric_limits<::ranges::detail::diffmax_t>
{};
template<>
struct numeric_limits<::ranges::detail::diffmax_t volatile>
: numeric_limits<::ranges::detail::diffmax_t>
{};
template<>
struct numeric_limits<::ranges::detail::diffmax_t const volatile>
: numeric_limits<::ranges::detail::diffmax_t>
{};
#if RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_specialized;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_signed;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_integer;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_exact;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::has_infinity;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::has_quiet_NaN;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::has_signaling_NaN;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::has_denorm;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::has_denorm_loss;
inline constexpr std::float_round_style
numeric_limits<::ranges::detail::diffmax_t>::round_style;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_iec559;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_bounded;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::is_modulo;
inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::digits;
inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::digits10;
inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::max_digits10;
inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::radix;
inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::min_exponent;
inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::min_exponent10;
inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::max_exponent;
inline constexpr int numeric_limits<::ranges::detail::diffmax_t>::max_exponent10;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::traps;
inline constexpr bool numeric_limits<::ranges::detail::diffmax_t>::tinyness_before;
#endif
} // namespace std
/// \endcond
RANGES_DIAGNOSTIC_POP
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/unreachable_sentinel.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_UNREACHABLE_SENTINEL_HPP
#define RANGES_V3_ITERATOR_UNREACHABLE_SENTINEL_HPP
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-iterator
/// @{
struct unreachable_sentinel_t
{
template<typename I>
friend constexpr auto operator==(I const &, unreachable_sentinel_t) noexcept
-> CPP_broken_friend_ret(bool)(
requires weakly_incrementable<I>)
{
return false;
}
template<typename I>
friend constexpr auto operator==(unreachable_sentinel_t, I const &) noexcept
-> CPP_broken_friend_ret(bool)(
requires weakly_incrementable<I>)
{
return false;
}
template<typename I>
friend constexpr auto operator!=(I const &, unreachable_sentinel_t) noexcept
-> CPP_broken_friend_ret(bool)(
requires weakly_incrementable<I>)
{
return true;
}
template<typename I>
friend constexpr auto operator!=(unreachable_sentinel_t, I const &) noexcept
-> CPP_broken_friend_ret(bool)(
requires weakly_incrementable<I>)
{
return true;
}
};
RANGES_INLINE_VARIABLE(unreachable_sentinel_t, unreachable)
namespace cpp20
{
using ranges::unreachable;
using ranges::unreachable_sentinel_t;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_ITERATOR_UNREACHABLE_SENTINEL_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/operations.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_OPERATIONS_HPP
#define RANGES_V3_ITERATOR_OPERATIONS_HPP
#include <type_traits>
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-iterator
/// @{
/// \cond
template<typename I>
// requires input_or_output_iterator<I>
struct counted_iterator;
/// \endcond
struct advance_fn
{
#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
template(typename I)(
requires input_or_output_iterator<I>)
constexpr void operator()(I & i, iter_difference_t<I> n) const
// [[expects: n >= 0 || bidirectional_iterator<I>]]
{
if constexpr(random_access_iterator<I>)
{
i += n;
}
else
{
if constexpr(bidirectional_iterator<I>)
for(; 0 > n; ++n)
--i;
RANGES_EXPECT(0 <= n);
for(; 0 < n; --n)
++i;
}
}
template(typename I, typename S)(
requires sentinel_for<S, I>)
constexpr void operator()(I & i, S bound) const
// [[expects axiom: reachable(i, bound)]]
{
if constexpr(assignable_from<I &, S>)
{
i = std::move(bound);
}
else if constexpr(sized_sentinel_for<S, I>)
{
iter_difference_t<I> d = bound - i;
RANGES_EXPECT(0 <= d);
(*this)(i, d);
}
else
while(i != bound)
++i;
}
template(typename I, typename S)(
requires sentinel_for<S, I>)
constexpr iter_difference_t<I> //
operator()(I & i, iter_difference_t<I> n, S bound) const
// [[expects axiom: 0 == n ||
// (0 < n && reachable(i, bound)) ||
// (0 > n && same_as<I, S> && bidirectional_iterator<I> && reachable(bound,
// i))]]
{
if constexpr(sized_sentinel_for<S, I>)
{
if(0 == n)
return 0;
const auto d = bound - i;
if constexpr(bidirectional_iterator<I> && same_as<I, S>)
{
RANGES_EXPECT(0 <= n ? 0 <= d : 0 >= d);
if(0 <= n ? d <= n : d >= n)
{
i = std::move(bound);
return n - d;
}
}
else
{
RANGES_EXPECT(0 <= n && 0 <= d);
if(d <= n)
{
(*this)(i, std::move(bound));
return n - d;
}
}
(*this)(i, n);
return 0;
}
else
{
if constexpr(bidirectional_iterator<I> && same_as<I, S>)
{
if(0 > n)
{
do
{
--i;
++n;
} while(0 != n && i != bound);
return n;
}
}
RANGES_EXPECT(0 <= n);
while(0 != n && i != bound)
{
++i;
--n;
}
return n;
}
}
#else
private:
template<typename I>
static constexpr void n_(I & i, iter_difference_t<I> n, std::input_iterator_tag);
template<typename I>
static constexpr void n_(I & i, iter_difference_t<I> n,
std::bidirectional_iterator_tag);
template<typename I>
static constexpr void n_(I & i, iter_difference_t<I> n,
std::random_access_iterator_tag);
template<typename I, typename S>
static constexpr void to_impl_(I & i, S s, sentinel_tag);
template<typename I, typename S>
static constexpr void to_impl_(I & i, S s, sized_sentinel_tag);
template<typename I, typename S>
static constexpr void to_(I & i, S s, std::true_type); // assignable
template<typename I, typename S>
static constexpr void to_(I & i, S s, std::false_type); // !assignable
template<typename I, typename S>
static constexpr iter_difference_t<I> bounded_(I & it, iter_difference_t<I> n,
S bound, sentinel_tag,
std::input_iterator_tag);
template<typename I>
static constexpr iter_difference_t<I> bounded_(I & it, iter_difference_t<I> n,
I bound, sentinel_tag,
std::bidirectional_iterator_tag);
template<typename I, typename S, typename Concept>
static constexpr iter_difference_t<I> bounded_(I & it, iter_difference_t<I> n,
S bound, sized_sentinel_tag,
Concept);
public:
// Advance a certain number of steps:
template(typename I)(
requires input_or_output_iterator<I>)
constexpr void operator()(I & i, iter_difference_t<I> n) const
{
advance_fn::n_(i, n, iterator_tag_of<I>{});
}
// Advance to a certain position:
template(typename I, typename S)(
requires sentinel_for<S, I>)
constexpr void operator()(I & i, S s) const
{
advance_fn::to_(
i, static_cast<S &&>(s), meta::bool_<assignable_from<I &, S>>());
}
// Advance a certain number of times, with a bound:
template(typename I, typename S)(
requires sentinel_for<S, I>)
constexpr iter_difference_t<I> //
operator()(I & it, iter_difference_t<I> n, S bound) const
{
return advance_fn::bounded_(it,
n,
static_cast<S &&>(bound),
sentinel_tag_of<S, I>(),
iterator_tag_of<I>());
}
#endif
template(typename I)(
requires input_or_output_iterator<I>)
constexpr void operator()(counted_iterator<I> & i, iter_difference_t<I> n) const;
};
/// \sa `advance_fn`
RANGES_INLINE_VARIABLE(advance_fn, advance)
#if RANGES_CXX_IF_CONSTEXPR < RANGES_CXX_IF_CONSTEXPR_17
template<typename I>
constexpr void advance_fn::n_(I & i, iter_difference_t<I> n, std::input_iterator_tag)
{
RANGES_EXPECT(n >= 0);
for(; n > 0; --n)
++i;
}
template<typename I>
constexpr void advance_fn::n_(I & i, iter_difference_t<I> n,
std::bidirectional_iterator_tag)
{
if(n > 0)
for(; n > 0; --n)
++i;
else
for(; n < 0; ++n)
--i;
}
template<typename I>
constexpr void advance_fn::n_(I & i, iter_difference_t<I> n,
std::random_access_iterator_tag)
{
i += n;
}
template<typename I, typename S>
constexpr void advance_fn::to_impl_(I & i, S s, sentinel_tag)
{
while(i != s)
++i;
}
template<typename I, typename S>
constexpr void advance_fn::to_impl_(I & i, S s, sized_sentinel_tag)
{
iter_difference_t<I> d = s - i;
RANGES_EXPECT(0 <= d);
advance(i, d);
}
// Advance to a certain position:
template<typename I, typename S>
constexpr void advance_fn::to_(I & i, S s, std::true_type)
{
i = static_cast<S &&>(s);
}
template<typename I, typename S>
constexpr void advance_fn::to_(I & i, S s, std::false_type)
{
advance_fn::to_impl_(i, static_cast<S &&>(s), sentinel_tag_of<S, I>());
}
template<typename I, typename S>
constexpr iter_difference_t<I> advance_fn::bounded_(I & it, iter_difference_t<I> n,
S bound, sentinel_tag,
std::input_iterator_tag)
{
RANGES_EXPECT(0 <= n);
for(; 0 != n && it != bound; --n)
++it;
return n;
}
template<typename I>
constexpr iter_difference_t<I> advance_fn::bounded_(I & it, iter_difference_t<I> n,
I bound, sentinel_tag,
std::bidirectional_iterator_tag)
{
if(0 <= n)
for(; 0 != n && it != bound; --n)
++it;
else
for(; 0 != n && it != bound; ++n)
--it;
return n;
}
template<typename I, typename S, typename Concept>
constexpr iter_difference_t<I> advance_fn::bounded_(I & it, iter_difference_t<I> n,
S bound, sized_sentinel_tag,
Concept)
{
RANGES_EXPECT(((bool)same_as<I, S> || 0 <= n));
if(n == 0)
return 0;
iter_difference_t<I> d = bound - it;
RANGES_EXPECT(0 <= n ? 0 <= d : 0 >= d);
if(0 <= n ? n >= d : n <= d)
{
advance(it, static_cast<S &&>(bound));
return n - d;
}
advance(it, n);
return 0;
}
#endif
struct next_fn
{
template(typename I)(
requires input_or_output_iterator<I>)
constexpr I operator()(I it) const
{
return ++it;
}
template(typename I)(
requires input_or_output_iterator<I>)
constexpr I operator()(I it, iter_difference_t<I> n) const
{
advance(it, n);
return it;
}
template(typename I, typename S)(
requires sentinel_for<S, I>)
constexpr I operator()(I it, S s) const
{
advance(it, static_cast<S &&>(s));
return it;
}
template(typename I, typename S)(
requires sentinel_for<S, I>)
constexpr I operator()(I it, iter_difference_t<I> n, S bound) const
{
advance(it, n, static_cast<S &&>(bound));
return it;
}
};
/// \sa `next_fn`
RANGES_INLINE_VARIABLE(next_fn, next)
struct prev_fn
{
template(typename I)(
requires bidirectional_iterator<I>)
constexpr I operator()(I it) const
{
return --it;
}
template(typename I)(
requires bidirectional_iterator<I>)
constexpr I operator()(I it, iter_difference_t<I> n) const
{
advance(it, -n);
return it;
}
template(typename I)(
requires bidirectional_iterator<I>)
constexpr I operator()(I it, iter_difference_t<I> n, I bound) const
{
advance(it, -n, static_cast<I &&>(bound));
return it;
}
};
/// \sa `prev_fn`
RANGES_INLINE_VARIABLE(prev_fn, prev)
struct iter_enumerate_fn
{
private:
template(typename I, typename S)(
requires (!sized_sentinel_for<I, I>)) //
static constexpr std::pair<iter_difference_t<I>, I> //
impl_i(I first, S last, sentinel_tag)
{
iter_difference_t<I> d = 0;
for(; first != last; ++first)
++d;
return {d, first};
}
template(typename I, typename S)(
requires sized_sentinel_for<I, I>)
static constexpr std::pair<iter_difference_t<I>, I> //
impl_i(I first, S end_, sentinel_tag)
{
I last = ranges::next(first, end_);
auto n = static_cast<iter_difference_t<I>>(last - first);
RANGES_EXPECT(((bool)same_as<I, S> || 0 <= n));
return {n, last};
}
template<typename I, typename S>
static constexpr std::pair<iter_difference_t<I>, I> //
impl_i(I first, S last, sized_sentinel_tag)
{
auto n = static_cast<iter_difference_t<I>>(last - first);
RANGES_EXPECT(((bool)same_as<I, S> || 0 <= n));
return {n, ranges::next(first, last)};
}
public:
template(typename I, typename S)(
requires sentinel_for<S, I>)
constexpr std::pair<iter_difference_t<I>, I> operator()(I first, S last) const
{
return iter_enumerate_fn::impl_i(static_cast<I &&>(first),
static_cast<S &&>(last),
sentinel_tag_of<S, I>());
}
};
/// \sa `iter_enumerate_fn`
RANGES_INLINE_VARIABLE(iter_enumerate_fn, iter_enumerate)
struct iter_distance_fn
{
private:
template<typename I, typename S>
static constexpr iter_difference_t<I> impl_i(I first, S last, sentinel_tag)
{
return iter_enumerate(static_cast<I &&>(first), static_cast<S &&>(last))
.first;
}
template<typename I, typename S>
static constexpr iter_difference_t<I> impl_i(I first, S last, sized_sentinel_tag)
{
auto n = static_cast<iter_difference_t<I>>(last - first);
RANGES_EXPECT(((bool)same_as<I, S> || 0 <= n));
return n;
}
public:
template(typename I, typename S)(
requires input_or_output_iterator<I> AND sentinel_for<S, I>)
constexpr iter_difference_t<I> operator()(I first, S last) const
{
return iter_distance_fn::impl_i(static_cast<I &&>(first),
static_cast<S &&>(last),
sentinel_tag_of<S, I>());
}
};
/// \sa `iter_distance_fn`
RANGES_INLINE_VARIABLE(iter_distance_fn, iter_distance)
struct iter_distance_compare_fn
{
private:
template<typename I, typename S>
static constexpr int impl_i(I first, S last, iter_difference_t<I> n, sentinel_tag)
{
if(n < 0)
return 1;
for(; n > 0; --n, ++first)
{
if(first == last)
return -1;
}
return first == last ? 0 : 1;
}
template<typename I, typename S>
static constexpr int impl_i(I first, S last, iter_difference_t<I> n,
sized_sentinel_tag)
{
iter_difference_t<I> dist = last - first;
if(n < dist)
return 1;
if(dist < n)
return -1;
return 0;
}
public:
template(typename I, typename S)(
requires input_iterator<I> AND sentinel_for<S, I>)
constexpr int operator()(I first, S last, iter_difference_t<I> n) const
{
return iter_distance_compare_fn::impl_i(static_cast<I &&>(first),
static_cast<S &&>(last),
n,
sentinel_tag_of<S, I>());
}
};
/// \sa `iter_distance_compare_fn`
RANGES_INLINE_VARIABLE(iter_distance_compare_fn, iter_distance_compare)
// Like distance(b,e), but guaranteed to be O(1)
struct iter_size_fn
{
template(typename I, typename S)(
requires sized_sentinel_for<S, I>)
constexpr meta::_t<std::make_unsigned<iter_difference_t<I>>> //
operator()(I const & first, S last) const
{
using size_type = meta::_t<std::make_unsigned<iter_difference_t<I>>>;
iter_difference_t<I> n = last - first;
RANGES_EXPECT(0 <= n);
return static_cast<size_type>(n);
}
};
/// \sa `iter_size_fn`
RANGES_INLINE_VARIABLE(iter_size_fn, iter_size)
/// \cond
namespace adl_uncounted_recounted_detail
{
template<typename I>
constexpr I uncounted(I i)
{
return i;
}
template<typename I>
constexpr I recounted(I const &, I i, iter_difference_t<I>)
{
return i;
}
struct uncounted_fn
{
template<typename I>
constexpr auto operator()(I i) const -> decltype(uncounted((I &&) i))
{
return uncounted((I &&) i);
}
};
struct recounted_fn
{
template<typename I, typename J>
constexpr auto operator()(I i, J j, iter_difference_t<J> n) const
-> decltype(recounted((I &&) i, (J &&) j, n))
{
return recounted((I &&) i, (J &&) j, n);
}
};
} // namespace adl_uncounted_recounted_detail
/// \endcond
RANGES_INLINE_VARIABLE(adl_uncounted_recounted_detail::uncounted_fn, uncounted)
RANGES_INLINE_VARIABLE(adl_uncounted_recounted_detail::recounted_fn, recounted)
struct enumerate_fn : iter_enumerate_fn
{
private:
template<typename Rng>
static constexpr std::pair<range_difference_t<Rng>, iterator_t<Rng>> impl_r(
Rng & rng, range_tag, range_tag)
{
return iter_enumerate(begin(rng), end(rng));
}
template<typename Rng>
static constexpr std::pair<range_difference_t<Rng>, iterator_t<Rng>> impl_r(
Rng & rng, common_range_tag, sized_range_tag)
{
return {static_cast<range_difference_t<Rng>>(size(rng)), end(rng)};
}
public:
using iter_enumerate_fn::operator();
template(typename Rng)(
requires range<Rng>)
constexpr std::pair<range_difference_t<Rng>, iterator_t<Rng>> operator()(Rng && rng) const
{
// Better not be trying to compute the distance of an infinite range:
RANGES_EXPECT(!is_infinite<Rng>::value);
return enumerate_fn::impl_r(
rng, common_range_tag_of<Rng>(), sized_range_tag_of<Rng>());
}
};
/// \sa `enumerate_fn`
RANGES_INLINE_VARIABLE(enumerate_fn, enumerate)
struct distance_fn : iter_distance_fn
{
private:
template<typename Rng>
static range_difference_t<Rng> impl_r(Rng & rng, range_tag)
{
return enumerate(rng).first;
}
template<typename Rng>
static constexpr range_difference_t<Rng> impl_r(Rng & rng, sized_range_tag)
{
return static_cast<range_difference_t<Rng>>(size(rng));
}
public:
using iter_distance_fn::operator();
template(typename Rng)(
requires range<Rng>)
constexpr range_difference_t<Rng> operator()(Rng && rng) const
{
// Better not be trying to compute the distance of an infinite range:
RANGES_EXPECT(!is_infinite<Rng>::value);
return distance_fn::impl_r(rng, sized_range_tag_of<Rng>());
}
};
/// \sa `distance_fn`
RANGES_INLINE_VARIABLE(distance_fn, distance)
// The interface of distance_compare is taken from Util.listLengthCmp in the GHC API.
struct distance_compare_fn : iter_distance_compare_fn
{
private:
template<typename Rng>
static constexpr int impl_r(Rng & rng, range_difference_t<Rng> n, range_tag)
{
// Infinite ranges are always compared to be larger than a finite number.
return is_infinite<Rng>::value
? 1
: iter_distance_compare(begin(rng), end(rng), n);
}
template<typename Rng>
static constexpr int impl_r(Rng & rng, range_difference_t<Rng> n, sized_range_tag)
{
auto dist = distance(rng); // O(1) since rng is a sized_range
if(dist > n)
return 1;
else if(dist < n)
return -1;
else
return 0;
}
public:
using iter_distance_compare_fn::operator();
template(typename Rng)(
requires range<Rng>)
constexpr int operator()(Rng && rng, range_difference_t<Rng> n) const
{
return distance_compare_fn::impl_r(rng, n, sized_range_tag_of<Rng>());
}
};
/// \sa `distance_compare_fn`
RANGES_INLINE_VARIABLE(distance_compare_fn, distance_compare)
namespace cpp20
{
using ranges::advance;
using ranges::distance;
using ranges::next;
using ranges::prev;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_ITERATOR_OPERATIONS_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/stream_iterators.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
// Copyright Google LLC 2020-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_STREAM_ITERATORS_HPP
#define RANGES_V3_ITERATOR_STREAM_ITERATORS_HPP
#include <cstddef>
#include <iosfwd>
#include <iterator>
#include <string>
#include <type_traits>
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-iterator
/// @{
template<typename T = void, typename Char = char,
typename Traits = std::char_traits<Char>>
struct ostream_iterator
{
private:
template<class U>
using value_t = meta::if_<std::is_void<T>, U, T>;
public:
using difference_type = std::ptrdiff_t;
using char_type = Char;
using traits_type = Traits;
using ostream_type = std::basic_ostream<Char, Traits>;
constexpr ostream_iterator() = default;
ostream_iterator(ostream_type & s, Char const * d = nullptr) noexcept
: sout_(&s)
, delim_(d)
{}
template(typename U)(
requires convertible_to<U, value_t<U> const &>)
ostream_iterator & operator=(U && value)
{
RANGES_EXPECT(sout_);
*sout_ << static_cast<value_t<U> const &>(static_cast<U &&>(value));
if(delim_)
*sout_ << delim_;
return *this;
}
ostream_iterator & operator*()
{
return *this;
}
ostream_iterator & operator++()
{
return *this;
}
ostream_iterator & operator++(int)
{
return *this;
}
private:
ostream_type * sout_;
Char const * delim_;
};
template<typename Delim, typename Char = char,
typename Traits = std::char_traits<Char>>
struct ostream_joiner
{
CPP_assert(semiregular<Delim>);
using difference_type = std::ptrdiff_t;
using char_type = Char;
using traits_type = Traits;
using ostream_type = std::basic_ostream<Char, Traits>;
constexpr ostream_joiner() = default;
ostream_joiner(ostream_type & s, Delim const & d)
: delim_(d)
, sout_(std::addressof(s))
, first_(true)
{}
ostream_joiner(ostream_type & s, Delim && d)
: delim_(std::move(d))
, sout_(std::addressof(s))
, first_(true)
{}
template<typename T>
ostream_joiner & operator=(T const & value)
{
RANGES_EXPECT(sout_);
if(!first_)
*sout_ << delim_;
first_ = false;
*sout_ << value;
return *this;
}
ostream_joiner & operator*() noexcept
{
return *this;
}
ostream_joiner & operator++() noexcept
{
return *this;
}
ostream_joiner & operator++(int) noexcept
{
return *this;
}
private:
Delim delim_;
ostream_type * sout_;
bool first_;
};
struct make_ostream_joiner_fn
{
template(typename Delim, typename Char, typename Traits)(
requires semiregular<detail::decay_t<Delim>>)
ostream_joiner<detail::decay_t<Delim>, Char, Traits> //
operator()(std::basic_ostream<Char, Traits> & s, Delim && d) const
{
return {s, std::forward<Delim>(d)};
}
};
/// \sa `make_ostream_joiner_fn`
RANGES_INLINE_VARIABLE(make_ostream_joiner_fn, make_ostream_joiner)
template<typename Char, typename Traits = std::char_traits<Char>>
struct ostreambuf_iterator
{
public:
typedef ptrdiff_t difference_type;
typedef Char char_type;
typedef Traits traits_type;
typedef std::basic_streambuf<Char, Traits> streambuf_type;
typedef std::basic_ostream<Char, Traits> ostream_type;
constexpr ostreambuf_iterator() = default;
ostreambuf_iterator(ostream_type & s) noexcept
: ostreambuf_iterator(s.rdbuf())
{}
ostreambuf_iterator(streambuf_type * s) noexcept
: sbuf_(s)
{
RANGES_ASSERT(s != nullptr);
}
ostreambuf_iterator & operator=(Char c)
{
RANGES_ASSERT(sbuf_ != nullptr);
if(!failed_)
failed_ = (sbuf_->sputc(c) == Traits::eof());
return *this;
}
ostreambuf_iterator & operator*()
{
return *this;
}
ostreambuf_iterator & operator++()
{
return *this;
}
ostreambuf_iterator & operator++(int)
{
return *this;
}
bool failed() const noexcept
{
return failed_;
}
private:
streambuf_type * sbuf_ = nullptr;
bool failed_ = false;
};
namespace cpp20
{
template<typename T, typename Char = char,
typename Traits = std::char_traits<Char>>
using ostream_iterator = ranges::ostream_iterator<T, Char, Traits>;
using ranges::ostreambuf_iterator;
} // namespace cpp20
/// \brief Writes to an ostream object using the unformatted
/// `std::basic_ostream::write` operation. This means that `32` will be encoded as
/// `100000` as opposed to the string "32".
///
template<typename CharT = char, typename Traits = std::char_traits<CharT>>
class unformatted_ostream_iterator final
{
public:
using iterator_category = std::output_iterator_tag;
using difference_type = std::ptrdiff_t;
using char_type = CharT;
using traits_type = Traits;
using ostream_type = std::basic_ostream<CharT, Traits>;
unformatted_ostream_iterator() = default;
explicit unformatted_ostream_iterator(ostream_type & out) noexcept
: out_(&out)
{}
template<typename T>
// requires stream_insertible<T, ostream_type>
unformatted_ostream_iterator & operator=(T const & t)
{
RANGES_EXPECT(out_);
out_->write(reinterpret_cast<char const *>(std::addressof(t)), sizeof(T));
return *this;
}
unformatted_ostream_iterator & operator*() noexcept
{
return *this;
}
unformatted_ostream_iterator & operator++() noexcept
{
return *this;
}
unformatted_ostream_iterator & operator++(int) noexcept
{
return *this;
}
private:
ostream_type * out_ = nullptr;
};
/// @}
} // namespace ranges
/// \cond
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
namespace std
{
template<typename T, typename Char, typename Traits>
struct iterator_traits<::ranges::ostream_iterator<T, Char, Traits>>
: ::ranges::detail::std_output_iterator_traits<>
{};
template<typename Char, typename Traits>
struct iterator_traits<::ranges::ostreambuf_iterator<Char, Traits>>
: ::ranges::detail::std_output_iterator_traits<>
{};
} // namespace std
RANGES_DIAGNOSTIC_POP
/// \endcond
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_ITERATOR_STREAM_ITERATORS_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/iterator/move_iterators.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_ITERATOR_MOVE_ITERATORS_HPP
#define RANGES_V3_ITERATOR_MOVE_ITERATORS_HPP
#include <cstddef>
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/basic_iterator.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-iterator
/// @{
template<typename I>
struct move_iterator
{
private:
CPP_assert(input_iterator<I>);
I current_ = I{};
public:
using iterator_type = I;
using difference_type = iter_difference_t<I>;
using value_type = iter_value_t<I>;
using iterator_category = std::input_iterator_tag;
using reference = iter_rvalue_reference_t<I>;
constexpr move_iterator() = default;
explicit move_iterator(I i)
: current_(i)
{}
template(typename O)(
requires convertible_to<O, I>)
move_iterator(move_iterator<O> const & i)
: current_(i.base())
{}
template(typename O)(
requires convertible_to<O, I>)
move_iterator & operator=(move_iterator<O> const & i)
{
current_ = i.base();
return *this;
}
I base() const
{
return current_;
}
// clang-format off
auto CPP_auto_fun(operator*)()(const)
(
return iter_move(current_)
)
// clang-format on
move_iterator &
operator++()
{
++current_;
return *this;
}
CPP_member
auto operator++(int) //
-> CPP_ret(void)(
requires (!forward_iterator<I>))
{
++current_;
}
CPP_member
auto operator++(int) //
-> CPP_ret(move_iterator)(
requires forward_iterator<I>)
{
return move_iterator(current_++);
}
CPP_member
auto operator--() //
-> CPP_ret(move_iterator &)(
requires forward_iterator<I>)
{
--current_;
return *this;
}
CPP_member
auto operator--(int) //
-> CPP_ret(move_iterator)(
requires bidirectional_iterator<I>)
{
return move_iterator(current_--);
}
CPP_member
auto operator+(difference_type n) const //
-> CPP_ret(move_iterator)(
requires random_access_iterator<I>)
{
return move_iterator(current_ + n);
}
CPP_member
auto operator+=(difference_type n)
-> CPP_ret(move_iterator &)(
requires random_access_iterator<I>)
{
current_ += n;
return *this;
}
CPP_member
auto operator-(difference_type n) const //
-> CPP_ret(move_iterator)(
requires random_access_iterator<I>)
{
return move_iterator(current_ - n);
}
CPP_member
auto operator-=(difference_type n) //
-> CPP_ret(move_iterator &)(
requires random_access_iterator<I>)
{
current_ -= n;
return *this;
}
CPP_member
auto operator[](difference_type n) const //
-> CPP_ret(reference)(
requires random_access_iterator<I>)
{
return iter_move(current_ + n);
}
template<typename I2>
friend auto operator==(move_iterator const & x, move_iterator<I2> const & y)
-> CPP_broken_friend_ret(bool)(
requires equality_comparable_with<I, I2>)
{
return x.base() == y.base();
}
template<typename I2>
friend auto operator!=(move_iterator const & x, move_iterator<I2> const & y)
-> CPP_broken_friend_ret(bool)(
requires equality_comparable_with<I, I2>)
{
return !(x == y);
}
template<typename I2>
friend auto operator<(move_iterator const & x, move_iterator<I2> const & y)
-> CPP_broken_friend_ret(bool)(
requires totally_ordered_with<I, I2>)
{
return x.base() < y.base();
}
template<typename I2>
friend auto operator<=(move_iterator const & x, move_iterator<I2> const & y)
-> CPP_broken_friend_ret(bool)(
requires totally_ordered_with<I, I2>)
{
return !(y < x);
}
template<typename I2>
friend auto operator>(move_iterator const & x, move_iterator<I2> const & y)
-> CPP_broken_friend_ret(bool)(
requires totally_ordered_with<I, I2>)
{
return y < x;
}
template<typename I2>
friend auto operator>=(move_iterator const & x, move_iterator<I2> const & y)
-> CPP_broken_friend_ret(bool)(
requires totally_ordered_with<I, I2>)
{
return !(x < y);
}
template<typename I2>
friend auto operator-(move_iterator const & x, move_iterator<I2> const & y)
-> CPP_broken_friend_ret(iter_difference_t<I2>)(
requires sized_sentinel_for<I, I2>)
{
return x.base() - y.base();
}
CPP_broken_friend_member
friend auto operator+(iter_difference_t<I> n,
move_iterator const & x)
-> CPP_broken_friend_ret(move_iterator)(
requires random_access_iterator<I>)
{
return x + n;
}
};
struct make_move_iterator_fn
{
template(typename I)(
requires input_iterator<I>)
constexpr move_iterator<I> operator()(I it) const
{
return move_iterator<I>{detail::move(it)};
}
};
RANGES_INLINE_VARIABLE(make_move_iterator_fn, make_move_iterator)
template<typename S>
struct move_sentinel
{
private:
S sent_;
public:
constexpr move_sentinel()
: sent_{}
{}
constexpr explicit move_sentinel(S s)
: sent_(detail::move(s))
{}
template(typename OS)(
requires convertible_to<OS, S>)
constexpr explicit move_sentinel(move_sentinel<OS> const & that)
: sent_(that.base())
{}
template(typename OS)(
requires convertible_to<OS, S>)
move_sentinel & operator=(move_sentinel<OS> const & that)
{
sent_ = that.base();
return *this;
}
S base() const
{
return sent_;
}
template<typename I>
friend auto operator==(move_iterator<I> const & i, move_sentinel const & s)
-> CPP_broken_friend_ret(bool)(
requires sentinel_for<S, I>)
{
return i.base() == s.base();
}
template<typename I>
friend auto operator==(move_sentinel const & s, move_iterator<I> const & i)
-> CPP_broken_friend_ret(bool)(
requires sentinel_for<S, I>)
{
return s.base() == i.base();
}
template<typename I>
friend auto operator!=(move_iterator<I> const & i, move_sentinel const & s)
-> CPP_broken_friend_ret(bool)(
requires sentinel_for<S, I>)
{
return i.base() != s.base();
}
template<typename I>
friend auto operator!=(move_sentinel const & s, move_iterator<I> const & i)
-> CPP_broken_friend_ret(bool)(
requires sentinel_for<S, I>)
{
return s.base() != i.base();
}
};
struct make_move_sentinel_fn
{
template(typename I)(
requires input_iterator<I>)
constexpr move_iterator<I> operator()(I i) const
{
return move_iterator<I>{detail::move(i)};
}
template(typename S)(
requires semiregular<S> AND (!input_iterator<S>)) //
constexpr move_sentinel<S> operator()(S s) const
{
return move_sentinel<S>{detail::move(s)};
}
};
RANGES_INLINE_VARIABLE(make_move_sentinel_fn, make_move_sentinel)
/// \cond
namespace detail
{
template<typename I, bool IsReadable>
struct move_into_cursor_types_
{};
template<typename I>
struct move_into_cursor_types_<I, true>
{
using value_type = iter_value_t<I>;
using single_pass = meta::bool_<(bool)single_pass_iterator_<I>>;
};
template<typename I>
using move_into_cursor_types =
move_into_cursor_types_<I, (bool)indirectly_readable<I>>;
template<typename I>
struct move_into_cursor : move_into_cursor_types<I>
{
private:
friend range_access;
struct mixin : basic_mixin<move_into_cursor>
{
mixin() = default;
#ifndef _MSC_VER
using basic_mixin<move_into_cursor>::basic_mixin;
#else
constexpr explicit mixin(move_into_cursor && cur)
: basic_mixin<move_into_cursor>(static_cast<move_into_cursor &&>(cur))
{}
constexpr explicit mixin(move_into_cursor const & cur)
: basic_mixin<move_into_cursor>(cur)
{}
#endif
explicit mixin(I it)
: mixin{move_into_cursor{std::move(it)}}
{}
I base() const
{
return this->get().it_;
}
};
I it_ = I();
explicit move_into_cursor(I it)
: it_(std::move(it))
{}
void next()
{
++it_;
}
template(typename T)(
requires indirectly_writable<I, aux::move_t<T>>)
void write(T && t) noexcept(noexcept(*it_ = std::move(t)))
{
*it_ = std::move(t);
}
template(typename T)(
requires indirectly_writable<I, aux::move_t<T>>)
void write(T && t) const noexcept(noexcept(*it_ = std::move(t)))
{
*it_ = std::move(t);
}
CPP_member
auto read() const noexcept(noexcept(*std::declval<I const &>()))
-> CPP_ret(iter_reference_t<I>)(
requires indirectly_readable<I>)
{
return *it_;
}
CPP_member
auto equal(move_into_cursor const & that) const //
-> CPP_ret(bool)(
requires input_iterator<I>)
{
return it_ == that.it_;
}
CPP_member
auto prev() //
-> CPP_ret(void)(
requires bidirectional_iterator<I>)
{
--it_;
}
CPP_member
auto advance(iter_difference_t<I> n) //
-> CPP_ret(void)(
requires random_access_iterator<I>)
{
it_ += n;
}
CPP_member
auto distance_to(move_into_cursor const & that) const //
-> CPP_ret(iter_difference_t<I>)(
requires sized_sentinel_for<I, I>)
{
return that.it_ - it_;
}
template(typename II = I const)(
requires same_as<I const, II> AND indirectly_readable<II>)
constexpr iter_rvalue_reference_t<II> move() const //
noexcept(has_nothrow_iter_move_v<II>)
{
return iter_move(it_);
}
public:
CPP_member
constexpr CPP_ctor(move_into_cursor)()( //
noexcept(std::is_nothrow_default_constructible<I>::value) //
requires default_constructible<I>)
{}
};
} // namespace detail
/// \endcond
struct move_into_fn
{
template<typename I>
constexpr move_into_iterator<I> operator()(I it) const
{
return move_into_iterator<I>{std::move(it)};
}
};
/// \sa `move_into_fn`
RANGES_INLINE_VARIABLE(move_into_fn, move_into)
namespace cpp20
{
using ranges::make_move_iterator;
using ranges::move_iterator;
using ranges::move_sentinel;
} // namespace cpp20
/// @}
} // namespace ranges
/// \cond
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
namespace std
{
template<typename I>
struct iterator_traits<::ranges::move_iterator<I>>
{
using iterator_category = std::input_iterator_tag;
using difference_type = typename ::ranges::move_iterator<I>::difference_type;
using value_type = typename ::ranges::move_iterator<I>::value_type;
using reference = typename ::ranges::move_iterator<I>::reference;
using pointer = meta::_t<std::add_pointer<reference>>;
};
} // namespace std
RANGES_DIAGNOSTIC_POP
/// \endcond
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_ITERATOR_MOVE_ITERATORS_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/filter.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_FILTER_HPP
#define RANGES_V3_VIEW_FILTER_HPP
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/compose.hpp>
#include <range/v3/functional/not_fn.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/remove_if.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng, typename Pred>
struct filter_view : remove_if_view<Rng, logical_negate<Pred>>
{
filter_view() = default;
constexpr filter_view(Rng rng, Pred pred)
: filter_view::remove_if_view{std::move(rng), not_fn(std::move(pred))}
{}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Pred)(
requires input_range<Rng> AND indirect_unary_predicate<Pred, iterator_t<Rng>> AND
view_<Rng> AND std::is_object<Pred>::value) //
filter_view(Rng &&, Pred)
->filter_view<views::all_t<Rng>, Pred>;
#endif
namespace views
{
struct filter_fn;
/// Given a source range and a unary predicate,
/// present a view of the elements that satisfy the predicate.
struct cpp20_filter_base_fn
{
template(typename Rng, typename Pred)(
requires viewable_range<Rng> AND input_range<Rng> AND
indirect_unary_predicate<Pred, iterator_t<Rng>>)
constexpr filter_view<all_t<Rng>, Pred> operator()(Rng && rng, Pred pred) //
const
{
return filter_view<all_t<Rng>, Pred>{all(static_cast<Rng &&>(rng)),
std::move(pred)};
}
};
struct cpp20_filter_fn : cpp20_filter_base_fn
{
using cpp20_filter_base_fn::operator();
template<typename Pred>
constexpr auto operator()(Pred pred) const
{
return make_view_closure(
bind_back(cpp20_filter_base_fn{}, std::move(pred)));
}
};
/// Given a source range, unary predicate, and optional projection,
/// present a view of the elements that satisfy the predicate.
struct filter_base_fn : cpp20_filter_base_fn
{
using cpp20_filter_base_fn::operator();
template(typename Rng, typename Pred, typename Proj)(
requires viewable_range<Rng> AND input_range<Rng> AND
indirect_unary_predicate<Pred, projected<iterator_t<Rng>, Proj>>)
constexpr filter_view<all_t<Rng>, composed<Pred, Proj>> //
operator()(Rng && rng, Pred pred, Proj proj) const
{
return filter_view<all_t<Rng>, composed<Pred, Proj>>{
all(static_cast<Rng &&>(rng)),
compose(std::move(pred), std::move(proj))};
}
};
/// # ranges::views::filter
/// The filter view takes in a predicate function `T -> bool` and converts an
/// input range of `T` into an output range of `T` by keeping all elements for
/// which the predicate returns true.
///
/// ## Example
/// \snippet example/view/filter.cpp filter example
///
/// ### Output
/// \include example/view/filter_golden.txt
///
/// ## Syntax
/// ```cpp
/// auto output_range = input_range | ranges::views::filter(filter_func);
/// ```
///
/// ## Parameters
/// <pre><b>filter_func</b></pre>
/// - Called once for each element of the input range
/// - Returns true for elements that should present in the output range
///
/// <pre><b>input_range</b></pre>
/// - The range of elements to filter
/// - Reference type: `T`
///
/// <pre><b>output_range</b></pre>
/// - The range of filtered values
/// - Is either a `forward_range` or the concept satisfied by the input
/// - Is a `common_range` if the input is a `common_range`
/// - Is not a `sized_range` or `borrowed_range`
/// - Reference type: `T`
///
struct filter_fn : filter_base_fn
{
using filter_base_fn::operator();
template<typename Pred>
constexpr auto operator()(Pred pred) const
{
return make_view_closure(bind_back(filter_base_fn{}, std::move(pred)));
}
template(typename Pred, typename Proj)(
requires (!range<Pred>))
constexpr auto operator()(Pred pred, Proj proj) const
{
return make_view_closure(
bind_back(filter_base_fn{}, std::move(pred), std::move(proj)));
}
};
/// \relates filter_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(filter_fn, filter)
} // namespace views
namespace cpp20
{
namespace views
{
RANGES_INLINE_VARIABLE(ranges::views::cpp20_filter_fn, filter)
}
template(typename V, typename Pred)(
requires input_range<V> AND indirect_unary_predicate<Pred, iterator_t<V>> AND
view_<V> AND std::is_object<Pred>::value) //
using filter_view = ranges::filter_view<V, Pred>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::filter_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/span.hpp | /// \file
// Range v3 library
//
// Copyright Casey Carter 2016-2017
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_SPAN_HPP
#define RANGES_V3_VIEW_SPAN_HPP
#include <cstddef>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/algorithm/equal.hpp>
#include <range/v3/algorithm/lexicographical_compare.hpp>
#include <range/v3/iterator/reverse_iterator.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
/// \cond
namespace detail
{
using span_index_t = std::ptrdiff_t;
} // namespace detail
/// \endcond
constexpr detail::span_index_t dynamic_extent = -1;
/// \cond
namespace detail
{
template(typename To, typename From)(
requires integral<To> AND integral<From>)
constexpr To narrow_cast(From from) noexcept
{
using C = common_type_t<To, From>;
return RANGES_EXPECT((from > 0) == (static_cast<To>(from) > 0)),
RANGES_EXPECT(static_cast<C>(from) ==
static_cast<C>(static_cast<To>(from))),
static_cast<To>(from);
}
template<typename T>
constexpr span_index_t byte_size(span_index_t n) noexcept
{
return n == dynamic_extent ? dynamic_extent
: (RANGES_EXPECT(n >= 0),
RANGES_EXPECT(narrow_cast<std::size_t>(n) <=
PTRDIFF_MAX / sizeof(T)),
n * narrow_cast<span_index_t>(sizeof(T)));
}
template<span_index_t N>
struct span_extent
{
CPP_assert(N >= 0);
constexpr span_extent() noexcept = default;
constexpr span_extent(span_index_t size) noexcept
// this constructor does nothing, the delegation exists only
// to provide a place for the contract check expression.
: span_extent{(RANGES_EXPECT(size == N), tag{})}
{}
constexpr span_index_t size() const noexcept
{
return N;
}
private:
struct tag
{};
constexpr span_extent(tag) noexcept
{}
};
template<>
struct span_extent<dynamic_extent>
{
span_extent() = default;
constexpr span_extent(span_index_t size) noexcept
: size_{((void)RANGES_EXPECT(size >= 0), size)}
{}
constexpr span_index_t size() const noexcept
{
return size_;
}
private:
span_index_t size_ = 0;
};
constexpr span_index_t subspan_extent(span_index_t Extent, span_index_t Offset,
span_index_t Count) noexcept
{
return Count == dynamic_extent && Extent != dynamic_extent ? Extent - Offset
: Count;
}
} // namespace detail
// clang-format off
/// \concept span_compatible_range_
/// \brief The \c span_compatible_range_ concept
template(typename Rng, typename T)(
concept (span_compatible_range_)(Rng, T),
detail::is_convertible<detail::element_t<Rng>(*)[], T(*)[]>::value
);
/// \concept span_compatible_range
/// \brief The \c span_compatible_range concept
template<typename Rng, typename T>
CPP_concept span_compatible_range =
sized_range<Rng> && contiguous_range<Rng> &&
CPP_concept_ref(ranges::span_compatible_range_, Rng, T);
/// \concept span_dynamic_conversion
/// \brief The \c span_dynamic_conversion concept
template<typename Rng, detail::span_index_t N>
CPP_concept span_dynamic_conversion =
N == dynamic_extent ||
range_cardinality<Rng>::value < cardinality();
/// \concept span_static_conversion
/// \brief The \c span_static_conversion concept
template<typename Rng, detail::span_index_t N>
CPP_concept span_static_conversion =
N != dynamic_extent && range_cardinality<Rng>::value == N;
// clang-format on
/// \endcond
template<typename T, detail::span_index_t N = dynamic_extent>
struct RANGES_EMPTY_BASES span
: public view_interface<
span<T, N>, (N == dynamic_extent ? finite : static_cast<cardinality>(N))>
, public detail::span_extent<N>
{
CPP_assert(std::is_object<T>::value);
using element_type = T;
using value_type = meta::_t<std::remove_cv<T>>;
using index_type = detail::span_index_t;
using difference_type = index_type;
using pointer = T *;
using reference = T &;
using iterator = T *;
using reverse_iterator = ranges::reverse_iterator<iterator>;
static constexpr index_type extent = N;
constexpr span() noexcept = default;
constexpr span(pointer ptr, index_type cnt) noexcept
: detail::span_extent<N>{(RANGES_EXPECT(cnt >= 0), cnt)}
, data_{(RANGES_EXPECT(0 == cnt || ptr != nullptr), ptr)}
{}
template<typename = void> // Artificially templatize so that the other
// constructor is preferred for {ptr, 0}
constexpr span(pointer first, pointer last) noexcept
: span{first, last - first}
{}
template(typename Rng)(
requires (!same_as<span, uncvref_t<Rng>>) AND
span_compatible_range<Rng, T> AND
span_dynamic_conversion<Rng, N>)
constexpr span(Rng && rng) noexcept(noexcept(ranges::data(rng),
ranges::size(rng)))
: span{ranges::data(rng), detail::narrow_cast<index_type>(ranges::size(rng))}
{}
template(typename Rng)(
requires (!same_as<span, uncvref_t<Rng>>) AND
span_compatible_range<Rng, T> AND
span_static_conversion<Rng, N>)
constexpr span(Rng && rng) noexcept(noexcept(ranges::data(rng)))
: span{ranges::data(rng), N}
{}
template<index_type Count>
constexpr span<T, Count> first() const noexcept
{
static_assert(Count >= 0, "Count of elements to extract cannot be negative.");
static_assert(
N == dynamic_extent || Count <= N,
"Count of elements to extract must be less than the static span extent.");
return RANGES_EXPECT(Count <= size()),
RANGES_EXPECT(Count == 0 || data_ != nullptr),
span<T, Count>{data_, Count};
}
constexpr span<T> first(index_type cnt) const noexcept
{
return RANGES_EXPECT(cnt >= 0 && cnt <= size()),
RANGES_EXPECT(cnt == 0 || data_ != nullptr), span<T>{data_, cnt};
}
template<index_type Count>
constexpr span<T, Count> last() const noexcept
{
static_assert(Count >= 0, "Count of elements to extract cannot be negative.");
static_assert(
N == dynamic_extent || Count <= N,
"Count of elements to extract must be less than the static span extent.");
return RANGES_EXPECT(Count <= size()),
RANGES_EXPECT((Count == 0 && size() == 0) || data_ != nullptr),
span<T, Count>{data_ + size() - Count, Count};
}
constexpr span<T> last(index_type cnt) const noexcept
{
return RANGES_EXPECT(cnt >= 0 && cnt <= size()),
RANGES_EXPECT((cnt == 0 && size() == 0) || data_ != nullptr),
span<T>{data_ + size() - cnt, cnt};
}
template<index_type Offset, index_type Count>
constexpr span<T, detail::subspan_extent(N, Offset, Count)> subspan() const
noexcept
{
static_assert(Offset >= 0,
"Offset of first element to extract cannot be negative.");
static_assert(Count >= dynamic_extent,
"Count of elements to extract cannot be negative.");
static_assert(
N == dynamic_extent ||
N >= Offset + (Count == dynamic_extent ? 0 : Count),
"Sequence of elements to extract must be within the static span extent.");
return RANGES_EXPECT(size() >=
Offset + (Count == dynamic_extent ? 0 : Count)),
RANGES_EXPECT((Offset == 0 && Count <= 0) || data_ != nullptr),
span<T, detail::subspan_extent(N, Offset, Count)>{
data_ + Offset, Count == dynamic_extent ? size() - Offset : Count};
}
template<index_type Offset>
constexpr span<T, (N >= Offset ? N - Offset : dynamic_extent)> subspan() const
noexcept
{
static_assert(Offset >= 0,
"Offset of first element to extract cannot be negative.");
static_assert(N == dynamic_extent || N >= Offset,
"Offset of first element to extract must be within the static "
"span extent.");
return RANGES_EXPECT(size() >= Offset),
RANGES_EXPECT((Offset == 0 && size() == 0) || data_ != nullptr),
span < T,
N >= Offset ? N - Offset
: dynamic_extent > {data_ + Offset, size() - Offset};
}
constexpr span<T, dynamic_extent> subspan(index_type offset) const noexcept
{
return RANGES_EXPECT(offset >= 0), RANGES_EXPECT(size() >= offset),
RANGES_EXPECT((offset == 0 && size() == 0) || data_ != nullptr),
span<T, dynamic_extent>{data_ + offset, size() - offset};
}
constexpr span<T, dynamic_extent> subspan(index_type offset, index_type cnt) const
noexcept
{
return RANGES_EXPECT(offset >= 0), RANGES_EXPECT(cnt >= 0),
RANGES_EXPECT(size() >= offset + cnt),
RANGES_EXPECT((offset == 0 && cnt == 0) || data_ != nullptr),
span<T, dynamic_extent>{data_ + offset, cnt};
}
constexpr pointer data() const noexcept
{
return data_;
}
using detail::span_extent<N>::size;
constexpr index_type size_bytes() const noexcept
{
return detail::byte_size<T>(size());
}
constexpr bool empty() const noexcept
{
return size() == 0;
}
constexpr reference operator[](index_type idx) const noexcept
{
return RANGES_EXPECT(idx >= 0), RANGES_EXPECT(idx < size()),
RANGES_EXPECT(data_), data_[idx];
}
constexpr iterator begin() const noexcept
{
return RANGES_EXPECT(!size() || data_), data_;
}
constexpr iterator end() const noexcept
{
return RANGES_EXPECT(!size() || data_), data_ + size();
}
constexpr reverse_iterator rbegin() const noexcept
{
return reverse_iterator{end()};
}
constexpr reverse_iterator rend() const noexcept
{
return reverse_iterator{begin()};
}
template(typename U, index_type M)(
requires equality_comparable_with<T, U>)
bool operator==(span<U, M> const & that) const
{
RANGES_EXPECT(!size() || data());
RANGES_EXPECT(!that.size() || that.data());
return ranges::equal(*this, that);
}
template(typename U, index_type M)(
requires equality_comparable_with<T, U>)
bool operator!=(span<U, M> const & that) const
{
return !(*this == that);
}
template(typename U, index_type M)(
requires totally_ordered_with<T, U>)
bool operator<(span<U, M> const & that) const
{
RANGES_EXPECT(!size() || data());
RANGES_EXPECT(!that.size() || that.data());
return ranges::lexicographical_compare(*this, that);
}
template(typename U, index_type M)(
requires totally_ordered_with<T, U>)
bool operator>(span<U, M> const & that) const
{
return that < *this;
}
template(typename U, index_type M)(
requires totally_ordered_with<T, U>)
bool operator<=(span<U, M> const & that) const
{
return !(that < *this);
}
template(typename U, index_type M)(
requires totally_ordered_with<T, U>)
bool operator>=(span<U, M> const & that) const
{
return !(*this < that);
}
private:
T * data_ = nullptr;
};
template<typename T, detail::span_index_t N>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<span<T, N>> = true;
template<typename T, detail::span_index_t N>
constexpr detail::span_index_t span<T, N>::extent;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng)(
requires contiguous_range<Rng>)
span(Rng && rng)
->span<detail::element_t<Rng>, (range_cardinality<Rng>::value < cardinality()
? dynamic_extent
: static_cast<detail::span_index_t>(
range_cardinality<Rng>::value))>;
#endif
template<typename T, detail::span_index_t N>
span<unsigned char const, detail::byte_size<T>(N)> as_bytes(span<T, N> s) noexcept
{
return {reinterpret_cast<unsigned char const *>(s.data()), s.size_bytes()};
}
template<typename T, detail::span_index_t N>
span<unsigned char, detail::byte_size<T>(N)> as_writeable_bytes(span<T, N> s) noexcept
{
return {reinterpret_cast<unsigned char *>(s.data()), s.size_bytes()};
}
template<typename ElementType>
constexpr span<ElementType> make_span(ElementType * ptr,
detail::span_index_t cnt) noexcept
{
return span<ElementType>{ptr, cnt};
}
template<typename ElementType>
constexpr span<ElementType> make_span(ElementType * first,
ElementType * last) noexcept
{
return span<ElementType>{first, last};
}
template(typename Rng)(
requires contiguous_range<Rng> AND
(range_cardinality<Rng>::value < cardinality())) //
constexpr span<detail::element_t<Rng>> make_span(Rng && rng) noexcept(
noexcept(ranges::data(rng), ranges::size(rng)))
{
return {ranges::data(rng),
detail::narrow_cast<detail::span_index_t>(ranges::size(rng))};
}
template(typename Rng)(
requires contiguous_range<Rng> AND
(range_cardinality<Rng>::value >= cardinality())) //
constexpr span<
detail::element_t<Rng>,
static_cast<detail::span_index_t>(
range_cardinality<Rng>::
value)> make_span(Rng && rng) noexcept(noexcept(ranges::data(rng)))
{
return {ranges::data(rng), range_cardinality<Rng>::value};
}
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_VIEW_SPAN_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/adjacent_filter.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_ADJACENT_FILTER_HPP
#define RANGES_V3_VIEW_ADJACENT_FILTER_HPP
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/algorithm/adjacent_find.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
// clang-format off
/// \concept adjacent_filter_constraints_
/// \brief The \c adjacent_filter_constraints_ concept
template(typename Rng, typename Pred)(
concept (adjacent_filter_constraints_)(Rng, Pred),
indirect_binary_predicate_<Pred, iterator_t<Rng>, iterator_t<Rng>>
);
/// \concept adjacent_filter_constraints
/// \brief The \c adjacent_filter_constraints concept
template<typename Rng, typename Pred>
CPP_concept adjacent_filter_constraints =
viewable_range<Rng> && forward_range<Rng> &&
CPP_concept_ref(detail::adjacent_filter_constraints_, Rng, Pred);
// clang-format on
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
template<typename Rng, typename Pred>
struct RANGES_EMPTY_BASES adjacent_filter_view
: view_adaptor<adjacent_filter_view<Rng, Pred>, Rng,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
, private box<semiregular_box_t<Pred>, adjacent_filter_view<Rng, Pred>>
{
private:
friend range_access;
template<bool Const>
struct adaptor : adaptor_base
{
private:
friend struct adaptor<!Const>;
using CRng = meta::const_if_c<Const, Rng>;
using Parent = meta::const_if_c<Const, adjacent_filter_view>;
Parent * rng_;
public:
adaptor() = default;
constexpr adaptor(Parent * rng) noexcept
: rng_(rng)
{}
template(bool Other)(
requires Const && CPP_NOT(Other)) //
constexpr adaptor(adaptor<Other> that)
: rng_(that.rng_)
{}
constexpr void next(iterator_t<CRng> & it) const
{
auto const last = ranges::end(rng_->base());
auto & pred = rng_->adjacent_filter_view::box::get();
RANGES_EXPECT(it != last);
for(auto tmp = it; ++it != last; tmp = it)
if(invoke(pred, *tmp, *it))
break;
}
CPP_member
constexpr auto prev(iterator_t<CRng> & it) const //
-> CPP_ret(void)(
requires bidirectional_range<CRng>)
{
auto const first = ranges::begin(rng_->base());
auto & pred = rng_->adjacent_filter_view::box::get();
RANGES_EXPECT(it != first);
--it;
while(it != first)
{
auto tmp = it;
if(invoke(pred, *--tmp, *it))
break;
it = tmp;
}
}
void distance_to() = delete;
};
constexpr adaptor<false> begin_adaptor() noexcept
{
return {this};
}
CPP_member
constexpr auto begin_adaptor() const noexcept //
-> CPP_ret(adaptor<true>)(
requires detail::adjacent_filter_constraints<Rng const, Pred const>)
{
return {this};
}
constexpr adaptor<false> end_adaptor() noexcept
{
return {this};
}
CPP_member
constexpr auto end_adaptor() const noexcept //
-> CPP_ret(adaptor<true>)(
requires detail::adjacent_filter_constraints<Rng const, Pred const>)
{
return {this};
}
public:
adjacent_filter_view() = default;
constexpr adjacent_filter_view(Rng rng, Pred pred)
: adjacent_filter_view::view_adaptor{detail::move(rng)}
, adjacent_filter_view::box(detail::move(pred))
{}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Fun)(
requires copy_constructible<Rng>)
adjacent_filter_view(Rng &&, Fun)
->adjacent_filter_view<views::all_t<Rng>, Fun>;
#endif
namespace views
{
struct adjacent_filter_base_fn
{
template(typename Rng, typename Pred)(
requires detail::adjacent_filter_constraints<Rng, Pred>)
constexpr adjacent_filter_view<all_t<Rng>, Pred> //
operator()(Rng && rng, Pred pred) const
{
return {all(static_cast<Rng &&>(rng)), std::move(pred)};
}
};
struct adjacent_filter_fn : adjacent_filter_base_fn
{
using adjacent_filter_base_fn::operator();
template<typename Pred>
constexpr auto operator()(Pred pred) const
{
return make_view_closure(
bind_back(adjacent_filter_base_fn{}, std::move(pred)));
}
};
/// \relates adjacent_filter_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(adjacent_filter_fn, adjacent_filter)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::adjacent_filter_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/subrange.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
// Copyright Casey Carter 2017
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_SUBRANGE_HPP
#define RANGES_V3_VIEW_SUBRANGE_HPP
#include <tuple>
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/unreachable_sentinel.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/dangling.hpp>
#include <range/v3/utility/get.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
enum class subrange_kind : bool
{
unsized,
sized
};
/// \cond
namespace detail
{
// clang-format off
/// \concept convertible_to_not_slicing_
/// \brief The \c convertible_to_not_slicing_ concept
template<typename From, typename To>
CPP_concept convertible_to_not_slicing_ =
convertible_to<From, To> &&
// A conversion is a slicing conversion if the source and the destination
// are both pointers, and if the pointed-to types differ after removing
// cv qualifiers.
(!(std::is_pointer<decay_t<From>>::value &&
std::is_pointer<decay_t<To>>::value &&
not_same_as_<std::remove_pointer_t<decay_t<From>>,
std::remove_pointer_t<decay_t<To>>>));
template<std::size_t N, typename T>
using tuple_element_fun_t = void (*)(meta::_t<std::tuple_element<N, T>> const &);
/// \concept pair_like_impl_
/// \brief The \c pair_like_impl_ concept
template<typename T>
CPP_requires(pair_like_impl_, //
requires(T t, tuple_element_fun_t<0, T> p0, tuple_element_fun_t<1, T> p1) //
(
p0( get<0>(t) ),
p1( get<1>(t) )
));
/// \concept pair_like_impl_
/// \brief The \c pair_like_impl_ concept
template<typename T>
CPP_concept pair_like_impl_ = CPP_requires_ref(detail::pair_like_impl_, T);
/// \concept is_complete_
/// \brief The \c is_complete_ concept
template(typename T)(
concept (is_complete_)(T),
0 != sizeof(T));
/// \concept is_complete_
/// \brief The \c is_complete_ concept
template<typename T>
CPP_concept is_complete_ = //
CPP_concept_ref(is_complete_, T);
template(typename T)( //
concept (pair_like_)(T), //
is_complete_<std::tuple_size<T>> AND
derived_from<std::tuple_size<T>, meta::size_t<2>> AND
detail::pair_like_impl_<T>);
/// \concept pair_like
/// \brief The \c pair_like concept
template<typename T>
CPP_concept pair_like = //
CPP_concept_ref(detail::pair_like_, T);
// clang-format off
template(typename T, typename U, typename V)( //
concept (pair_like_convertible_from_helper_)(T, U, V), //
convertible_to_not_slicing_<U, meta::_t<std::tuple_element<0, T>>> AND
convertible_to<V, meta::_t<std::tuple_element<1, T>>>);
/// \concept pair_like_convertible_from_helper_
/// \brief The \c pair_like_convertible_from_helper_ concept
template<typename T, typename U, typename V>
CPP_concept pair_like_convertible_from_helper_ = //
CPP_concept_ref(pair_like_convertible_from_helper_, T, U, V);
template(typename T, typename U, typename V)( //
concept (pair_like_convertible_from_impl_)(T, U, V),
(!range<T>) AND
constructible_from<T, U, V> AND
pair_like<uncvref_t<T>> AND
pair_like_convertible_from_helper_<T, U, V>);
/// \concept pair_like_convertible_from_
/// \brief The \c pair_like_convertible_from_ concept
template<typename T, typename U, typename V>
CPP_concept pair_like_convertible_from_ =
CPP_concept_ref(detail::pair_like_convertible_from_impl_, T, U, V);
/// \concept range_convertible_to_impl_
/// \brief The \c range_convertible_to_impl_ concept
template(typename R, typename I, typename S)(
concept (range_convertible_to_impl_)(R, I, S),
convertible_to_not_slicing_<iterator_t<R>, I> AND
convertible_to<sentinel_t<R>, S>);
/// \concept range_convertible_to_
/// \brief The \c range_convertible_to_ concept
template<typename R, typename I, typename S>
CPP_concept range_convertible_to_ =
borrowed_range<R> &&
CPP_concept_ref(detail::range_convertible_to_impl_, R, I, S);
// clang-format on
template(typename S, typename I)(
requires sentinel_for<S, I>)
constexpr bool is_sized_sentinel_() noexcept
{
return (bool)sized_sentinel_for<S, I>;
}
template<subrange_kind K, typename S, typename I>
constexpr bool store_size_() noexcept
{
return K == subrange_kind::sized && !(bool)sized_sentinel_for<S, I>;
}
} // namespace detail
/// \endcond
template< //
typename I, //
typename S = I, //
subrange_kind K = static_cast<subrange_kind>(detail::is_sized_sentinel_<S, I>())>
struct subrange;
template<typename I, typename S, subrange_kind K>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<subrange<I, S, K>> = true;
/// \cond
namespace _subrange_
{
struct adl_hook
{};
template(std::size_t N, typename I, typename S, subrange_kind K)(
requires (N == 0)) //
constexpr I get(subrange<I, S, K> const & r)
{
return r.begin();
}
template(std::size_t N, typename I, typename S, subrange_kind K)(
requires (N == 1)) //
constexpr S get(subrange<I, S, K> const & r)
{
return r.end();
}
} // namespace _subrange_
/// \endcond
template<typename I, typename S, subrange_kind K>
struct subrange
: view_interface<subrange<I, S, K>,
same_as<S, unreachable_sentinel_t>
? infinite
: K == subrange_kind::sized ? finite : unknown>
, private _subrange_::adl_hook
{
CPP_assert(input_or_output_iterator<I>);
CPP_assert(sentinel_for<S, I>);
CPP_assert(K == subrange_kind::sized || !sized_sentinel_for<S, I>);
CPP_assert(K != subrange_kind::sized || !same_as<S, unreachable_sentinel_t>);
using size_type = detail::iter_size_t<I>;
using iterator = I;
using sentinel = S;
subrange() = default;
template(typename I2)(
requires detail::convertible_to_not_slicing_<I2, I> AND
(!detail::store_size_<K, S, I>())) //
constexpr subrange(I2 && i, S s)
: data_{static_cast<I2 &&>(i), std::move(s)}
{}
template(typename I2)(
requires detail::convertible_to_not_slicing_<I2, I> AND
(detail::store_size_<K, S, I>())) //
constexpr subrange(I2 && i, S s, size_type n)
: data_{static_cast<I2 &&>(i), std::move(s), n}
{
if(RANGES_CONSTEXPR_IF((bool)random_access_iterator<I>))
{
using D = iter_difference_t<I>;
RANGES_EXPECT(n <= (size_type)std::numeric_limits<D>::max());
RANGES_EXPECT(ranges::next(first_(), (D)n) == last_());
}
}
template(typename I2)(
requires detail::convertible_to_not_slicing_<I2, I> AND
sized_sentinel_for<S, I>)
constexpr subrange(I2 && i, S s, size_type n)
: data_{static_cast<I2 &&>(i), std::move(s)}
{
RANGES_EXPECT(static_cast<size_type>(last_() - first_()) == n);
}
template(typename R)(
requires (!same_as<detail::decay_t<R>, subrange>) AND
detail::range_convertible_to_<R, I, S> AND
(!detail::store_size_<K, S, I>()))
constexpr subrange(R && r)
: subrange{ranges::begin(r), ranges::end(r)}
{}
template(typename R)(
requires (!same_as<detail::decay_t<R>, subrange>) AND
detail::range_convertible_to_<R, I, S> AND
(detail::store_size_<K, S, I>()) AND
sized_range<R>)
constexpr subrange(R && r)
: subrange{ranges::begin(r), ranges::end(r), ranges::size(r)}
{}
template(typename R)(
requires (K == subrange_kind::sized) AND
detail::range_convertible_to_<R, I, S>)
constexpr subrange(R && r, size_type n) //
: subrange{ranges::begin(r), ranges::end(r), n}
{
if(RANGES_CONSTEXPR_IF((bool)sized_range<R>))
{
RANGES_EXPECT(n == ranges::size(r));
}
}
template(typename PairLike)(
requires (!same_as<PairLike, subrange>) AND
detail::pair_like_convertible_from_<PairLike, I const &, S const &>)
constexpr operator PairLike() const
{
return PairLike(first_(), last_());
}
constexpr I begin() const noexcept(std::is_nothrow_copy_constructible<I>::value)
{
return first_();
}
constexpr S end() const noexcept(std::is_nothrow_copy_constructible<S>::value)
{
return last_();
}
constexpr bool empty() const
{
return first_() == last_();
}
CPP_member
constexpr auto size() const //
-> CPP_ret(size_type)(
requires (K == subrange_kind::sized))
{
return get_size_();
}
RANGES_NODISCARD
constexpr subrange next(iter_difference_t<I> n = 1) const
{
auto tmp = *this;
tmp.advance(n);
return tmp;
}
CPP_member
RANGES_NODISCARD constexpr auto prev(iter_difference_t<I> n = 1) const
-> CPP_ret(subrange)(
requires bidirectional_iterator<I>)
{
auto tmp = *this;
tmp.advance(-n);
return tmp;
}
constexpr subrange & advance(iter_difference_t<I> n)
{
set_size_(static_cast<size_type>(n - ranges::advance(first_(), n, last_())));
return *this;
}
private:
using data_t =
meta::conditional_t< //
detail::store_size_<K, S, I>(), //
std::tuple<I, S, size_type>, //
std::tuple<I, S>>;
data_t data_;
constexpr I & first_() noexcept
{
return std::get<0>(data_);
}
constexpr const I & first_() const noexcept
{
return std::get<0>(data_);
}
constexpr S & last_() noexcept
{
return std::get<1>(data_);
}
constexpr const S & last_() const noexcept
{
return std::get<1>(data_);
}
CPP_member
constexpr auto get_size_() const //
-> CPP_ret(size_type)(
requires sized_sentinel_for<S, I>)
{
return static_cast<size_type>(last_() - first_());
}
CPP_member
constexpr auto get_size_() const noexcept //
-> CPP_ret(size_type)(
requires (detail::store_size_<K, S, I>()))
{
return std::get<2>(data_);
}
static constexpr void set_size_(...) noexcept
{}
CPP_member
constexpr auto set_size_(size_type n) noexcept //
-> CPP_ret(void)(
requires (detail::store_size_<K, S, I>()))
{
std::get<2>(data_) = get_size_() - n;
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename I, typename S>
subrange(I, S) //
-> subrange<I, S>;
template(typename I, typename S)(
requires input_or_output_iterator<I> AND sentinel_for<S, I>)
subrange(I, S, detail::iter_size_t<I>)
-> subrange<I, S, subrange_kind::sized>;
template(typename R)(
requires borrowed_range<R>)
subrange(R &&) //
-> subrange<iterator_t<R>, sentinel_t<R>,
(sized_range<R> ||
sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)
? subrange_kind::sized
: subrange_kind::unsized>;
template(typename R)(
requires borrowed_range<R>)
subrange(R &&, detail::iter_size_t<iterator_t<R>>)
-> subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized>;
#endif
// in lieu of deduction guides, use make_subrange
struct make_subrange_fn
{
template<typename I, typename S>
constexpr subrange<I, S> operator()(I i, S s) const
{
return {i, s};
}
template(typename I, typename S)(
requires input_or_output_iterator<I> AND sentinel_for<S, I>)
constexpr subrange<I, S, subrange_kind::sized> //
operator()(I i, S s, detail::iter_size_t<I> n) const
{
return {i, s, n};
}
template(typename R)(
requires borrowed_range<R>)
constexpr auto operator()(R && r) const
-> subrange<iterator_t<R>, sentinel_t<R>,
(sized_range<R> || sized_sentinel_for<sentinel_t<R>, iterator_t<R>>)
? subrange_kind::sized
: subrange_kind::unsized>
{
return {(R &&) r};
}
template(typename R)(
requires borrowed_range<R>)
constexpr subrange<iterator_t<R>, sentinel_t<R>, subrange_kind::sized> //
operator()(R && r, detail::iter_size_t<iterator_t<R>> n) const
{
return {(R &&) r, n};
}
};
/// \relates make_subrange_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(make_subrange_fn, make_subrange)
template<typename R>
using borrowed_subrange_t = detail::maybe_dangling_<R, subrange<iterator_t<R>>>;
template<typename R>
using safe_subrange_t RANGES_DEPRECATED("Use borrowed_subrange_t instead.") =
borrowed_subrange_t<R>;
namespace cpp20
{
using ranges::subrange_kind;
template(typename I, //
typename S = I, //
subrange_kind K = //
static_cast<subrange_kind>( //
detail::is_sized_sentinel_<S, I>()))(
requires input_or_output_iterator<I> AND sentinel_for<S, I> AND
(K == subrange_kind::sized || !sized_sentinel_for<S, I>)) //
using subrange = ranges::subrange<I, S, K>;
using ranges::borrowed_subrange_t;
template<typename R>
using safe_subrange_t RANGES_DEPRECATED("Use borrowed_subrange_t instead.") =
borrowed_subrange_t<R>;
} // namespace cpp20
/// @}
} // namespace ranges
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
namespace std
{
template<typename I, typename S, ::ranges::subrange_kind K>
struct tuple_size<::ranges::subrange<I, S, K>> : std::integral_constant<size_t, 2>
{};
template<typename I, typename S, ::ranges::subrange_kind K>
struct tuple_element<0, ::ranges::subrange<I, S, K>>
{
using type = I;
};
template<typename I, typename S, ::ranges::subrange_kind K>
struct tuple_element<1, ::ranges::subrange<I, S, K>>
{
using type = S;
};
} // namespace std
RANGES_DIAGNOSTIC_POP
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/chunk_by.hpp | /// \file
// Range v3 library
//
// Copyright Hui Xie 2021
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_CHUNK_BY_HPP
#define RANGES_V3_VIEW_CHUNK_BY_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/algorithm/adjacent_find.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/not_fn.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/subrange.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng, typename Fun>
struct chunk_by_view
: view_facade<chunk_by_view<Rng, Fun>,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
{
private:
friend range_access;
Rng rng_;
// cached version of the end of the first subrange / start of the second subrange
detail::non_propagating_cache<iterator_t<Rng>> second_;
semiregular_box_t<Fun> fun_;
struct cursor
{
private:
friend range_access;
friend chunk_by_view;
iterator_t<Rng> cur_;
iterator_t<Rng> next_cur_;
sentinel_t<Rng> last_;
semiregular_box_ref_or_val_t<Fun, false> fun_;
#ifdef _MSC_VER
template<typename I = iterator_t<Rng>>
subrange<I> read() const
{
return {cur_, next_cur_};
}
#else
subrange<iterator_t<Rng>> read() const
{
return {cur_, next_cur_};
}
#endif
void next()
{
cur_ = next_cur_;
auto partition_cur = adjacent_find(cur_, last_, not_fn(fun_));
next_cur_ =
partition_cur != last_ ? ranges::next(partition_cur) : partition_cur;
}
bool equal(default_sentinel_t) const
{
return cur_ == last_;
}
bool equal(cursor const & that) const
{
return cur_ == that.cur_;
}
cursor(semiregular_box_ref_or_val_t<Fun, false> fun, iterator_t<Rng> first,
iterator_t<Rng> next_cur, sentinel_t<Rng> last)
: cur_(first)
, next_cur_(next_cur)
, last_(last)
, fun_(fun)
{}
public:
cursor() = default;
};
cursor begin_cursor()
{
auto first = ranges::begin(rng_);
auto last = ranges::end(rng_);
if(!second_)
{
auto partition_cur = adjacent_find(first, last, not_fn(fun_));
second_ =
partition_cur != last ? ranges::next(partition_cur) : partition_cur;
}
return {fun_, first, *second_, last};
}
public:
chunk_by_view() = default;
constexpr chunk_by_view(Rng rng, Fun fun)
: rng_(std::move(rng))
, fun_(std::move(fun))
{}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Fun)(
requires copy_constructible<Fun>) chunk_by_view(Rng &&, Fun)
->chunk_by_view<views::all_t<Rng>, Fun>;
#endif
namespace views
{
struct chunk_by_base_fn
{
template(typename Rng, typename Fun)(
requires viewable_range<Rng> AND forward_range<Rng> AND //
indirect_relation<Fun, iterator_t<Rng>>) //
constexpr chunk_by_view<all_t<Rng>, Fun>
operator()(Rng && rng, Fun fun) const
{
return {all(static_cast<Rng &&>(rng)), std::move(fun)};
}
};
struct chunk_by_fn : chunk_by_base_fn
{
using chunk_by_base_fn::operator();
template<typename Fun>
constexpr auto operator()(Fun fun) const
{
return make_view_closure(bind_back(chunk_by_base_fn{}, std::move(fun)));
}
};
/// \relates chunk_by_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(chunk_by_fn, chunk_by)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::chunk_by_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/stride.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
// Copyright Casey Carter 2017
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_STRIDE_HPP
#define RANGES_V3_VIEW_STRIDE_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
template<typename Rng>
struct stride_view;
namespace detail
{
template<typename Rng>
using stride_view_adaptor =
view_adaptor<stride_view<Rng>, Rng,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>;
// Bidirectional stride views need to remember the distance between
// the penultimate iterator and the last iterator - which may be less
// than the stride - so that decrementing an last iterator properly
// produces the penultimate iterator. stride_view_base specializes on
// that distinction so that only Bidirectional stride views have the
// data member "offset_".
template<typename Rng, bool BidiRange>
struct stride_view_base_;
template<typename Rng>
using stride_view_base = stride_view_base_<Rng, (bool)bidirectional_range<Rng>>;
template<typename Rng, bool /*= bidirectional_range<Rng>*/>
struct stride_view_base_ : stride_view_adaptor<Rng>
{
stride_view_base_() = default;
constexpr stride_view_base_(Rng && rng, range_difference_t<Rng> const stride)
: stride_view_adaptor<Rng>{std::move(rng)}
, stride_{(RANGES_EXPECT(0 < stride), stride)}
, offset_{calc_offset(meta::bool_<sized_range<Rng>>{})}
{}
protected:
constexpr void set_offset(range_difference_t<Rng> const delta) noexcept
{
RANGES_EXPECT(0 <= delta && delta < stride_);
if(0 > offset_)
offset_ = delta;
else
RANGES_EXPECT(offset_ == delta);
}
constexpr void set_offset(range_difference_t<Rng> const) const noexcept
{}
constexpr range_difference_t<Rng> get_offset(bool check = true) const noexcept
{
RANGES_EXPECT(!check || 0 <= offset_);
return offset_;
}
range_difference_t<Rng> stride_;
range_difference_t<Rng> offset_ = -1;
private:
constexpr range_difference_t<Rng> calc_offset(std::true_type)
{
if(auto const rem = ranges::distance(this->base()) % stride_)
return stride_ - rem;
else
return 0;
}
constexpr range_difference_t<Rng> calc_offset(std::false_type) const noexcept
{
return -1;
}
};
template<typename Rng>
struct stride_view_base_<Rng, false> : stride_view_adaptor<Rng>
{
stride_view_base_() = default;
constexpr stride_view_base_(Rng && rng, range_difference_t<Rng> const stride)
: stride_view_adaptor<Rng>{std::move(rng)}
, stride_{(RANGES_EXPECT(0 < stride), stride)}
{}
protected:
constexpr void set_offset(range_difference_t<Rng> const) const noexcept
{}
constexpr range_difference_t<Rng> get_offset(bool = true) const noexcept
{
return 0;
}
range_difference_t<Rng> stride_;
};
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
template<typename Rng>
struct stride_view : detail::stride_view_base<Rng>
{
private:
friend range_access;
// stride_view const models Range if Rng const models Range, and
// either (1) Rng is sized, so we can pre-calculate offset_, or (2)
// Rng is !Bidirectional, so it does not need offset_.
static constexpr bool const_iterable() noexcept
{
return range<Rng const> &&
(sized_range<Rng const> || !bidirectional_range<Rng const>);
}
// If the underlying range doesn't model common_range, then we can't
// decrement the last and there's no reason to adapt the sentinel. Strictly
// speaking, we don't have to adapt the last iterator of input and forward
// ranges, but in the interests of making the resulting stride view model
// common_range, adapt it anyway.
template<bool Const>
static constexpr bool can_bound() noexcept
{
using CRng = meta::const_if_c<Const, Rng>;
return common_range<CRng> &&
(sized_range<CRng> || !bidirectional_range<CRng>);
}
template<bool Const>
struct adaptor : adaptor_base
{
private:
friend struct adaptor<!Const>;
using CRng = meta::const_if_c<Const, Rng>;
using stride_view_t = meta::const_if_c<Const, stride_view>;
stride_view_t * rng_;
public:
adaptor() = default;
constexpr adaptor(stride_view_t * rng) noexcept
: rng_(rng)
{}
template(bool Other)(
requires Const AND CPP_NOT(Other)) //
adaptor(adaptor<Other> that)
: rng_(that.rng_)
{}
constexpr void next(iterator_t<CRng> & it)
{
auto const last = ranges::end(rng_->base());
RANGES_EXPECT(it != last);
auto const delta = ranges::advance(it, rng_->stride_, last);
if(it == last)
{
rng_->set_offset(delta);
}
}
CPP_member
constexpr auto prev(iterator_t<CRng> & it) //
-> CPP_ret(void)(
requires bidirectional_range<CRng>)
{
RANGES_EXPECT(it != ranges::begin(rng_->base()));
auto delta = -rng_->stride_;
if(it == ranges::end(rng_->base()))
{
RANGES_EXPECT(rng_->get_offset() >= 0);
delta += rng_->get_offset();
}
ranges::advance(it, delta);
}
template(typename Other)(
requires sized_sentinel_for<Other, iterator_t<CRng>>)
constexpr range_difference_t<Rng> distance_to(iterator_t<CRng> const & here,
Other const & there) const
{
range_difference_t<Rng> delta = there - here;
if(delta < 0)
delta -= rng_->stride_ - 1;
else
delta += rng_->stride_ - 1;
return delta / rng_->stride_;
}
CPP_member
constexpr auto advance(iterator_t<CRng> & it, range_difference_t<Rng> n) //
-> CPP_ret(void)(
requires random_access_range<CRng>)
{
if(0 == n)
return;
n *= rng_->stride_;
auto const last = ranges::end(rng_->base());
if(it == last)
{
RANGES_EXPECT(n < 0);
RANGES_EXPECT(rng_->get_offset() >= 0);
n += rng_->get_offset();
}
if(0 < n)
{
auto delta = ranges::advance(it, n, last);
if(it == last)
{
// advance hit the last of the base range.
rng_->set_offset(delta % rng_->stride_);
}
}
else if(0 > n)
{
#ifdef NDEBUG
ranges::advance(it, n);
#else
auto const first = ranges::begin(rng_->base());
auto const delta = ranges::advance(it, n, first);
RANGES_EXPECT(delta == 0);
#endif
}
}
};
constexpr adaptor<false> begin_adaptor() noexcept
{
return adaptor<false>{this};
}
CPP_member
constexpr auto begin_adaptor() const noexcept
-> CPP_ret(adaptor<true>)(
requires(const_iterable()))
{
return adaptor<true>{this};
}
constexpr meta::if_c<can_bound<false>(), adaptor<false>, adaptor_base> //
end_adaptor() noexcept
{
return {this};
}
CPP_member
constexpr auto end_adaptor() const noexcept //
-> CPP_ret(meta::if_c<can_bound<true>(), adaptor<true>, adaptor_base>)(
requires (const_iterable()))
{
return {this};
}
public:
stride_view() = default;
constexpr stride_view(Rng rng, range_difference_t<Rng> const stride)
: detail::stride_view_base<Rng>{std::move(rng), stride}
{}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires sized_range<Rng>)
{
using size_type = range_size_t<Rng>;
auto const n = ranges::size(this->base());
return (n + static_cast<size_type>(this->stride_) - 1) /
static_cast<size_type>(this->stride_);
}
CPP_auto_member
constexpr auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
using size_type = range_size_t<Rng const>;
auto const n = ranges::size(this->base());
return (n + static_cast<size_type>(this->stride_) - 1) /
static_cast<size_type>(this->stride_);
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
stride_view(Rng &&, range_difference_t<Rng>)
-> stride_view<views::all_t<Rng>>;
#endif
namespace views
{
struct stride_base_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng>)
constexpr stride_view<all_t<Rng>> //
operator()(Rng && rng, range_difference_t<Rng> step) const
{
return stride_view<all_t<Rng>>{all(static_cast<Rng &&>(rng)), step};
}
};
struct stride_fn : stride_base_fn
{
using stride_base_fn::operator();
template(typename Difference)(
requires detail::integer_like_<Difference>)
constexpr auto operator()(Difference step) const
{
return make_view_closure(bind_back(stride_base_fn{}, step));
}
};
/// \relates stride_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(stride_fn, stride)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::stride_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/drop.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_DROP_HPP
#define RANGES_V3_VIEW_DROP_HPP
#include <type_traits>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/algorithm/min.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/box.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/view/subrange.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng>
struct RANGES_EMPTY_BASES drop_view
: view_interface<drop_view<Rng>,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
, private detail::non_propagating_cache<iterator_t<Rng>, drop_view<Rng>,
!random_access_range<Rng>>
{
private:
using difference_type_ = range_difference_t<Rng>;
Rng rng_;
difference_type_ n_;
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng>>)
iterator_t<meta::const_if_c<Const, Rng>> //
get_begin_(std::true_type, std::true_type) const
{
CPP_assert(random_access_range<meta::const_if_c<Const, Rng>>);
return next(ranges::begin(rng_), n_, ranges::end(rng_));
}
iterator_t<Rng> get_begin_(std::true_type, std::false_type)
{
CPP_assert(random_access_range<Rng>);
return next(ranges::begin(rng_), n_, ranges::end(rng_));
}
iterator_t<Rng> get_begin_(std::false_type, detail::ignore_t)
{
CPP_assert(!random_access_range<Rng>);
using cache_t =
detail::non_propagating_cache<iterator_t<Rng>, drop_view<Rng>>;
auto & begin_ = static_cast<cache_t &>(*this);
if(!begin_)
begin_ = next(ranges::begin(rng_), n_, ranges::end(rng_));
return *begin_;
}
public:
drop_view() = default;
drop_view(Rng rng, difference_type_ n)
: rng_(std::move(rng))
, n_(n)
{
RANGES_EXPECT(n >= 0);
}
iterator_t<Rng> begin()
{
return this->get_begin_(meta::bool_<random_access_range<Rng>>{},
std::false_type{});
}
sentinel_t<Rng> end()
{
return ranges::end(rng_);
}
template(bool Const = true)(
requires Const AND random_access_range<meta::const_if_c<Const, Rng>>)
iterator_t<meta::const_if_c<Const, Rng>> begin() const
{
return this->get_begin_(std::true_type{}, std::true_type{});
}
template(bool Const = true)(
requires Const AND random_access_range<meta::const_if_c<Const, Rng>>)
sentinel_t<meta::const_if_c<Const, Rng>> end() const
{
return ranges::end(rng_);
}
CPP_auto_member
auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
auto const s = ranges::size(rng_);
auto const n = static_cast<range_size_t<Rng const>>(n_);
return s < n ? 0 : s - n;
}
CPP_auto_member
auto CPP_fun(size)()(
requires sized_range<Rng>)
{
auto const s = ranges::size(rng_);
auto const n = static_cast<range_size_t<Rng>>(n_);
return s < n ? 0 : s - n;
}
Rng base() const
{
return rng_;
}
};
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<drop_view<Rng>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
drop_view(Rng &&, range_difference_t<Rng>)
-> drop_view<views::all_t<Rng>>;
#endif
namespace views
{
struct drop_base_fn
{
private:
template<typename Rng>
static auto impl_(Rng && rng, range_difference_t<Rng> n, input_range_tag)
-> drop_view<all_t<Rng>>
{
return {all(static_cast<Rng &&>(rng)), n};
}
template(typename Rng)(
requires borrowed_range<Rng> AND sized_range<Rng>)
static subrange<iterator_t<Rng>, sentinel_t<Rng>> //
impl_(Rng && rng, range_difference_t<Rng> n, random_access_range_tag)
{
return {begin(rng) + ranges::min(n, distance(rng)), end(rng)};
}
public:
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng>)
auto operator()(Rng && rng, range_difference_t<Rng> n) const
{
return drop_base_fn::impl_(
static_cast<Rng &&>(rng), n, range_tag_of<Rng>{});
}
};
struct drop_fn : drop_base_fn
{
using drop_base_fn::operator();
template(typename Int)(
requires detail::integer_like_<Int>)
constexpr auto operator()(Int n) const
{
return make_view_closure(bind_back(drop_base_fn{}, n));
}
};
/// \relates drop_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(drop_fn, drop)
} // namespace views
namespace cpp20
{
namespace views
{
using ranges::views::drop;
}
template(typename Rng)(
requires view_<Rng>)
using drop_view = ranges::drop_view<Rng>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::drop_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/slice.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_SLICE_HPP
#define RANGES_V3_VIEW_SLICE_HPP
#include <type_traits>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/counted_iterator.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/drop_exactly.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/subrange.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
template<typename Rng, typename Int>
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);
}
template<typename Rng, typename Int>
iterator_t<Rng> pos_at_(Rng && rng, Int i, bidirectional_range_tag,
std::false_type)
{
if(0 > i)
{
// If it's not common and we know the size, faster to count from the front
if(RANGES_CONSTEXPR_IF(sized_range<Rng> && !common_range<Rng>))
return next(ranges::begin(rng), distance(rng) + i);
// Otherwise, probably faster to count from the back.
return next(ranges::next(ranges::begin(rng), ranges::end(rng)), i);
}
return next(ranges::begin(rng), i);
}
template<typename Rng, typename Int>
iterator_t<Rng> pos_at_(Rng && rng, Int i, input_range_tag, std::false_type)
{
RANGES_EXPECT(i >= 0 || (bool)sized_range<Rng> || (bool)forward_range<Rng>);
if(0 > i)
return next(ranges::begin(rng), distance(rng) + i);
return next(ranges::begin(rng), i);
}
template<typename Rng, bool IsRandomAccess>
struct slice_view_ : view_facade<slice_view<Rng>, finite>
{
private:
friend range_access;
Rng rng_;
range_difference_t<Rng> from_, count_;
detail::non_propagating_cache<iterator_t<Rng>> begin_;
iterator_t<Rng> get_begin_()
{
if(!begin_)
begin_ = detail::pos_at_(
rng_, from_, range_tag_of<Rng>{}, is_infinite<Rng>{});
return *begin_;
}
public:
slice_view_() = default;
constexpr slice_view_(Rng rng, range_difference_t<Rng> from,
range_difference_t<Rng> count)
: rng_(std::move(rng))
, from_(from)
, count_(count)
{}
counted_iterator<iterator_t<Rng>> begin()
{
return make_counted_iterator(get_begin_(), count_);
}
default_sentinel_t end()
{
return {};
}
auto size() const
{
return static_cast<detail::iter_size_t<iterator_t<Rng>>>(count_);
}
Rng base() const
{
return rng_;
}
};
template<typename Rng>
struct slice_view_<Rng, true> : view_interface<slice_view<Rng>, finite>
{
private:
Rng rng_;
range_difference_t<Rng> from_, count_;
public:
slice_view_() = default;
constexpr 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_);
}
iterator_t<Rng> begin()
{
return detail::pos_at_(
rng_, from_, range_tag_of<Rng>{}, is_infinite<Rng>{});
}
iterator_t<Rng> end()
{
return detail::pos_at_(
rng_, from_, range_tag_of<Rng>{}, is_infinite<Rng>{}) +
count_;
}
template(typename BaseRng = Rng)(
requires range<BaseRng const>)
iterator_t<BaseRng const> begin() const
{
return detail::pos_at_(
rng_, from_, range_tag_of<Rng>{}, is_infinite<Rng>{});
}
template(typename BaseRng = Rng)(
requires range<BaseRng const>)
iterator_t<BaseRng const> end() const
{
return detail::pos_at_(
rng_, from_, range_tag_of<Rng>{}, is_infinite<Rng>{}) +
count_;
}
auto size() const
{
return static_cast<detail::iter_size_t<iterator_t<Rng>>>(count_);
}
Rng base() const
{
return rng_;
}
};
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
template<typename Rng>
struct slice_view : detail::slice_view_<Rng, (bool)random_access_range<Rng>>
{
using detail::slice_view_<Rng, (bool)random_access_range<Rng>>::slice_view_;
};
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<slice_view<Rng>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
slice_view(Rng &&, range_difference_t<Rng>, range_difference_t<Rng>)
->slice_view<views::all_t<Rng>>;
#endif
namespace views
{
struct slice_base_fn
{
private:
template<typename Rng>
static constexpr slice_view<all_t<Rng>> impl_(Rng && rng,
range_difference_t<Rng> from,
range_difference_t<Rng> count,
input_range_tag, range_tag = {})
{
return {all(static_cast<Rng &&>(rng)), from, count};
}
template(typename Rng)(
requires borrowed_range<Rng>)
static subrange<iterator_t<Rng>> impl_(Rng && rng,
range_difference_t<Rng> from,
range_difference_t<Rng> count,
random_access_range_tag,
common_range_tag = {})
{
auto it =
detail::pos_at_(rng, from, range_tag_of<Rng>{}, is_infinite<Rng>{});
return {it, it + count};
}
public:
// slice(rng, 2, 4)
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng>)
constexpr auto operator()(Rng && rng,
range_difference_t<Rng> from,
range_difference_t<Rng> to) const
{
RANGES_EXPECT(0 <= from && from <= to);
return slice_base_fn::impl_(
static_cast<Rng &&>(rng), from, to - from, range_tag_of<Rng>{});
}
// slice(rng, 4, end-2)
// TODO Support Forward, non-Sized ranges by returning a range that
// doesn't know it's size?
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng> AND sized_range<Rng>)
auto operator()(Rng && rng,
range_difference_t<Rng> from,
detail::from_end_of_t<Rng> to) const
{
static_assert(!is_infinite<Rng>::value,
"Can't index from the end of an infinite range!");
RANGES_EXPECT(0 <= from);
RANGES_ASSERT(from <= distance(rng) + to.dist_);
return slice_base_fn::impl_(static_cast<Rng &&>(rng),
from,
distance(rng) + to.dist_ - from,
range_tag_of<Rng>{});
}
// slice(rng, end-4, end-2)
template(typename Rng)(
requires viewable_range<Rng> AND
(forward_range<Rng> || (input_range<Rng> && sized_range<Rng>)))
auto operator()(Rng && rng,
detail::from_end_of_t<Rng> from,
detail::from_end_of_t<Rng> to) const
{
static_assert(!is_infinite<Rng>::value,
"Can't index from the end of an infinite range!");
RANGES_EXPECT(from.dist_ <= to.dist_);
return slice_base_fn::impl_(static_cast<Rng &&>(rng),
from.dist_,
to.dist_ - from.dist_,
range_tag_of<Rng>{},
common_range_tag_of<Rng>{});
}
// slice(rng, 4, end)
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng>)
auto operator()(Rng && rng, range_difference_t<Rng> from, end_fn) const
{
RANGES_EXPECT(0 <= from);
return ranges::views::drop_exactly(static_cast<Rng &&>(rng), from);
}
// slice(rng, end-4, end)
template(typename Rng)(
requires viewable_range<Rng> AND
(forward_range<Rng> || (input_range<Rng> && sized_range<Rng>)))
auto operator()(Rng && rng,
detail::from_end_of_t<Rng> from,
end_fn) const
{
static_assert(!is_infinite<Rng>::value,
"Can't index from the end of an infinite range!");
return slice_base_fn::impl_(static_cast<Rng &&>(rng),
from.dist_,
-from.dist_,
range_tag_of<Rng>{},
common_range_tag_of<Rng>{});
}
};
struct slice_fn : slice_base_fn
{
using slice_base_fn::operator();
// Overloads for the pipe syntax: rng | views::slice(from,to)
template(typename Int)(
requires detail::integer_like_<Int>)
constexpr auto operator()(Int from, Int to) const
{
return make_view_closure(bind_back(slice_base_fn{}, from, to));
}
template(typename Int)(
requires detail::integer_like_<Int>)
constexpr auto operator()(Int from, detail::from_end_<Int> to) const
{
return make_view_closure(bind_back(slice_base_fn{}, from, to));
}
template(typename Int)(
requires detail::integer_like_<Int>)
constexpr auto operator()(detail::from_end_<Int> from,
detail::from_end_<Int> to) const
{
return make_view_closure(bind_back(slice_base_fn{}, from, to));
}
template(typename Int)(
requires detail::integer_like_<Int>)
constexpr auto operator()(Int from, end_fn) const
{
return make_view_closure(
bind_back(ranges::views::drop_exactly_base_fn{}, from));
}
template(typename Int)(
requires detail::integer_like_<Int>)
constexpr auto operator()(detail::from_end_<Int> from, end_fn to) const
{
return make_view_closure(bind_back(slice_base_fn{}, from, to));
}
};
/// \relates _slice_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(slice_fn, slice)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::slice_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/bounded.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_BOUNDED_HPP
#define RANGES_V3_VIEW_BOUNDED_HPP
#include <range/v3/detail/config.hpp>
RANGES_DEPRECATED_HEADER(
"This header is deprecated. Please #include <range/v3/view/common.hpp> instead.")
#include <range/v3/view/common.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/partial_sum.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_PARTIAL_SUM_HPP
#define RANGES_V3_VIEW_PARTIAL_SUM_HPP
#include <iterator>
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/arithmetic.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/addressof.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
// clang-format off
/// \concept partial_sum_view_constraints_
/// \brief The \c partial_sum_view_constraints_ concept
template(typename Rng, typename Fun)(
concept (partial_sum_view_constraints_)(Rng, Fun),
copy_constructible<range_value_t<Rng>> AND
constructible_from<range_value_t<Rng>, range_reference_t<Rng>> AND
assignable_from<range_value_t<Rng> &, range_reference_t<Rng>> AND
indirectly_binary_invocable_<Fun &, iterator_t<Rng>, iterator_t<Rng>> AND
assignable_from<
range_value_t<Rng> &,
indirect_result_t<Fun &, iterator_t<Rng>, iterator_t<Rng>>>
);
/// \concept partial_sum_view_constraints
/// \brief The \c partial_sum_view_constraints concept
template<typename Rng, typename Fun>
CPP_concept partial_sum_view_constraints =
input_range<Rng> &&
copy_constructible<Fun> &&
CPP_concept_ref(detail::partial_sum_view_constraints_, Rng, Fun);
// clang-format on
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
template<typename Rng, typename Fun>
struct partial_sum_view
: view_facade<partial_sum_view<Rng, Fun>, range_cardinality<Rng>::value>
{
private:
friend range_access;
CPP_assert(view_<Rng>);
CPP_assert(detail::partial_sum_view_constraints<Rng, Fun>);
RANGES_NO_UNIQUE_ADDRESS Rng base_{};
RANGES_NO_UNIQUE_ADDRESS semiregular_box_t<Fun> fun_;
template<bool IsConst>
struct cursor
{
private:
friend cursor<true>;
using Parent = meta::const_if_c<IsConst, partial_sum_view>;
using Base = meta::const_if_c<IsConst, Rng>;
Parent * parent_ = nullptr;
RANGES_NO_UNIQUE_ADDRESS iterator_t<Base> current_{};
RANGES_NO_UNIQUE_ADDRESS semiregular_box_t<range_value_t<Rng>> sum_;
public:
using single_pass = meta::bool_<single_pass_iterator_<iterator_t<Base>>>;
cursor() = default;
constexpr explicit cursor(Parent * rng)
: parent_{rng}
, current_(ranges::begin(rng->base_))
{
if(current_ != ranges::end(rng->base_))
sum_ = *current_;
}
template(bool Other)(
requires IsConst AND CPP_NOT(Other) AND
convertible_to<iterator_t<Rng> const &,
iterator_t<Base>>)
constexpr cursor(cursor<Other> const & that)
: parent_{that.parent_}
, current_(that.current_)
, sum_(that.sum_)
{}
constexpr range_value_t<Rng> read() const
{
RANGES_EXPECT(current_ != ranges::end(parent_->base_));
return sum_;
}
constexpr void next()
{
auto last = ranges::end(parent_->base_);
RANGES_EXPECT(current_ != last);
if(++current_ != last)
{
auto & sum = static_cast<range_value_t<Rng> &>(sum_);
using F = meta::const_if_c<IsConst, Fun>;
auto & f = static_cast<F &>(parent_->fun_);
sum = invoke(f, sum, *current_);
}
}
constexpr bool equal(default_sentinel_t) const
{
return current_ == ranges::end(parent_->base_);
}
CPP_auto_member
constexpr bool CPP_fun(equal)(cursor const & that)(const //
requires equality_comparable<iterator_t<Base>>)
{
RANGES_EXPECT(parent_ == that.parent_);
return current_ == that.current_;
}
};
constexpr cursor<false> begin_cursor()
{
return cursor<false>{this};
}
template(typename CRng = Rng const)(
requires detail::partial_sum_view_constraints<CRng, Fun const>)
constexpr cursor<true> begin_cursor() const
{
return cursor<true>{this};
}
public:
partial_sum_view() = default;
constexpr partial_sum_view(Rng rng, Fun fun) noexcept(
std::is_nothrow_move_constructible<Rng>::value &&
std::is_nothrow_move_constructible<Fun>::value)
: base_(std::move(rng))
, fun_(std::move(fun))
{}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return ranges::size(base_);
}
CPP_auto_member
constexpr auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
return ranges::size(base_);
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Fun)(
requires copy_constructible<Fun>)
partial_sum_view(Rng &&, Fun)
-> partial_sum_view<views::all_t<Rng>, Fun>;
#endif
namespace views
{
struct partial_sum_base_fn
{
template(typename Rng, typename Fun = plus)(
requires detail::partial_sum_view_constraints<all_t<Rng>, Fun>)
constexpr partial_sum_view<all_t<Rng>, Fun> //
operator()(Rng && rng, Fun fun = {}) const
{
return {all(static_cast<Rng &&>(rng)), std::move(fun)};
}
};
struct partial_sum_fn : partial_sum_base_fn
{
using partial_sum_base_fn::operator();
template(typename Fun)(
requires (!range<Fun>))
constexpr auto operator()(Fun && fun) const
{
return make_view_closure(
bind_back(partial_sum_base_fn{}, static_cast<Fun &&>(fun)));
}
template<typename Fun = plus>
RANGES_DEPRECATED(
"Use \"ranges::views::partial_sum\" instead of "
"\"ranges::views::partial_sum()\".")
constexpr auto
operator()() const
{
return make_view_closure(bind_back(partial_sum_base_fn{}, Fun{}));
}
};
/// \relates partial_sum_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<partial_sum_fn>, partial_sum)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::partial_sum_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/exclusive_scan.hpp | /// \file
// Range v3 library
//
// Copyright Mitsutaka Takeda 2018-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_EXCLUSIVE_SCAN_HPP
#define RANGES_V3_VIEW_EXCLUSIVE_SCAN_HPP
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/arithmetic.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
// clang-format off
/// \concept exclusive_scan_constraints_
/// \brief The \c exclusive_scan_constraints_ concept
template(typename Rng, typename T, typename Fun)(
concept (exclusive_scan_constraints_)(Rng, T, Fun),
invocable<Fun &, T, range_reference_t<Rng>> AND
assignable_from<T &, invoke_result_t<Fun &, T, range_reference_t<Rng>>>
);
/// \concept exclusive_scan_constraints
/// \brief The \c exclusive_scan_constraints concept
template<typename Rng, typename T, typename Fun>
CPP_concept exclusive_scan_constraints =
viewable_range<Rng> && input_range<Rng> &&
copy_constructible<T> &&
CPP_concept_ref(ranges::exclusive_scan_constraints_, Rng, T, Fun);
// clang-format on
/// \addtogroup group-views
/// @{
template<typename Rng, typename T, typename Fun>
struct exclusive_scan_view : view_adaptor<exclusive_scan_view<Rng, T, Fun>, Rng>
{
private:
friend range_access;
CPP_assert(exclusive_scan_constraints<Rng, T, Fun>);
semiregular_box_t<T> init_;
semiregular_box_t<Fun> fun_;
using single_pass = meta::bool_<single_pass_iterator_<iterator_t<Rng>>>;
using use_sentinel_t = meta::bool_<!common_range<Rng> || single_pass{}>;
template<bool IsConst>
struct adaptor : adaptor_base
{
private:
friend struct adaptor<!IsConst>;
using exclusive_scan_view_t = meta::const_if_c<IsConst, exclusive_scan_view>;
using CRng = meta::const_if_c<IsConst, Rng>;
semiregular_box_t<T> sum_;
exclusive_scan_view_t * rng_;
// clang-format off
auto CPP_auto_fun(move_or_copy_init)(std::false_type)
(
return (rng_->init_)
)
// If the base range is single-pass, we can move the init value.
auto CPP_auto_fun(move_or_copy_init)(std::true_type)
(
return std::move(rng_->init_)
)
// clang-format on
public : using single_pass = exclusive_scan_view::single_pass;
adaptor() = default;
adaptor(exclusive_scan_view_t * rng)
: rng_(rng)
{}
template(bool Other)(
requires IsConst AND CPP_NOT(Other)) //
adaptor(adaptor<Other> that)
: rng_(that.rng_)
{}
iterator_t<CRng> begin(exclusive_scan_view_t &)
{
sum_ = move_or_copy_init(single_pass{});
return ranges::begin(rng_->base());
}
T read(iterator_t<CRng> const &) const
{
return sum_;
}
void next(iterator_t<CRng> & it)
{
RANGES_EXPECT(it != ranges::end(rng_->base()));
sum_ = invoke(rng_->fun_, static_cast<T &&>(std::move(sum_)), *it);
++it;
}
void prev() = delete;
};
adaptor<false> begin_adaptor()
{
return {this};
}
meta::if_<use_sentinel_t, adaptor_base, adaptor<false>> end_adaptor()
{
return {this};
}
CPP_member
auto begin_adaptor() const //
-> CPP_ret(adaptor<true>)(
requires exclusive_scan_constraints<Rng const, T, Fun const>)
{
return {this};
}
CPP_member
auto end_adaptor() const
-> CPP_ret(meta::if_<use_sentinel_t, adaptor_base, adaptor<true>>)(
requires exclusive_scan_constraints<Rng const, T, Fun const>)
{
return {this};
}
public:
exclusive_scan_view() = default;
constexpr exclusive_scan_view(Rng rng, T init, Fun fun)
: exclusive_scan_view::view_adaptor{std::move(rng)}
, init_(std::move(init))
, fun_(std::move(fun))
{}
CPP_auto_member
auto CPP_fun(size)()(const
requires sized_range<Rng const>)
{
return ranges::size(this->base());
}
CPP_auto_member
auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return ranges::size(this->base());
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename T, typename Fun)(
requires copy_constructible<T> AND copy_constructible<Fun>)
exclusive_scan_view(Rng &&, T, Fun) //
-> exclusive_scan_view<views::all_t<Rng>, T, Fun>;
#endif
namespace views
{
struct exclusive_scan_base_fn
{
template(typename Rng, typename T, typename Fun = plus)(
requires exclusive_scan_constraints<Rng, T, Fun>)
constexpr exclusive_scan_view<all_t<Rng>, T, Fun> //
operator()(Rng && rng, T init, Fun fun = Fun{}) const
{
return {all(static_cast<Rng &&>(rng)), std::move(init), std::move(fun)};
}
};
struct exclusive_scan_fn : exclusive_scan_base_fn
{
using exclusive_scan_base_fn::operator();
template<typename T, typename Fun = plus>
constexpr auto operator()(T init, Fun fun = {}) const
{
return make_view_closure(
bind_back(exclusive_scan_base_fn{}, std::move(init), std::move(fun)));
}
};
/// \relates exclusive_scan_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(exclusive_scan_fn, exclusive_scan)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_VIEW_EXCLUSIVE_SCAN_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/generate_n.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_GENERATE_N_HPP
#define RANGES_V3_VIEW_GENERATE_N_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/generate.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename G>
struct generate_n_view : view_facade<generate_n_view<G>, finite>
{
private:
friend range_access;
using result_t = invoke_result_t<G &>;
semiregular_box_t<G> gen_;
detail::non_propagating_cache<result_t> val_;
std::size_t n_;
struct cursor
{
private:
generate_n_view * rng_;
public:
cursor() = default;
explicit cursor(generate_n_view * rng)
: rng_(rng)
{}
bool equal(default_sentinel_t) const
{
return 0 == rng_->n_;
}
result_t && read() const
{
if(!rng_->val_)
rng_->val_.emplace(rng_->gen_());
return static_cast<result_t &&>(static_cast<result_t &>(*rng_->val_));
}
void next()
{
RANGES_EXPECT(0 != rng_->n_);
if(rng_->val_)
rng_->val_.reset();
else
static_cast<void>(rng_->gen_());
--rng_->n_;
}
};
cursor begin_cursor()
{
return cursor{this};
}
public:
generate_n_view() = default;
explicit generate_n_view(G g, std::size_t n)
: gen_(std::move(g))
, n_(n)
{}
result_t & cached()
{
return *val_;
}
std::size_t size() const
{
return n_;
}
};
namespace views
{
struct generate_n_fn
{
template(typename G)(
requires invocable<G &> AND copy_constructible<G> AND
std::is_object<detail::decay_t<invoke_result_t<G &>>>::value AND
constructible_from<detail::decay_t<invoke_result_t<G &>>,
invoke_result_t<G &>> AND
assignable_from<detail::decay_t<invoke_result_t<G &>> &,
invoke_result_t<G &>>)
generate_n_view<G> operator()(G g, std::size_t n) const
{
return generate_n_view<G>{std::move(g), n};
}
};
/// \relates generate_n_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(generate_n_fn, generate_n)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::generate_n_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/cache1.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_CACHE1_HPP
#define RANGES_V3_VIEW_CACHE1_HPP
#include <range/v3/range_fwd.hpp>
#include <range/v3/detail/range_access.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng>
struct cache1_view : view_facade<cache1_view<Rng>, range_cardinality<Rng>::value>
{
private:
CPP_assert(view_<Rng>);
CPP_assert(input_range<Rng>);
CPP_assert(constructible_from<range_value_t<Rng>, range_reference_t<Rng>>);
friend range_access;
Rng rng_;
bool dirty_ = true;
detail::non_propagating_cache<range_value_t<Rng>> cache_;
CPP_member
auto update_(range_reference_t<Rng> && val) //
-> CPP_ret(void)(
requires assignable_from<range_value_t<Rng> &, range_reference_t<Rng>>)
{
if(!cache_)
cache_.emplace(static_cast<range_reference_t<Rng> &&>(val));
else
*cache_ = static_cast<range_reference_t<Rng> &&>(val);
}
CPP_member
auto update_(range_reference_t<Rng> && val) //
-> CPP_ret(void)(
requires (!assignable_from<range_value_t<Rng> &, range_reference_t<Rng>>))
{
cache_.emplace(static_cast<range_reference_t<Rng> &&>(val));
}
struct cursor;
struct sentinel
{
private:
friend cursor;
sentinel_t<Rng> last_;
public:
sentinel() = default;
constexpr explicit sentinel(sentinel_t<Rng> last)
: last_(std::move(last))
{}
};
struct cursor
{
private:
cache1_view * parent_;
iterator_t<Rng> current_;
public:
using value_type = range_value_t<Rng>;
using single_pass = std::true_type;
using difference_type = range_difference_t<Rng>;
cursor() = default;
constexpr explicit cursor(cache1_view * parent, iterator_t<Rng> current)
: parent_(parent)
, current_(std::move(current))
{}
range_value_t<Rng> && read() const
{
if(parent_->dirty_)
{
parent_->update_(*current_);
parent_->dirty_ = false;
}
return std::move(*parent_->cache_);
}
void next()
{
++current_;
parent_->dirty_ = true;
}
bool equal(cursor const & that) const
{
return current_ == that.current_;
}
bool equal(sentinel const & that) const
{
return current_ == that.last_;
}
CPP_member
auto distance_to(cursor const & that) const //
-> CPP_ret(difference_type)(
requires sized_sentinel_for<iterator_t<Rng>, iterator_t<Rng>>)
{
return that.current_ - current_;
}
CPP_member
auto distance_to(sentinel const & that) const //
-> CPP_ret(difference_type)(
requires sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>)
{
return that.last_ - current_;
}
};
cursor begin_cursor()
{
dirty_ = true;
return cursor{this, ranges::begin(rng_)};
}
cursor end_cursor_impl(std::true_type)
{
return cursor{this, ranges::end(rng_)};
}
sentinel end_cursor_impl(std::false_type)
{
return sentinel{ranges::end(rng_)};
}
auto end_cursor()
{
return end_cursor_impl(meta::bool_<(bool)common_range<Rng>>{});
}
public:
cache1_view() = default;
constexpr explicit cache1_view(Rng rng)
: rng_{std::move(rng)}
{}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return ranges::size(rng_);
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
cache1_view(Rng &&) //
-> cache1_view<views::all_t<Rng>>;
#endif
namespace views
{
struct cache1_fn
{
/// \brief Caches the most recent element within the view so that
/// dereferencing the view's iterator multiple times doesn't incur any
/// recomputation. This can be useful in adaptor pipelines that include
/// combinations of \c view::filter and \c view::transform, for instance.
/// \note \c views::cache1 is always single-pass.
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng> AND
constructible_from<range_value_t<Rng>, range_reference_t<Rng>>)
constexpr cache1_view<all_t<Rng>> operator()(Rng && rng) const //
{
return cache1_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
}
};
/// \relates cache1_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<cache1_fn>, cache1)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::cache1_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/remove_if.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_REMOVE_IF_HPP
#define RANGES_V3_VIEW_REMOVE_IF_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/compose.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/box.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng, typename Pred>
struct RANGES_EMPTY_BASES remove_if_view
: view_adaptor<remove_if_view<Rng, Pred>, Rng,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
, private box<semiregular_box_t<Pred>>
{
remove_if_view() = default;
constexpr remove_if_view(Rng rng, Pred pred)
: remove_if_view::view_adaptor{detail::move(rng)}
, remove_if_view::box(detail::move(pred))
{}
private:
friend range_access;
struct adaptor : adaptor_base
{
adaptor() = default;
constexpr adaptor(remove_if_view * rng) noexcept
: rng_(rng)
{}
static constexpr iterator_t<Rng> begin(remove_if_view & rng)
{
return *rng.begin_;
}
constexpr void next(iterator_t<Rng> & it) const
{
RANGES_ASSERT(it != ranges::end(rng_->base()));
rng_->satisfy_forward(++it);
}
CPP_member
constexpr auto prev(iterator_t<Rng> & it) const //
-> CPP_ret(void)(
requires bidirectional_range<Rng>)
{
rng_->satisfy_reverse(it);
}
void advance() = delete;
void distance_to() = delete;
private:
remove_if_view * rng_;
};
constexpr adaptor begin_adaptor()
{
cache_begin();
return {this};
}
CPP_member
constexpr auto end_adaptor() const noexcept //
-> CPP_ret(adaptor_base)(
requires (!common_range<Rng>))
{
return {};
}
CPP_member
constexpr auto end_adaptor() //
-> CPP_ret(adaptor)(
requires common_range<Rng>)
{
if(bidirectional_range<Rng>)
cache_begin();
return {this};
}
constexpr void satisfy_forward(iterator_t<Rng> & it)
{
auto const last = ranges::end(this->base());
auto & pred = this->remove_if_view::box::get();
while(it != last && invoke(pred, *it))
++it;
}
constexpr void satisfy_reverse(iterator_t<Rng> & it)
{
RANGES_ASSERT(begin_);
auto const & first = *begin_;
auto & pred = this->remove_if_view::box::get();
do
{
RANGES_ASSERT(it != first);
(void)first;
--it;
} while(invoke(pred, *it));
}
constexpr void cache_begin()
{
if(begin_)
return;
auto it = ranges::begin(this->base());
satisfy_forward(it);
begin_.emplace(std::move(it));
}
detail::non_propagating_cache<iterator_t<Rng>> begin_;
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Pred)(
requires copy_constructible<Pred>)
remove_if_view(Rng &&, Pred)
-> remove_if_view<views::all_t<Rng>, Pred>;
#endif
namespace views
{
/// Given a source range, unary predicate, and optional projection,
/// present a view of the elements that do not satisfy the predicate.
struct remove_if_base_fn
{
template(typename Rng, typename Pred)(
requires viewable_range<Rng> AND input_range<Rng> AND
indirect_unary_predicate<Pred, iterator_t<Rng>>)
constexpr remove_if_view<all_t<Rng>, Pred> operator()(Rng && rng, Pred pred)
const
{
return remove_if_view<all_t<Rng>, Pred>{all(static_cast<Rng &&>(rng)),
std::move(pred)};
}
template(typename Rng, typename Pred, typename Proj)(
requires viewable_range<Rng> AND input_range<Rng> AND
indirect_unary_predicate<Pred, projected<iterator_t<Rng>, Proj>>)
constexpr remove_if_view<all_t<Rng>, composed<Pred, Proj>> //
operator()(Rng && rng, Pred pred, Proj proj) const
{
return remove_if_view<all_t<Rng>, composed<Pred, Proj>>{
all(static_cast<Rng &&>(rng)),
compose(std::move(pred), std::move(proj))};
}
};
struct remove_if_bind_fn
{
template<typename Pred>
constexpr auto operator()(Pred pred) const // TODO: underconstrained
{
return make_view_closure(bind_back(remove_if_base_fn{}, std::move(pred)));
}
template(typename Pred, typename Proj)(
requires (!range<Pred>)) // TODO: underconstrained
constexpr auto operator()(Pred && pred, Proj proj) const
{
return make_view_closure(bind_back(
remove_if_base_fn{}, static_cast<Pred &&>(pred), std::move(proj)));
}
};
struct RANGES_EMPTY_BASES remove_if_fn
: remove_if_base_fn, remove_if_bind_fn
{
using remove_if_base_fn::operator();
using remove_if_bind_fn::operator();
};
/// \relates remove_if_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(remove_if_fn, remove_if)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::remove_if_view)
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/zip.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_ZIP_HPP
#define RANGES_V3_VIEW_ZIP_HPP
#include <tuple>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/utility/common_tuple.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/empty.hpp>
#include <range/v3/view/zip_with.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
struct indirect_zip_fn_
{
// tuple value
template(typename... Its)(
requires (sizeof...(Its) != 2) AND and_v<indirectly_readable<Its>...>)
std::tuple<iter_value_t<Its>...> operator()(copy_tag, Its...) const
{
RANGES_EXPECT(false);
}
// tuple reference
template(typename... Its)(
requires (sizeof...(Its) != 2) AND and_v<indirectly_readable<Its>...>)
common_tuple<iter_reference_t<Its>...>
operator()(Its const &... its) const //
noexcept(meta::and_c<noexcept(iter_reference_t<Its>(*its))...>::value)
{
return common_tuple<iter_reference_t<Its>...>{*its...};
}
// tuple rvalue reference
template(typename... Its)(
requires (sizeof...(Its) != 2) AND and_v<indirectly_readable<Its>...>)
common_tuple<iter_rvalue_reference_t<Its>...> //
operator()(move_tag, Its const &... its) const //
noexcept(meta::and_c<noexcept(
iter_rvalue_reference_t<Its>(iter_move(its)))...>::value)
{
return common_tuple<iter_rvalue_reference_t<Its>...>{iter_move(its)...};
}
// pair value
template(typename It1, typename It2)(
requires indirectly_readable<It1> AND indirectly_readable<It2>)
std::pair<iter_value_t<It1>, iter_value_t<It2>> //
operator()(copy_tag, It1, It2) const
{
RANGES_EXPECT(false);
}
// pair reference
template(typename It1, typename It2)(
requires indirectly_readable<It1> AND indirectly_readable<It2>)
common_pair<iter_reference_t<It1>, iter_reference_t<It2>>
operator()(It1 const & it1, It2 const & it2) const //
noexcept( //
noexcept(iter_reference_t<It1>(*it1)) && //
noexcept(iter_reference_t<It2>(*it2)))
{
return {*it1, *it2};
}
// pair rvalue reference
template(typename It1, typename It2)(
requires indirectly_readable<It1> AND indirectly_readable<It2>)
common_pair<iter_rvalue_reference_t<It1>, iter_rvalue_reference_t<It2>>
operator()(move_tag, It1 const & it1, It2 const & it2) const
noexcept(noexcept(iter_rvalue_reference_t<It1>(iter_move(it1))) &&
noexcept(iter_rvalue_reference_t<It2>(iter_move(it2))))
{
return {iter_move(it1), iter_move(it2)};
}
};
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
template<typename... Rngs>
struct zip_view : iter_zip_with_view<detail::indirect_zip_fn_, Rngs...>
{
CPP_assert(sizeof...(Rngs) != 0);
zip_view() = default;
explicit zip_view(Rngs... rngs)
: iter_zip_with_view<detail::indirect_zip_fn_, Rngs...>{
detail::indirect_zip_fn_{},
std::move(rngs)...}
{}
};
template<typename... Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<zip_view<Rng...>> =
and_v<enable_borrowed_range<Rng>...>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename... Rng>
zip_view(Rng &&...) //
-> zip_view<views::all_t<Rng>...>;
#endif
namespace views
{
struct zip_fn
{
constexpr empty_view<std::tuple<>> operator()() const noexcept
{
return {};
}
template(typename... Rngs)(
requires and_v<viewable_range<Rngs>...> AND
and_v<input_range<Rngs>...> AND
(sizeof...(Rngs) != 0)) //
zip_view<all_t<Rngs>...> operator()(Rngs &&... rngs) const
{
return zip_view<all_t<Rngs>...>{all(static_cast<Rngs &&>(rngs))...};
}
#if defined(_MSC_VER)
template(typename Rng0)(
requires input_range<Rng0> AND viewable_range<Rng0>)
constexpr zip_view<all_t<Rng0>> operator()(Rng0 && rng0) const
{
return zip_view<all_t<Rng0>>{all(static_cast<Rng0 &&>(rng0))};
}
template(typename Rng0, typename Rng1)(
requires input_range<Rng0> AND viewable_range<Rng0> AND
input_range<Rng1> AND viewable_range<Rng1>)
constexpr zip_view<all_t<Rng0>, all_t<Rng1>> //
operator()(Rng0 && rng0, Rng1 && rng1) const
{
return zip_view<all_t<Rng0>, all_t<Rng1>>{ //
all(static_cast<Rng0 &&>(rng0)), //
all(static_cast<Rng1 &&>(rng1))};
}
template(typename Rng0, typename Rng1, typename Rng2)(
requires input_range<Rng0> AND viewable_range<Rng0> AND
input_range<Rng1> AND viewable_range<Rng1> AND
input_range<Rng2> AND viewable_range<Rng2>)
constexpr zip_view<all_t<Rng0>, all_t<Rng1>, all_t<Rng2>> //
operator()(Rng0 && rng0, Rng1 && rng1, Rng2 && rng2) const
{
return zip_view<all_t<Rng0>, all_t<Rng1>, all_t<Rng2>>{ //
all(static_cast<Rng0 &&>(rng0)), //
all(static_cast<Rng1 &&>(rng1)), //
all(static_cast<Rng2 &&>(rng2))};
}
#endif
};
/// \relates zip_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(zip_fn, zip)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::zip_view)
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/set_algorithm.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
// Copyright Tomislav Ivek 2015-2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_SET_ALGORITHM_HPP
#define RANGES_V3_VIEW_SET_ALGORITHM_HPP
#include <algorithm>
#include <iterator>
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/comparisons.hpp>
#include <range/v3/functional/identity.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/move.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
/// \cond
namespace detail
{
template<typename Rng1, typename Rng2, typename C, typename P1, typename P2,
template<bool, typename...> class Cursor, cardinality Cardinality>
struct set_algorithm_view
: view_facade<set_algorithm_view<Rng1, Rng2, C, P1, P2, Cursor, Cardinality>,
Cardinality>
{
private:
friend range_access;
semiregular_box_t<C> pred_;
semiregular_box_t<P1> proj1_;
semiregular_box_t<P2> proj2_;
Rng1 rng1_;
Rng2 rng2_;
template<bool IsConst>
using cursor = Cursor<IsConst, Rng1, Rng2, C, P1, P2>;
cursor<simple_view<Rng1>() && simple_view<Rng2>()> begin_cursor()
{
return {pred_,
proj1_,
proj2_,
ranges::begin(rng1_),
ranges::end(rng1_),
ranges::begin(rng2_),
ranges::end(rng2_)};
}
CPP_member
auto begin_cursor() const //
-> CPP_ret(cursor<true>)(
requires range<Rng1 const> && range<Rng2 const>)
{
return {pred_,
proj1_,
proj2_,
ranges::begin(rng1_),
ranges::end(rng1_),
ranges::begin(rng2_),
ranges::end(rng2_)};
}
public:
set_algorithm_view() = default;
set_algorithm_view(Rng1 rng1, Rng2 rng2, C pred, P1 proj1, P2 proj2)
: pred_(std::move(pred))
, proj1_(std::move(proj1))
, proj2_(std::move(proj2))
, rng1_(std::move(rng1))
, rng2_(std::move(rng2))
{}
};
template<bool IsConst, typename Rng1, typename Rng2, typename C, typename P1,
typename P2>
struct set_difference_cursor
{
private:
friend struct set_difference_cursor<!IsConst, Rng1, Rng2, C, P1, P2>;
using pred_ref_ = semiregular_box_ref_or_val_t<C, IsConst>;
using proj1_ref_ = semiregular_box_ref_or_val_t<P1, IsConst>;
using proj2_ref_ = semiregular_box_ref_or_val_t<P2, IsConst>;
pred_ref_ pred_;
proj1_ref_ proj1_;
proj2_ref_ proj2_;
template<typename T>
using constify_if = meta::const_if_c<IsConst, T>;
using R1 = constify_if<Rng1>;
using R2 = constify_if<Rng2>;
iterator_t<R1> it1_;
sentinel_t<R1> end1_;
iterator_t<R2> it2_;
sentinel_t<R2> end2_;
void satisfy()
{
while(it1_ != end1_)
{
if(it2_ == end2_)
return;
if(invoke(pred_, invoke(proj1_, *it1_), invoke(proj2_, *it2_)))
return;
if(!invoke(pred_, invoke(proj2_, *it2_), invoke(proj1_, *it1_)))
++it1_;
++it2_;
}
}
public:
using value_type = range_value_t<constify_if<Rng1>>;
using single_pass = meta::or_c<single_pass_iterator_<iterator_t<R1>>,
single_pass_iterator_<iterator_t<R2>>>;
set_difference_cursor() = default;
set_difference_cursor(pred_ref_ pred, proj1_ref_ proj1, proj2_ref_ proj2,
iterator_t<R1> it1, sentinel_t<R1> end1,
iterator_t<R2> it2, sentinel_t<R2> end2)
: pred_(std::move(pred))
, proj1_(std::move(proj1))
, proj2_(std::move(proj2))
, it1_(std::move(it1))
, end1_(std::move(end1))
, it2_(std::move(it2))
, end2_(std::move(end2))
{
satisfy();
}
template(bool Other)(
requires IsConst && CPP_NOT(Other)) //
set_difference_cursor(
set_difference_cursor<Other, Rng1, Rng2, C, P1, P2> that)
: pred_(std::move(that.pred_))
, proj1_(std::move(that.proj1_))
, proj2_(std::move(that.proj2_))
, it1_(std::move(that.it1_))
, end1_(std::move(that.end1_))
, it2_(std::move(that.it2_))
, end2_(std::move(that.end2_))
{}
// clang-format off
auto CPP_auto_fun(read)()(const)
(
return *it1_
)
// clang-format on
void next()
{
++it1_;
satisfy();
}
CPP_member
auto equal(set_difference_cursor const & that) const //
-> CPP_ret(bool)(
requires forward_range<Rng1>)
{
// does not support comparing iterators from different ranges
return it1_ == that.it1_;
}
bool equal(default_sentinel_t) const
{
return it1_ == end1_;
}
// clang-format off
auto CPP_auto_fun(move)()(const)
(
return iter_move(it1_)
)
// clang-format on
};
constexpr cardinality set_difference_cardinality(cardinality c1, cardinality c2)
{
return (c1 == unknown)
? unknown
: (c1 >= 0) || (c1 == finite) ? finite : // else, c1 == infinite
(c2 >= 0) || (c2 == finite) ? infinite : unknown;
}
} // namespace detail
/// \endcond
template<typename Rng1, typename Rng2, typename C, typename P1, typename P2>
using set_difference_view =
detail::set_algorithm_view<Rng1, Rng2, C, P1, P2, detail::set_difference_cursor,
detail::set_difference_cardinality(
range_cardinality<Rng1>::value,
range_cardinality<Rng2>::value)>;
namespace views
{
struct set_difference_base_fn
{
template(typename Rng1, typename Rng2, typename C = less,
typename P1 = identity, typename P2 = identity)(
requires //
viewable_range<Rng1> AND input_range<Rng1> AND
viewable_range<Rng2> AND input_range<Rng2> AND
indirect_relation<C,
projected<iterator_t<Rng1>, P1>,
projected<iterator_t<Rng2>, P2>>)
set_difference_view<all_t<Rng1>, all_t<Rng2>, C, P1, P2> //
operator()(Rng1 && rng1,
Rng2 && rng2,
C pred = C{},
P1 proj1 = P1{},
P2 proj2 = P2{}) const
{
return {all(static_cast<Rng1 &&>(rng1)),
all(static_cast<Rng2 &&>(rng2)),
std::move(pred),
std::move(proj1),
std::move(proj2)};
}
};
struct set_difference_fn : set_difference_base_fn
{
using set_difference_base_fn::operator();
template(typename Rng2, typename C = less, typename P1 = identity,
typename P2 = identity)(
requires viewable_range<Rng2> AND input_range<Rng2> AND (!range<C>))
constexpr auto operator()(Rng2 && rng2,
C && pred = C{},
P1 proj1 = P1{},
P2 proj2 = P2{}) const
{
return make_view_closure(bind_back(set_difference_base_fn{},
all(rng2),
static_cast<C &&>(pred),
std::move(proj1),
std::move(proj2)));
}
};
/// \relates set_difference_fn
RANGES_INLINE_VARIABLE(set_difference_fn, set_difference)
} // namespace views
/// \cond
namespace detail
{
template<bool IsConst, typename Rng1, typename Rng2, typename C, typename P1,
typename P2>
struct set_intersection_cursor
{
private:
friend struct set_intersection_cursor<!IsConst, Rng1, Rng2, C, P1, P2>;
using pred_ref_ = semiregular_box_ref_or_val_t<C, IsConst>;
using proj1_ref_ = semiregular_box_ref_or_val_t<P1, IsConst>;
using proj2_ref_ = semiregular_box_ref_or_val_t<P2, IsConst>;
pred_ref_ pred_;
proj1_ref_ proj1_;
proj2_ref_ proj2_;
template<typename T>
using constify_if = meta::const_if_c<IsConst, T>;
using R1 = constify_if<Rng1>;
using R2 = constify_if<Rng2>;
iterator_t<R1> it1_;
sentinel_t<R1> end1_;
iterator_t<R2> it2_;
sentinel_t<R2> end2_;
void satisfy()
{
while(it1_ != end1_ && it2_ != end2_)
{
if(invoke(pred_, invoke(proj1_, *it1_), invoke(proj2_, *it2_)))
++it1_;
else
{
if(!invoke(pred_, invoke(proj2_, *it2_), invoke(proj1_, *it1_)))
return;
++it2_;
}
}
}
public:
using value_type = range_value_t<R1>;
using single_pass = meta::or_c<single_pass_iterator_<iterator_t<R1>>,
single_pass_iterator_<iterator_t<R2>>>;
set_intersection_cursor() = default;
set_intersection_cursor(pred_ref_ pred, proj1_ref_ proj1, proj2_ref_ proj2,
iterator_t<R1> it1, sentinel_t<R1> end1,
iterator_t<R2> it2, sentinel_t<R2> end2)
: pred_(std::move(pred))
, proj1_(std::move(proj1))
, proj2_(std::move(proj2))
, it1_(std::move(it1))
, end1_(std::move(end1))
, it2_(std::move(it2))
, end2_(std::move(end2))
{
satisfy();
}
template(bool Other)(
requires IsConst && CPP_NOT(Other)) //
set_intersection_cursor(
set_intersection_cursor<Other, Rng1, Rng2, C, P1, P2> that)
: pred_(std::move(that.pred_))
, proj1_(std::move(that.proj1_))
, proj2_(std::move(that.proj2_))
, it1_(std::move(that.it1_))
, end1_(std::move(that.end1_))
, it2_(std::move(that.it2_))
, end2_(std::move(that.end2_))
{}
// clang-format off
auto CPP_auto_fun(read)()(const)
(
return *it1_
)
// clang-format on
void next()
{
++it1_;
++it2_;
satisfy();
}
CPP_member
auto equal(set_intersection_cursor const & that) const //
-> CPP_ret(bool)(
requires forward_range<Rng1>)
{
// does not support comparing iterators from different ranges
return it1_ == that.it1_;
}
bool equal(default_sentinel_t) const
{
return (it1_ == end1_) || (it2_ == end2_);
}
// clang-format off
auto CPP_auto_fun(move)()(const)
(
return iter_move(it1_)
)
// clang-format on
};
constexpr cardinality set_intersection_cardinality(cardinality c1, cardinality c2)
{
return (c1 == unknown) || (c2 == unknown)
? unknown
: (c1 >= 0 || c1 == finite) || (c2 >= 0 || c2 == finite) ? finite
: unknown;
}
} // namespace detail
/// \endcond
template<typename Rng1, typename Rng2, typename C, typename P1, typename P2>
using set_intersection_view =
detail::set_algorithm_view<Rng1, Rng2, C, P1, P2, detail::set_intersection_cursor,
detail::set_intersection_cardinality(
range_cardinality<Rng1>::value,
range_cardinality<Rng2>::value)>;
namespace views
{
struct set_intersection_base_fn
{
template(typename Rng1, typename Rng2, typename C = less,
typename P1 = identity, typename P2 = identity)(
requires viewable_range<Rng1> AND input_range<Rng1> AND
viewable_range<Rng2> AND input_range<Rng2> AND
indirect_relation<
C,
projected<iterator_t<Rng1>, P1>,
projected<iterator_t<Rng2>, P2>>)
set_intersection_view<all_t<Rng1>, all_t<Rng2>, C, P1, P2>
operator()(Rng1 && rng1,
Rng2 && rng2,
C pred = C{},
P1 proj1 = P1{},
P2 proj2 = P2{}) const
{
return {all(static_cast<Rng1 &&>(rng1)),
all(static_cast<Rng2 &&>(rng2)),
std::move(pred),
std::move(proj1),
std::move(proj2)};
}
};
struct set_intersection_fn : set_intersection_base_fn
{
using set_intersection_base_fn::operator();
template(typename Rng2, typename C = less, typename P1 = identity,
typename P2 = identity)(
requires viewable_range<Rng2> AND input_range<Rng2> AND (!range<C>))
constexpr auto operator()(Rng2 && rng2,
C && pred = C{},
P1 proj1 = P1{},
P2 proj2 = P2{}) const
{
return make_view_closure(bind_back(set_intersection_base_fn{},
all(rng2),
static_cast<C &&>(pred),
std::move(proj1),
std::move(proj2)));
}
};
/// \relates set_intersection_fn
RANGES_INLINE_VARIABLE(set_intersection_fn, set_intersection)
} // namespace views
/// \cond
namespace detail
{
template<bool IsConst, typename Rng1, typename Rng2, typename C, typename P1,
typename P2>
struct set_union_cursor
{
private:
friend struct set_union_cursor<!IsConst, Rng1, Rng2, C, P1, P2>;
using pred_ref_ = semiregular_box_ref_or_val_t<C, IsConst>;
using proj1_ref_ = semiregular_box_ref_or_val_t<P1, IsConst>;
using proj2_ref_ = semiregular_box_ref_or_val_t<P2, IsConst>;
pred_ref_ pred_;
proj1_ref_ proj1_;
proj2_ref_ proj2_;
template<typename T>
using constify_if = meta::const_if_c<IsConst, T>;
using R1 = constify_if<Rng1>;
using R2 = constify_if<Rng2>;
iterator_t<R1> it1_;
sentinel_t<R1> end1_;
iterator_t<R2> it2_;
sentinel_t<R2> end2_;
enum class state_t
{
FIRST,
SECOND
} state;
void satisfy()
{
if(it1_ == end1_)
{
state = state_t::SECOND;
return;
}
if(it2_ == end2_)
{
state = state_t::FIRST;
return;
}
if(invoke(pred_, invoke(proj2_, *it2_), invoke(proj1_, *it1_)))
{
state = state_t::SECOND;
return;
}
if(!invoke(pred_, invoke(proj1_, *it1_), invoke(proj2_, *it2_)))
++it2_;
state = state_t::FIRST;
}
public:
using value_type = common_type_t<range_value_t<R1>, range_value_t<R2>>;
using reference_type =
common_reference_t<range_reference_t<R1>, range_reference_t<R2>>;
using rvalue_reference_type =
common_reference_t<range_rvalue_reference_t<R1>,
range_rvalue_reference_t<R2>>;
using single_pass = meta::or_c<single_pass_iterator_<iterator_t<R1>>,
single_pass_iterator_<iterator_t<R2>>>;
set_union_cursor() = default;
set_union_cursor(pred_ref_ pred, proj1_ref_ proj1, proj2_ref_ proj2,
iterator_t<R1> it1, sentinel_t<R1> end1, iterator_t<R2> it2,
sentinel_t<R2> end2)
: pred_(std::move(pred))
, proj1_(std::move(proj1))
, proj2_(std::move(proj2))
, it1_(std::move(it1))
, end1_(std::move(end1))
, it2_(std::move(it2))
, end2_(std::move(end2))
{
satisfy();
}
template(bool Other)(
requires IsConst AND CPP_NOT(Other))
set_union_cursor(set_union_cursor<Other, Rng1, Rng2, C, P1, P2> that)
: pred_(std::move(that.pred_))
, proj1_(std::move(that.proj1_))
, proj2_(std::move(that.proj2_))
, it1_(std::move(that.it1_))
, end1_(std::move(that.end1_))
, it2_(std::move(that.it2_))
, end2_(std::move(that.end2_))
{}
reference_type read() const noexcept(noexcept(*it1_) && noexcept(*it2_))
{
if(state == state_t::SECOND)
return *it2_;
else
return *it1_;
}
void next()
{
if(state == state_t::FIRST)
++it1_;
else
++it2_;
satisfy();
}
CPP_member
auto equal(set_union_cursor const & that) const //
-> CPP_ret(bool)(
requires forward_range<Rng1> && forward_range<Rng2>)
{
// does not support comparing iterators from different ranges
return (it1_ == that.it1_) && (it2_ == that.it2_);
}
bool equal(default_sentinel_t) const
{
return (it1_ == end1_) && (it2_ == end2_);
}
rvalue_reference_type move() const
noexcept(noexcept(iter_move(it1_)) && noexcept(iter_move(it2_)))
{
if(state == state_t::SECOND)
return iter_move(it2_);
else
return iter_move(it1_);
}
};
constexpr cardinality set_union_cardinality(cardinality c1, cardinality c2)
{
return (c1 == infinite) || (c2 == infinite)
? infinite
: (c1 == unknown) || (c2 == unknown) ? unknown : finite;
}
} // namespace detail
/// \endcond
template<typename Rng1, typename Rng2, typename C, typename P1, typename P2>
using set_union_view =
detail::set_algorithm_view<Rng1, Rng2, C, P1, P2, detail::set_union_cursor,
detail::set_union_cardinality(
range_cardinality<Rng1>::value,
range_cardinality<Rng2>::value)>;
namespace views
{
struct set_union_base_fn
{
public:
template(typename Rng1, typename Rng2, typename C = less,
typename P1 = identity, typename P2 = identity)(
requires //
viewable_range<Rng1> AND input_range<Rng1> AND
viewable_range<Rng2> AND input_range<Rng2> AND
common_with<range_value_t<Rng1>, range_value_t<Rng2>> AND
common_reference_with<range_reference_t<Rng1>,
range_reference_t<Rng2>> AND
common_reference_with<range_rvalue_reference_t<Rng1>,
range_rvalue_reference_t<Rng2>> AND
indirect_relation<C,
projected<iterator_t<Rng1>, P1>,
projected<iterator_t<Rng2>, P2>>)
set_union_view<all_t<Rng1>, all_t<Rng2>, C, P1, P2> //
operator()(Rng1 && rng1,
Rng2 && rng2,
C pred = C{},
P1 proj1 = P1{},
P2 proj2 = P2{}) const
{
return {all(static_cast<Rng1 &&>(rng1)),
all(static_cast<Rng2 &&>(rng2)),
std::move(pred),
std::move(proj1),
std::move(proj2)};
}
};
struct set_union_fn : set_union_base_fn
{
using set_union_base_fn::operator();
template(typename Rng2, typename C = less, typename P1 = identity,
typename P2 = identity)(
requires viewable_range<Rng2> AND input_range<Rng2> AND (!range<C>))
constexpr auto operator()(Rng2 && rng2,
C && pred = C{},
P1 proj1 = P1{},
P2 proj2 = P2{}) const
{
return make_view_closure(bind_back(set_union_base_fn{},
all(rng2),
static_cast<C &&>(pred),
std::move(proj1),
std::move(proj2)));
}
};
/// \relates set_union_fn
RANGES_INLINE_VARIABLE(set_union_fn, set_union)
} // namespace views
/// \cond
namespace detail
{
template<bool IsConst, typename Rng1, typename Rng2, typename C, typename P1,
typename P2>
struct set_symmetric_difference_cursor
{
private:
friend struct set_symmetric_difference_cursor<!IsConst, Rng1, Rng2, C, P1,
P2>;
using pred_ref_ = semiregular_box_ref_or_val_t<C, IsConst>;
using proj1_ref_ = semiregular_box_ref_or_val_t<P1, IsConst>;
using proj2_ref_ = semiregular_box_ref_or_val_t<P2, IsConst>;
pred_ref_ pred_;
proj1_ref_ proj1_;
proj2_ref_ proj2_;
template<typename T>
using constify_if = meta::const_if_c<IsConst, T>;
using R1 = constify_if<Rng1>;
using R2 = constify_if<Rng2>;
iterator_t<R1> it1_;
sentinel_t<R1> end1_;
iterator_t<R2> it2_;
sentinel_t<R2> end2_;
enum class state_t
{
FIRST,
SECOND,
ONLY_FIRST,
ONLY_SECOND
} state;
void satisfy()
{
while(it1_ != end1_)
{
if(it2_ == end2_)
{
state = state_t::ONLY_FIRST;
return;
}
if(invoke(pred_, invoke(proj1_, *it1_), invoke(proj2_, *it2_)))
{
state = state_t::FIRST;
return;
}
else
{
if(invoke(pred_, invoke(proj2_, *it2_), invoke(proj1_, *it1_)))
{
state = state_t::SECOND;
return;
}
else
{
++it1_;
++it2_;
}
}
}
state = state_t::ONLY_SECOND;
}
public:
using value_type = common_type_t<range_value_t<R1>, range_value_t<R2>>;
using reference_type =
common_reference_t<range_reference_t<R1>, range_reference_t<R2>>;
using rvalue_reference_type =
common_reference_t<range_rvalue_reference_t<R1>,
range_rvalue_reference_t<R2>>;
using single_pass = meta::or_c<single_pass_iterator_<iterator_t<R1>>,
single_pass_iterator_<iterator_t<R2>>>;
set_symmetric_difference_cursor() = default;
set_symmetric_difference_cursor(pred_ref_ pred, proj1_ref_ proj1,
proj2_ref_ proj2, iterator_t<R1> it1,
sentinel_t<R1> end1, iterator_t<R2> it2,
sentinel_t<R2> end2)
: pred_(std::move(pred))
, proj1_(std::move(proj1))
, proj2_(std::move(proj2))
, it1_(std::move(it1))
, end1_(std::move(end1))
, it2_(std::move(it2))
, end2_(std::move(end2))
, state()
{
satisfy();
}
template(bool Other)(
requires IsConst && CPP_NOT(Other)) //
set_symmetric_difference_cursor(
set_symmetric_difference_cursor<Other, Rng1, Rng2, C, P1, P2> that)
: pred_(std::move(that.pred_))
, proj1_(std::move(that.proj1_))
, proj2_(std::move(that.proj2_))
, it1_(std::move(that.it1_))
, end1_(std::move(that.end1_))
, it2_(std::move(that.it2_))
, end2_(std::move(that.end2_))
, state(that.state)
{}
reference_type read() const noexcept(noexcept(*it1_) && noexcept(*it2_))
{
if(state == state_t::SECOND || state == state_t::ONLY_SECOND)
return *it2_;
else
return *it1_;
}
void next()
{
switch(state)
{
case state_t::FIRST:
++it1_;
satisfy();
break;
case state_t::ONLY_FIRST:
++it1_;
break;
case state_t::SECOND:
++it2_;
satisfy();
break;
case state_t::ONLY_SECOND:
++it2_;
break;
}
}
CPP_member
auto equal(set_symmetric_difference_cursor const & that) const
-> CPP_ret(bool)(
requires forward_range<R1> && forward_range<R2>)
{
// does not support comparing iterators from different ranges:
return (it1_ == that.it1_) && (it2_ == that.it2_);
}
bool equal(default_sentinel_t) const
{
return (it1_ == end1_) && (it2_ == end2_);
}
rvalue_reference_type move() const
noexcept(noexcept(iter_move(it1_)) && noexcept(iter_move(it2_)))
{
if(state == state_t::SECOND || state == state_t::ONLY_SECOND)
return iter_move(it2_);
else
return iter_move(it1_);
}
};
constexpr cardinality set_symmetric_difference_cardinality(cardinality c1,
cardinality c2)
{
return (c1 == unknown) || (c2 == unknown)
? unknown
: (c1 == infinite) != (c2 == infinite)
? infinite
: (c1 == infinite) && (c2 == infinite) ? unknown : finite;
}
} // namespace detail
/// \endcond
template<typename Rng1, typename Rng2, typename C, typename P1, typename P2>
using set_symmetric_difference_view = detail::set_algorithm_view<
Rng1, Rng2, C, P1, P2, detail::set_symmetric_difference_cursor,
detail::set_symmetric_difference_cardinality(range_cardinality<Rng1>::value,
range_cardinality<Rng2>::value)>;
namespace views
{
struct set_symmetric_difference_base_fn
{
template(typename Rng1, typename Rng2, typename C = less,
typename P1 = identity, typename P2 = identity)(
requires //
viewable_range<Rng1> AND input_range<Rng1> AND
viewable_range<Rng2> AND input_range<Rng2> AND
common_with<range_value_t<Rng1>, range_value_t<Rng2>> AND
common_reference_with<range_reference_t<Rng1>,
range_reference_t<Rng2>> AND
common_reference_with<range_rvalue_reference_t<Rng1>,
range_rvalue_reference_t<Rng2>> AND
indirect_relation<C,
projected<iterator_t<Rng1>, P1>,
projected<iterator_t<Rng2>, P2>>)
set_symmetric_difference_view<all_t<Rng1>, all_t<Rng2>, C, P1, P2>
operator()(Rng1 && rng1,
Rng2 && rng2,
C pred = C{},
P1 proj1 = P1{},
P2 proj2 = P2{}) const
{
return {all(static_cast<Rng1 &&>(rng1)),
all(static_cast<Rng2 &&>(rng2)),
std::move(pred),
std::move(proj1),
std::move(proj2)};
}
};
struct set_symmetric_difference_fn : set_symmetric_difference_base_fn
{
using set_symmetric_difference_base_fn::operator();
template(typename Rng2, typename C = less, typename P1 = identity,
typename P2 = identity)(
requires viewable_range<Rng2> AND input_range<Rng2> AND (!range<C>))
constexpr auto operator()(Rng2 && rng2,
C && pred = C{},
P1 proj1 = P1{},
P2 proj2 = P2{}) const
{
return make_view_closure(bind_back(set_symmetric_difference_base_fn{},
all(rng2),
static_cast<C &&>(pred),
std::move(proj1),
std::move(proj2)));
}
};
/// \relates set_symmetric_difference_fn
RANGES_INLINE_VARIABLE(set_symmetric_difference_fn, set_symmetric_difference)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/trim.hpp | /// \file
// Range v3 library
//
// Copyright Johel Guerrero 2019
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_TRIM_HPP
#define RANGES_V3_VIEW_TRIM_HPP
#include <utility>
#include <concepts/concepts.hpp>
#include <range/v3/algorithm/find_if_not.hpp>
#include <range/v3/detail/config.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/compose.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng, typename Pred>
struct trim_view : view_interface<trim_view<Rng, Pred>>
{
private:
Rng rng_;
semiregular_box_t<Pred> pred_;
detail::non_propagating_cache<iterator_t<Rng>> begin_;
detail::non_propagating_cache<iterator_t<Rng>> end_;
public:
CPP_assert(bidirectional_range<Rng> && view_<Rng> && indirect_unary_predicate<
Pred, iterator_t<Rng>> && common_range<Rng>);
trim_view() = default;
constexpr trim_view(Rng rng, Pred pred)
: rng_(std::move(rng))
, pred_(std::move(pred))
{}
iterator_t<Rng> begin()
{
if(!begin_)
begin_ = find_if_not(rng_, std::ref(pred_));
return *begin_;
}
iterator_t<Rng> end()
{
if(!end_)
{
const auto first = begin();
auto last = ranges::end(rng_);
while(last != first)
if(!invoke(pred_, *--last))
{
++last;
break;
}
end_ = std::move(last);
}
return *end_;
}
Rng base() const
{
return rng_;
}
};
template<typename Rng, typename Pred>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<trim_view<Rng, Pred>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng, typename Pred>
trim_view(Rng &&, Pred) //
-> trim_view<views::all_t<Rng>, Pred>;
#endif
template<typename Rng, typename Pred>
RANGES_INLINE_VAR constexpr bool disable_sized_range<trim_view<Rng, Pred>> = true;
namespace views
{
struct trim_base_fn
{
template(typename Rng, typename Pred)(
requires viewable_range<Rng> AND bidirectional_range<Rng> AND
indirect_unary_predicate<Pred, iterator_t<Rng>> AND
common_range<Rng>)
constexpr trim_view<all_t<Rng>, Pred> //
operator()(Rng && rng, Pred pred) const //
{
return {all(static_cast<Rng &&>(rng)), std::move(pred)};
}
template(typename Rng, typename Pred, typename Proj)(
requires viewable_range<Rng> AND bidirectional_range<Rng> AND
indirect_unary_predicate<composed<Pred, Proj>, iterator_t<Rng>> AND
common_range<Rng>)
constexpr trim_view<all_t<Rng>, composed<Pred, Proj>> //
operator()(Rng && rng, Pred pred, Proj proj) const
{
return {all(static_cast<Rng &&>(rng)),
compose(std::move(pred), std::move(proj))};
}
};
struct trim_bind_fn
{
template<typename Pred>
constexpr auto operator()(Pred pred) const // TODO: underconstrained
{
return make_view_closure(bind_back(trim_base_fn{}, std::move(pred)));
}
template(typename Pred, typename Proj)(
requires (!range<Pred>)) // TODO: underconstrained
constexpr auto operator()(Pred && pred, Proj proj) const
{
return make_view_closure(bind_back(
trim_base_fn{}, static_cast<Pred &&>(pred), std::move(proj)));
}
};
struct RANGES_EMPTY_BASES trim_fn
: trim_base_fn, trim_bind_fn
{
using trim_base_fn::operator();
using trim_bind_fn::operator();
};
/// \relates trim_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(trim_fn, trim)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::trim_view)
#endif // RANGES_V3_VIEW_TRIM_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/common.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_COMMON_HPP
#define RANGES_V3_VIEW_COMMON_HPP
#include <type_traits>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/common_iterator.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
/// \cond
namespace detail
{
// clang-format off
/// \concept random_access_and_sized_range
/// \brief The \c random_access_and_sized_range concept
template<typename R>
CPP_concept random_access_and_sized_range =
random_access_range<R> && sized_range<R>;
// clang-format on
template<typename R>
using common_view_iterator_t =
meta::if_c<random_access_and_sized_range<R>, iterator_t<R>,
common_iterator_t<iterator_t<R>, sentinel_t<R>>>;
template<typename Rng>
struct is_common_range : meta::bool_<common_range<Rng>>
{};
} // namespace detail
/// \endcond
template<typename Rng, bool = detail::is_common_range<Rng>::value>
struct common_view : view_interface<common_view<Rng>, range_cardinality<Rng>::value>
{
private:
CPP_assert(view_<Rng>);
CPP_assert(!(common_range<Rng> && view_<Rng>));
Rng rng_;
sentinel_t<Rng> end_(std::false_type)
{
return ranges::end(rng_);
}
iterator_t<Rng> end_(std::true_type)
{
return ranges::begin(rng_) + ranges::distance(rng_);
}
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng>>)
sentinel_t<meta::const_if_c<Const, Rng>> end_(std::false_type) const
{
return ranges::end(rng_);
}
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng>>)
iterator_t<meta::const_if_c<Const, Rng>> end_(std::true_type) const
{
return ranges::begin(rng_) + ranges::distance(rng_);
}
public:
common_view() = default;
explicit common_view(Rng rng)
: rng_(detail::move(rng))
{}
Rng base() const
{
return rng_;
}
detail::common_view_iterator_t<Rng> begin()
{
return detail::common_view_iterator_t<Rng>{ranges::begin(rng_)};
}
detail::common_view_iterator_t<Rng> end()
{
return detail::common_view_iterator_t<Rng>{
end_(meta::bool_<detail::random_access_and_sized_range<Rng>>{})};
}
CPP_auto_member
auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return ranges::size(rng_);
}
template(bool Const = true)(
requires range<meta::const_if_c<Const, Rng>>)
auto begin() const
-> detail::common_view_iterator_t<meta::const_if_c<Const, Rng>>
{
return detail::common_view_iterator_t<meta::const_if_c<Const, Rng>>{
ranges::begin(rng_)};
}
template(bool Const = true)(
requires range<meta::const_if_c<Const, Rng>>)
auto end() const
-> detail::common_view_iterator_t<meta::const_if_c<Const, Rng>>
{
return detail::common_view_iterator_t<meta::const_if_c<Const, Rng>>{
end_(meta::bool_<detail::random_access_and_sized_range<
meta::const_if_c<Const, Rng>>>{})};
}
CPP_auto_member
auto CPP_fun(size)()(const
requires sized_range<Rng const>)
{
return ranges::size(rng_);
}
};
template<typename Rng, bool B>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<common_view<Rng, B>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng)(
requires (!common_range<Rng>)) //
common_view(Rng &&)
->common_view<views::all_t<Rng>>;
#endif
template<typename Rng>
struct common_view<Rng, true> : identity_adaptor<Rng>
{
CPP_assert(common_range<Rng>);
using identity_adaptor<Rng>::identity_adaptor;
};
namespace views
{
struct cpp20_common_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND common_range<Rng>)
all_t<Rng> operator()(Rng && rng) const
{
return all(static_cast<Rng &&>(rng));
}
template(typename Rng)(
requires viewable_range<Rng> AND (!common_range<Rng>)) //
common_view<all_t<Rng>> operator()(Rng && rng) const
{
return common_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
}
};
struct common_fn
{
template(typename Rng)(
requires viewable_range<Rng>)
common_view<all_t<Rng>> operator()(Rng && rng) const
{
return common_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
}
};
/// \relates common_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<common_fn>, common)
} // namespace views
/// @}
/// \cond
template<typename Rng>
using bounded_view RANGES_DEPRECATED(
"The name bounded_view is deprecated. "
"Please use common_view instead.") = common_view<Rng>;
/// \endcond
namespace views
{
/// \cond
namespace
{
RANGES_DEPRECATED(
"The name views::bounded is deprecated. "
"Please use views::common instead.")
RANGES_INLINE_VAR constexpr auto & bounded = common;
} // namespace
template<typename Rng>
using bounded_t RANGES_DEPRECATED("The name views::bounded_t is deprecated.") =
decltype(common(std::declval<Rng>()));
/// \endcond
} // namespace views
namespace cpp20
{
namespace views
{
RANGES_INLINE_VARIABLE(
ranges::views::view_closure<ranges::views::cpp20_common_fn>, common)
}
template(typename Rng)(
requires view_<Rng> && (!common_range<Rng>)) //
using common_view = ranges::common_view<Rng>;
} // namespace cpp20
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::common_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/move.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_MOVE_HPP
#define RANGES_V3_VIEW_MOVE_HPP
#include <type_traits>
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng>
struct move_view : view_adaptor<move_view<Rng>, Rng>
{
private:
friend range_access;
template<bool Const>
struct adaptor : adaptor_base
{
adaptor() = default;
template(bool Other)(
requires Const AND CPP_NOT(Other)) //
constexpr adaptor(adaptor<Other>)
{}
using CRng = meta::const_if_c<Const, Rng>;
using value_type = range_value_t<Rng>;
range_rvalue_reference_t<CRng> read(iterator_t<CRng> const & it) const
{
return ranges::iter_move(it);
}
range_rvalue_reference_t<CRng> iter_move(iterator_t<CRng> const & it) const
{
return ranges::iter_move(it);
}
};
adaptor<simple_view<Rng>()> begin_adaptor()
{
return {};
}
adaptor<simple_view<Rng>()> end_adaptor()
{
return {};
}
CPP_member
auto begin_adaptor() const //
-> CPP_ret(adaptor<true>)(
requires input_range<Rng const>)
{
return {};
}
CPP_member
auto end_adaptor() const //
-> CPP_ret(adaptor<true>)(
requires input_range<Rng const>)
{
return {};
}
public:
move_view() = default;
explicit move_view(Rng rng)
: move_view::view_adaptor{std::move(rng)}
{}
CPP_auto_member
auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
return ranges::size(this->base());
}
CPP_auto_member
auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return ranges::size(this->base());
}
};
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<move_view<Rng>> =
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
move_view(Rng &&) //
-> move_view<views::all_t<Rng>>;
#endif
namespace views
{
struct move_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng>)
move_view<all_t<Rng>> operator()(Rng && rng) const
{
return move_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
}
};
/// \relates move_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<move_fn>, move)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::move_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/drop_exactly.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_DROP_EXACTLY_HPP
#define RANGES_V3_VIEW_DROP_EXACTLY_HPP
#include <type_traits>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/box.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/view/subrange.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng>
struct RANGES_EMPTY_BASES drop_exactly_view
: view_interface<drop_exactly_view<Rng>,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
, private detail::non_propagating_cache<iterator_t<Rng>, drop_exactly_view<Rng>,
!random_access_range<Rng>>
{
private:
using difference_type_ = range_difference_t<Rng>;
Rng rng_;
difference_type_ n_;
// random_access_range == true
template(bool Const = true)(
requires Const AND random_access_range<meta::const_if_c<Const, Rng>>)
iterator_t<meta::const_if_c<Const, Rng>> get_begin_(std::true_type) const
{
return next(ranges::begin(rng_), n_);
}
iterator_t<Rng> get_begin_(std::true_type)
{
return next(ranges::begin(rng_), n_);
}
// random_access_range == false
iterator_t<Rng> get_begin_(std::false_type)
{
using cache_t =
detail::non_propagating_cache<iterator_t<Rng>, drop_exactly_view<Rng>>;
auto & begin_ = static_cast<cache_t &>(*this);
if(!begin_)
begin_ = next(ranges::begin(rng_), n_);
return *begin_;
}
public:
drop_exactly_view() = default;
drop_exactly_view(Rng rng, difference_type_ n)
: rng_(std::move(rng))
, n_(n)
{
RANGES_EXPECT(n >= 0);
}
iterator_t<Rng> begin()
{
return this->get_begin_(meta::bool_<random_access_range<Rng>>{});
}
sentinel_t<Rng> end()
{
return ranges::end(rng_);
}
template(bool Const = true)(
requires Const AND random_access_range<meta::const_if_c<Const, Rng>>)
iterator_t<meta::const_if_c<Const, Rng>> begin() const
{
return this->get_begin_(std::true_type{});
}
template(bool Const = true)(
requires Const AND random_access_range<meta::const_if_c<Const, Rng>>)
sentinel_t<meta::const_if_c<Const, Rng>> end() const
{
return ranges::end(rng_);
}
CPP_auto_member
auto CPP_fun(size)()(const
requires sized_range<Rng const>)
{
return ranges::size(rng_) - static_cast<range_size_t<Rng const>>(n_);
}
CPP_auto_member
auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return ranges::size(rng_) - static_cast<range_size_t<Rng>>(n_);
}
Rng base() const
{
return rng_;
}
};
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<drop_exactly_view<Rng>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
drop_exactly_view(Rng &&, range_difference_t<Rng>)
->drop_exactly_view<views::all_t<Rng>>;
#endif
namespace views
{
struct drop_exactly_base_fn
{
private:
template<typename Rng>
static auto impl_(Rng && rng, range_difference_t<Rng> n, input_range_tag)
-> drop_exactly_view<all_t<Rng>>
{
return {all(static_cast<Rng &&>(rng)), n};
}
template(typename Rng)(
requires borrowed_range<Rng>)
static subrange<iterator_t<Rng>, sentinel_t<Rng>> //
impl_(Rng && rng, range_difference_t<Rng> n, random_access_range_tag)
{
return {begin(rng) + n, end(rng)};
}
public:
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng>)
auto operator()(Rng && rng, range_difference_t<Rng> n) const
{
return drop_exactly_base_fn::impl_(
static_cast<Rng &&>(rng), n, range_tag_of<Rng>{});
}
};
struct drop_exactly_fn : drop_exactly_base_fn
{
using drop_exactly_base_fn::operator();
template(typename Int)(
requires detail::integer_like_<Int>)
constexpr auto operator()(Int n) const
{
return make_view_closure(bind_back(drop_exactly_base_fn{}, n));
}
};
/// \relates drop_exactly_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(drop_exactly_fn, drop_exactly)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::drop_exactly_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/adjacent_remove_if.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_ADJACENT_REMOVE_IF_HPP
#define RANGES_V3_VIEW_ADJACENT_REMOVE_IF_HPP
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/utility/box.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng, typename Pred>
struct RANGES_EMPTY_BASES adjacent_remove_if_view
: view_adaptor<adjacent_remove_if_view<Rng, Pred>, Rng,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
, private box<semiregular_box_t<Pred>, adjacent_remove_if_view<Rng, Pred>>
{
adjacent_remove_if_view() = default;
constexpr adjacent_remove_if_view(Rng rng, Pred pred)
: adjacent_remove_if_view::view_adaptor{detail::move(rng)}
, adjacent_remove_if_view::box(detail::move(pred))
{}
private:
friend range_access;
struct adaptor : adaptor_base
{
private:
adjacent_remove_if_view * rng_;
public:
adaptor() = default;
constexpr adaptor(adjacent_remove_if_view * rng) noexcept
: rng_(rng)
{}
static constexpr iterator_t<Rng> begin(adjacent_remove_if_view & rng)
{
return *rng.begin_;
}
constexpr void next(iterator_t<Rng> & it) const
{
RANGES_ASSERT(it != ranges::end(rng_->base()));
rng_->satisfy_forward(++it);
}
CPP_member
constexpr auto prev(iterator_t<Rng> & it) const //
-> CPP_ret(void)(
requires bidirectional_range<Rng>)
{
rng_->satisfy_reverse(it);
}
void advance() = delete;
void distance_to() = delete;
};
constexpr adaptor begin_adaptor()
{
cache_begin();
return {this};
}
CPP_member
constexpr auto end_adaptor() //
-> CPP_ret(adaptor)(
requires common_range<Rng>)
{
if(bidirectional_range<Rng>)
cache_begin();
return {this};
}
CPP_member
constexpr auto end_adaptor() noexcept //
-> CPP_ret(adaptor_base)(
requires (!common_range<Rng>))
{
return {};
}
constexpr void satisfy_forward(iterator_t<Rng> & it)
{
auto const last = ranges::end(this->base());
if(it == last)
return;
auto & pred = this->adjacent_remove_if_view::box::get();
for(auto nxt = it; ++nxt != last && invoke(pred, *it, *nxt); it = nxt)
;
}
constexpr void satisfy_reverse(iterator_t<Rng> & it)
{
auto const & first = *begin_;
RANGES_ASSERT(it != first);
(void)first;
auto prv = it;
--it;
if(prv == ranges::end(this->base()))
{
return;
}
auto & pred = this->adjacent_remove_if_view::box::get();
for(; invoke(pred, *it, *prv); prv = it, --it)
RANGES_ASSERT(it != first);
}
void cache_begin()
{
if(begin_)
return;
auto it = ranges::begin(this->base());
satisfy_forward(it);
begin_.emplace(std::move(it));
}
detail::non_propagating_cache<iterator_t<Rng>> begin_;
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Fun)(
requires copy_constructible<Rng>)
adjacent_remove_if_view(Rng &&, Fun)
-> adjacent_remove_if_view<views::all_t<Rng>, Fun>;
#endif
namespace views
{
struct adjacent_remove_if_base_fn
{
template(typename Rng, typename Pred)(
requires viewable_range<Rng> AND forward_range<Rng> AND
indirect_binary_predicate_<Pred, iterator_t<Rng>, iterator_t<Rng>>)
constexpr adjacent_remove_if_view<all_t<Rng>, Pred> //
operator()(Rng && rng, Pred pred) const
{
return {all(static_cast<Rng &&>(rng)), std::move(pred)};
}
};
struct adjacent_remove_if_fn : adjacent_remove_if_base_fn
{
using adjacent_remove_if_base_fn::operator();
template<typename Pred>
constexpr auto operator()(Pred pred) const
{
return make_view_closure(
bind_back(adjacent_remove_if_base_fn{}, std::move(pred)));
}
};
/// \relates adjacent_remove_if_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(adjacent_remove_if_fn, adjacent_remove_if)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::adjacent_remove_if_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/linear_distribute.hpp | /// \file
// Range v3 library
//
// Copyright Casey Carter 2017
// Copyright Gonzalo Brito Gadeschi 2017
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_LINEAR_DISTRIBUTE_HPP
#define RANGES_V3_VIEW_LINEAR_DISTRIBUTE_HPP
#include <type_traits>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
namespace views
{
/// \addtogroup group-views
/// @{
template<typename T>
struct linear_distribute_view : view_facade<linear_distribute_view<T>, finite>
{
CPP_assert(std::is_arithmetic<T>());
private:
friend range_access;
using Calc = meta::conditional_t<std::is_floating_point<T>::value, T, double>;
T from_, to_;
Calc delta_;
std::ptrdiff_t n_;
constexpr T read() const noexcept
{
return from_;
}
constexpr bool equal(default_sentinel_t) const noexcept
{
return n_ == 0;
}
constexpr bool equal(linear_distribute_view const & other) const noexcept
{
bool const eq = n_ == other.n_;
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_FLOAT_EQUAL
RANGES_EXPECT(to_ == other.to_);
RANGES_EXPECT(!eq || from_ == other.from_);
RANGES_DIAGNOSTIC_POP
return eq;
}
constexpr void next() noexcept
{
RANGES_EXPECT(n_ > 0);
--n_;
if(n_ == 0)
{
from_ = to_;
}
else
{
from_ = T(to_ - (delta_ * Calc(n_ - 1)));
}
}
public:
constexpr linear_distribute_view() = default;
constexpr linear_distribute_view(T from, T to, std::ptrdiff_t n) noexcept
: from_(from)
, to_(to)
, delta_(n > 1 ? (to - from) / Calc(n - 1) : 0)
, n_(n)
{
RANGES_EXPECT(n_ > 0);
RANGES_EXPECT(to_ >= from_);
}
constexpr std::size_t size() const noexcept
{
return static_cast<std::size_t>(n_);
}
};
/// Distributes `n` values linearly in the closed interval [`from`, `to`].
///
/// \pre `from <= to && n > 0`
///
/// If `from == to`, returns n-times `to`.
/// If `n == 1` returns `to`.
struct linear_distribute_fn
{
template(typename T)(
requires std::is_arithmetic<T>::value)
constexpr auto operator()(T from, T to, std::ptrdiff_t n) const
{
return linear_distribute_view<T>{from, to, n};
}
};
/// \relates linear_distribute_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(linear_distribute_fn, linear_distribute)
} // namespace views
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/split_when.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_SPLIT_WHEN_HPP
#define RANGES_V3_VIEW_SPLIT_WHEN_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/algorithm/find_if_not.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/indirect.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/view/take_while.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng, typename Fun>
struct split_when_view
: view_facade<split_when_view<Rng, Fun>,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
{
private:
friend range_access;
Rng rng_;
semiregular_box_t<Fun> fun_;
template<bool IsConst>
struct cursor
{
private:
friend range_access;
friend split_when_view;
friend struct cursor<!IsConst>;
bool zero_;
using CRng = meta::const_if_c<IsConst, Rng>;
iterator_t<CRng> cur_;
sentinel_t<CRng> last_;
using fun_ref_t = semiregular_box_ref_or_val_t<Fun, IsConst>;
fun_ref_t fun_;
struct search_pred
{
bool zero_;
iterator_t<CRng> first_;
sentinel_t<CRng> last_;
fun_ref_t fun_;
bool operator()(iterator_t<CRng> cur) const
{
return (zero_ && cur == first_) ||
(cur != last_ && !invoke(fun_, cur, last_).first);
}
};
using reference_ =
indirect_view<take_while_view<iota_view<iterator_t<CRng>>, search_pred>>;
reference_ read() const
{
return reference_{{views::iota(cur_), {zero_, cur_, last_, fun_}}};
}
void next()
{
RANGES_EXPECT(cur_ != last_);
// If the last match consumed zero elements, bump the position.
if(zero_)
{
zero_ = false;
++cur_;
}
for(; cur_ != last_; ++cur_)
{
auto p = invoke(fun_, cur_, last_);
if(p.first)
{
zero_ = (cur_ == p.second);
cur_ = p.second;
return;
}
}
}
bool equal(default_sentinel_t) const
{
return cur_ == last_;
}
bool equal(cursor const & that) const
{
return cur_ == that.cur_;
}
cursor(fun_ref_t fun, iterator_t<CRng> first, sentinel_t<CRng> last)
: cur_(first)
, last_(last)
, fun_(fun)
{
// For skipping an initial zero-length match
auto p = invoke(fun, first, last);
zero_ = p.first && first == p.second;
}
public:
cursor() = default;
template(bool Other)(
requires IsConst AND CPP_NOT(Other)) //
cursor(cursor<Other> that)
: cursor{std::move(that.cur_), std::move(that.last_), std::move(that.fun_)}
{}
};
cursor<false> begin_cursor()
{
return {fun_, ranges::begin(rng_), ranges::end(rng_)};
}
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng>> AND
invocable<Fun const &, iterator_t<meta::const_if_c<Const, Rng>>,
sentinel_t<meta::const_if_c<Const, Rng>>>)
cursor<Const> begin_cursor() const
{
return {fun_, ranges::begin(rng_), ranges::end(rng_)};
}
public:
split_when_view() = default;
split_when_view(Rng rng, Fun fun)
: rng_(std::move(rng))
, fun_(std::move(fun))
{}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Fun)(
requires copy_constructible<Fun>)
split_when_view(Rng &&, Fun)
-> split_when_view<views::all_t<Rng>, Fun>;
#endif
namespace views
{
struct split_when_base_fn
{
private:
template<typename Pred>
struct predicate_pred_
{
semiregular_box_t<Pred> pred_;
template(typename I, typename S)(
requires sentinel_for<S, I>)
std::pair<bool, I> operator()(I cur, S last) const
{
auto where = ranges::find_if_not(cur, last, std::ref(pred_));
return {cur != where, where};
}
};
public:
template(typename Rng, typename Fun)(
requires viewable_range<Rng> AND forward_range<Rng> AND
invocable<Fun &, iterator_t<Rng>, sentinel_t<Rng>> AND
invocable<Fun &, iterator_t<Rng>, iterator_t<Rng>> AND
copy_constructible<Fun> AND
convertible_to<
invoke_result_t<Fun &, iterator_t<Rng>, sentinel_t<Rng>>,
std::pair<bool, iterator_t<Rng>>>)
split_when_view<all_t<Rng>, Fun> operator()(Rng && rng, Fun fun) const //
{
return {all(static_cast<Rng &&>(rng)), std::move(fun)};
}
template(typename Rng, typename Fun)(
requires viewable_range<Rng> AND forward_range<Rng> AND
predicate<Fun const &, range_reference_t<Rng>> AND
copy_constructible<Fun>)
split_when_view<all_t<Rng>, predicate_pred_<Fun>> //
operator()(Rng && rng, Fun fun) const
{
return {all(static_cast<Rng &&>(rng)),
predicate_pred_<Fun>{std::move(fun)}};
}
};
struct split_when_fn : split_when_base_fn
{
using split_when_base_fn::operator();
template<typename T>
constexpr auto operator()(T && t) const
{
return make_view_closure(
bind_back(split_when_base_fn{}, static_cast<T &&>(t)));
}
};
/// \relates split_when_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(split_when_fn, split_when)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::split_when_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/zip_with.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_ZIP_WITH_HPP
#define RANGES_V3_VIEW_ZIP_WITH_HPP
#include <limits>
#include <tuple>
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/indirect.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/common_type.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/utility/tuple_algorithm.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/empty.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
struct equal_to_
{
template<typename T, typename U>
bool operator()(T const & t, U const & u) const
{
return static_cast<bool>(t == u);
}
};
RANGES_INLINE_VARIABLE(equal_to_, equal_to)
struct dec_
{
template<typename T>
void operator()(T & t) const
{
--t;
}
};
RANGES_INLINE_VARIABLE(dec_, dec)
struct inc_
{
template<typename T>
void operator()(T & t) const
{
++t;
}
};
RANGES_INLINE_VARIABLE(inc_, inc)
struct _advance_
{
template(typename I, typename Diff)(
requires input_or_output_iterator<I> AND integer_like_<Diff>)
void operator()(I & i, Diff n) const
{
advance(i, static_cast<iter_difference_t<I>>(n));
}
};
RANGES_INLINE_VARIABLE(_advance_, advance_)
struct distance_to_
{
template<typename T>
constexpr auto operator()(T const & t, T const & u) const -> decltype(u - t)
{
return u - t;
}
};
RANGES_INLINE_VARIABLE(distance_to_, distance_to)
struct _min_
{
template<typename T, typename U>
constexpr auto operator()(T const & t, U const & u) const
-> decltype(true ? t : u)
{
return u < t ? u : t;
}
};
RANGES_INLINE_VARIABLE(_min_, min_)
struct _max_
{
template<typename T, typename U>
constexpr auto operator()(T const & t, U const & u) const
-> decltype(true ? u : t)
{
return u < t ? t : u;
}
};
RANGES_INLINE_VARIABLE(_max_, max_)
template<typename State, typename Value>
using zip_cardinality = std::integral_constant<
cardinality,
State::value >= 0 && Value::value >= 0
? min_(State::value, Value::value)
: State::value >=0 && Value::value == infinite
? State::value
: State::value == infinite && Value::value >= 0
? Value::value
: State::value == finite || Value::value == finite
? finite
: State::value == unknown || Value::value == unknown
? unknown
: infinite>;
} // namespace detail
/// \endcond
namespace views
{
// clang-format off
/// \concept zippable_with_
/// \brief The \c zippable_with_ concept
template(typename Fun, typename... Rngs)(
concept (zippable_with_)(Fun, Rngs...),
invocable<Fun&, iterator_t<Rngs>...> AND
invocable<Fun&, copy_tag, iterator_t<Rngs>...> AND
invocable<Fun&, move_tag, iterator_t<Rngs>...>
);
/// \concept zippable_with
/// \brief The \c zippable_with concept
template<typename Fun, typename ...Rngs>
CPP_concept zippable_with =
and_v<input_range<Rngs>...> &&
copy_constructible<Fun> &&
CPP_concept_ref(views::zippable_with_, Fun, Rngs...);
// clang-format on
} // namespace views
/// \addtogroup group-views
/// @{
template<typename Fun, typename... Rngs>
struct iter_zip_with_view
: view_facade<iter_zip_with_view<Fun, Rngs...>,
meta::fold<meta::list<range_cardinality<Rngs>...>,
std::integral_constant<cardinality, cardinality::infinite>,
meta::quote<detail::zip_cardinality>>::value>
{
private:
CPP_assert(sizeof...(Rngs) != 0);
friend range_access;
semiregular_box_t<Fun> fun_;
std::tuple<Rngs...> rngs_;
using difference_type_ = common_type_t<range_difference_t<Rngs>...>;
template<bool Const>
struct cursor;
template<bool Const>
struct sentinel
{
private:
friend struct cursor<Const>;
friend struct sentinel<!Const>;
std::tuple<sentinel_t<meta::const_if_c<Const, Rngs>>...> ends_;
public:
sentinel() = default;
sentinel(detail::ignore_t,
std::tuple<sentinel_t<meta::const_if_c<Const, Rngs>>...> ends)
: ends_(std::move(ends))
{}
template(bool Other)(
requires Const AND CPP_NOT(Other)) //
sentinel(sentinel<Other> that)
: ends_(std::move(that.ends_))
{}
};
template<bool Const>
struct cursor
{
private:
friend struct cursor<!Const>;
using fun_ref_ = semiregular_box_ref_or_val_t<Fun, Const>;
fun_ref_ fun_;
std::tuple<iterator_t<meta::const_if_c<Const, Rngs>>...> its_;
public:
using difference_type =
common_type_t<range_difference_t<meta::const_if_c<Const, Rngs>>...>;
using single_pass = meta::or_c<(
bool)single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rngs>>>...>;
using value_type = detail::decay_t<invoke_result_t<
fun_ref_ &, copy_tag, iterator_t<meta::const_if_c<Const, Rngs>>...>>;
cursor() = default;
cursor(fun_ref_ fun,
std::tuple<iterator_t<meta::const_if_c<Const, Rngs>>...> its)
: fun_(std::move(fun))
, its_(std::move(its))
{}
template(bool Other)(
requires Const AND CPP_NOT(Other)) //
cursor(cursor<Other> that)
: fun_(std::move(that.fun_))
, its_(std::move(that.its_))
{}
// clang-format off
auto CPP_auto_fun(read)()(const)
(
return tuple_apply(fun_, its_)
)
// clang-format on
void next()
{
tuple_for_each(its_, detail::inc);
}
CPP_member
auto equal(cursor const & that) const //
-> CPP_ret(bool)(
requires and_v<
sentinel_for<iterator_t<meta::const_if_c<Const, Rngs>>,
iterator_t<meta::const_if_c<Const, Rngs>>>...>)
{
// By returning true if *any* of the iterators are equal, we allow
// zipped ranges to be of different lengths, stopping when the first
// one reaches the last.
return tuple_foldl(tuple_transform(its_, that.its_, detail::equal_to),
false,
[](bool a, bool b) { return a || b; });
}
bool equal(sentinel<Const> const & s) const
{
// By returning true if *any* of the iterators are equal, we allow
// zipped ranges to be of different lengths, stopping when the first
// one reaches the last.
return tuple_foldl(tuple_transform(its_, s.ends_, detail::equal_to),
false,
[](bool a, bool b) { return a || b; });
}
CPP_member
auto prev() //
-> CPP_ret(void)(
requires and_v<bidirectional_range<meta::const_if_c<Const, Rngs>>...>)
{
tuple_for_each(its_, detail::dec);
}
CPP_member
auto advance(difference_type n) //
-> CPP_ret(void)(
requires and_v<random_access_range<meta::const_if_c<Const, Rngs>>...>)
{
tuple_for_each(its_, bind_back(detail::advance_, n));
}
CPP_member
auto distance_to(cursor const & that) const //
-> CPP_ret(difference_type)(
requires and_v<
sized_sentinel_for<iterator_t<meta::const_if_c<Const, Rngs>>,
iterator_t<meta::const_if_c<Const, Rngs>>>...>)
{
// Return the smallest distance (in magnitude) of any of the iterator
// pairs. This is to accommodate zippers of sequences of different length.
auto first_size = std::get<0>(that.its_) - std::get<0>(its_);
if(first_size == 0)
return static_cast<difference_type>(0);
if(0 < first_size)
return tuple_foldl(
tuple_transform(its_, that.its_, detail::distance_to),
(std::numeric_limits<difference_type>::max)(),
detail::min_);
else
return tuple_foldl(
tuple_transform(its_, that.its_, detail::distance_to),
(std::numeric_limits<difference_type>::min)(),
detail::max_);
}
// clang-format off
template<std::size_t... Is>
auto CPP_auto_fun(move_)(meta::index_sequence<Is...>)(const)
(
return invoke(fun_, move_tag{}, std::get<Is>(its_)...)
)
// clang-format on
auto move() const noexcept(noexcept(std::declval<cursor const &>().move_(
meta::make_index_sequence<sizeof...(Rngs)>{})))
-> decltype(std::declval<cursor const &>().move_(
meta::make_index_sequence<sizeof...(Rngs)>{}))
{
return move_(meta::make_index_sequence<sizeof...(Rngs)>{});
}
};
template<bool Const>
using end_cursor_t =
meta::if_c<concepts::and_v<(bool)common_range<Rngs>...,
!(bool)single_pass_iterator_<iterator_t<Rngs>>...>,
cursor<Const>, sentinel<Const>>;
cursor<false> begin_cursor()
{
return {fun_, tuple_transform(rngs_, ranges::begin)};
}
end_cursor_t<false> end_cursor()
{
return {fun_, tuple_transform(rngs_, ranges::end)};
}
template(bool Const = true)(
requires Const AND and_v<range<Rngs const>...> AND
views::zippable_with<Fun, meta::if_c<Const, Rngs const>...>)
cursor<Const> begin_cursor() const
{
return {fun_, tuple_transform(rngs_, ranges::begin)};
}
template(bool Const = true)(
requires Const AND and_v<range<Rngs const>...> AND
views::zippable_with<Fun, meta::if_c<Const, Rngs const>...>)
end_cursor_t<Const> end_cursor() const
{
return {fun_, tuple_transform(rngs_, ranges::end)};
}
public:
iter_zip_with_view() = default;
explicit iter_zip_with_view(Rngs... rngs)
: fun_(Fun{})
, rngs_{std::move(rngs)...}
{}
explicit iter_zip_with_view(Fun fun, Rngs... rngs)
: fun_(std::move(fun))
, rngs_{std::move(rngs)...}
{}
CPP_auto_member
constexpr auto CPP_fun(size)()(const //
requires and_v<sized_range<Rngs const>...>)
{
using size_type = common_type_t<range_size_t<Rngs const>...>;
return range_cardinality<iter_zip_with_view>::value >= 0
? size_type{(
std::size_t)range_cardinality<iter_zip_with_view>::value}
: tuple_foldl(tuple_transform(rngs_,
[](auto && r) -> size_type {
return ranges::size(r);
}),
(std::numeric_limits<size_type>::max)(),
detail::min_);
}
};
template<typename Fun, typename... Rngs>
struct zip_with_view : iter_zip_with_view<indirected<Fun>, Rngs...>
{
CPP_assert(sizeof...(Rngs) != 0);
zip_with_view() = default;
explicit zip_with_view(Rngs... rngs)
: iter_zip_with_view<indirected<Fun>, Rngs...>{{Fun{}}, std::move(rngs)...}
{}
explicit zip_with_view(Fun fun, Rngs... rngs)
: iter_zip_with_view<indirected<Fun>, Rngs...>{{std::move(fun)},
std::move(rngs)...}
{}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Fun, typename... Rng)(
requires copy_constructible<Fun>)
zip_with_view(Fun, Rng &&...)
-> zip_with_view<Fun, views::all_t<Rng>...>;
#endif
namespace views
{
struct iter_zip_with_fn
{
template(typename... Rngs, typename Fun)(
requires and_v<viewable_range<Rngs>...> AND
zippable_with<Fun, Rngs...> AND (sizeof...(Rngs) != 0)) //
iter_zip_with_view<Fun, all_t<Rngs>...> //
operator()(Fun fun, Rngs &&... rngs) const
{
return iter_zip_with_view<Fun, all_t<Rngs>...>{
std::move(fun), all(static_cast<Rngs &&>(rngs))...};
}
template(typename Fun)(
requires zippable_with<Fun>) //
constexpr empty_view<detail::decay_t<invoke_result_t<Fun &>>>
operator()(Fun) const noexcept
{
return {};
}
};
/// \relates iter_zip_with_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(iter_zip_with_fn, iter_zip_with)
struct zip_with_fn
{
template(typename... Rngs, typename Fun)(
requires and_v<viewable_range<Rngs>...> AND
and_v<input_range<Rngs>...> AND copy_constructible<Fun> AND
invocable<Fun &, range_reference_t<Rngs>...> AND
(sizeof...(Rngs) != 0)) //
zip_with_view<Fun, all_t<Rngs>...> operator()(Fun fun, Rngs &&... rngs) const
{
return zip_with_view<Fun, all_t<Rngs>...>{
std::move(fun), all(static_cast<Rngs &&>(rngs))...};
}
template(typename Fun)(
requires copy_constructible<Fun> AND invocable<Fun &>) //
constexpr empty_view<detail::decay_t<invoke_result_t<Fun &>>>
operator()(Fun) const noexcept
{
return {};
}
};
/// \relates zip_with_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(zip_with_fn, zip_with)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::iter_zip_with_view)
RANGES_SATISFY_BOOST_RANGE(::ranges::zip_with_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/map.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_MAP_HPP
#define RANGES_V3_VIEW_MAP_HPP
#include <utility>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
// TODO: Reuse subrange's pair_like concept here and have get_first and get_second
// dispatch through get<>()
namespace ranges
{
/// \cond
namespace detail
{
template<typename T>
constexpr T & get_first_second_helper(T & t, std::true_type) noexcept
{
return t;
}
template(typename T)(
requires move_constructible<T>)
constexpr T get_first_second_helper(T & t, std::false_type) //
noexcept(std::is_nothrow_move_constructible<T>::value)
{
return std::move(t);
}
template<typename P, typename E>
using get_first_second_tag = meta::bool_<std::is_lvalue_reference<P>::value ||
std::is_lvalue_reference<E>::value>;
struct get_first
{
// clang-format off
template<typename Pair>
constexpr auto CPP_auto_fun(operator())(Pair &&p)(const)
(
return get_first_second_helper(
p.first,
get_first_second_tag<Pair, decltype(p.first)>{})
)
// clang-format on
};
struct get_second
{
// clang-format off
template<typename Pair>
constexpr auto CPP_auto_fun(operator())(Pair &&p)(const)
(
return get_first_second_helper(
p.second,
get_first_second_tag<Pair, decltype(p.second)>{})
)
// clang-format on
};
// clang-format off
/// \concept kv_pair_like_
/// \brief The \c kv_pair_like_ concept
template<typename T>
CPP_concept kv_pair_like_ =
invocable<get_first const &, T> &&
invocable<get_second const &, T>;
// clang-format on
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
namespace views
{
struct keys_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng> AND
detail::kv_pair_like_<range_reference_t<Rng>>)
keys_range_view<all_t<Rng>> operator()(Rng && rng) const
{
return {all(static_cast<Rng &&>(rng)), detail::get_first{}};
}
};
struct values_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng> AND
detail::kv_pair_like_<range_reference_t<Rng>>)
values_view<all_t<Rng>> operator()(Rng && rng) const
{
return {all(static_cast<Rng &&>(rng)), detail::get_second{}};
}
};
/// \relates keys_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<keys_fn>, keys)
/// \relates values_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<values_fn>, values)
} // namespace views
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<keys_range_view<Rng>> =
enable_borrowed_range<Rng>;
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<values_view<Rng>> =
enable_borrowed_range<Rng>;
namespace cpp20
{
namespace views
{
using ranges::views::keys;
using ranges::views::values;
} // namespace views
// TODO(@cjdb): provide implementation for elements_view
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/getlines.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_GETLINES_HPP
#define RANGES_V3_VIEW_GETLINES_HPP
#include <istream>
#include <string>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
struct getlines_view : view_facade<getlines_view, unknown>
{
private:
friend range_access;
std::istream * sin_;
std::string str_;
char delim_;
struct cursor
{
private:
friend range_access;
using single_pass = std::true_type;
getlines_view * rng_ = nullptr;
public:
cursor() = default;
explicit cursor(getlines_view * rng)
: rng_(rng)
{}
void next()
{
rng_->next();
}
std::string & read() const noexcept
{
return rng_->str_;
}
bool equal(default_sentinel_t) const
{
return !rng_->sin_;
}
bool equal(cursor that) const
{
return !rng_->sin_ == !that.rng_->sin_;
}
};
void next()
{
if(!std::getline(*sin_, str_, delim_))
sin_ = nullptr;
}
cursor begin_cursor()
{
return cursor{this};
}
public:
getlines_view() = default;
getlines_view(std::istream & sin, char delim = '\n')
: sin_(&sin)
, str_{}
, delim_(delim)
{
this->next(); // prime the pump
}
std::string & cached() noexcept
{
return str_;
}
};
/// \cond
using getlines_range RANGES_DEPRECATED(
"getlines_range has been renamed getlines_view") = getlines_view;
/// \endcond
struct getlines_fn
{
getlines_view operator()(std::istream & sin, char delim = '\n') const
{
return getlines_view{sin, delim};
}
};
RANGES_INLINE_VARIABLE(getlines_fn, getlines)
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/single.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_SINGLE_HPP
#define RANGES_V3_VIEW_SINGLE_HPP
#include <type_traits>
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/addressof.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename T>
struct single_view : view_interface<single_view<T>, (cardinality)1>
{
private:
CPP_assert(copy_constructible<T>);
static_assert(std::is_object<T>::value,
"The template parameter of single_view must be an object type");
semiregular_box_t<T> value_;
template<typename... Args>
constexpr single_view(in_place_t, std::true_type, Args &&... args)
: value_{static_cast<Args &&>(args)...}
{}
template<typename... Args>
constexpr single_view(in_place_t, std::false_type, Args &&... args)
: value_{in_place, static_cast<Args &&>(args)...}
{}
public:
single_view() = default;
constexpr explicit single_view(T const & t)
: value_(t)
{}
constexpr explicit single_view(T && t)
: value_(std::move(t))
{}
template(class... Args)(
requires constructible_from<T, Args...>)
constexpr single_view(in_place_t, Args &&... args)
: single_view{in_place,
meta::bool_<(bool)semiregular<T>>{},
static_cast<Args &&>(args)...}
{}
constexpr T * begin() noexcept
{
return data();
}
constexpr T const * begin() const noexcept
{
return data();
}
constexpr T * end() noexcept
{
return data() + 1;
}
constexpr T const * end() const noexcept
{
return data() + 1;
}
static constexpr std::size_t size() noexcept
{
return 1u;
}
constexpr T * data() noexcept
{
return detail::addressof(static_cast<T &>(value_));
}
constexpr T const * data() const noexcept
{
return detail::addressof(static_cast<T const &>(value_));
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<class T>
explicit single_view(T &&) //
-> single_view<detail::decay_t<T>>;
#endif
namespace views
{
struct single_fn
{
template(typename Val)(
requires copy_constructible<Val>)
single_view<Val> operator()(Val value) const
{
return single_view<Val>{std::move(value)};
}
};
/// \relates single_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(single_fn, single)
} // namespace views
namespace cpp20
{
namespace views
{
using ranges::views::single;
}
template(typename T)(
requires std::is_object<T>::value) //
using single_view = ranges::single_view<T>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::single_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/const.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_CONST_HPP
#define RANGES_V3_VIEW_CONST_HPP
#include <type_traits>
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/utility/common_type.hpp>
#include <range/v3/utility/move.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng>
struct const_view : view_adaptor<const_view<Rng>, Rng>
{
private:
friend range_access;
template<bool Const>
struct adaptor : adaptor_base
{
using CRng = meta::const_if_c<Const, Rng>;
using value_ = range_value_t<CRng>;
using reference_ =
common_reference_t<value_ const &&, range_reference_t<CRng>>;
using rvalue_reference_ =
common_reference_t<value_ const &&, range_rvalue_reference_t<CRng>>;
adaptor() = default;
template(bool Other)(
requires Const && CPP_NOT(Other)) //
constexpr adaptor(adaptor<Other>)
{}
reference_ read(iterator_t<CRng> const & it) const
{
return *it;
}
rvalue_reference_ iter_move(iterator_t<CRng> const & it) const
noexcept(noexcept(rvalue_reference_(ranges::iter_move(it))))
{
return ranges::iter_move(it);
}
};
adaptor<simple_view<Rng>()> begin_adaptor()
{
return {};
}
CPP_member
auto begin_adaptor() const //
-> CPP_ret(adaptor<true>)(
requires range<Rng const>)
{
return {};
}
adaptor<simple_view<Rng>()> end_adaptor()
{
return {};
}
CPP_member
auto end_adaptor() const //
-> CPP_ret(adaptor<true>)(
requires range<Rng const>)
{
return {};
}
public:
const_view() = default;
explicit const_view(Rng rng)
: const_view::view_adaptor{std::move(rng)}
{}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return ranges::size(this->base());
}
CPP_auto_member
constexpr auto CPP_fun(size)()(const
requires sized_range<Rng const>)
{
return ranges::size(this->base());
}
};
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<const_view<Rng>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
const_view(Rng &&) //
-> const_view<views::all_t<Rng>>;
#endif
namespace views
{
struct const_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng>)
const_view<all_t<Rng>> operator()(Rng && rng) const
{
return const_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
}
};
/// \relates const_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<const_fn>, const_)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::const_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/indices.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
// Copyright Gonzalo Brito Gadeschi
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_INDICES_HPP
#define RANGES_V3_VIEW_INDICES_HPP
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/iota.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
namespace views
{
/// Half-open range of indices: [from, to).
struct indices_fn : iota_view<std::size_t>
{
indices_fn() = default;
template(typename Val)(
requires integral<Val>)
iota_view<Val, Val> operator()(Val to) const
{
return {Val(), to};
}
template(typename Val)(
requires integral<Val>)
iota_view<Val, Val> operator()(Val from, Val to) const
{
return {from, to};
}
};
/// Inclusive range of indices: [from, to].
struct closed_indices_fn
{
template(typename Val)(
requires integral<Val>)
closed_iota_view<Val> operator()(Val to) const
{
return {Val(), to};
}
template(typename Val)(
requires integral<Val>)
closed_iota_view<Val> operator()(Val from, Val to) const
{
return {from, to};
}
};
/// \relates indices_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(indices_fn, indices)
/// \relates closed_indices_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(closed_indices_fn, closed_indices)
} // namespace views
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_VIEW_INDICES_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/replace_if.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_REPLACE_IF_HPP
#define RANGES_V3_VIEW_REPLACE_IF_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/utility/compressed_pair.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
template<typename Pred, typename Val>
struct replacer_if_fn : compressed_pair<semiregular_box_t<Pred>, Val>
{
private:
using base_t = compressed_pair<semiregular_box_t<Pred>, Val>;
using base_t::first;
using base_t::second;
public:
replacer_if_fn() = default;
constexpr replacer_if_fn(Pred pred, Val new_value)
: base_t{std::move(pred), std::move(new_value)}
{}
template<typename I>
[[noreturn]] common_type_t<decay_t<unwrap_reference_t<Val const &>>,
iter_value_t<I>> &
operator()(copy_tag, I const &) const
{
RANGES_EXPECT(false);
}
template(typename I)(
requires (!invocable<Pred const &, iter_reference_t<I>>))
common_reference_t<unwrap_reference_t<Val const &>, iter_reference_t<I>> //
operator()(I const & i)
{
auto && x = *i;
if(invoke(first(), (decltype(x) &&)x)) //
return unwrap_reference(second());
return (decltype(x) &&)x;
}
template(typename I)(
requires invocable<Pred const &, iter_reference_t<I>>)
common_reference_t<unwrap_reference_t<Val const &>, iter_reference_t<I>> //
operator()(I const & i) const
{
auto && x = *i;
if(invoke(first(), (decltype(x) &&)x)) //
return unwrap_reference(second());
return (decltype(x) &&)x;
}
template(typename I)(
requires (!invocable<Pred const &, iter_rvalue_reference_t<I>>))
common_reference_t<
unwrap_reference_t<Val const &>, //
iter_rvalue_reference_t<I>> //
operator()(move_tag, I const & i)
{
auto && x = iter_move(i);
if(invoke(first(), (decltype(x) &&)x)) //
return unwrap_reference(second());
return (decltype(x) &&)x;
}
template(typename I)(
requires invocable<Pred const &, iter_rvalue_reference_t<I>>)
common_reference_t< //
unwrap_reference_t<Val const &>, //
iter_rvalue_reference_t<I>> //
operator()(move_tag, I const & i) const
{
auto && x = iter_move(i);
if(invoke(first(), (decltype(x) &&)x)) //
return unwrap_reference(second());
return (decltype(x) &&)x;
}
};
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
namespace views
{
struct replace_if_base_fn
{
template(typename Rng, typename Pred, typename Val)(
requires viewable_range<Rng> AND input_range<Rng> AND
indirect_unary_predicate<Pred, iterator_t<Rng>> AND
common_with<detail::decay_t<unwrap_reference_t<Val const &>>,
range_value_t<Rng>> AND
common_reference_with<unwrap_reference_t<Val const &>,
range_reference_t<Rng>> AND
common_reference_with<unwrap_reference_t<Val const &>,
range_rvalue_reference_t<Rng>>)
constexpr replace_if_view<all_t<Rng>, Pred, Val> //
operator()(Rng && rng, Pred pred, Val new_value) const
{
return {all(static_cast<Rng &&>(rng)),
{std::move(pred), std::move(new_value)}};
}
};
struct replace_if_fn : replace_if_base_fn
{
using replace_if_base_fn::operator();
template<typename Pred, typename Val>
constexpr auto operator()(Pred pred, Val new_value) const
{
return make_view_closure(bind_back(
replace_if_base_fn{}, std::move(pred), std::move(new_value)));
}
};
/// \relates replace_if_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(replace_if_fn, replace_if)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/sample.hpp | /// \file
// Range v3 library
//
// Copyright Casey Carter 2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_SAMPLE_HPP
#define RANGES_V3_VIEW_SAMPLE_HPP
#include <meta/meta.hpp>
#include <range/v3/algorithm/shuffle.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
template<typename Rng,
bool = (bool)sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>>
class size_tracker
{
range_difference_t<Rng> size_;
public:
CPP_assert(forward_range<Rng> || sized_range<Rng>);
size_tracker() = default;
size_tracker(Rng & rng)
: size_(ranges::distance(rng))
{}
void decrement()
{
--size_;
}
range_difference_t<Rng> get(Rng &, iterator_t<Rng> &) const
{
return size_;
}
};
// Impl for sized_sentinel_for (no need to store anything)
template<typename Rng>
class size_tracker<Rng, true>
{
public:
size_tracker() = default;
size_tracker(Rng &)
{}
void decrement()
{}
range_difference_t<Rng> get(Rng & rng, iterator_t<Rng> const & it) const
{
return ranges::end(rng) - it;
}
};
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
// Take a random sampling from another view
template<typename Rng, typename URNG>
class sample_view : public view_facade<sample_view<Rng, URNG>, finite>
{
friend range_access;
using D = range_difference_t<Rng>;
Rng rng_;
// Mutable is OK here because sample_view is an Input view.
mutable range_difference_t<Rng> size_;
URNG * engine_;
template<bool IsConst>
class cursor
{
friend cursor<!IsConst>;
using Base = meta::const_if_c<IsConst, Rng>;
meta::const_if_c<IsConst, sample_view> * parent_;
iterator_t<Base> current_;
RANGES_NO_UNIQUE_ADDRESS detail::size_tracker<Base> size_;
D pop_size()
{
return size_.get(parent_->rng_, current_);
}
void advance()
{
if(parent_->size_ > 0)
{
using Dist = std::uniform_int_distribution<D>;
Dist dist{};
URNG & engine = *parent_->engine_;
for(;; ++current_, size_.decrement())
{
RANGES_ASSERT(current_ != ranges::end(parent_->rng_));
auto n = pop_size();
RANGES_EXPECT(n > 0);
typename Dist::param_type const interval{0, n - 1};
if(dist(engine, interval) < parent_->size_)
break;
}
}
}
public:
using value_type = range_value_t<Rng>;
using difference_type = D;
cursor() = default;
explicit cursor(meta::const_if_c<IsConst, sample_view> * rng)
: parent_(rng)
, current_(ranges::begin(rng->rng_))
, size_{rng->rng_}
{
auto n = pop_size();
if(rng->size_ > n)
rng->size_ = n;
advance();
}
template(bool Other)(
requires IsConst AND CPP_NOT(Other)) //
cursor(cursor<Other> that)
: parent_(that.parent_)
, current_(std::move(that.current_))
, size_(that.size_)
{}
range_reference_t<Rng> read() const
{
return *current_;
}
bool equal(default_sentinel_t) const
{
RANGES_EXPECT(parent_);
return parent_->size_ <= 0;
}
void next()
{
RANGES_EXPECT(parent_);
RANGES_EXPECT(parent_->size_ > 0);
--parent_->size_;
RANGES_ASSERT(current_ != ranges::end(parent_->rng_));
++current_;
size_.decrement();
advance();
}
};
cursor<false> begin_cursor()
{
return cursor<false>{this};
}
template(bool Const = true)(
requires Const AND
(sized_range<meta::const_if_c<Const, Rng>> ||
sized_sentinel_for<sentinel_t<meta::const_if_c<Const, Rng>>,
iterator_t<meta::const_if_c<Const, Rng>>> ||
forward_range<meta::const_if_c<Const, Rng>>)) //
cursor<Const> begin_cursor() const
{
return cursor<true>{this};
}
public:
sample_view() = default;
explicit sample_view(Rng rng, D sample_size, URNG & generator)
: rng_(std::move(rng))
, size_(sample_size)
, engine_(std::addressof(generator))
{
RANGES_EXPECT(sample_size >= 0);
}
Rng base() const
{
return rng_;
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng, typename URNG>
sample_view(Rng &&, range_difference_t<Rng>, URNG &)
->sample_view<views::all_t<Rng>, URNG>;
#endif
namespace views
{
/// Returns a random sample of a range of length `size(range)`.
struct sample_base_fn
{
template(typename Rng, typename URNG = detail::default_random_engine)(
requires viewable_range<Rng> AND input_range<Rng> AND
uniform_random_bit_generator<URNG> AND
convertible_to<invoke_result_t<URNG &>, range_difference_t<Rng>> AND
(sized_range<Rng> ||
sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>> ||
forward_range<Rng>)) //
sample_view<all_t<Rng>, URNG> operator()(
Rng && rng,
range_difference_t<Rng> sample_size,
URNG & generator = detail::get_random_engine()) const
{
return sample_view<all_t<Rng>, URNG>{
all(static_cast<Rng &&>(rng)), sample_size, generator};
}
/// \cond
template<typename Rng, typename URNG>
invoke_result_t<sample_base_fn, Rng, range_difference_t<Rng>, URNG &> //
operator()(
Rng && rng,
range_difference_t<Rng> sample_size,
detail::reference_wrapper_<URNG> r) const
{
return (*this)(static_cast<Rng &&>(rng), sample_size, r.get());
}
/// \endcond
};
struct sample_fn : sample_base_fn
{
using sample_base_fn::operator();
template(typename Size, typename URNG = detail::default_random_engine)(
requires integral<Size> AND uniform_random_bit_generator<URNG>)
constexpr auto operator()(
Size n,
URNG & urng = detail::get_random_engine()) const //
{
return make_view_closure(bind_back(
sample_base_fn{}, n, detail::reference_wrapper_<URNG>(urng)));
}
};
/// \relates sample_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(sample_fn, sample)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::sample_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/chunk.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_CHUNK_HPP
#define RANGES_V3_VIEW_CHUNK_HPP
#include <limits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/box.hpp>
#include <range/v3/utility/optional.hpp> // for non_propagating_cache
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/take.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
template<typename Rng, bool Const>
constexpr bool can_sized_sentinel_() noexcept
{
using I = iterator_t<meta::const_if_c<Const, Rng>>;
return (bool)sized_sentinel_for<I, I>;
}
template<typename T>
struct zero
{
zero() = default;
constexpr explicit zero(T const &) noexcept
{}
constexpr zero & operator=(T const &) noexcept
{
return *this;
}
constexpr zero const & operator=(T const &) const noexcept
{
return *this;
}
constexpr operator T() const
{
return T(0);
}
constexpr T exchange(T const &) const
{
return T(0);
}
};
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
template<typename Rng, bool IsForwardRange>
struct chunk_view_
: view_adaptor<chunk_view_<Rng, IsForwardRange>, Rng,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
{
private:
friend range_access;
CPP_assert(forward_range<Rng>);
template<bool Const>
using offset_t =
meta::if_c<bidirectional_range<meta::const_if_c<Const, Rng>> ||
detail::can_sized_sentinel_<Rng, Const>(),
range_difference_t<Rng>, detail::zero<range_difference_t<Rng>>>;
range_difference_t<Rng> n_ = 0;
template<bool Const>
struct RANGES_EMPTY_BASES adaptor
: adaptor_base
, private box<offset_t<Const>>
{
private:
friend adaptor<!Const>;
using CRng = meta::const_if_c<Const, Rng>;
range_difference_t<CRng> n_;
sentinel_t<CRng> end_;
constexpr offset_t<Const> const & offset() const
{
offset_t<Const> const & result = this->box<offset_t<Const>>::get();
RANGES_EXPECT(0 <= result && result < n_);
return result;
}
constexpr offset_t<Const> & offset()
{
return const_cast<offset_t<Const> &>(
const_cast<adaptor const &>(*this).offset());
}
public:
adaptor() = default;
constexpr adaptor(meta::const_if_c<Const, chunk_view_> * cv)
: box<offset_t<Const>>{0}
, n_((RANGES_EXPECT(0 < cv->n_), cv->n_))
, end_(ranges::end(cv->base()))
{}
template(bool Other)(
requires Const AND CPP_NOT(Other)) //
constexpr adaptor(adaptor<Other> that)
: box<offset_t<Const>>(that.offset())
, n_(that.n_)
, end_(that.end_)
{}
constexpr auto read(iterator_t<CRng> const & it) const
-> decltype(views::take(make_subrange(it, end_), n_))
{
RANGES_EXPECT(it != end_);
RANGES_EXPECT(0 == offset());
return views::take(make_subrange(it, end_), n_);
}
constexpr void next(iterator_t<CRng> & it)
{
RANGES_EXPECT(it != end_);
RANGES_EXPECT(0 == offset());
offset() = ranges::advance(it, n_, end_);
}
CPP_member
constexpr auto prev(iterator_t<CRng> & it) //
-> CPP_ret(void)(
requires bidirectional_range<CRng>)
{
ranges::advance(it, -n_ + offset());
offset() = 0;
}
CPP_member
constexpr auto distance_to(iterator_t<CRng> const & here,
iterator_t<CRng> const & there,
adaptor const & that) const
-> CPP_ret(range_difference_t<Rng>)(
requires (detail::can_sized_sentinel_<Rng, Const>()))
{
auto const delta = (there - here) + (that.offset() - offset());
// This can fail for cyclic base ranges when the chunk size does not
// divide the cycle length. Such iterator pairs are NOT in the domain of
// -.
RANGES_ENSURE(0 == delta % n_);
return delta / n_;
}
CPP_member
constexpr auto advance(iterator_t<CRng> & it, range_difference_t<Rng> n) //
-> CPP_ret(void)(
requires random_access_range<CRng>)
{
using Limits = std::numeric_limits<range_difference_t<CRng>>;
if(0 < n)
{
RANGES_EXPECT(0 == offset());
RANGES_EXPECT(n <= Limits::max() / n_);
auto const remainder = ranges::advance(it, n * n_, end_) % n_;
RANGES_EXPECT(0 <= remainder && remainder < n_);
offset() = remainder;
}
else if(0 > n)
{
RANGES_EXPECT(n >= Limits::min() / n_);
ranges::advance(it, n * n_ + offset());
offset() = 0;
}
}
};
constexpr adaptor<simple_view<Rng>()> begin_adaptor()
{
return adaptor<simple_view<Rng>()>{this};
}
CPP_member
constexpr auto begin_adaptor() const //
-> CPP_ret(adaptor<true>)(
requires forward_range<Rng const>)
{
return adaptor<true>{this};
}
template<typename Size>
constexpr Size size_(Size base_size) const
{
auto const n = static_cast<Size>(n_);
return base_size / n + (0 != (base_size % n));
}
public:
chunk_view_() = default;
constexpr chunk_view_(Rng rng, range_difference_t<Rng> n)
: chunk_view_::view_adaptor(detail::move(rng))
, n_((RANGES_EXPECT(0 < n), n))
{}
CPP_auto_member
constexpr auto CPP_fun(size)()(const
requires sized_range<Rng const>)
{
return size_(ranges::size(this->base()));
}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return size_(ranges::size(this->base()));
}
};
template<typename Rng>
struct chunk_view_<Rng, false>
: view_facade<chunk_view_<Rng, false>,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
{
private:
friend range_access;
CPP_assert(input_range<Rng> && !forward_range<Rng>);
using iter_cache_t = detail::non_propagating_cache<iterator_t<Rng>>;
Rng base_;
range_difference_t<Rng> n_;
range_difference_t<Rng> remainder_;
mutable iter_cache_t it_cache_;
constexpr iterator_t<Rng> & it() noexcept
{
return *it_cache_;
}
constexpr iterator_t<Rng> const & it() const noexcept
{
return *it_cache_;
}
struct outer_cursor
{
private:
struct inner_view : view_facade<inner_view, finite>
{
private:
friend range_access;
using value_type = range_value_t<Rng>;
chunk_view_ * rng_ = nullptr;
constexpr bool done() const noexcept
{
RANGES_EXPECT(rng_);
return rng_->remainder_ == 0;
}
constexpr bool equal(default_sentinel_t) const noexcept
{
return done();
}
constexpr iter_reference_t<iterator_t<Rng>> read() const
{
RANGES_EXPECT(!done());
return *rng_->it();
}
constexpr iter_rvalue_reference_t<iterator_t<Rng>> move() const
{
RANGES_EXPECT(!done());
return ranges::iter_move(rng_->it());
}
constexpr void next()
{
RANGES_EXPECT(!done());
++rng_->it();
--rng_->remainder_;
if(rng_->remainder_ != 0 && rng_->it() == ranges::end(rng_->base_))
rng_->remainder_ = 0;
}
CPP_member
constexpr auto distance_to(default_sentinel_t) const
-> CPP_ret(range_difference_t<Rng>)(
requires sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>)
{
RANGES_EXPECT(rng_);
auto const d = ranges::end(rng_->base_) - rng_->it();
return ranges::min(d, rng_->remainder_);
}
public:
inner_view() = default;
constexpr explicit inner_view(chunk_view_ * view) noexcept
: rng_{view}
{}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>)
{
using size_type = detail::iter_size_t<iterator_t<Rng>>;
return static_cast<size_type>(distance_to(default_sentinel_t{}));
}
};
chunk_view_ * rng_ = nullptr;
public:
using value_type = inner_view;
outer_cursor() = default;
constexpr explicit outer_cursor(chunk_view_ * view) noexcept
: rng_{view}
{}
constexpr inner_view read() const
{
RANGES_EXPECT(!done());
return inner_view{rng_};
}
constexpr bool done() const
{
RANGES_EXPECT(rng_);
return rng_->it() == ranges::end(rng_->base_) && rng_->remainder_ != 0;
}
constexpr bool equal(default_sentinel_t) const
{
return done();
}
constexpr void next()
{
RANGES_EXPECT(!done());
ranges::advance(rng_->it(), rng_->remainder_, ranges::end(rng_->base_));
rng_->remainder_ = rng_->n_;
}
CPP_member
constexpr auto distance_to(default_sentinel_t) const
-> CPP_ret(range_difference_t<Rng>)(
requires sized_sentinel_for<sentinel_t<Rng>, iterator_t<Rng>>)
{
RANGES_EXPECT(rng_);
auto d = ranges::end(rng_->base_) - rng_->it();
if(d < rng_->remainder_)
return 1;
d -= rng_->remainder_;
d = (d + rng_->n_ - 1) / rng_->n_;
d += (rng_->remainder_ != 0);
return d;
}
};
constexpr outer_cursor begin_cursor() noexcept
{
it_cache_ = ranges::begin(base_);
return outer_cursor{this};
}
template<typename Size>
constexpr Size size_(Size base_size) const
{
auto const n = static_cast<Size>(this->n_);
return base_size / n + (0 != base_size % n);
}
public:
chunk_view_() = default;
constexpr chunk_view_(Rng rng, range_difference_t<Rng> n)
: base_(detail::move(rng))
, n_((RANGES_EXPECT(0 < n), n))
, remainder_(n)
, it_cache_{nullopt}
{}
CPP_auto_member
constexpr auto CPP_fun(size)()(const
requires sized_range<Rng const>)
{
return size_(ranges::size(base_));
}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return size_(ranges::size(base_));
}
Rng base() const
{
return base_;
}
};
template<typename Rng>
struct chunk_view : chunk_view_<Rng, (bool)forward_range<Rng>>
{
chunk_view() = default;
constexpr chunk_view(Rng rng, range_difference_t<Rng> n)
: chunk_view_<Rng, (bool)forward_range<Rng>>(static_cast<Rng &&>(rng), n)
{}
};
// Need to keep extra state for input_range, but forward_range is transparent
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<chunk_view<Rng>> =
enable_borrowed_range<Rng> && forward_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
chunk_view(Rng &&, range_difference_t<Rng>)
-> chunk_view<views::all_t<Rng>>;
#endif
namespace views
{
// In: range<T>
// Out: range<range<T>>, where each inner range has $n$ elements.
// The last range may have fewer.
struct chunk_base_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng>)
constexpr chunk_view<all_t<Rng>> //
operator()(Rng && rng, range_difference_t<Rng> n) const
{
return {all(static_cast<Rng &&>(rng)), n};
}
};
struct chunk_fn : chunk_base_fn
{
using chunk_base_fn::operator();
template(typename Int)(
requires detail::integer_like_<Int>)
constexpr auto operator()(Int n) const
{
return make_view_closure(bind_back(chunk_base_fn{}, n));
}
};
/// \relates chunk_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(chunk_fn, chunk)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::chunk_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/facade.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_FACADE_HPP
#define RANGES_V3_VIEW_FACADE_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/basic_iterator.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
template<typename Derived>
using begin_cursor_t = detail::decay_t<decltype(
range_access::begin_cursor(std::declval<Derived &>()))>;
template<typename Derived>
using end_cursor_t = detail::decay_t<decltype(
range_access::end_cursor(std::declval<Derived &>()))>;
template<typename Derived>
using facade_iterator_t = basic_iterator<begin_cursor_t<Derived>>;
template<typename Derived>
using facade_sentinel_t =
meta::if_c<same_as<begin_cursor_t<Derived>, end_cursor_t<Derived>>,
facade_iterator_t<Derived>, end_cursor_t<Derived>>;
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
/// \brief A utility for constructing a view from a (derived) type that
/// implements begin and end cursors.
/// \tparam Derived A type that derives from `view_facade` and implements
/// begin and end cursors. This type is permitted to be incomplete.
/// \tparam Cardinality The cardinality of this view: `finite`, `infinite`,
/// or `unknown`. See `ranges::cardinality`.
template<typename Derived, cardinality Cardinality>
struct view_facade : view_interface<Derived, Cardinality>
{
protected:
friend range_access;
struct view_as_cursor : Derived
{
view_as_cursor() = default;
explicit view_as_cursor(Derived const * derived)
: Derived(*derived)
{}
explicit operator bool() = delete;
explicit operator bool() const = delete;
};
// Default implementations
constexpr view_as_cursor begin_cursor() const
{
return view_as_cursor{static_cast<Derived const *>(this)};
}
constexpr default_sentinel_t end_cursor() const
{
return {};
}
public:
/// Let `d` be `static_cast<Derived &>(*this)`. Let `b` be
/// `std::as_const(d).begin_cursor()` if that expression is well-formed;
/// otherwise, let `b` be `d.begin_cursor()`. Let `B` be the type of
/// `b`.
/// \return `ranges::basic_iterator<B>(b)`
template(typename D = Derived)(
requires same_as<D, Derived>)
constexpr auto begin() -> detail::facade_iterator_t<D>
{
return detail::facade_iterator_t<D>{
range_access::begin_cursor(*static_cast<Derived *>(this))};
}
/// \overload
template(typename D = Derived)(
requires same_as<D, Derived>)
constexpr auto begin() const -> detail::facade_iterator_t<D const>
{
return detail::facade_iterator_t<D const>{
range_access::begin_cursor(*static_cast<Derived const *>(this))};
}
/// Let `d` be `static_cast<Derived &>(*this)`. Let `e` be
/// `std::as_const(d).end_cursor()` if that expression is well-formed;
/// otherwise, let `e` be `d.end_cursor()`. Let `E` be the type of
/// `e`.
/// \return `ranges::basic_iterator<E>(e)` if `E` is the same
/// as `B` computed above for `begin()`; otherwise, return `e`.
template(typename D = Derived)(
requires same_as<D, Derived>)
constexpr auto end() -> detail::facade_sentinel_t<D>
{
return static_cast<detail::facade_sentinel_t<D>>(
range_access::end_cursor(*static_cast<Derived *>(this)));
}
/// \overload
template(typename D = Derived)(
requires same_as<D, Derived>)
constexpr auto end() const -> detail::facade_sentinel_t<D const>
{
return static_cast<detail::facade_sentinel_t<D const>>(
range_access::end_cursor(*static_cast<Derived const *>(this)));
}
};
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/interface.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_INTERFACE_HPP
#define RANGES_V3_VIEW_INTERFACE_HPP
#include <iosfwd>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/common_iterator.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/detail/prologue.hpp>
#if defined(RANGES_WORKAROUND_GCC_91525)
#define CPP_template_gcc_workaround CPP_template_sfinae
#else
#define CPP_template_gcc_workaround template
#endif
namespace ranges
{
/// \cond
namespace detail
{
template<typename From, typename To = From>
struct slice_bounds
{
From from;
To to;
template(typename F, typename T)(
requires convertible_to<F, From> AND convertible_to<T, To>)
constexpr slice_bounds(F f, T t)
: from(static_cast<From>(f))
, to(static_cast<To>(t))
{}
};
template<typename Int>
struct from_end_
{
Int dist_;
constexpr explicit from_end_(Int dist)
: dist_(dist)
{}
template(typename Other)(
requires integer_like_<Other> AND explicitly_convertible_to<Other, Int>)
constexpr operator from_end_<Other>() const
{
return from_end_<Other>{static_cast<Other>(dist_)};
}
};
template<typename Rng>
using from_end_of_t = from_end_<range_difference_t<Rng>>;
// clang-format off
/// \concept _can_empty_
/// \brief The \c _can_empty_ concept
template<typename Rng>
CPP_requires(_can_empty_,
requires(Rng & rng) //
(
ranges::empty(rng)
));
/// \concept can_empty_
/// \brief The \c can_empty_ concept
template<typename Rng>
CPP_concept can_empty_ = //
CPP_requires_ref(detail::_can_empty_, Rng);
// clang-format on
template<cardinality C>
RANGES_INLINE_VAR constexpr bool has_fixed_size_ = (C >= 0 || C == infinite);
template<bool>
struct dependent_
{
template<typename T>
using invoke = T;
};
template<typename Stream, typename Rng>
Stream & print_rng_(Stream & sout, Rng & rng)
{
sout << '[';
auto it = ranges::begin(rng);
auto const e = ranges::end(rng);
if(it != e)
{
for(;;)
{
sout << *it;
if(++it == e)
break;
sout << ',';
}
}
sout << ']';
return sout;
}
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
template<typename Derived, cardinality Cardinality /* = finite*/>
struct view_interface : basic_view<Cardinality>
{
protected:
template<bool B>
using D = meta::invoke<detail::dependent_<B>, Derived>;
constexpr Derived & derived() noexcept
{
CPP_assert(derived_from<Derived, view_interface>);
return static_cast<Derived &>(*this);
}
/// \overload
constexpr Derived const & derived() const noexcept
{
CPP_assert(derived_from<Derived, view_interface>);
return static_cast<Derived const &>(*this);
}
public:
view_interface() = default;
view_interface(view_interface &&) = default;
view_interface(view_interface const &) = default;
view_interface & operator=(view_interface &&) = default;
view_interface & operator=(view_interface const &) = default;
/// \brief Test whether a range can be empty:
CPP_member
constexpr auto empty() const noexcept //
-> CPP_ret(bool)(
requires (detail::has_fixed_size_<Cardinality>))
{
return Cardinality == 0;
}
/// \overload
template(bool True = true)(
requires True AND (Cardinality < 0) AND (Cardinality != infinite) AND
(!forward_range<D<True>>) AND sized_range<D<True>>)
constexpr bool empty() //
noexcept(noexcept(bool(ranges::size(std::declval<D<True> &>()) == 0)))
{
return ranges::size(derived()) == 0;
}
/// \overload
template(bool True = true)(
requires True AND (Cardinality < 0) AND (Cardinality != infinite) AND
(!forward_range<D<True> const>) AND sized_range<D<True> const>)
constexpr bool empty() const //
noexcept(noexcept(bool(ranges::size(std::declval<D<True> const &>()) == 0)))
{
return ranges::size(derived()) == 0;
}
/// \overload
template(bool True = true)(
requires True AND (!detail::has_fixed_size_<Cardinality>) AND
forward_range<D<True>>)
constexpr bool empty() noexcept(
noexcept(bool(ranges::begin(std::declval<D<True> &>()) ==
ranges::end(std::declval<D<True> &>()))))
{
return bool(ranges::begin(derived()) == ranges::end(derived()));
}
/// \overload
template(bool True = true)(
requires True AND (!detail::has_fixed_size_<Cardinality>) AND
forward_range<D<True> const>)
constexpr bool empty() const
noexcept(noexcept(bool(ranges::begin(std::declval<D<True> const &>()) ==
ranges::end(std::declval<D<True> const &>()))))
{
return bool(ranges::begin(derived()) == ranges::end(derived()));
}
CPP_template_gcc_workaround(bool True = true)(
requires True && detail::can_empty_<D<True>>) // clang-format off
constexpr explicit operator bool()
noexcept(noexcept(ranges::empty(std::declval<D<True> &>())))
{
return !ranges::empty(derived());
}
// clang-format on
/// \overload
CPP_template_gcc_workaround(bool True = true)(
requires True && detail::can_empty_<D<True> const>) // clang-format off
constexpr explicit operator bool() const
noexcept(noexcept(ranges::empty(std::declval<D<True> const &>())))
{
return !ranges::empty(derived());
}
// clang-format on
/// If the size of the range is known at compile-time and finite,
/// return it.
template(bool True = true, int = 42)(
requires True AND (Cardinality >= 0)) //
static constexpr std::size_t size() noexcept
{
return static_cast<std::size_t>(Cardinality);
}
/// If `sized_sentinel_for<sentinel_t<Derived>, iterator_t<Derived>>` is
/// satisfied, and if `Derived` is a `forward_range`, then return
/// `end - begin` cast to an unsigned integer.
template(bool True = true)(
requires True AND (Cardinality < 0) AND
sized_sentinel_for<sentinel_t<D<True>>, iterator_t<D<True>>> AND
forward_range<D<True>>)
constexpr detail::iter_size_t<iterator_t<D<True>>> size()
{
using size_type = detail::iter_size_t<iterator_t<D<True>>>;
return static_cast<size_type>(derived().end() - derived().begin());
}
/// \overload
template(bool True = true)(
requires True AND (Cardinality < 0) AND
sized_sentinel_for<sentinel_t<D<True> const>,
iterator_t<D<True> const>> AND
forward_range<D<True> const>)
constexpr detail::iter_size_t<iterator_t<D<True>>> size() const //
{
using size_type = detail::iter_size_t<iterator_t<D<True>>>;
return static_cast<size_type>(derived().end() - derived().begin());
}
/// Access the first element in a range:
template(bool True = true)(
requires True AND forward_range<D<True>>)
constexpr range_reference_t<D<True>> front()
{
return *derived().begin();
}
/// \overload
template(bool True = true)(
requires True AND forward_range<D<True> const>)
constexpr range_reference_t<D<True> const> front() const
{
return *derived().begin();
}
/// Access the last element in a range:
template(bool True = true)(
requires True AND common_range<D<True>> AND bidirectional_range<D<True>>)
constexpr range_reference_t<D<True>> back()
{
return *prev(derived().end());
}
/// \overload
template(bool True = true)(
requires True AND common_range<D<True> const> AND
bidirectional_range<D<True> const>)
constexpr range_reference_t<D<True> const> back() const
{
return *prev(derived().end());
}
/// Simple indexing:
template(bool True = true)(
requires True AND random_access_range<D<True>>)
constexpr range_reference_t<D<True>> operator[](range_difference_t<D<True>> n)
{
return derived().begin()[n];
}
/// \overload
template(bool True = true)(
requires True AND random_access_range<D<True> const>)
constexpr range_reference_t<D<True> const> //
operator[](range_difference_t<D<True>> n) const
{
return derived().begin()[n];
}
/// Returns a pointer to the block of memory
/// containing the elements of a contiguous range:
template(bool True = true)(
requires True AND contiguous_iterator<iterator_t<D<True>>>)
constexpr std::add_pointer_t<range_reference_t<D<True>>> data() //
{
return std::addressof(*ranges::begin(derived()));
}
/// \overload
template(bool True = true)(
requires True AND contiguous_iterator<iterator_t<D<True> const>>)
constexpr std::add_pointer_t<range_reference_t<D<True> const>> data() const //
{
return std::addressof(*ranges::begin(derived()));
}
/// Returns a reference to the element at specified location pos, with bounds
/// checking.
template(bool True = true)(
requires True AND random_access_range<D<True>> AND sized_range<D<True>>)
constexpr range_reference_t<D<True>> at(range_difference_t<D<True>> n)
{
using size_type = range_size_t<Derived>;
if(n < 0 || size_type(n) >= ranges::size(derived()))
{
throw std::out_of_range("view_interface::at");
}
return derived().begin()[n];
}
/// \overload
template(bool True = true)(
requires True AND random_access_range<D<True> const> AND
sized_range<D<True> const>)
constexpr range_reference_t<D<True> const> at(range_difference_t<D<True>> n) const
{
using size_type = range_size_t<Derived const>;
if(n < 0 || size_type(n) >= ranges::size(derived()))
{
throw std::out_of_range("view_interface::at");
}
return derived().begin()[n];
}
/// Python-ic slicing:
// rng[{4,6}]
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND input_range<D<True> &>)
constexpr auto
operator[](detail::slice_bounds<range_difference_t<D<True>>> offs) &
{
return Slice{}(derived(), offs.from, offs.to);
}
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND input_range<D<True> const &>)
constexpr auto
operator[](detail::slice_bounds<range_difference_t<D<True>>> offs) const &
{
return Slice{}(derived(), offs.from, offs.to);
}
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND input_range<D<True>>)
constexpr auto
operator[](detail::slice_bounds<range_difference_t<D<True>>> offs) &&
{
return Slice{}(detail::move(derived()), offs.from, offs.to);
}
// rng[{4,end-2}]
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND input_range<D<True> &> AND sized_range<D<True> &>)
constexpr auto //
operator[](detail::slice_bounds<range_difference_t<D<True>>,
detail::from_end_of_t<D<True>>> offs) &
{
return Slice{}(derived(), offs.from, offs.to);
}
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND input_range<D<True> const &> AND
sized_range<D<True> const &>)
constexpr auto //
operator[](detail::slice_bounds<range_difference_t<D<True>>,
detail::from_end_of_t<D<True>>> offs) const &
{
return Slice{}(derived(), offs.from, offs.to);
}
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND input_range<D<True>> AND sized_range<D<True>>)
constexpr auto //
operator[](detail::slice_bounds<range_difference_t<D<True>>,
detail::from_end_of_t<D<True>>> offs) &&
{
return Slice{}(detail::move(derived()), offs.from, offs.to);
}
// rng[{end-4,end-2}]
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND (forward_range<D<True> &> ||
(input_range<D<True> &> && sized_range<D<True> &>))) //
constexpr auto //
operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>,
detail::from_end_of_t<D<True>>> offs) &
{
return Slice{}(derived(), offs.from, offs.to);
}
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND
(forward_range<D<True> const &> ||
(input_range<D<True> const &> && sized_range<D<True> const &>))) //
constexpr auto //
operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>,
detail::from_end_of_t<D<True>>> offs) const &
{
return Slice{}(derived(), offs.from, offs.to);
}
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND
(forward_range<D<True>> ||
(input_range<D<True>> && sized_range<D<True>>))) //
constexpr auto //
operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>,
detail::from_end_of_t<D<True>>> offs) &&
{
return Slice{}(detail::move(derived()), offs.from, offs.to);
}
// rng[{4,end}]
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND input_range<D<True> &>)
constexpr auto //
operator[](detail::slice_bounds<range_difference_t<D<True>>, end_fn> offs) &
{
return Slice{}(derived(), offs.from, offs.to);
}
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND input_range<D<True> const &>)
constexpr auto //
operator[](detail::slice_bounds<range_difference_t<D<True>>, end_fn> offs) const &
{
return Slice{}(derived(), offs.from, offs.to);
}
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND input_range<D<True>>)
constexpr auto //
operator[](detail::slice_bounds<range_difference_t<D<True>>, end_fn> offs) &&
{
return Slice{}(detail::move(derived()), offs.from, offs.to);
}
// rng[{end-4,end}]
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND
(forward_range<D<True> &> ||
(input_range<D<True> &> && sized_range<D<True> &>))) //
constexpr auto //
operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>, end_fn> offs) &
{
return Slice{}(derived(), offs.from, offs.to);
}
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND
(forward_range<D<True> const &> ||
(input_range<D<True> const &> && sized_range<D<True> const &>))) //
constexpr auto //
operator[](
detail::slice_bounds<detail::from_end_of_t<D<True>>, end_fn> offs) const &
{
return Slice{}(derived(), offs.from, offs.to);
}
/// \overload
template(bool True = true, typename Slice = views::slice_fn)(
requires True AND
(forward_range<D<True>> ||
(input_range<D<True>> && sized_range<D<True>>))) //
constexpr auto //
operator[](detail::slice_bounds<detail::from_end_of_t<D<True>>, end_fn> offs) &&
{
return Slice{}(detail::move(derived()), offs.from, offs.to);
}
private:
#ifndef RANGES_V3_DISABLE_IO
/// \brief Print a range to an ostream
template<bool True = true>
friend auto operator<<(std::ostream & sout, Derived const & rng)
-> CPP_broken_friend_ret(std::ostream &)(
requires True && input_range<D<True> const>)
{
return detail::print_rng_(sout, rng);
}
/// \overload
template<bool True = true>
friend auto operator<<(std::ostream & sout, Derived & rng)
-> CPP_broken_friend_ret(std::ostream &)(
requires True && (!range<D<True> const>) && input_range<D<True>>)
{
return detail::print_rng_(sout, rng);
}
/// \overload
template<bool True = true>
friend auto operator<<(std::ostream & sout, Derived && rng)
-> CPP_broken_friend_ret(std::ostream &)(
requires True && (!range<D<True> const>) && input_range<D<True>>)
{
return detail::print_rng_(sout, rng);
}
#endif
};
namespace cpp20
{
template(typename Derived)(
requires std::is_class<Derived>::value AND
same_as<Derived, meta::_t<std::remove_cv<Derived>>>)
using view_interface = ranges::view_interface<Derived, ranges::unknown>;
}
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/all.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_ALL_HPP
#define RANGES_V3_VIEW_ALL_HPP
#include <type_traits>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/ref.hpp>
#include <range/v3/view/subrange.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
namespace views
{
struct all_fn
{
private:
/// If it's a view already, pass it though.
template<typename T>
static constexpr auto from_range_(T && t, std::true_type, detail::ignore_t,
detail::ignore_t)
{
return static_cast<T &&>(t);
}
/// If it is container-like, turn it into a view, being careful
/// to preserve the Sized-ness of the range.
template<typename T>
static constexpr auto from_range_(T && t, std::false_type, std::true_type,
detail::ignore_t)
{
return ranges::views::ref(t);
}
/// Not a view and not an lvalue? If it's a borrowed_range, then
/// return a subrange holding the range's begin/end.
template<typename T>
static constexpr auto from_range_(T && t, std::false_type, std::false_type,
std::true_type)
{
return make_subrange(static_cast<T &&>(t));
}
public:
template(typename T)(
requires range<T &> AND viewable_range<T>)
constexpr auto operator()(T && t) const
{
return all_fn::from_range_(static_cast<T &&>(t),
meta::bool_<view_<uncvref_t<T>>>{},
std::is_lvalue_reference<T>{},
meta::bool_<borrowed_range<T>>{});
}
template<typename T>
RANGES_DEPRECATED("Passing a reference_wrapper to views::all is deprecated.")
constexpr ref_view<T> operator()(std::reference_wrapper<T> r) const
{
return ranges::views::ref(r.get());
}
};
/// \relates all_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<all_fn>, all)
template<typename Rng>
using all_t = decltype(all(std::declval<Rng>()));
} // namespace views
template<typename Rng>
struct identity_adaptor : Rng
{
CPP_assert(view_<Rng>);
identity_adaptor() = default;
constexpr explicit identity_adaptor(Rng const & rng)
: Rng(rng)
{}
constexpr explicit identity_adaptor(Rng && rng)
: Rng(detail::move(rng))
{}
};
namespace cpp20
{
namespace views
{
using ranges::views::all;
using ranges::views::all_t;
}
template(typename Rng)(
requires viewable_range<Rng>)
using all_view RANGES_DEPRECATED(
"Please use ranges::cpp20::views::all_t instead.") =
ranges::views::all_t<Rng>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/cartesian_product.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-2014.
// Copyright Casey Carter 2017.
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_CARTESIAN_PRODUCT_HPP
#define RANGES_V3_VIEW_CARTESIAN_PRODUCT_HPP
#include <cstdint>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/utility/tuple_algorithm.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/empty.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/view.hpp> // for dereference_fn
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
template<typename State, typename Value>
using product_cardinality = std::integral_constant<
cardinality,
State::value == 0 || Value::value == 0
? static_cast<cardinality>(0)
: State::value == unknown || Value::value == unknown
? unknown
: State::value == infinite || Value::value == infinite
? infinite
: State::value == finite || Value::value == finite
? finite
: static_cast<cardinality>(
State::value * Value::value)>;
struct cartesian_size_fn
{
template(typename Size, typename Rng)(
requires integer_like_<Size> AND sized_range<Rng> AND
common_with<Size, range_size_t<Rng>>)
common_type_t<Size, range_size_t<Rng>> operator()(Size s, Rng && rng) const
{
using S = common_type_t<Size, range_size_t<Rng>>;
return static_cast<S>(s) * static_cast<S>(ranges::size(rng));
}
};
template<typename... Views>
using cartesian_product_cardinality =
meta::fold<meta::list<range_cardinality<Views>...>,
std::integral_constant<cardinality, static_cast<cardinality>(
(sizeof...(Views) > 0))>,
meta::quote<detail::product_cardinality>>;
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
// clang-format off
/// \concept cartesian_produce_view_can_const
/// \brief The \c cartesian_produce_view_can_const concept
template<typename...Views>
CPP_concept cartesian_produce_view_can_const =
and_v<range<Views const>...>;
/// \concept cartesian_produce_view_can_size_
/// \brief The \c cartesian_produce_view_can_size_ concept
template(typename IsConst, typename... Views)(
concept (cartesian_produce_view_can_size_)(IsConst, Views...),
and_v<common_with<std::uintmax_t, range_size_t<meta::const_if<IsConst, Views>>>...>
);
/// \concept cartesian_produce_view_can_size
/// \brief The \c cartesian_produce_view_can_size concept
template<typename IsConst, typename...Views>
CPP_concept cartesian_produce_view_can_size =
and_v<sized_range<meta::const_if<IsConst, Views>>...> &&
CPP_concept_ref(ranges::cartesian_produce_view_can_size_, IsConst, Views...);
/// \concept cartesian_produce_view_can_distance_
/// \brief The \c cartesian_produce_view_can_distance_ concept
template(typename IsConst, typename... Views)(
concept (cartesian_produce_view_can_distance_)(IsConst, Views...),
and_v<sized_sentinel_for<
iterator_t<meta::const_if<IsConst, Views>>,
iterator_t<meta::const_if<IsConst, Views>>>...>
);
/// \concept cartesian_produce_view_can_distance
/// \brief The \c cartesian_produce_view_can_distance concept
template<typename IsConst, typename...Views>
CPP_concept cartesian_produce_view_can_distance =
cartesian_produce_view_can_size<IsConst, Views...> &&
CPP_concept_ref(ranges::cartesian_produce_view_can_distance_, IsConst, Views...);
/// \concept cartesian_produce_view_can_random_
/// \brief The \c cartesian_produce_view_can_random_ concept
template(typename IsConst, typename... Views)(
concept (cartesian_produce_view_can_random_)(IsConst, Views...),
and_v<random_access_iterator<iterator_t<meta::const_if<IsConst, Views>>>...>
);
/// \concept cartesian_produce_view_can_random
/// \brief The \c cartesian_produce_view_can_random concept
template<typename IsConst, typename...Views>
CPP_concept cartesian_produce_view_can_random =
cartesian_produce_view_can_distance<IsConst, Views...> &&
CPP_concept_ref(ranges::cartesian_produce_view_can_random_, IsConst, Views...);
/// \concept cartesian_produce_view_can_bidi_
/// \brief The \c cartesian_produce_view_can_bidi_ concept
template(typename IsConst, typename... Views)(
concept (cartesian_produce_view_can_bidi_)(IsConst, Views...),
and_v<common_range<meta::const_if<IsConst, Views>>...,
bidirectional_iterator<iterator_t<meta::const_if<IsConst, Views>>>...>
);
/// \concept cartesian_produce_view_can_bidi
/// \brief The \c cartesian_produce_view_can_bidi concept
template<typename IsConst, typename...Views>
CPP_concept cartesian_produce_view_can_bidi =
cartesian_produce_view_can_random<IsConst, Views...> ||
CPP_concept_ref(ranges::cartesian_produce_view_can_bidi_, IsConst, Views...);
// clang-format on
template<typename... Views>
struct cartesian_product_view
: view_facade<cartesian_product_view<Views...>,
detail::cartesian_product_cardinality<Views...>::value>
{
private:
friend range_access;
CPP_assert(and_v<(forward_range<Views> && view_<Views>)...>);
CPP_assert(sizeof...(Views) != 0);
static constexpr auto my_cardinality =
detail::cartesian_product_cardinality<Views...>::value;
std::tuple<Views...> views_;
template<bool IsConst_>
struct cursor
{
private:
using IsConst = meta::bool_<IsConst_>;
friend cursor<true>;
template<typename T>
using constify_if = meta::const_if_c<IsConst_, T>;
using difference_type =
common_type_t<std::intmax_t, range_difference_t<Views>...>;
constify_if<cartesian_product_view> * view_;
std::tuple<iterator_t<constify_if<Views>>...> its_;
void next_(meta::size_t<1>)
{
auto & v = std::get<0>(view_->views_);
auto & i = std::get<0>(its_);
auto const last = ranges::end(v);
RANGES_EXPECT(i != last);
++i;
}
template<std::size_t N>
void next_(meta::size_t<N>)
{
auto & v = std::get<N - 1>(view_->views_);
auto & i = std::get<N - 1>(its_);
auto const last = ranges::end(v);
RANGES_EXPECT(i != last);
if(++i == last)
{
i = ranges::begin(v);
next_(meta::size_t<N - 1>{});
}
}
void prev_(meta::size_t<0>)
{
RANGES_EXPECT(false);
}
template<std::size_t N>
void prev_(meta::size_t<N>)
{
auto & v = std::get<N - 1>(view_->views_);
auto & i = std::get<N - 1>(its_);
if(i == ranges::begin(v))
{
CPP_assert(cartesian_produce_view_can_bidi<IsConst, Views...>);
// cartesian_produce_view_can_bidi<IsConst, Views...> implies this
// advance call is O(1)
ranges::advance(i, ranges::end(v));
prev_(meta::size_t<N - 1>{});
}
--i;
}
bool equal_(cursor const &, meta::size_t<0>) const
{
return true;
}
template<std::size_t N>
bool equal_(cursor const & that, meta::size_t<N>) const
{
return std::get<N - 1>(its_) == std::get<N - 1>(that.its_) &&
equal_(that, meta::size_t<N - 1>{});
}
difference_type distance_(cursor const & that, meta::size_t<1>) const
{
return difference_type{std::get<0>(that.its_) - std::get<0>(its_)};
}
template<std::size_t N>
difference_type distance_(cursor const & that, meta::size_t<N>) const
{
difference_type const d = distance_(that, meta::size_t<N - 1>{});
auto const scale = ranges::distance(std::get<N - 1>(view_->views_));
auto const increment = std::get<N - 1>(that.its_) - std::get<N - 1>(its_);
return difference_type{d * scale + increment};
}
void advance_(meta::size_t<0>, difference_type)
{
RANGES_EXPECT(false);
}
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_DIVIDE_BY_ZERO
template<std::size_t N>
void advance_(meta::size_t<N>, difference_type n)
{
if(n == 0)
return;
auto & i = std::get<N - 1>(its_);
auto const my_size = static_cast<difference_type>(
ranges::size(std::get<N - 1>(view_->views_)));
auto const first = ranges::begin(std::get<N - 1>(view_->views_));
auto const idx = static_cast<difference_type>(i - first);
RANGES_EXPECT(0 <= idx);
RANGES_EXPECT(idx < my_size || (N == 1 && idx == my_size && n < 0));
RANGES_EXPECT(n < INTMAX_MAX - idx);
n += idx;
auto n_div = n / my_size;
auto n_mod = n % my_size;
if(RANGES_CONSTEXPR_IF(N != 1))
{
if(n_mod < 0)
{
n_mod += my_size;
--n_div;
}
advance_(meta::size_t<N - 1>{}, n_div);
}
RANGES_EXPECT(0 <= n_mod && n_mod < my_size);
if(RANGES_CONSTEXPR_IF(N == 1))
{
if(n_div > 0)
{
RANGES_EXPECT(n_div == 1);
RANGES_EXPECT(n_mod == 0);
n_mod = my_size;
}
else if(n_div < 0)
{
RANGES_EXPECT(n_div == -1);
RANGES_EXPECT(n_mod == 0);
}
}
using D = iter_difference_t<decltype(first)>;
i = first + static_cast<D>(n_mod);
}
RANGES_DIAGNOSTIC_POP
void check_at_end_(meta::size_t<1>, bool at_end = false)
{
if(at_end)
ranges::advance(std::get<0>(its_),
ranges::end(std::get<0>(view_->views_)));
}
template<std::size_t N>
void check_at_end_(meta::size_t<N>, bool at_end = false)
{
return check_at_end_(
meta::size_t<N - 1>{},
at_end || bool(std::get<N - 1>(its_) ==
ranges::end(std::get<N - 1>(view_->views_))));
}
cursor(end_tag, constify_if<cartesian_product_view> * view,
std::true_type) // common_with
: cursor(begin_tag{}, view)
{
CPP_assert(
common_range<meta::at_c<meta::list<constify_if<Views>...>, 0>>);
std::get<0>(its_) = ranges::end(std::get<0>(view->views_));
}
cursor(end_tag, constify_if<cartesian_product_view> * view,
std::false_type) // !common_with
: cursor(begin_tag{}, view)
{
using View0 = meta::at_c<meta::list<constify_if<Views>...>, 0>;
CPP_assert(!common_range<View0> && random_access_range<View0> &&
sized_range<View0>);
std::get<0>(its_) += ranges::distance(std::get<0>(view->views_));
}
public:
using value_type = std::tuple<range_value_t<Views>...>;
cursor() = default;
explicit cursor(begin_tag, constify_if<cartesian_product_view> * view)
: view_(view)
, its_(tuple_transform(view->views_, ranges::begin))
{
// If any of the constituent views is empty, the cartesian_product is
// empty and this "begin" iterator needs to become an "end" iterator.
check_at_end_(meta::size_t<sizeof...(Views)>{});
}
explicit cursor(end_tag, constify_if<cartesian_product_view> * view)
: cursor(
end_tag{}, view,
meta::bool_<
common_range<meta::at_c<meta::list<constify_if<Views>...>, 0>>>{})
{}
template(bool Other)(
requires IsConst_ AND CPP_NOT(Other)) //
cursor(cursor<Other> that)
: view_(that.view_)
, its_(std::move(that.its_))
{}
common_tuple<range_reference_t<constify_if<Views>>...> read() const
{
return tuple_transform(its_, detail::dereference_fn{});
}
void next()
{
next_(meta::size_t<sizeof...(Views)>{});
}
bool equal(default_sentinel_t) const
{
return std::get<0>(its_) == ranges::end(std::get<0>(view_->views_));
}
bool equal(cursor const & that) const
{
return equal_(that, meta::size_t<sizeof...(Views)>{});
}
CPP_member
auto prev() -> CPP_ret(void)(
requires cartesian_produce_view_can_bidi<IsConst, Views...>)
{
prev_(meta::size_t<sizeof...(Views)>{});
}
CPP_auto_member
auto CPP_fun(distance_to)(cursor const & that)(
const requires cartesian_produce_view_can_distance<IsConst, Views...>)
{
return distance_(that, meta::size_t<sizeof...(Views)>{});
}
CPP_member
auto advance(difference_type n) //
-> CPP_ret(void)(
requires cartesian_produce_view_can_random<IsConst, Views...>)
{
advance_(meta::size_t<sizeof...(Views)>{}, n);
}
};
cursor<false> begin_cursor()
{
return cursor<false>{begin_tag{}, this};
}
CPP_member
auto begin_cursor() const //
-> CPP_ret(cursor<true>)(
requires cartesian_produce_view_can_const<Views...>)
{
return cursor<true>{begin_tag{}, this};
}
CPP_member
auto end_cursor() //
-> CPP_ret(cursor<false>)(
requires cartesian_produce_view_can_bidi<std::false_type, Views...>)
{
return cursor<false>{end_tag{}, this};
}
CPP_member
auto end_cursor() const //
-> CPP_ret(cursor<true>)(
requires cartesian_produce_view_can_bidi<std::true_type, Views...>)
{
return cursor<true>{end_tag{}, this};
}
CPP_member
auto end_cursor() const //
-> CPP_ret(default_sentinel_t)(
requires (!cartesian_produce_view_can_bidi<std::true_type, Views...>))
{
return {};
}
public:
cartesian_product_view() = default;
constexpr explicit cartesian_product_view(Views... views)
: views_{detail::move(views)...}
{}
template(typename...)(
requires (my_cardinality >= 0)) //
static constexpr std::size_t size() noexcept
{
return std::size_t{my_cardinality};
}
CPP_auto_member
auto CPP_fun(size)()(const //
requires (my_cardinality < 0) &&
cartesian_produce_view_can_size<std::true_type, Views...>)
{
return tuple_foldl(views_, std::uintmax_t{1}, detail::cartesian_size_fn{});
}
CPP_auto_member
auto CPP_fun(size)()(
requires (my_cardinality < 0) &&
cartesian_produce_view_can_size<std::false_type, Views...>)
{
return tuple_foldl(views_, std::uintmax_t{1}, detail::cartesian_size_fn{});
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename... Rng>
cartesian_product_view(Rng &&...) //
-> cartesian_product_view<views::all_t<Rng>...>;
#endif
namespace views
{
struct cartesian_product_fn
{
constexpr empty_view<std::tuple<>> operator()() const noexcept
{
return {};
}
template(typename... Rngs)(
requires (sizeof...(Rngs) != 0) AND
concepts::and_v<(forward_range<Rngs> && viewable_range<Rngs>)...>)
constexpr cartesian_product_view<all_t<Rngs>...> operator()(Rngs &&... rngs)
const
{
return cartesian_product_view<all_t<Rngs>...>{
all(static_cast<Rngs &&>(rngs))...};
}
#if defined(_MSC_VER)
template(typename Rng0)(
requires forward_range<Rng0> AND viewable_range<Rng0>)
constexpr cartesian_product_view<all_t<Rng0>> operator()(Rng0 && rng0) const
{
return cartesian_product_view<all_t<Rng0>>{
all(static_cast<Rng0 &&>(rng0))};
}
template(typename Rng0, typename Rng1)(
requires forward_range<Rng0> AND viewable_range<Rng0> AND
forward_range<Rng1> AND viewable_range<Rng1>)
constexpr cartesian_product_view<all_t<Rng0>, all_t<Rng1>> //
operator()(Rng0 && rng0, Rng1 && rng1) const
{
return cartesian_product_view<all_t<Rng0>, all_t<Rng1>>{
all(static_cast<Rng0 &&>(rng0)), //
all(static_cast<Rng1 &&>(rng1))};
}
template(typename Rng0, typename Rng1, typename Rng2)(
requires forward_range<Rng0> AND viewable_range<Rng0> AND
forward_range<Rng1> AND viewable_range<Rng1> AND
forward_range<Rng2> AND viewable_range<Rng2>)
constexpr cartesian_product_view<all_t<Rng0>, all_t<Rng1>, all_t<Rng2>> //
operator()(Rng0 && rng0, Rng1 && rng1, Rng2 && rng2) const
{
return cartesian_product_view<all_t<Rng0>, all_t<Rng1>, all_t<Rng2>>{
all(static_cast<Rng0 &&>(rng0)), //
all(static_cast<Rng1 &&>(rng1)), //
all(static_cast<Rng2 &&>(rng2))};
}
#endif
};
RANGES_INLINE_VARIABLE(cartesian_product_fn, cartesian_product)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/reverse.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_REVERSE_HPP
#define RANGES_V3_VIEW_REVERSE_HPP
#include <iterator>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/reverse_iterator.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/box.hpp>
#include <range/v3/utility/get.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng>
struct RANGES_EMPTY_BASES reverse_view
: view_interface<reverse_view<Rng>, range_cardinality<Rng>::value>
, private detail::non_propagating_cache<iterator_t<Rng>, reverse_view<Rng>,
!common_range<Rng>>
{
private:
CPP_assert(bidirectional_range<Rng>);
Rng rng_;
constexpr reverse_iterator<iterator_t<Rng>> begin_(std::true_type)
{
return make_reverse_iterator(ranges::end(rng_));
}
constexpr reverse_iterator<iterator_t<Rng>> begin_(std::false_type)
{
using cache_t =
detail::non_propagating_cache<iterator_t<Rng>, reverse_view<Rng>>;
auto & end_ = static_cast<cache_t &>(*this);
if(!end_)
{
#if defined(_MSC_VER)
auto tmp = ranges::begin(rng_);
auto e = ranges::end(rng_);
while(tmp != e)
++tmp;
#else
auto tmp = ranges::next(ranges::begin(rng_), ranges::end(rng_));
#endif
end_ = std::move(tmp);
}
return make_reverse_iterator(*end_);
}
public:
reverse_view() = default;
constexpr explicit reverse_view(Rng rng)
: rng_(detail::move(rng))
{}
Rng base() const
{
return rng_;
}
constexpr reverse_iterator<iterator_t<Rng>> begin()
{
return begin_(meta::bool_<(bool)common_range<Rng>>{});
}
template(bool Const = true)(
requires Const AND common_range<meta::const_if_c<Const, Rng>>)
constexpr reverse_iterator<iterator_t<meta::const_if_c<Const, Rng>>> begin() const
{
return make_reverse_iterator(ranges::end(rng_));
}
constexpr reverse_iterator<iterator_t<Rng>> end()
{
return make_reverse_iterator(ranges::begin(rng_));
}
template(bool Const = true)(
requires Const AND common_range<meta::const_if_c<Const, Rng>>)
constexpr reverse_iterator<iterator_t<meta::const_if_c<Const, Rng>>> end() const
{
return make_reverse_iterator(ranges::begin(rng_));
}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return ranges::size(rng_);
}
CPP_auto_member
constexpr auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
return ranges::size(rng_);
}
};
template<typename Rng>
struct reverse_view<reverse_view<Rng>> : Rng
{
CPP_assert(bidirectional_range<Rng>);
CPP_assert(
same_as<detail::decay_t<decltype(std::declval<reverse_view<Rng>>().base())>,
Rng>);
reverse_view() = default;
constexpr explicit reverse_view(reverse_view<Rng> rng)
: Rng(rng.base())
{}
constexpr reverse_view<Rng> base() const
{
return reverse_view<Rng>{*this};
}
};
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<reverse_view<Rng>> =
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
reverse_view(Rng &&) //
-> reverse_view<views::all_t<Rng>>;
template<typename Rng>
reverse_view(reverse_view<Rng>)
-> reverse_view<reverse_view<Rng>>;
#endif
namespace views
{
struct reverse_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND bidirectional_range<Rng>)
constexpr reverse_view<all_t<Rng>> operator()(Rng && rng) const
{
return reverse_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
}
};
/// \relates reverse_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<reverse_fn>, reverse)
} // namespace views
namespace cpp20
{
namespace views
{
using ranges::views::reverse;
}
template(typename Rng)(
requires view_<Rng> AND bidirectional_range<Rng>)
using reverse_view = ranges::reverse_view<Rng>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::reverse_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/counted.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_COUNTED_HPP
#define RANGES_V3_VIEW_COUNTED_HPP
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/iterator/counted_iterator.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/view/subrange.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename I>
struct counted_view : view_interface<counted_view<I>, finite>
{
private:
friend range_access;
I it_;
iter_difference_t<I> n_;
public:
counted_view() = default;
counted_view(I it, iter_difference_t<I> n)
: it_(it)
, n_(n)
{
RANGES_EXPECT(0 <= n_);
}
counted_iterator<I> begin() const
{
return make_counted_iterator(it_, n_);
}
default_sentinel_t end() const
{
return {};
}
auto size() const
{
return static_cast<detail::iter_size_t<I>>(n_);
}
};
template<typename I>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<counted_view<I>> = true;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename I>
counted_view(I, iter_difference_t<I>)
-> counted_view<I>;
#endif
namespace views
{
struct cpp20_counted_fn
{
template(typename I)(
requires input_or_output_iterator<I> AND (!random_access_iterator<I>)) //
subrange<counted_iterator<I>, default_sentinel_t> //
operator()(I it, iter_difference_t<I> n) const
{
return {make_counted_iterator(std::move(it), n), default_sentinel};
}
template(typename I)(
requires random_access_iterator<I>)
subrange<I> operator()(I it, iter_difference_t<I> n) const
{
return {it, it + n};
}
};
struct counted_fn
{
template(typename I)(
requires input_or_output_iterator<I> AND (!random_access_iterator<I>)) //
counted_view<I> operator()(I it, iter_difference_t<I> n) const
{
return {std::move(it), n};
}
template(typename I)(
requires random_access_iterator<I>)
subrange<I> operator()(I it, iter_difference_t<I> n) const
{
return {it, it + n};
}
};
/// \relates counted_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(counted_fn, counted)
} // namespace views
namespace cpp20
{
namespace views
{
RANGES_INLINE_VARIABLE(ranges::views::cpp20_counted_fn, counted)
}
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::counted_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/view.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_VIEW_HPP
#define RANGES_V3_VIEW_VIEW_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/compose.hpp>
#include <range/v3/functional/concepts.hpp>
#include <range/v3/functional/pipeable.hpp>
#include <range/v3/functional/reference_wrapper.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
/// \cond
namespace detail
{
struct dereference_fn
{
// clang-format off
template<typename I>
constexpr auto CPP_auto_fun(operator())(I &&i) (const)
(
return *(I &&) i
)
// clang-format on
};
struct view_closure_base_
{};
} // namespace detail
/// \endcond
// clang-format off
/// \concept simple_view_impl_
/// \brief The \c simple_view_impl_ concept
template(typename Rng)(
concept (simple_view_impl_)(Rng),
same_as<iterator_t<Rng>, iterator_t<Rng const>> AND
same_as<sentinel_t<Rng>, sentinel_t<Rng const>>);
/// \concept simple_view_
/// \brief The \c simple_view_ concept
template<typename Rng>
CPP_concept simple_view_ =
view_<Rng> &&
range<Rng const> &&
CPP_concept_ref(ranges::simple_view_impl_, Rng);
/// \concept invocable_view_closure_
/// \brief The \c invocable_view_closure_ concept
template(typename ViewFn, typename Rng)(
concept (invocable_view_closure_)(ViewFn, Rng),
!derived_from<invoke_result_t<ViewFn, Rng>, detail::view_closure_base_>);
/// \concept invocable_view_closure
/// \brief The \c invocable_view_closure concept
template<typename ViewFn, typename Rng>
CPP_concept invocable_view_closure =
invocable<ViewFn, Rng> &&
CPP_concept_ref(ranges::invocable_view_closure_, ViewFn, Rng);
// clang-format on
template<typename Rng>
constexpr bool simple_view() noexcept
{
return (bool)simple_view_<Rng>;
}
struct make_view_closure_fn
{
template<typename Fun>
constexpr views::view_closure<Fun> operator()(Fun fun) const
{
return views::view_closure<Fun>{static_cast<Fun &&>(fun)};
}
};
/// \ingroup group-views
/// \sa make_view_closure_fn
RANGES_INLINE_VARIABLE(make_view_closure_fn, make_view_closure)
namespace views
{
struct RANGES_STRUCT_WITH_ADL_BARRIER(view_closure_base)
: detail::view_closure_base_
{
// Piping requires viewable_ranges. Pipeing a value into a closure
// should not yield another closure.
template(typename Rng, typename ViewFn)(
requires viewable_range<Rng> AND
invocable_view_closure<ViewFn, Rng>)
friend constexpr auto operator|(Rng && rng, view_closure<ViewFn> vw)
{
return static_cast<ViewFn &&>(vw)(static_cast<Rng &&>(rng));
}
#ifndef RANGES_WORKAROUND_CLANG_43400
// This overload is deleted because when piping a range into an
// view, it must be moved in.
template<typename Rng, typename ViewFn> // **************************
friend constexpr auto // **************************
operator|(Rng &&, view_closure<ViewFn> const &) // ******* READ THIS ********
// **** IF YOUR COMPILE *****
-> CPP_broken_friend_ret(Rng)( // ****** BREAKS HERE *******
requires range<Rng> && // **************************
(!viewable_range<Rng>)) = delete; // **************************
// **************************************************************************
// * When piping a range into an adaptor, the range must satisfy the *
// * "viewable_range" concept. A range is viewable when either or both *
// * of these things are true: *
// * - The range is an lvalue (not a temporary object), OR *
// * - The range is a view (not a container). *
// **************************************************************************
#endif
template<typename ViewFn, typename Pipeable>
friend constexpr auto operator|(view_closure<ViewFn> vw, Pipeable pipe)
-> CPP_broken_friend_ret(view_closure<composed<Pipeable, ViewFn>>)(
requires (is_pipeable_v<Pipeable>))
{
return make_view_closure(
compose(static_cast<Pipeable &&>(pipe), static_cast<ViewFn &&>(vw)));
}
};
#ifdef RANGES_WORKAROUND_CLANG_43400
namespace RANGES_ADL_BARRIER_FOR(view_closure_base)
{
// This overload is deleted because when piping a range into an
// view, it must be moved in.
template(typename Rng, typename ViewFn)( // ************************
requires range<Rng> AND (!viewable_range<Rng>))// ************************
constexpr Rng // ************************
operator|(Rng &&, view_closure<ViewFn> const &) // ****** READ THIS *******
= delete; // *** IF YOUR COMPILE ****
// ***** BREAKS HERE ******
// ************************
// ************************
// ***************************************************************************
// * When piping a range into an adaptor, the range must satisfy the *
// * "viewable_range" concept. A range is viewable when either or both *
// * of these things are true: *
// * - The range is an lvalue (not a temporary object), OR *
// * - The range is a view (not a container). *
// ***************************************************************************
} // namespace )
#endif // RANGES_WORKAROUND_CLANG_43400
template<typename ViewFn>
struct RANGES_EMPTY_BASES view_closure
: view_closure_base
, ViewFn
{
view_closure() = default;
constexpr explicit view_closure(ViewFn fn)
: ViewFn(static_cast<ViewFn &&>(fn))
{}
};
/// \cond
/// DEPRECATED STUFF
struct view_access_
{
template<typename ViewFn>
struct impl
{
// clang-format off
template<typename... Ts, typename V = ViewFn>
static constexpr auto CPP_auto_fun(bind)(Ts &&... ts)
(
return V::bind(static_cast<Ts &&>(ts)...)
)
// clang-format on
};
};
using view_access RANGES_DEPRECATED(
"view_access and views::view<> are deprecated. Please "
"replace view<> with view_closure<> and discontinue use of view_access.") =
view_access_;
template<typename>
struct old_view_;
struct make_view_fn_
{
template<typename Fun>
constexpr old_view_<Fun> operator()(Fun fun) const
{
return old_view_<Fun>{static_cast<Fun &&>(fun)};
}
};
using make_view_fn RANGES_DEPRECATED(
"make_view_fn is deprecated. Please use "
"make_view_closure instead.") = make_view_fn_;
namespace
{
RANGES_DEPRECATED(
"make_view and views::view<> has been deprecated. Please switch to "
"make_view_closure and views::view_closure.")
RANGES_INLINE_VAR constexpr auto & make_view =
static_const<make_view_fn_>::value;
} // namespace
template<typename ViewFn>
struct old_view_ : pipeable_base
{
private:
ViewFn vw_;
friend pipeable_access;
// Piping requires range arguments or lvalue containers.
template(typename Rng, typename Vw)(
requires viewable_range<Rng> AND invocable<ViewFn &, Rng>)
static constexpr auto pipe(Rng && rng, Vw && v)
{
return v.vw_(static_cast<Rng &&>(rng));
}
public:
old_view_() = default;
constexpr explicit old_view_(ViewFn a) noexcept(
std::is_nothrow_move_constructible<ViewFn>::value)
: vw_(std::move(a))
{}
// Calling directly requires a viewable_range.
template(typename Rng, typename... Rest)(
requires viewable_range<Rng> AND invocable<ViewFn const &, Rng, Rest...>)
constexpr invoke_result_t<ViewFn const &, Rng, Rest...> //
operator()(Rng && rng, Rest &&... rest) const
{
return vw_(static_cast<Rng &&>(rng), static_cast<Rest &&>(rest)...);
}
// Currying overload.
// clang-format off
template<typename... Ts, typename V = ViewFn>
constexpr auto CPP_auto_fun(operator())(Ts &&... ts)(const)
(
return make_view_fn_{}(
view_access_::impl<V>::bind(vw_, static_cast<Ts &&>(ts)...))
)
// clang-format on
};
template<typename ViewFn>
using view RANGES_DEPRECATED(
"The views::view<> template is deprecated. Please switch to view_closure") =
old_view_<ViewFn>;
/// \endcond
} // namespace views
template<typename ViewFn>
RANGES_INLINE_VAR constexpr bool is_pipeable_v<views::view_closure<ViewFn>> = true;
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/empty.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_EMPTY_HPP
#define RANGES_V3_VIEW_EMPTY_HPP
#include <range/v3/range_fwd.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename T>
struct empty_view : view_interface<empty_view<T>, (cardinality)0>
{
static_assert(std::is_object<T>::value,
"The template parameter to empty_view must be an object type.");
empty_view() = default;
static constexpr T * begin() noexcept
{
return nullptr;
}
static constexpr T * end() noexcept
{
return nullptr;
}
static constexpr std::size_t size() noexcept
{
return 0u;
}
static constexpr T * data() noexcept
{
return nullptr;
}
RANGES_DEPRECATED(
"Replace views::empty<T>() with views::empty<T>. "
"It is now a variable template.")
empty_view operator()() const
{
return *this;
}
};
template<typename T>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<empty_view<T>> = true;
namespace views
{
template<typename T>
RANGES_INLINE_VAR constexpr empty_view<T> empty{};
}
namespace cpp20
{
namespace views
{
using ranges::views::empty;
}
template(typename T)(
requires std::is_object<T>::value) //
using empty_view = ranges::empty_view<T>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::empty_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/take_exactly.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_TAKE_EXACTLY_HPP
#define RANGES_V3_VIEW_TAKE_EXACTLY_HPP
#include <type_traits>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/counted_iterator.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/view/subrange.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
template<typename Rng>
struct is_random_access_common_
: meta::bool_<(bool)random_access_range<Rng> && (bool)common_range<Rng>>
{};
// BUGBUG Per the discussion in https://github.com/ericniebler/stl2/issues/63,
// it's unclear if we can infer anything from random_access_range<Rng> &&
// common_range<Rng>
template<typename Rng,
bool IsRandomAccessCommon /*= is_random_access_common_<Rng>::value*/>
struct take_exactly_view_
: view_interface<take_exactly_view_<Rng, IsRandomAccessCommon>, finite>
{
private:
Rng rng_;
range_difference_t<Rng> n_;
public:
take_exactly_view_() = default;
take_exactly_view_(Rng rng, range_difference_t<Rng> n)
: rng_(std::move(rng))
, n_(n)
{
RANGES_EXPECT(n >= 0);
}
counted_iterator<iterator_t<Rng>> begin()
{
return {ranges::begin(rng_), n_};
}
template(typename BaseRng = Rng)(
requires range<BaseRng const>)
counted_iterator<iterator_t<BaseRng const>> begin() const
{
return {ranges::begin(rng_), n_};
}
default_sentinel_t end() const
{
return {};
}
auto size() const
{
return static_cast<detail::iter_size_t<iterator_t<Rng>>>(n_);
}
Rng base() const
{
return rng_;
}
};
template<typename Rng>
struct take_exactly_view_<Rng, true>
: view_interface<take_exactly_view_<Rng, true>, finite>
{
private:
Rng rng_;
range_difference_t<Rng> n_;
public:
take_exactly_view_() = default;
take_exactly_view_(Rng rng, range_difference_t<Rng> n)
: rng_(std::move(rng))
, n_(n)
{
RANGES_EXPECT(n >= 0);
RANGES_EXPECT(!(bool)sized_range<Rng> || n <= ranges::distance(rng_));
}
iterator_t<Rng> begin()
{
return ranges::begin(rng_);
}
iterator_t<Rng> end()
{
return ranges::begin(rng_) + n_;
}
CPP_auto_member
auto CPP_fun(begin)()(const //
requires range<Rng const>)
{
return ranges::begin(rng_);
}
CPP_auto_member
auto CPP_fun(end)()(const //
requires range<Rng const>)
{
return ranges::begin(rng_) + n_;
}
detail::iter_size_t<iterator_t<Rng>> size() const
{
return static_cast<detail::iter_size_t<iterator_t<Rng>>>(n_);
}
Rng base() const
{
return rng_;
}
};
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
template<typename Rng>
using take_exactly_view = detail::take_exactly_view_<Rng>;
template<typename Rng, bool B>
RANGES_INLINE_VAR constexpr bool //
enable_borrowed_range<detail::take_exactly_view_<Rng, B>> = //
enable_borrowed_range<Rng>;
namespace views
{
struct take_exactly_base_fn
{
private:
template<typename Rng>
static constexpr take_exactly_view<all_t<Rng>> impl_(
Rng && rng, range_difference_t<Rng> n, input_range_tag)
{
return {all(static_cast<Rng &&>(rng)), n};
}
template(typename Rng)(
requires borrowed_range<Rng>)
static constexpr subrange<iterator_t<Rng>> impl_(Rng && rng,
range_difference_t<Rng> n,
random_access_range_tag)
{
return {begin(rng), next(begin(rng), n)};
}
public:
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng>)
constexpr auto operator()(Rng && rng, range_difference_t<Rng> n) const
{
return take_exactly_base_fn::impl_(
static_cast<Rng &&>(rng), n, range_tag_of<Rng>{});
}
};
struct take_exactly_fn : take_exactly_base_fn
{
using take_exactly_base_fn::operator();
template(typename Int)(
requires detail::integer_like_<Int>)
constexpr auto operator()(Int n) const
{
return make_view_closure(bind_back(take_exactly_base_fn{}, n));
}
};
/// \relates take_exactly_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(take_exactly_fn, take_exactly)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::detail::take_exactly_view_)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/delimit.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_DELIMIT_HPP
#define RANGES_V3_VIEW_DELIMIT_HPP
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/iterator/unreachable_sentinel.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/subrange.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng, typename Val>
struct delimit_view
: view_adaptor<delimit_view<Rng, Val>, Rng,
is_finite<Rng>::value ? finite : unknown>
{
private:
friend range_access;
Val value_;
struct sentinel_adaptor : adaptor_base
{
sentinel_adaptor() = default;
sentinel_adaptor(Val value)
: value_(std::move(value))
{}
template<class I, class S>
bool empty(I const & it, S const & last) const
{
return it == last || *it == value_;
}
Val value_;
};
sentinel_adaptor end_adaptor() const
{
return {value_};
}
public:
delimit_view() = default;
constexpr delimit_view(Rng rng, Val value)
: delimit_view::view_adaptor{std::move(rng)}
, value_(std::move(value))
{}
};
// the begin iterator will be an iterator into the underlying view (conditionally
// borrowed) and the end iterator owns the value to be compared against (borrowed)
template<typename Rng, typename Val>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<delimit_view<Rng, Val>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Val)(
requires copy_constructible<Val>)
delimit_view(Rng &&, Val)
-> delimit_view<views::all_t<Rng>, Val>;
#endif
namespace views
{
struct delimit_base_fn
{
template(typename I_, typename Val, typename I = detail::decay_t<I_>)(
requires (!range<I_>) AND convertible_to<I_, I> AND input_iterator<I> AND
semiregular<Val> AND
equality_comparable_with<Val, iter_reference_t<I>>)
constexpr auto operator()(I_ && begin_, Val value) const
-> delimit_view<subrange<I, unreachable_sentinel_t>, Val>
{
return {{static_cast<I_ &&>(begin_), {}}, std::move(value)};
}
template(typename Rng, typename Val)(
requires viewable_range<Rng> AND input_range<Rng> AND semiregular<
Val> AND equality_comparable_with<Val, range_reference_t<Rng>>)
constexpr auto operator()(Rng && rng, Val value) const //
-> delimit_view<all_t<Rng>, Val>
{
return {all(static_cast<Rng &&>(rng)), std::move(value)};
}
};
struct delimit_fn : delimit_base_fn
{
using delimit_base_fn::operator();
template<typename Val>
constexpr auto operator()(Val value) const
{
return make_view_closure(bind_back(delimit_base_fn{}, std::move(value)));
}
};
/// \relates delimit_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(delimit_fn, delimit)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::delimit_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/take.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_TAKE_HPP
#define RANGES_V3_VIEW_TAKE_HPP
#include <type_traits>
#include <range/v3/range_fwd.hpp>
#include <range/v3/algorithm/min.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/counted_iterator.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng>
struct take_view : view_interface<take_view<Rng>, finite>
{
private:
CPP_assert(view_<Rng>);
Rng base_ = Rng();
range_difference_t<Rng> count_ = 0;
template<bool Const>
struct sentinel
{
private:
using Base = meta::conditional_t<Const, Rng const, Rng>;
using CI = counted_iterator<iterator_t<Base>>;
sentinel_t<Base> end_ = sentinel_t<Base>();
public:
sentinel() = default;
constexpr explicit sentinel(sentinel_t<Base> last)
: end_(std::move(last))
{}
template(bool Other)(
requires Const AND CPP_NOT(Other) AND
convertible_to<sentinel_t<Rng>,
sentinel_t<Base>>)
constexpr sentinel(sentinel<Other> that)
: end_(std::move(that.end_))
{}
constexpr sentinel_t<Base> base() const
{
return end_;
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr bool operator==(sentinel const & x, CI const & y)
{
return y.count() == 0 || y.base() == x.end_;
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr bool operator==(CI const & y, sentinel const & x)
{
return y.count() == 0 || y.base() == x.end_;
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr bool operator!=(sentinel const & x, CI const & y)
{
return y.count() != 0 && y.base() != x.end_;
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr bool operator!=(CI const & y, sentinel const & x)
{
return y.count() != 0 && y.base() != x.end_;
}
};
#if RANGES_CXX_IF_CONSTEXPR < RANGES_CXX_IF_CONSTEXPR_17
template<typename Take>
static auto begin_random_access_(Take & take, std::true_type)
{
return ranges::begin(take.base_);
}
template<typename Take>
static auto begin_random_access_(Take & take, std::false_type)
{
auto s = static_cast<range_difference_t<Rng>>(take.size());
return make_counted_iterator(ranges::begin(take.base_), s);
}
template<typename Take>
static auto begin_sized_(Take & take, std::true_type)
{
return begin_random_access_(
take, meta::bool_<random_access_range<decltype((take.base_))>>{});
}
template<typename Take>
static auto begin_sized_(Take & take, std::false_type)
{
return make_counted_iterator(ranges::begin(take.base_), take.count_);
}
template<typename Take>
static auto end_random_access_(Take & take, std::true_type)
{
return ranges::begin(take.base_) +
static_cast<range_difference_t<Rng>>(take.size());
}
static auto end_random_access_(detail::ignore_t, std::false_type)
{
return default_sentinel;
}
template<typename Take>
static auto end_sized_(Take & take, std::true_type, std::false_type) // sized
{
return end_random_access_(
take, meta::bool_<random_access_range<decltype((take.base_))>>{});
}
static auto end_sized_(detail::ignore_t, std::false_type,
std::true_type) // infinite
{
return default_sentinel;
}
static auto end_sized_(take_view & take, std::false_type, std::false_type)
{
return sentinel<false>{ranges::end(take.base_)};
}
static auto end_sized_(take_view const & take, std::false_type, std::false_type)
{
return sentinel<true>{ranges::end(take.base_)};
}
#endif
public:
take_view() = default;
constexpr take_view(Rng base, range_difference_t<Rng> cnt)
: base_(std::move(base))
, count_(cnt)
{}
constexpr Rng base() const
{
return base_;
}
CPP_auto_member
constexpr auto CPP_fun(begin)()(
requires(!simple_view<Rng>()))
{
#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
if constexpr(sized_range<Rng>)
if constexpr(random_access_range<Rng>)
return ranges::begin(base_);
else
{
// cannot always delegate to size() member on GCC with ConceptsTS
#if defined(__cpp_concepts) && __cpp_concepts <= 201507
auto s = ranges::min(
static_cast<range_difference_t<Rng>>(count_),
static_cast<range_difference_t<Rng>>(ranges::size(base_)));
#else
auto s = static_cast<range_difference_t<Rng>>(size());
#endif
return make_counted_iterator(ranges::begin(base_), s);
}
else
return make_counted_iterator(ranges::begin(base_), count_);
#else
return begin_sized_(*this, meta::bool_<sized_range<Rng>>{});
#endif
}
CPP_auto_member
constexpr auto CPP_fun(begin)()(const //
requires range<Rng const>)
{
#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
if constexpr(sized_range<Rng const>)
if constexpr(random_access_range<Rng const>)
return ranges::begin(base_);
else
{
auto s = static_cast<range_difference_t<Rng>>(size());
return make_counted_iterator(ranges::begin(base_), s);
}
else
return make_counted_iterator(ranges::begin(base_), count_);
#else
return begin_sized_(*this, meta::bool_<sized_range<Rng const>>{});
#endif
}
CPP_auto_member
constexpr auto CPP_fun(end)()(
requires(!simple_view<Rng>()))
{
#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
if constexpr(sized_range<Rng>)
if constexpr(random_access_range<Rng>)
return ranges::begin(base_) +
static_cast<range_difference_t<Rng>>(size());
else
return default_sentinel;
// Not to spec: Infinite ranges:
else if constexpr(is_infinite<Rng>::value)
return default_sentinel;
else
return sentinel<false>{ranges::end(base_)};
#else
return end_sized_(*this, meta::bool_<sized_range<Rng>>{}, is_infinite<Rng>{});
#endif
}
CPP_auto_member
constexpr auto CPP_fun(end)()(const //
requires range<Rng const>)
{
#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
if constexpr(sized_range<Rng const>)
if constexpr(random_access_range<Rng const>)
return ranges::begin(base_) +
static_cast<range_difference_t<Rng>>(size());
else
return default_sentinel;
// Not to spec: Infinite ranges:
else if constexpr(is_infinite<Rng const>::value)
return default_sentinel;
else
return sentinel<true>{ranges::end(base_)};
#else
return end_sized_(
*this, meta::bool_<sized_range<Rng const>>{}, is_infinite<Rng const>{});
#endif
}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires sized_range<Rng>)
{
auto n = ranges::size(base_);
return ranges::min(n, static_cast<decltype(n)>(count_));
}
CPP_auto_member
constexpr auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
auto n = ranges::size(base_);
return ranges::min(n, static_cast<decltype(n)>(count_));
}
};
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<take_view<Rng>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
take_view(Rng &&, range_difference_t<Rng>)
-> take_view<views::all_t<Rng>>;
#endif
namespace views
{
struct take_base_fn
{
template(typename Rng)(
requires viewable_range<Rng>)
take_view<all_t<Rng>> operator()(Rng && rng, range_difference_t<Rng> n) const
{
return {all(static_cast<Rng &&>(rng)), n};
}
};
struct take_fn : take_base_fn
{
using take_base_fn::operator();
template(typename Int)(
requires detail::integer_like_<Int>)
constexpr auto operator()(Int n) const
{
return make_view_closure(bind_back(take_base_fn{}, n));
}
};
/// \relates take_fn
RANGES_INLINE_VARIABLE(take_fn, take)
} // namespace views
namespace cpp20
{
namespace views
{
using ranges::views::take;
}
template(typename Rng)(
requires view_<Rng>)
using take_view = ranges::take_view<Rng>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::take_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/concat.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-2014.
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_CONCAT_HPP
#define RANGES_V3_VIEW_CONCAT_HPP
#include <tuple>
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/arithmetic.hpp>
#include <range/v3/functional/compose.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/utility/tuple_algorithm.hpp>
#include <range/v3/utility/variant.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
template<typename State, typename Value>
using concat_cardinality_ = std::integral_constant<
cardinality,
State::value == infinite || Value::value == infinite
? infinite
: State::value == unknown || Value::value == unknown
? unknown
: State::value == finite || Value::value == finite
? finite
: static_cast<cardinality>(State::value + Value::value)>;
template<typename... Rngs>
using concat_cardinality =
meta::fold<meta::list<range_cardinality<Rngs>...>,
std::integral_constant<cardinality, static_cast<cardinality>(0)>,
meta::quote<concat_cardinality_>>;
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
template<typename... Rngs>
struct concat_view
: view_facade<concat_view<Rngs...>, detail::concat_cardinality<Rngs...>::value>
{
private:
friend range_access;
using difference_type_ = common_type_t<range_difference_t<Rngs>...>;
static constexpr std::size_t cranges{sizeof...(Rngs)};
std::tuple<Rngs...> rngs_;
template<bool IsConst>
struct cursor;
template<bool IsConst>
struct sentinel
{
private:
friend struct sentinel<!IsConst>;
friend struct cursor<IsConst>;
template<typename T>
using constify_if = meta::const_if_c<IsConst, T>;
using concat_view_t = constify_if<concat_view>;
sentinel_t<constify_if<meta::back<meta::list<Rngs...>>>> end_;
public:
sentinel() = default;
sentinel(concat_view_t * rng, end_tag)
: end_(end(std::get<cranges - 1>(rng->rngs_)))
{}
template(bool Other)(
requires IsConst AND CPP_NOT(Other)) //
sentinel(sentinel<Other> that)
: end_(std::move(that.end_))
{}
};
template<bool IsConst>
struct cursor
{
using difference_type = common_type_t<range_difference_t<Rngs>...>;
private:
friend struct cursor<!IsConst>;
template<typename T>
using constify_if = meta::const_if_c<IsConst, T>;
using concat_view_t = constify_if<concat_view>;
concat_view_t * rng_;
variant<iterator_t<constify_if<Rngs>>...> its_;
template<std::size_t N>
void satisfy(meta::size_t<N>)
{
RANGES_EXPECT(its_.index() == N);
if(ranges::get<N>(its_) == end(std::get<N>(rng_->rngs_)))
{
ranges::emplace<N + 1>(its_, begin(std::get<N + 1>(rng_->rngs_)));
this->satisfy(meta::size_t<N + 1>{});
}
}
void satisfy(meta::size_t<cranges - 1>)
{
RANGES_EXPECT(its_.index() == cranges - 1);
}
struct next_fun
{
cursor * pos;
template(typename I, std::size_t N)(
requires input_iterator<I>)
void operator()(indexed_element<I, N> it) const
{
RANGES_ASSERT(it.get() != end(std::get<N>(pos->rng_->rngs_)));
++it.get();
pos->satisfy(meta::size_t<N>{});
}
};
struct prev_fun
{
cursor * pos;
template(typename I)(
requires bidirectional_iterator<I>)
void operator()(indexed_element<I, 0> it) const
{
RANGES_ASSERT(it.get() != begin(std::get<0>(pos->rng_->rngs_)));
--it.get();
}
template(typename I, std::size_t N)(
requires (N != 0) AND bidirectional_iterator<I>)
void operator()(indexed_element<I, N> it) const
{
if(it.get() == begin(std::get<N>(pos->rng_->rngs_)))
{
auto && rng = std::get<N - 1>(pos->rng_->rngs_);
ranges::emplace<N - 1>(
pos->its_,
ranges::next(ranges::begin(rng), ranges::end(rng)));
pos->its_.visit_i(*this);
}
else
--it.get();
}
};
struct advance_fwd_fun
{
cursor * pos;
difference_type n;
template(typename I)(
requires random_access_iterator<I>)
void operator()(indexed_element<I, cranges - 1> it) const
{
ranges::advance(it.get(), n);
}
template(typename I, std::size_t N)(
requires random_access_iterator<I>)
void operator()(indexed_element<I, N> it) const
{
auto last = ranges::end(std::get<N>(pos->rng_->rngs_));
// BUGBUG If distance(it, last) > n, then using bounded advance
// is O(n) when it need not be since the last iterator position
// is actually not interesting. Only the "rest" is needed, which
// can sometimes be O(1).
auto rest = ranges::advance(it.get(), n, std::move(last));
pos->satisfy(meta::size_t<N>{});
if(rest != 0)
pos->its_.visit_i(advance_fwd_fun{pos, rest});
}
};
struct advance_rev_fun
{
cursor * pos;
difference_type n;
template(typename I)(
requires random_access_iterator<I>)
void operator()(indexed_element<I, 0> it) const
{
ranges::advance(it.get(), n);
}
template(typename I, std::size_t N)(
requires random_access_iterator<I>)
void operator()(indexed_element<I, N> it) const
{
auto first = ranges::begin(std::get<N>(pos->rng_->rngs_));
if(it.get() == first)
{
auto && rng = std::get<N - 1>(pos->rng_->rngs_);
ranges::emplace<N - 1>(
pos->its_,
ranges::next(ranges::begin(rng), ranges::end(rng)));
pos->its_.visit_i(*this);
}
else
{
auto rest = ranges::advance(it.get(), n, std::move(first));
if(rest != 0)
pos->its_.visit_i(advance_rev_fun{pos, rest});
}
}
};
[[noreturn]] static difference_type distance_to_(meta::size_t<cranges>,
cursor const &,
cursor const &)
{
RANGES_EXPECT(false);
}
template<std::size_t N>
static difference_type distance_to_(meta::size_t<N>, cursor const & from,
cursor const & to)
{
if(from.its_.index() > N)
return cursor::distance_to_(meta::size_t<N + 1>{}, from, to);
if(from.its_.index() == N)
{
if(to.its_.index() == N)
return distance(ranges::get<N>(from.its_),
ranges::get<N>(to.its_));
return distance(ranges::get<N>(from.its_),
end(std::get<N>(from.rng_->rngs_))) +
cursor::distance_to_(meta::size_t<N + 1>{}, from, to);
}
if(from.its_.index() < N && to.its_.index() > N)
return distance(std::get<N>(from.rng_->rngs_)) +
cursor::distance_to_(meta::size_t<N + 1>{}, from, to);
RANGES_EXPECT(to.its_.index() == N);
return distance(begin(std::get<N>(from.rng_->rngs_)),
ranges::get<N>(to.its_));
}
public:
// BUGBUG what about rvalue_reference and common_reference?
using reference = common_reference_t<range_reference_t<constify_if<Rngs>>...>;
using single_pass = meta::or_c<single_pass_iterator_<iterator_t<Rngs>>...>;
cursor() = default;
cursor(concat_view_t * rng, begin_tag)
: rng_(rng)
, its_{emplaced_index<0>, begin(std::get<0>(rng->rngs_))}
{
this->satisfy(meta::size_t<0>{});
}
cursor(concat_view_t * rng, end_tag)
: rng_(rng)
, its_{emplaced_index<cranges - 1>, end(std::get<cranges - 1>(rng->rngs_))}
{}
template(bool Other)(
requires IsConst && CPP_NOT(Other)) //
cursor(cursor<Other> that)
: rng_(that.rng_)
, its_(std::move(that.its_))
{}
reference read() const
{
// Kind of a dumb implementation. Surely there's a better way.
return ranges::get<0>(unique_variant(its_.visit(
compose(convert_to<reference>{}, detail::dereference_fn{}))));
}
void next()
{
its_.visit_i(next_fun{this});
}
CPP_member
auto equal(cursor const & pos) const //
-> CPP_ret(bool)(
requires //
equality_comparable<variant<iterator_t<constify_if<Rngs>>...>>)
{
return its_ == pos.its_;
}
bool equal(sentinel<IsConst> const & pos) const
{
return its_.index() == cranges - 1 &&
ranges::get<cranges - 1>(its_) == pos.end_;
}
CPP_member
auto prev() //
-> CPP_ret(void)(
requires and_v<bidirectional_range<Rngs>...>)
{
its_.visit_i(prev_fun{this});
}
CPP_member
auto advance(difference_type n) //
-> CPP_ret(void)(
requires and_v<random_access_range<Rngs>...>)
{
if(n > 0)
its_.visit_i(advance_fwd_fun{this, n});
else if(n < 0)
its_.visit_i(advance_rev_fun{this, n});
}
CPP_member
auto distance_to(cursor const & that) const //
-> CPP_ret(difference_type)(
requires and_v<sized_sentinel_for<iterator_t<Rngs>,
iterator_t<Rngs>>...>)
{
if(its_.index() <= that.its_.index())
return cursor::distance_to_(meta::size_t<0>{}, *this, that);
return -cursor::distance_to_(meta::size_t<0>{}, that, *this);
}
};
cursor<meta::and_c<simple_view<Rngs>()...>::value> begin_cursor()
{
return {this, begin_tag{}};
}
meta::if_<meta::and_c<(bool)common_range<Rngs>...>,
cursor<meta::and_c<simple_view<Rngs>()...>::value>,
sentinel<meta::and_c<simple_view<Rngs>()...>::value>>
end_cursor()
{
return {this, end_tag{}};
}
CPP_member
auto begin_cursor() const //
-> CPP_ret(cursor<true>)(
requires and_v<range<Rngs const>...>)
{
return {this, begin_tag{}};
}
CPP_member
auto end_cursor() const //
-> CPP_ret(
meta::if_<meta::and_c<(bool)common_range<Rngs const>...>, //
cursor<true>, //
sentinel<true>>)(
requires and_v<range<Rngs const>...>)
{
return {this, end_tag{}};
}
public:
concat_view() = default;
explicit concat_view(Rngs... rngs)
: rngs_{std::move(rngs)...}
{}
CPP_member
constexpr auto size() const //
-> CPP_ret(std::size_t)(
requires (detail::concat_cardinality<Rngs...>::value >= 0))
{
return static_cast<std::size_t>(detail::concat_cardinality<Rngs...>::value);
}
CPP_auto_member
constexpr auto CPP_fun(size)()(const //
requires(detail::concat_cardinality<Rngs...>::value < 0) &&
and_v<sized_range<Rngs const>...>)
{
using size_type = common_type_t<range_size_t<Rngs const>...>;
return tuple_foldl(
tuple_transform(rngs_,
[](auto && r) -> size_type { return ranges::size(r); }),
size_type{0},
plus{});
}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires (detail::concat_cardinality<Rngs...>::value < 0) &&
and_v<sized_range<Rngs>...>)
{
using size_type = common_type_t<range_size_t<Rngs>...>;
return tuple_foldl(
tuple_transform(rngs_,
[](auto && r) -> size_type { return ranges::size(r); }),
size_type{0},
plus{});
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename... Rng>
concat_view(Rng &&...) //
-> concat_view<views::all_t<Rng>...>;
#endif
namespace views
{
struct concat_fn
{
template(typename... Rngs)(
requires and_v<(viewable_range<Rngs> && input_range<Rngs>)...>)
concat_view<all_t<Rngs>...> operator()(Rngs &&... rngs) const
{
return concat_view<all_t<Rngs>...>{all(static_cast<Rngs &&>(rngs))...};
}
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng>)
all_t<Rng> operator()(Rng && rng) const //
{
return all(static_cast<Rng &&>(rng));
}
// MSVC doesn't like variadics in operator() for some reason
#if defined(_MSC_VER)
template(typename Rng0, typename Rng1)(
requires viewable_range<Rng0> AND input_range<Rng0> AND
viewable_range<Rng1> AND input_range<Rng1>)
concat_view<all_t<Rng0>, all_t<Rng1>> operator()(Rng0 && rng0, Rng1 && rng1)
const
{
return concat_view<all_t<Rng0>, all_t<Rng1>>{
all(static_cast<Rng0 &&>(rng0)),
all(static_cast<Rng1 &&>(rng1))};
}
template(typename Rng0, typename Rng1, typename Rng2)(
requires viewable_range<Rng0> AND input_range<Rng0> AND
viewable_range<Rng1> AND input_range<Rng1> AND
viewable_range<Rng2> AND input_range<Rng2>)
concat_view<all_t<Rng0>, all_t<Rng1>, all_t<Rng2>> //
operator()(Rng0 && rng0, Rng1 && rng1, Rng2 && rng2) const
{
return concat_view<all_t<Rng0>, all_t<Rng1>, all_t<Rng2>>{
all(static_cast<Rng0 &&>(rng0)),
all(static_cast<Rng1 &&>(rng1)),
all(static_cast<Rng2 &&>(rng2))};
}
#endif
};
/// \relates concat_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(concat_fn, concat)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::concat_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/drop_while.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_DROP_WHILE_HPP
#define RANGES_V3_VIEW_DROP_WHILE_HPP
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/algorithm/find_if_not.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/compose.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng, typename Pred>
struct drop_while_view
: view_interface<drop_while_view<Rng, Pred>,
is_finite<Rng>::value ? finite : unknown>
{
private:
Rng rng_;
RANGES_NO_UNIQUE_ADDRESS semiregular_box_t<Pred> pred_;
detail::non_propagating_cache<iterator_t<Rng>> begin_;
iterator_t<Rng> get_begin_()
{
if(!begin_)
begin_ = find_if_not(rng_, std::ref(pred_));
return *begin_;
}
public:
drop_while_view() = default;
drop_while_view(Rng rng, Pred pred)
: rng_(std::move(rng))
, pred_(std::move(pred))
{}
iterator_t<Rng> begin()
{
return get_begin_();
}
sentinel_t<Rng> end()
{
return ranges::end(rng_);
}
Rng base() const
{
return rng_;
}
};
// unlike take_while_view, drop_while_view is transparently safe because we only
// need the predicate to find begin()
template<typename Rng, typename Pred>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<drop_while_view<Rng, Pred>> =
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Fun)(
requires copy_constructible<Fun>)
drop_while_view(Rng &&, Fun)
-> drop_while_view<views::all_t<Rng>, Fun>;
#endif
template<typename Rng, typename Pred>
RANGES_INLINE_VAR constexpr bool disable_sized_range<drop_while_view<Rng, Pred>> =
true;
namespace views
{
struct drop_while_base_fn
{
template(typename Rng, typename Pred)(
requires viewable_range<Rng> AND input_range<Rng> AND
indirect_unary_predicate<Pred, iterator_t<Rng>>)
auto operator()(Rng && rng, Pred pred) const
-> drop_while_view<all_t<Rng>, Pred>
{
return {all(static_cast<Rng &&>(rng)), std::move(pred)};
}
template(typename Rng, typename Pred, typename Proj)(
requires viewable_range<Rng> AND input_range<Rng> AND
indirect_unary_predicate<composed<Pred, Proj>, iterator_t<Rng>>)
auto operator()(Rng && rng, Pred pred, Proj proj) const
-> drop_while_view<all_t<Rng>, composed<Pred, Proj>>
{
return {all(static_cast<Rng &&>(rng)),
compose(std::move(pred), std::move(proj))};
}
};
struct drop_while_bind_fn
{
template<typename Pred>
constexpr auto operator()(Pred pred) const // TODO: underconstrained
{
return make_view_closure(
bind_back(drop_while_base_fn{}, std::move(pred)));
}
template(typename Pred, typename Proj)(
requires (!range<Pred>)) // TODO: underconstrained
constexpr auto operator()(Pred && pred, Proj proj) const
{
return make_view_closure(bind_back(
drop_while_base_fn{}, static_cast<Pred &&>(pred), std::move(proj)));
}
};
struct RANGES_EMPTY_BASES drop_while_fn
: drop_while_base_fn, drop_while_bind_fn
{
using drop_while_base_fn::operator();
using drop_while_bind_fn::operator();
};
/// \relates drop_while_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(drop_while_fn, drop_while)
} // namespace views
namespace cpp20
{
namespace views
{
using ranges::views::drop_while;
}
template(typename Rng, typename Pred)(
requires viewable_range<Rng> AND input_range<Rng> AND
indirect_unary_predicate<Pred, iterator_t<Rng>>)
using drop_while_view = ranges::drop_while_view<Rng, Pred>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::drop_while_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/for_each.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_FOR_EACH_HPP
#define RANGES_V3_VIEW_FOR_EACH_HPP
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/generate_n.hpp>
#include <range/v3/view/join.hpp>
#include <range/v3/view/repeat_n.hpp>
#include <range/v3/view/single.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
namespace views
{
/// Lazily applies an unary function to each element in the source
/// range that returns another range (possibly empty), flattening
/// the result.
struct for_each_base_fn
{
template(typename Rng, typename Fun)(
requires viewable_range<Rng> AND transformable_range<Rng, Fun> AND
joinable_range<transform_view<all_t<Rng>, Fun>>)
constexpr auto operator()(Rng && rng, Fun fun) const
{
return join(transform(static_cast<Rng &&>(rng), std::move(fun)));
}
};
struct for_each_fn : for_each_base_fn
{
using for_each_base_fn::operator();
template<typename Fun>
constexpr auto operator()(Fun fun) const
{
return make_view_closure(bind_back(for_each_base_fn{}, std::move(fun)));
}
};
/// \relates for_each_fn
RANGES_INLINE_VARIABLE(for_each_fn, for_each)
} // namespace views
struct yield_fn
{
template(typename V)(
requires copy_constructible<V>)
single_view<V> operator()(V v) const
{
return views::single(std::move(v));
}
};
/// \relates yield_fn
RANGES_INLINE_VARIABLE(yield_fn, yield)
struct yield_from_fn
{
template(typename Rng)(
requires view_<Rng>)
Rng operator()(Rng rng) const
{
return rng;
}
};
/// \relates yield_from_fn
RANGES_INLINE_VARIABLE(yield_from_fn, yield_from)
struct yield_if_fn
{
template<typename V>
repeat_n_view<V> operator()(bool b, V v) const
{
return views::repeat_n(std::move(v), b ? 1 : 0);
}
};
/// \relates yield_if_fn
RANGES_INLINE_VARIABLE(yield_if_fn, yield_if)
struct lazy_yield_if_fn
{
template(typename F)(
requires invocable<F &>)
generate_n_view<F> operator()(bool b, F f) const
{
return views::generate_n(std::move(f), b ? 1 : 0);
}
};
/// \relates lazy_yield_if_fn
RANGES_INLINE_VARIABLE(lazy_yield_if_fn, lazy_yield_if)
/// @}
/// \cond
template(typename Rng, typename Fun)(
requires viewable_range<Rng> AND views::transformable_range<Rng, Fun> AND
input_range<invoke_result_t<Fun &, range_reference_t<Rng>>>)
auto
operator>>=(Rng && rng, Fun fun)
{
return views::for_each(static_cast<Rng &&>(rng), std::move(fun));
}
/// \endcond
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/split.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_SPLIT_HPP
#define RANGES_V3_VIEW_SPLIT_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/algorithm/mismatch.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/view/single.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
/// \cond
namespace detail
{
// clang-format off
#if defined(_MSC_VER) && !defined(__clang__) && \
RANGES_CXX_VER <= RANGES_CXX_STD_17
template<typename R, std::size_t Sz = static_cast<std::size_t>(R::size())>
constexpr bool _is_tiny_range_(R const *) noexcept
{
return R::size() <= 1u;
}
constexpr bool _is_tiny_range_(void const*) noexcept
{
return false;
}
/// \concept tiny_range
/// \brief The \c tiny_range concept
template<typename R>
CPP_concept tiny_range =
sized_range<R> &&
detail::_is_tiny_range_(static_cast<std::add_pointer_t<R>>(nullptr));
#else // ^^^^ workaround / no workaround vvvv
/// \concept tiny_range_
/// \brief The \c tiny_range_ concept
template(typename R)(
concept (tiny_range_)(R),
ranges::type<
std::integral_constant<decltype(R::size()), R::size()>> AND
(R::size() <= 1)
);
/// \concept tiny_range
/// \brief The \c tiny_range concept
template<typename R>
CPP_concept tiny_range =
sized_range<R> &&
CPP_concept_ref(detail::tiny_range_, std::remove_reference_t<R>);
#endif
// clang-format on
} // namespace detail
template<typename V, typename Pattern>
#if CPP_CXX_CONCEPTS
requires input_range<V> && forward_range<Pattern> && view_<V> && view_<
Pattern> && indirectly_comparable<iterator_t<V>, iterator_t<Pattern>,
ranges::equal_to> &&
(forward_range<V> || detail::tiny_range<Pattern>)
#endif
struct split_view;
namespace detail
{
struct there
{
template<typename T>
static decltype(auto) current_(T & t) noexcept
{
return (t.curr_);
}
};
template<typename It>
struct here
{
It curr_ = It();
It & current_(ignore_t) noexcept
{
return curr_;
}
It const & current_(ignore_t) const noexcept
{
return curr_;
}
};
template<bool>
struct here_or_there_
{
template<typename>
using invoke = there;
};
template<>
struct here_or_there_<true>
{
template<typename It>
using invoke = here<It>;
};
template<typename It>
using split_view_base = meta::invoke<here_or_there_<!forward_iterator<It>>, It>;
template<typename JoinView, bool Const>
struct split_outer_iterator;
template<typename JoinView, bool Const>
struct split_inner_iterator;
template<typename V, typename Pattern, bool Const>
struct split_inner_iterator<split_view<V, Pattern>, Const>
{
private:
using Outer = split_outer_iterator<split_view<V, Pattern>, Const>;
using Base = meta::const_if_c<Const, V>;
using BaseIterCategory =
typename std::iterator_traits<iterator_t<Base>>::iterator_category;
Outer i_ = Outer();
bool incremented_ = false;
constexpr decltype(auto) current_() noexcept
{
return i_.current_();
}
constexpr decltype(auto) current_() const noexcept
{
return i_.current_();
}
constexpr bool done_() const
{
auto cur = current_();
auto last = ranges::end(i_.parent_->base_);
if(cur == last)
return true;
auto pcur = ranges::begin(i_.parent_->pattern_);
auto pend = ranges::end(i_.parent_->pattern_);
if(pcur == pend)
return incremented_;
do
{
if(*cur != *pcur)
return false;
if(++pcur == pend)
return true;
} while(++cur != last);
return false;
}
#if RANGES_CXX_IF_CONSTEXPR < RANGES_CXX_IF_CONSTEXPR_17
constexpr void pre_inc(std::true_type) // Forward
{
++current_();
}
constexpr void pre_inc(std::false_type) // Input
{
if(Pattern::size() != 0)
++current_();
}
constexpr split_inner_iterator post_inc(std::true_type) // Forward
{
auto tmp = *this;
pre_inc(std::true_type{});
return tmp;
}
constexpr void post_inc(std::false_type) // Input
{
pre_inc(std::false_type{});
}
#endif
public:
using iterator_concept = typename Outer::iterator_concept;
using iterator_category =
meta::conditional_t<
derived_from<BaseIterCategory, std::forward_iterator_tag>,
std::forward_iterator_tag,
std::input_iterator_tag>;
using value_type = range_value_t<Base>;
using difference_type = range_difference_t<Base>;
using reference = range_reference_t<Base>; // Not to spec
using pointer = iter_pointer_t<iterator_t<Base>>; // Not to spec
split_inner_iterator() = default;
constexpr explicit split_inner_iterator(Outer i)
: i_(std::move(i))
{}
constexpr decltype(auto) operator*() const
{
return *current_();
}
constexpr split_inner_iterator & operator++()
{
incremented_ = true;
#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
if constexpr(!forward_range<Base>)
if constexpr(Pattern::size() == 0)
return *this;
++current_();
#else
pre_inc(meta::bool_<forward_range<Base>>{});
#endif
return *this;
}
constexpr decltype(auto) operator++(int)
{
#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
if constexpr(forward_range<V>)
{
auto tmp = *this;
++*this;
return tmp;
}
else
++*this;
#else
return post_inc(meta::bool_<forward_range<V>>{});
#endif
}
CPP_broken_friend_member
friend constexpr auto operator==(split_inner_iterator const & x,
split_inner_iterator const & y)
-> CPP_broken_friend_ret(bool)(
requires forward_range<Base>)
{
return x.i_.curr_ == y.i_.curr_;
}
CPP_broken_friend_member
friend constexpr auto operator!=(split_inner_iterator const & x,
split_inner_iterator const & y)
-> CPP_broken_friend_ret(bool)(
requires forward_range<Base>)
{
return x.i_.curr_ != y.i_.curr_;
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr bool operator==(split_inner_iterator const & x,
default_sentinel_t)
{
return x.done_();
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr bool operator==(default_sentinel_t,
split_inner_iterator const & x)
{
return x.done_();
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr bool operator!=(split_inner_iterator const & x,
default_sentinel_t)
{
return !x.done_();
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr bool operator!=(default_sentinel_t,
split_inner_iterator const & x)
{
return !x.done_();
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr decltype(auto) iter_move(
split_inner_iterator const &
i) noexcept(noexcept(ranges::iter_move(i.current_())))
{
return ranges::iter_move(i.current_());
}
CPP_broken_friend_member
friend constexpr auto iter_swap(
split_inner_iterator const & x,
split_inner_iterator const &
y) noexcept(noexcept(ranges::iter_swap(x.current_(), y.current_())))
-> CPP_broken_friend_ret(void)(
requires indirectly_swappable<iterator_t<Base>>)
{
ranges::iter_swap(x.current_(), y.current_());
}
};
template<typename It>
using split_outer_iterator_base =
meta::invoke<here_or_there_<forward_iterator<It>>, It>;
template<typename JoinView, bool Const>
struct split_outer_iterator;
template<typename V, typename Pattern, bool Const>
struct split_outer_iterator<split_view<V, Pattern>, Const>
: split_outer_iterator_base<iterator_t<meta::const_if_c<Const, V>>>
{
private:
friend struct split_inner_iterator<split_view<V, Pattern>, Const>;
using Parent = meta::const_if_c<Const, split_view<V, Pattern>>;
using Base = meta::const_if_c<Const, V>;
using Current = split_outer_iterator_base<iterator_t<Base>>;
Parent * parent_ = nullptr;
constexpr decltype(auto) current_() noexcept
{
return parent_->current_(*this);
}
constexpr decltype(auto) current_() const noexcept
{
return parent_->current_(*this);
}
constexpr decltype(auto) base_() const noexcept
{
return (parent_->base_);
}
#if RANGES_CXX_IF_CONSTEXPR < RANGES_CXX_IF_CONSTEXPR_17
constexpr split_outer_iterator post_inc(std::true_type) // Forward
{
auto tmp = *this;
++*this;
return tmp;
}
constexpr void post_inc(std::false_type) // Input
{
++*this;
}
#endif
public:
using iterator_concept =
meta::conditional_t<forward_range<Base>, std::forward_iterator_tag,
std::input_iterator_tag>;
using iterator_category = std::input_iterator_tag;
struct value_type : view_interface<value_type>
{
private:
split_outer_iterator i_ = split_outer_iterator();
public:
value_type() = default;
constexpr explicit value_type(split_outer_iterator i)
: i_(std::move(i))
{}
constexpr split_inner_iterator<split_view<V, Pattern>, Const> begin()
const
{
return split_inner_iterator<split_view<V, Pattern>, Const>(i_);
}
constexpr default_sentinel_t end() const
{
return default_sentinel;
}
};
using difference_type = range_difference_t<Base>;
using reference = value_type; // Not to spec
using pointer = value_type *; // Not to spec
split_outer_iterator() = default;
CPP_member
constexpr explicit CPP_ctor(split_outer_iterator)(Parent * parent)(
requires (!forward_range<Base>))
: parent_(parent)
{}
CPP_member
constexpr CPP_ctor(split_outer_iterator)(Parent * parent,
iterator_t<Base> current)(
requires forward_range<Base>)
: Current{std::move(current)}
, parent_(parent)
{}
template(bool Other)(
requires Const AND CPP_NOT(Other) AND
convertible_to<iterator_t<V>, iterator_t<Base>>)
constexpr split_outer_iterator(
split_outer_iterator<split_view<V, Pattern>, Other> i)
: Current{std::move(i.curr_)}
, parent_(i.parent_)
{}
constexpr value_type operator*() const
{
return value_type{*this};
}
constexpr split_outer_iterator & operator++()
{
auto & current = current_();
const auto last = ranges::end(base_());
if(current == last)
return *this;
auto const pbegin = ranges::begin(parent_->pattern_);
auto const pend = ranges::end(parent_->pattern_);
if(pbegin == pend)
++current;
else
do
{
const auto ret = ranges::mismatch(current, last, pbegin, pend);
if(ret.in2 == pend)
{
current = ret.in1; // The pattern matched; skip it
break;
}
} while(++current != last);
return *this;
}
constexpr decltype(auto) operator++(int)
{
#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
if constexpr(forward_range<Base>)
{
auto tmp = *this;
++*this;
return tmp;
}
else
++*this;
#else
return post_inc(meta::bool_<forward_range<Base>>{});
#endif
}
CPP_broken_friend_member
friend constexpr auto operator==(split_outer_iterator const & x,
split_outer_iterator const & y)
-> CPP_broken_friend_ret(bool)(
requires forward_range<Base>)
{
return x.curr_ == y.curr_;
}
CPP_broken_friend_member
friend constexpr auto operator!=(split_outer_iterator const & x,
split_outer_iterator const & y)
-> CPP_broken_friend_ret(bool)(
requires forward_range<Base>)
{
return x.curr_ != y.curr_;
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr bool operator==(split_outer_iterator const & x,
default_sentinel_t)
{
return x.current_() == ranges::end(x.base_());
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr bool operator==(default_sentinel_t,
split_outer_iterator const & x)
{
return x.current_() == ranges::end(x.base_());
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr bool operator!=(split_outer_iterator const & x,
default_sentinel_t)
{
return x.current_() != ranges::end(x.base_());
}
#ifdef RANGES_WORKAROUND_MSVC_756601
template<typename = void>
#endif // RANGES_WORKAROUND_MSVC_756601
friend constexpr bool operator!=(default_sentinel_t,
split_outer_iterator const & x)
{
return x.current_() != ranges::end(x.base_());
}
};
} // namespace detail
/// \endcond
template<typename V, typename Pattern>
#if CPP_CXX_CONCEPTS
requires input_range<V> && forward_range<Pattern> && view_<V> && view_<
Pattern> && indirectly_comparable<iterator_t<V>, iterator_t<Pattern>,
ranges::equal_to> &&
(forward_range<V> || detail::tiny_range<Pattern>)
#endif
struct RANGES_EMPTY_BASES split_view
: view_interface<split_view<V, Pattern>, is_finite<V>::value ? finite : unknown>
, private detail::split_view_base<iterator_t<V>>
{
private:
template<typename, bool>
friend struct detail::split_outer_iterator;
template<typename, bool>
friend struct detail::split_inner_iterator;
V base_ = V();
Pattern pattern_ = Pattern();
template<bool Const>
using outer_iterator = detail::split_outer_iterator<split_view, Const>;
#if RANGES_CXX_IF_CONSTEXPR < RANGES_CXX_IF_CONSTEXPR_17
outer_iterator<simple_view<V>()> begin_(std::true_type)
{
return outer_iterator<simple_view<V>()>{this, ranges::begin(base_)};
}
outer_iterator<false> begin_(std::false_type)
{
this->curr_ = ranges::begin(base_);
return outer_iterator<false>{this};
}
outer_iterator<simple_view<V>()> end_(std::true_type) const
{
return outer_iterator<true>{this, ranges::end(base_)};
}
default_sentinel_t end_(std::false_type) const
{
return default_sentinel;
}
#endif
public:
split_view() = default;
constexpr split_view(V base, Pattern pattern)
: base_((V &&) base)
, pattern_((Pattern &&) pattern)
{}
CPP_member
constexpr CPP_ctor(split_view)(V base, range_value_t<V> e)(
requires constructible_from<Pattern, range_value_t<V>>)
: base_(std::move(base))
, pattern_(e)
{}
constexpr V base() const
{
return base_;
}
constexpr outer_iterator<forward_range<V> && simple_view<V>()> begin()
{
#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
if constexpr(forward_range<V>)
return outer_iterator<simple_view<V>()>{this, ranges::begin(base_)};
else
{
this->curr_ = ranges::begin(base_);
return outer_iterator<false>{this};
}
#else
return begin_(meta::bool_<forward_range<V>>{});
#endif
}
CPP_member
constexpr auto begin() const //
-> CPP_ret(outer_iterator<true>)(
requires forward_range<V> && forward_range<const V>)
{
return {this, ranges::begin(base_)};
}
CPP_member
constexpr auto end() //
-> CPP_ret(outer_iterator<simple_view<V>()>)(
requires forward_range<V> && common_range<V>)
{
return outer_iterator<simple_view<V>()>{this, ranges::end(base_)};
}
constexpr auto end() const
{
#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
if constexpr(forward_range<V> && forward_range<const V> &&
common_range<const V>)
return outer_iterator<true>{this, ranges::end(base_)};
else
return default_sentinel;
#else
return end_(meta::bool_ < forward_range<V> && forward_range<const V> &&
common_range<const V> > {});
#endif
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename R, typename P)(
requires input_range<R> AND forward_range<P> AND viewable_range<R> AND
viewable_range<P> AND
indirectly_comparable<iterator_t<R>, iterator_t<P>, ranges::equal_to> AND
(forward_range<R> || detail::tiny_range<P>)) //
split_view(R &&, P &&)
->split_view<views::all_t<R>, views::all_t<P>>;
template(typename R)(
requires input_range<R>)
split_view(R &&, range_value_t<R>)
->split_view<views::all_t<R>, single_view<range_value_t<R>>>;
#endif
namespace views
{
struct split_base_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng> AND
indirectly_comparable<iterator_t<Rng>,
range_value_t<Rng> const *,
ranges::equal_to>)
constexpr split_view<all_t<Rng>, single_view<range_value_t<Rng>>> //
operator()(Rng && rng, range_value_t<Rng> val) const
{
return {all(static_cast<Rng &&>(rng)), single(std::move(val))};
}
template(typename Rng, typename Pattern)(
requires viewable_range<Rng> AND input_range<Rng> AND
viewable_range<Pattern> AND forward_range<Pattern> AND
indirectly_comparable<
iterator_t<Rng>,
iterator_t<Pattern>,
ranges::equal_to> AND
(forward_range<Rng> || detail::tiny_range<Pattern>)) //
constexpr split_view<all_t<Rng>, all_t<Pattern>> //
operator()(Rng && rng, Pattern && pattern) const
{
return {all((Rng &&) rng), all((Pattern &&) pattern)};
}
};
struct split_fn : split_base_fn
{
using split_base_fn::operator();
template<typename T>
constexpr auto operator()(T t) const
{
return make_view_closure(bind_back(split_base_fn{}, std::move(t)));
}
};
/// \relates split_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(split_fn, split)
} // namespace views
namespace cpp20
{
namespace views
{
using ranges::views::split;
}
template(typename Rng, typename Pattern)(
requires input_range<Rng> AND forward_range<Pattern> AND view_<Rng> AND
view_<Pattern> AND
indirectly_comparable<
iterator_t<Rng>,
iterator_t<Pattern>,
ranges::equal_to> AND
(forward_range<Rng> || ranges::detail::tiny_range<Pattern>)) //
using split_view =
ranges::split_view<Rng, Pattern>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::split_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/adaptor.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_ADAPTOR_HPP
#define RANGES_V3_VIEW_ADAPTOR_HPP
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/compressed_pair.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
template<typename Derived>
using begin_adaptor_t = detail::decay_t<decltype(
range_access::begin_adaptor(std::declval<Derived &>()))>;
template<typename Derived>
using end_adaptor_t = detail::decay_t<decltype(
range_access::end_adaptor(std::declval<Derived &>()))>;
template<typename Derived>
using adapted_iterator_t = detail::decay_t<decltype(
std::declval<begin_adaptor_t<Derived>>().begin(std::declval<Derived &>()))>;
template<typename Derived>
using adapted_sentinel_t = detail::decay_t<decltype(
std::declval<end_adaptor_t<Derived>>().end(std::declval<Derived &>()))>;
struct adaptor_base_current_mem_fn
{};
template<typename BaseIter, typename Adapt>
constexpr int which_adaptor_value_(priority_tag<0>)
{
return 0;
}
template<typename BaseIter, typename Adapt>
constexpr always_<int, decltype(Adapt::read(std::declval<BaseIter const &>(),
adaptor_base_current_mem_fn{}))> //
which_adaptor_value_(priority_tag<1>)
{
return 1;
}
template<typename BaseIter, typename Adapt>
constexpr always_<int, typename Adapt::value_type> //
which_adaptor_value_(priority_tag<2>)
{
return 2;
}
template<typename BaseIter, typename Adapt,
int = detail::which_adaptor_value_<BaseIter, Adapt>(priority_tag<2>{})>
struct adaptor_value_type_
{
compressed_pair<BaseIter, Adapt> data_;
};
template<typename BaseIter, typename Adapt>
struct adaptor_value_type_<BaseIter, Adapt, 1>
{
using value_type = iter_value_t<BaseIter>;
compressed_pair<BaseIter, Adapt> data_;
};
template<typename BaseIter, typename Adapt>
struct adaptor_value_type_<BaseIter, Adapt, 2>
{
#ifdef RANGES_WORKAROUND_MSVC_688606
using value_type = typename indirectly_readable_traits<Adapt>::value_type;
#else // ^^^ workaround ^^^ / vvv no workaround vvv
using value_type = typename Adapt::value_type;
#endif // RANGES_WORKAROUND_MSVC_688606
compressed_pair<BaseIter, Adapt> data_;
};
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
template<typename BaseIt, typename Adapt>
struct adaptor_cursor;
template<typename BaseSent, typename Adapt>
struct base_adaptor_sentinel;
struct adaptor_base
{
adaptor_base() = default;
adaptor_base(adaptor_base &&) = default;
adaptor_base(adaptor_base const &) = default;
adaptor_base & operator=(adaptor_base &&) = default;
adaptor_base & operator=(adaptor_base const &) = default;
adaptor_base(detail::ignore_t, detail::ignore_t = {}, detail::ignore_t = {})
{}
// clang-format off
template<typename Rng>
static constexpr auto CPP_auto_fun(begin)(Rng &rng)
(
return ranges::begin(rng.base())
)
template<typename Rng>
static constexpr auto CPP_auto_fun(end)(Rng &rng)
(
return ranges::end(rng.base())
)
// clang-format on
template(typename I)(
requires equality_comparable<I>)
static bool equal(I const & it0, I const & it1)
{
return it0 == it1;
}
template(typename I)(
requires input_or_output_iterator<I>)
static iter_reference_t<I> read(I const & it,
detail::adaptor_base_current_mem_fn = {})
noexcept(noexcept(iter_reference_t<I>(*it)))
{
return *it;
}
template(typename I)(
requires input_or_output_iterator<I>)
static void next(I & it)
{
++it;
}
template(typename I)(
requires bidirectional_iterator<I>)
static void prev(I & it)
{
--it;
}
template(typename I)(
requires random_access_iterator<I>)
static void advance(I & it, iter_difference_t<I> n)
{
it += n;
}
template(typename I)(
requires sized_sentinel_for<I, I>)
static iter_difference_t<I> distance_to(I const & it0, I const & it1)
{
return it1 - it0;
}
template(typename I, typename S)(
requires sentinel_for<S, I>)
static constexpr bool empty(I const & it, S const & last)
{
return it == last;
}
};
// Build a sentinel out of a sentinel into the adapted range, and an
// adaptor that customizes behavior.
template<typename BaseSent, typename Adapt>
struct base_adaptor_sentinel
{
private:
template<typename, typename>
friend struct adaptor_cursor;
RANGES_NO_UNIQUE_ADDRESS compressed_pair<BaseSent, Adapt> data_;
public:
base_adaptor_sentinel() = default;
base_adaptor_sentinel(BaseSent sent, Adapt adapt)
: data_{std::move(sent), std::move(adapt)}
{}
// All sentinels into adapted ranges have a base() member for fetching
// the underlying sentinel.
BaseSent base() const
{
return data_.first();
}
protected:
// Adaptor accessor
Adapt & get()
{
return data_.second();
}
Adapt const & get() const
{
return data_.second();
}
};
/// \cond
namespace detail
{
template<typename BaseSent, typename Adapt>
meta::id<base_adaptor_sentinel<BaseSent, Adapt>> base_adaptor_sentinel_2_(long);
template<typename BaseSent, typename Adapt>
meta::id<typename Adapt::template mixin<base_adaptor_sentinel<BaseSent, Adapt>>>
base_adaptor_sentinel_2_(int);
template<typename BaseSent, typename Adapt>
struct base_adaptor_sentinel_
: decltype(base_adaptor_sentinel_2_<BaseSent, Adapt>(42))
{};
template<typename BaseSent, typename Adapt>
using adaptor_sentinel_ = meta::_t<base_adaptor_sentinel_<BaseSent, Adapt>>;
} // namespace detail
/// \endcond
template<typename BaseSent, typename Adapt>
struct adaptor_sentinel : detail::adaptor_sentinel_<BaseSent, Adapt>
{
using detail::adaptor_sentinel_<BaseSent, Adapt>::adaptor_sentinel_;
};
// Build a cursor out of an iterator into the adapted range, and an
// adaptor that customizes behavior.
template<typename BaseIter, typename Adapt>
struct adaptor_cursor : private detail::adaptor_value_type_<BaseIter, Adapt>
{
private:
friend range_access;
template<typename, typename>
friend struct adaptor_cursor;
using base_t = detail::adaptor_value_type_<BaseIter, Adapt>;
using single_pass = meta::bool_<(bool)range_access::single_pass_t<Adapt>() ||
(bool)single_pass_iterator_<BaseIter>>;
struct basic_adaptor_mixin : basic_mixin<adaptor_cursor>
{
basic_adaptor_mixin() = default;
#ifndef _MSC_VER
using basic_mixin<adaptor_cursor>::basic_mixin;
#else
constexpr explicit basic_adaptor_mixin(adaptor_cursor && cur)
: basic_mixin<adaptor_cursor>(static_cast<adaptor_cursor &&>(cur))
{}
constexpr explicit basic_adaptor_mixin(adaptor_cursor const & cur)
: basic_mixin<adaptor_cursor>(cur)
{}
#endif
// All iterators into adapted ranges have a base() member for fetching
// the underlying iterator.
BaseIter base() const
{
return basic_adaptor_mixin::basic_mixin::get().data_.first();
}
protected:
// Adaptor accessor
Adapt & get()
{
return basic_adaptor_mixin::basic_mixin::get().data_.second();
}
const Adapt & get() const
{
return basic_adaptor_mixin::basic_mixin::get().data_.second();
}
};
template<typename Adapt_>
static meta::id<basic_adaptor_mixin> basic_adaptor_mixin_2_(long);
template<typename Adapt_>
static meta::id<typename Adapt_::template mixin<basic_adaptor_mixin>>
basic_adaptor_mixin_2_(int);
using mixin = meta::_t<decltype(basic_adaptor_mixin_2_<Adapt>(42))>;
template<typename A = Adapt, typename R = decltype(std::declval<A const &>().read(
std::declval<BaseIter const &>()))>
R read() const noexcept(
noexcept(std::declval<A const &>().read(std::declval<BaseIter const &>())))
{
using V = range_access::cursor_value_t<adaptor_cursor>;
static_assert(common_reference_with<R &&, V &>,
"In your adaptor, you've specified a value type that does not "
"share a common reference type with the return type of read.");
return this->data_.second().read(this->data_.first());
}
template<typename A = Adapt, typename = decltype(std::declval<A &>().next(
std::declval<BaseIter &>()))>
void next()
{
this->data_.second().next(this->data_.first());
}
template<typename A = Adapt,
typename = decltype(std::declval<A const &>().equal(
std::declval<BaseIter const &>(), std::declval<BaseIter const &>(),
std::declval<A const &>()))>
bool equal_(adaptor_cursor const & that, int) const
{
return this->data_.second().equal(
this->data_.first(), that.data_.first(), that.data_.second());
}
template<typename A = Adapt,
typename = decltype(std::declval<A const &>().equal(
std::declval<BaseIter const &>(), std::declval<BaseIter const &>()))>
bool equal_(adaptor_cursor const & that, long) const
{
return this->data_.second().equal(this->data_.first(), that.data_.first());
}
template<typename C = adaptor_cursor>
auto equal(adaptor_cursor const & that) const
-> decltype(std::declval<C const &>().equal_(that, 42))
{
return this->equal_(that, 42);
}
template<typename S, typename A,
typename = decltype(std::declval<A const &>().empty(
std::declval<BaseIter const &>(), std::declval<Adapt const &>(),
std::declval<S const &>()))>
constexpr bool equal_(adaptor_sentinel<S, A> const & that, int) const
{
return that.data_.second().empty(
this->data_.first(), this->data_.second(), that.data_.first());
}
template<typename S, typename A,
typename = decltype(std::declval<A const &>().empty(
std::declval<BaseIter const &>(), std::declval<S const &>()))>
constexpr bool equal_(adaptor_sentinel<S, A> const & that, long) const
{
return that.data_.second().empty(this->data_.first(), that.data_.first());
}
template<typename S, typename A>
constexpr auto equal(adaptor_sentinel<S, A> const & that) const
-> decltype(std::declval<adaptor_cursor const &>().equal_(that, 42))
{
return this->equal_(that, 42);
}
template<typename A = Adapt, typename = decltype(std::declval<A &>().prev(
std::declval<BaseIter &>()))>
void prev()
{
this->data_.second().prev(this->data_.first());
}
template<typename A = Adapt, typename = decltype(std::declval<A &>().advance(
std::declval<BaseIter &>(), 0))>
void advance(iter_difference_t<BaseIter> n)
{
this->data_.second().advance(this->data_.first(), n);
}
template<typename A = Adapt,
typename R = decltype(std::declval<A const &>().distance_to(
std::declval<BaseIter const &>(), std::declval<BaseIter const &>(),
std::declval<A const &>()))>
R distance_to_(adaptor_cursor const & that, int) const
{
return this->data_.second().distance_to(
this->data_.first(), that.data_.first(), that.data_.second());
}
template<typename A = Adapt,
typename R = decltype(std::declval<A const &>().distance_to(
std::declval<BaseIter const &>(), std::declval<BaseIter const &>()))>
R distance_to_(adaptor_cursor const & that, long) const
{
return this->data_.second().distance_to(this->data_.first(),
that.data_.first());
}
template<typename C = adaptor_cursor>
auto distance_to(adaptor_cursor const & that) const
-> decltype(std::declval<C const &>().distance_to_(that, 42))
{
return this->distance_to_(that, 42);
}
// If the adaptor has an iter_move function, use it.
template<typename A = Adapt,
typename X = decltype(std::declval<A const &>().iter_move(
std::declval<BaseIter const &>()))>
X iter_move_(int) const noexcept(noexcept(
std::declval<A const &>().iter_move(std::declval<BaseIter const &>())))
{
using V = range_access::cursor_value_t<adaptor_cursor>;
using R = decltype(this->data_.second().read(this->data_.first()));
static_assert(
common_reference_with<X &&, V const &>,
"In your adaptor, the result of your iter_move member function does "
"not share a common reference with your value type.");
static_assert(
common_reference_with<R &&, X &&>,
"In your adaptor, the result of your iter_move member function does "
"not share a common reference with the result of your read member "
"function.");
return this->data_.second().iter_move(this->data_.first());
}
// If there is no iter_move member and the adaptor has not overridden the read
// member function, then dispatch to the base iterator's iter_move function.
template<typename A = Adapt,
typename R = decltype(std::declval<A const &>().read(
std::declval<BaseIter const &>(),
detail::adaptor_base_current_mem_fn{})),
typename X = iter_rvalue_reference_t<BaseIter>>
X iter_move_(long) const
noexcept(noexcept(X(ranges::iter_move(std::declval<BaseIter const &>()))))
{
return ranges::iter_move(this->data_.first());
}
// If the adaptor does not have an iter_move function but overrides the read
// member function, apply std::move to the result of calling read.
template<typename A = Adapt,
typename R = decltype(
std::declval<A const &>().read(std::declval<BaseIter const &>())),
typename X = aux::move_t<R>>
X iter_move_(detail::ignore_t) const noexcept(noexcept(X(static_cast<X &&>(
std::declval<A const &>().read(std::declval<BaseIter const &>())))))
{
using V = range_access::cursor_value_t<adaptor_cursor>;
static_assert(
common_reference_with<X &&, V const &>,
"In your adaptor, you've specified a value type that does not share a "
"common "
"reference type with the result of moving the result of the read member "
"function. Consider defining an iter_move function in your adaptor.");
return static_cast<X &&>(this->data_.second().read(this->data_.first()));
}
// Gives users a way to override the default iter_move function in their adaptors.
auto move() const
noexcept(noexcept(std::declval<const adaptor_cursor &>().iter_move_(42)))
-> decltype(std::declval<const adaptor_cursor &>().iter_move_(42))
{
return iter_move_(42);
}
public:
adaptor_cursor() = default;
adaptor_cursor(BaseIter iter, Adapt adapt)
: base_t{{std::move(iter), std::move(adapt)}}
{}
template(typename OtherIter, typename OtherAdapt)(
requires //
(!same_as<adaptor_cursor<OtherIter, OtherAdapt>, adaptor_cursor>) AND
convertible_to<OtherIter, BaseIter> AND
convertible_to<OtherAdapt, Adapt>)
adaptor_cursor(adaptor_cursor<OtherIter, OtherAdapt> that)
: base_t{{std::move(that.data_.first()), std::move(that.data_.second())}}
{}
};
template<typename D>
using adaptor_cursor_t =
adaptor_cursor<detail::adapted_iterator_t<D>, detail::begin_adaptor_t<D>>;
template<typename D>
using adaptor_sentinel_t = meta::if_c<
same_as<detail::adapted_iterator_t<D>, detail::adapted_sentinel_t<D>> &&
same_as<detail::begin_adaptor_t<D>, detail::end_adaptor_t<D>>,
adaptor_cursor_t<D>,
adaptor_sentinel<detail::adapted_sentinel_t<D>, detail::end_adaptor_t<D>>>;
template<typename Derived, typename BaseRng,
cardinality Cardinality /*= range_cardinality<BaseRng>::value*/>
struct view_adaptor : view_facade<Derived, Cardinality>
{
private:
friend Derived;
friend range_access;
friend adaptor_base;
CPP_assert(viewable_range<BaseRng>);
using base_range_t = views::all_t<BaseRng>;
using view_facade<Derived, Cardinality>::derived;
base_range_t rng_;
constexpr adaptor_base begin_adaptor() const noexcept
{
return {};
}
constexpr adaptor_base end_adaptor() const noexcept
{
return {};
}
template<typename D>
static constexpr adaptor_cursor_t<D> begin_cursor_(D & d) noexcept(noexcept(
adaptor_cursor_t<D>{std::declval<detail::begin_adaptor_t<D> &>().begin(d),
range_access::begin_adaptor(d)}))
{
auto adapt = range_access::begin_adaptor(d);
auto pos = adapt.begin(d);
return {std::move(pos), std::move(adapt)};
}
template(typename D = Derived)(
requires same_as<D, Derived>)
constexpr auto begin_cursor() noexcept(
noexcept(view_adaptor::begin_cursor_(std::declval<D &>())))
-> decltype(view_adaptor::begin_cursor_(std::declval<D &>()))
{
return view_adaptor::begin_cursor_(derived());
}
template(typename D = Derived)(
requires same_as<D, Derived> AND range<base_range_t const>)
constexpr auto begin_cursor() const
noexcept(noexcept(view_adaptor::begin_cursor_(std::declval<D const &>())))
-> decltype(view_adaptor::begin_cursor_(std::declval<D const &>()))
{
return view_adaptor::begin_cursor_(derived());
}
template<typename D>
static constexpr adaptor_sentinel_t<D> end_cursor_(D & d) noexcept(noexcept(
adaptor_sentinel_t<D>{std::declval<detail::end_adaptor_t<D> &>().end(d),
range_access::end_adaptor(d)}))
{
auto adapt = range_access::end_adaptor(d);
auto pos = adapt.end(d);
return {std::move(pos), std::move(adapt)};
}
template(typename D = Derived)(
requires same_as<D, Derived>)
constexpr auto end_cursor() noexcept(
noexcept(view_adaptor::end_cursor_(std::declval<D &>())))
-> decltype(view_adaptor::end_cursor_(std::declval<D &>()))
{
return view_adaptor::end_cursor_(derived());
}
template(typename D = Derived)(
requires same_as<D, Derived> AND range<base_range_t const>)
constexpr auto end_cursor() const noexcept(
noexcept(view_adaptor::end_cursor_(std::declval<D const &>())))
-> decltype(view_adaptor::end_cursor_(std::declval<D const &>()))
{
return view_adaptor::end_cursor_(derived());
}
protected:
~view_adaptor() = default;
public:
view_adaptor() = default;
view_adaptor(view_adaptor &&) = default;
view_adaptor(view_adaptor const &) = default;
view_adaptor & operator=(view_adaptor &&) = default;
view_adaptor & operator=(view_adaptor const &) = default;
constexpr explicit view_adaptor(BaseRng && rng)
: rng_(views::all(static_cast<BaseRng &&>(rng)))
{}
constexpr base_range_t & base() noexcept
{
return rng_;
}
/// \overload
constexpr base_range_t const & base() const noexcept
{
return rng_;
}
};
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/repeat_n.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_REPEAT_N_HPP
#define RANGES_V3_VIEW_REPEAT_N_HPP
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
// Ordinarily, a view shouldn't contain its elements. This is so that copying
// and assigning ranges is O(1), and also so that in the event of element
// mutation, all the copies of the range see the mutation the same way. The
// repeat_n_view *does* own its lone element, though. This is OK because:
// - O(N) copying is fine when N==1 as it is in this case, and
// - The element is immutable, so there is no potential for incorrect
// semantics.
template<typename Val>
struct repeat_n_view : view_facade<repeat_n_view<Val>, finite>
{
private:
friend range_access;
semiregular_box_t<Val> value_;
std::ptrdiff_t n_;
struct cursor
{
private:
Val const * value_;
std::ptrdiff_t n_;
public:
cursor() = default;
cursor(Val const & value, std::ptrdiff_t n)
: value_(std::addressof(value))
, n_(n)
{}
Val const & read() const
{
return *value_;
}
constexpr bool equal(default_sentinel_t) const
{
return 0 == n_;
}
bool equal(cursor const & that) const
{
return n_ == that.n_;
}
void next()
{
RANGES_EXPECT(0 != n_);
--n_;
}
void prev()
{
++n_;
}
void advance(std::ptrdiff_t n)
{
n_ -= n;
}
std::ptrdiff_t distance_to(cursor const & that) const
{
return n_ - that.n_;
}
};
cursor begin_cursor() const
{
return {value_, n_};
}
public:
repeat_n_view() = default;
constexpr repeat_n_view(Val value, std::ptrdiff_t n)
: value_(detail::move(value))
, n_((RANGES_EXPECT(0 <= n), n))
{}
constexpr std::size_t size() const
{
return static_cast<std::size_t>(n_);
}
};
namespace views
{
struct repeat_n_fn
{
template(typename Val)(
requires copy_constructible<Val>)
repeat_n_view<Val> operator()(Val value, std::ptrdiff_t n) const
{
return repeat_n_view<Val>{std::move(value), n};
}
};
/// \relates repeat_n_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(repeat_n_fn, repeat_n)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::repeat_n_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/unique.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_UNIQUE_HPP
#define RANGES_V3_VIEW_UNIQUE_HPP
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/not_fn.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adjacent_filter.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
namespace views
{
struct unique_base_fn
{
template(typename Rng, typename C = equal_to)(
requires viewable_range<Rng> AND forward_range<Rng> AND
indirect_relation<C, iterator_t<Rng>>)
constexpr adjacent_filter_view<all_t<Rng>, logical_negate<C>> //
operator()(Rng && rng, C pred = {}) const
{
return {all(static_cast<Rng &&>(rng)), not_fn(pred)};
}
};
struct unique_fn : unique_base_fn
{
using unique_base_fn::operator();
template(typename C)(
requires (!range<C>))
constexpr auto operator()(C && pred) const
{
return make_view_closure(
bind_back(unique_base_fn{}, static_cast<C &&>(pred)));
}
};
/// \relates unique_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<unique_fn>, unique)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/istream.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_ISTREAM_HPP
#define RANGES_V3_VIEW_ISTREAM_HPP
#include <istream>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Val>
struct istream_view : view_facade<istream_view<Val>, unknown>
{
private:
friend range_access;
std::istream * sin_;
semiregular_box_t<Val> obj_;
struct cursor
{
private:
friend range_access;
using single_pass = std::true_type;
istream_view * rng_ = nullptr;
public:
cursor() = default;
explicit cursor(istream_view * rng)
: rng_(rng)
{}
void next()
{
rng_->next();
}
Val & read() const noexcept
{
return rng_->cached();
}
bool equal(default_sentinel_t) const
{
return !rng_->sin_;
}
bool equal(cursor that) const
{
return !rng_->sin_ == !that.rng_->sin_;
}
};
void next()
{
if(!(*sin_ >> cached()))
sin_ = nullptr;
}
cursor begin_cursor()
{
return cursor{this};
}
public:
istream_view() = default;
explicit istream_view(std::istream & sin)
: sin_(&sin)
, obj_{}
{
next(); // prime the pump
}
Val & cached() noexcept
{
return obj_;
}
};
/// \cond
template<typename Val>
using istream_range RANGES_DEPRECATED(
"istream_range<T> has been renamed to istream_view<T>") = istream_view<Val>;
/// \endcond
/// \cond
namespace _istream_
{
/// \endcond
template(typename Val)(
requires copy_constructible<Val> AND default_constructible<Val>)
inline istream_view<Val> istream(std::istream & sin)
{
return istream_view<Val>{sin};
}
/// \cond
} // namespace _istream_
using namespace _istream_;
/// \endcond
namespace cpp20
{
template<typename Val>
using basic_istream_view = ::ranges::istream_view<Val>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/transform.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_TRANSFORM_HPP
#define RANGES_V3_VIEW_TRANSFORM_HPP
#include <iterator>
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/algorithm/max.hpp>
#include <range/v3/algorithm/min.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/indirect.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/move.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
constexpr cardinality transform2_cardinality(cardinality c1, cardinality c2)
{
return c1 >= 0 || c2 >= 0
? (c1 >= 0 && c2 >= 0 ? (c1 < c2 ? c1 : c2) : finite)
: c1 == finite || c2 == finite
? finite
: c1 == unknown || c2 == unknown ? unknown : infinite;
}
// clang-format off
/// \concept iter_transform_1_readable_
/// \brief The \c iter_transform_1_readable_ concept
template(typename Fun, typename Rng)(
concept (iter_transform_1_readable_)(Fun, Rng),
regular_invocable<Fun &, iterator_t<Rng>> AND
regular_invocable<Fun &, copy_tag, iterator_t<Rng>> AND
regular_invocable<Fun &, move_tag, iterator_t<Rng>> AND
common_reference_with<
invoke_result_t<Fun &, iterator_t<Rng>> &&,
invoke_result_t<Fun &, copy_tag, iterator_t<Rng>> &> AND
common_reference_with<
invoke_result_t<Fun &, iterator_t<Rng>> &&,
invoke_result_t<Fun &, move_tag, iterator_t<Rng>> &&> AND
common_reference_with<
invoke_result_t<Fun &, move_tag, iterator_t<Rng>> &&,
invoke_result_t<Fun &, copy_tag, iterator_t<Rng>> const &>
);
/// \concept iter_transform_1_readable
/// \brief The \c iter_transform_1_readable concept
template<typename Fun, typename Rng>
CPP_concept iter_transform_1_readable =
CPP_concept_ref(detail::iter_transform_1_readable_, Fun, Rng);
/// \concept iter_transform_2_readable_
/// \brief The \c iter_transform_2_readable_ concept
template(typename Fun, typename Rng1, typename Rng2)(
concept (iter_transform_2_readable_)(Fun, Rng1, Rng2),
regular_invocable<Fun &, iterator_t<Rng1>, iterator_t<Rng2>> AND
regular_invocable<Fun &, copy_tag, iterator_t<Rng1>, iterator_t<Rng2>> AND
regular_invocable<Fun &, move_tag, iterator_t<Rng1>, iterator_t<Rng2>> AND
common_reference_with<
invoke_result_t<Fun &, iterator_t<Rng1>, iterator_t<Rng2>> &&,
invoke_result_t<Fun &, copy_tag, iterator_t<Rng1>, iterator_t<Rng2>> &> AND
common_reference_with<
invoke_result_t<Fun &, iterator_t<Rng1>, iterator_t<Rng2>> &&,
invoke_result_t<Fun &, move_tag, iterator_t<Rng1>, iterator_t<Rng2>> &&> AND
common_reference_with<
invoke_result_t<Fun &, move_tag, iterator_t<Rng1>, iterator_t<Rng2>> &&,
invoke_result_t<Fun &, copy_tag, iterator_t<Rng1>, iterator_t<Rng2>> const &>
);
/// \concept iter_transform_2_readable
/// \brief The \c iter_transform_2_readable concept
template<typename Fun, typename Rng1, typename Rng2>
CPP_concept iter_transform_2_readable =
CPP_concept_ref(detail::iter_transform_2_readable_, Fun, Rng1, Rng2);
// clang-format on
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
template<typename Rng, typename Fun>
struct iter_transform_view : view_adaptor<iter_transform_view<Rng, Fun>, Rng>
{
private:
friend range_access;
RANGES_NO_UNIQUE_ADDRESS semiregular_box_t<Fun> fun_;
template<bool Const>
using use_sentinel_t =
meta::bool_<!common_range<meta::const_if_c<Const, Rng>> ||
single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng>>>>;
template<bool IsConst>
struct adaptor : adaptor_base
{
private:
friend struct adaptor<!IsConst>;
using CRng = meta::const_if_c<IsConst, Rng>;
using fun_ref_ = semiregular_box_ref_or_val_t<Fun, IsConst>;
RANGES_NO_UNIQUE_ADDRESS fun_ref_ fun_;
public:
using value_type =
detail::decay_t<invoke_result_t<Fun &, copy_tag, iterator_t<CRng>>>;
adaptor() = default;
adaptor(fun_ref_ fun)
: fun_(std::move(fun))
{}
template(bool Other)(
requires IsConst AND CPP_NOT(Other)) //
adaptor(adaptor<Other> that)
: fun_(std::move(that.fun_))
{}
// clang-format off
auto CPP_auto_fun(read)(iterator_t<CRng> it)(const)
(
return invoke(fun_, it)
)
auto CPP_auto_fun(iter_move)(iterator_t<CRng> it)(const)
(
return invoke(fun_, move_tag{}, it)
)
// clang-format on
};
adaptor<false> begin_adaptor()
{
return {fun_};
}
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng>> AND
detail::iter_transform_1_readable<Fun const,
meta::const_if_c<Const, Rng>>)
adaptor<Const> begin_adaptor() const
{
return {fun_};
}
meta::if_<use_sentinel_t<false>, adaptor_base, adaptor<false>> end_adaptor()
{
return {fun_};
}
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng>> AND
detail::iter_transform_1_readable<Fun const,
meta::const_if_c<Const, Rng>>)
meta::if_<use_sentinel_t<Const>, adaptor_base, adaptor<Const>> end_adaptor() const
{
return {fun_};
}
public:
iter_transform_view() = default;
iter_transform_view(Rng rng, Fun fun)
: iter_transform_view::view_adaptor{std::move(rng)}
, fun_(std::move(fun))
{}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return ranges::size(this->base());
}
CPP_auto_member
constexpr auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
return ranges::size(this->base());
}
};
template<typename Rng, typename Fun>
struct transform_view : iter_transform_view<Rng, indirected<Fun>>
{
transform_view() = default;
transform_view(Rng rng, Fun fun)
: iter_transform_view<Rng, indirected<Fun>>{std::move(rng),
indirect(std::move(fun))}
{}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Fun)(
requires copy_constructible<Fun>)
transform_view(Rng &&, Fun)
-> transform_view<views::all_t<Rng>, Fun>;
#endif
template<typename Rng1, typename Rng2, typename Fun>
struct iter_transform2_view
: view_facade<iter_transform2_view<Rng1, Rng2, Fun>,
detail::transform2_cardinality(range_cardinality<Rng1>::value,
range_cardinality<Rng2>::value)>
{
private:
friend range_access;
RANGES_NO_UNIQUE_ADDRESS semiregular_box_t<Fun> fun_;
Rng1 rng1_;
Rng2 rng2_;
using difference_type_ =
common_type_t<range_difference_t<Rng1>, range_difference_t<Rng2>>;
static constexpr cardinality my_cardinality = detail::transform2_cardinality(
range_cardinality<Rng1>::value, range_cardinality<Rng2>::value);
template<bool>
struct cursor;
template<bool Const>
struct sentinel
{
private:
friend struct cursor<Const>;
sentinel_t<meta::const_if_c<Const, Rng1>> end1_;
sentinel_t<meta::const_if_c<Const, Rng2>> end2_;
public:
sentinel() = default;
sentinel(meta::const_if_c<Const, iter_transform2_view> * parent,
decltype(ranges::end))
: end1_(end(parent->rng1_))
, end2_(end(parent->rng2_))
{}
template(bool Other)(
requires Const AND CPP_NOT(Other)) //
sentinel(sentinel<Other> that)
: end1_(std::move(that.end1_))
, end2_(std::move(that.end2_))
{}
};
template<bool Const>
struct cursor
{
private:
using fun_ref_ = semiregular_box_ref_or_val_t<Fun, Const>;
using R1 = meta::const_if_c<Const, Rng1>;
using R2 = meta::const_if_c<Const, Rng2>;
fun_ref_ fun_;
iterator_t<R1> it1_;
iterator_t<R2> it2_;
public:
using difference_type = difference_type_;
using single_pass = meta::or_c<(bool)single_pass_iterator_<iterator_t<R1>>,
(bool)single_pass_iterator_<iterator_t<R2>>>;
using value_type =
detail::decay_t<invoke_result_t<meta::const_if_c<Const, Fun> &, copy_tag,
iterator_t<R1>, iterator_t<R2>>>;
cursor() = default;
template<typename BeginEndFn>
cursor(meta::const_if_c<Const, iter_transform2_view> * parent,
BeginEndFn begin_end)
: fun_(parent->fun_)
, it1_(begin_end(parent->rng1_))
, it2_(begin_end(parent->rng2_))
{}
template(bool Other)(
requires Const AND CPP_NOT(Other)) //
cursor(cursor<Other> that)
: fun_(std::move(that.fun_))
, it1_(std::move(that.end1_))
, it2_(std::move(that.end2_))
{}
// clang-format off
auto CPP_auto_fun(read)()(const)
(
return invoke(fun_, it1_, it2_)
)
// clang-format on
void next()
{
++it1_;
++it2_;
}
CPP_member
auto equal(cursor const & that) const //
-> CPP_ret(bool)(
requires forward_range<Rng1> && forward_range<Rng2>)
{
// By returning true if *any* of the iterators are equal, we allow
// transformed ranges to be of different lengths, stopping when the first
// one reaches the last.
return it1_ == that.it1_ || it2_ == that.it2_;
}
bool equal(sentinel<Const> const & s) const
{
// By returning true if *any* of the iterators are equal, we allow
// transformed ranges to be of different lengths, stopping when the first
// one reaches the last.
return it1_ == s.end1_ || it2_ == s.end2_;
}
CPP_member
auto prev() //
-> CPP_ret(void)(
requires bidirectional_range<R1> && bidirectional_range<R2>)
{
--it1_;
--it2_;
}
CPP_member
auto advance(difference_type n) -> CPP_ret(void)(
requires random_access_range<R1> && random_access_range<R2>)
{
ranges::advance(it1_, n);
ranges::advance(it2_, n);
}
CPP_member
auto distance_to(cursor const & that) const //
-> CPP_ret(difference_type)(
requires sized_sentinel_for<iterator_t<R1>, iterator_t<R1>> &&
sized_sentinel_for<iterator_t<R2>, iterator_t<R2>>)
{
// Return the smallest distance (in magnitude) of any of the iterator
// pairs. This is to accommodate zippers of sequences of different length.
difference_type d1 = that.it1_ - it1_, d2 = that.it2_ - it2_;
return 0 < d1 ? ranges::min(d1, d2) : ranges::max(d1, d2);
}
// clang-format off
auto CPP_auto_fun(move)()(const)
(
return invoke(fun_, move_tag{}, it1_, it2_)
)
// clang-format on
};
template<bool Const>
using end_cursor_t = meta::if_c<
common_range<meta::const_if_c<Const, Rng1>> &&
common_range<meta::const_if_c<Const, Rng2>> &&
!single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng1>>> &&
!single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng2>>>,
cursor<Const>, sentinel<Const>>;
cursor<simple_view<Rng1>() && simple_view<Rng2>()> begin_cursor()
{
return {this, ranges::begin};
}
end_cursor_t<simple_view<Rng1>() && simple_view<Rng2>()> end_cursor()
{
return {this, ranges::end};
}
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng1>> AND
range<meta::const_if_c<Const, Rng2>> AND
detail::iter_transform_2_readable< //
Fun const, //
meta::const_if_c<Const, Rng1>, //
meta::const_if_c<Const, Rng2>>)
cursor<true> begin_cursor() const
{
return {this, ranges::begin};
}
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng1>> AND
range<meta::const_if_c<Const, Rng2>> AND
detail::iter_transform_2_readable< //
Fun const, //
meta::const_if_c<Const, Rng1>, //
meta::const_if_c<Const, Rng2>>)
end_cursor_t<Const> end_cursor() const
{
return {this, ranges::end};
}
template<typename Self>
static constexpr auto size_(Self & self)
{
using size_type = common_type_t<range_size_t<Rng1>, range_size_t<Rng2>>;
return ranges::min(static_cast<size_type>(ranges::size(self.rng1_)),
static_cast<size_type>(ranges::size(self.rng2_)));
}
template<bool B>
using R1 = meta::invoke<detail::dependent_<B>, Rng1>;
template<bool B>
using R2 = meta::invoke<detail::dependent_<B>, Rng2>;
public:
iter_transform2_view() = default;
constexpr iter_transform2_view(Rng1 rng1, Rng2 rng2, Fun fun)
: fun_(std::move(fun))
, rng1_(std::move(rng1))
, rng2_(std::move(rng2))
{}
CPP_member
static constexpr auto size() //
-> CPP_ret(std::size_t)(
requires (my_cardinality >= 0))
{
return static_cast<std::size_t>(my_cardinality);
}
template(bool True = true)(
requires (my_cardinality < 0) AND sized_range<Rng1 const> AND
sized_range<Rng2 const> AND
common_with<range_size_t<R1<True>>, range_size_t<R2<True>>>)
constexpr auto size() const
{
return size_(*this);
}
template(bool True = true)(
requires (my_cardinality < 0) AND sized_range<Rng1> AND sized_range<Rng2> AND
common_with<range_size_t<R1<True>>, range_size_t<R2<True>>>)
constexpr auto size()
{
return size_(*this);
}
};
template<typename Rng1, typename Rng2, typename Fun>
struct transform2_view : iter_transform2_view<Rng1, Rng2, indirected<Fun>>
{
transform2_view() = default;
constexpr transform2_view(Rng1 rng1, Rng2 rng2, Fun fun)
: iter_transform2_view<Rng1, Rng2, indirected<Fun>>{std::move(rng1),
std::move(rng2),
indirect(std::move(fun))}
{}
};
namespace views
{
struct iter_transform_base_fn
{
template(typename Rng, typename Fun)(
requires viewable_range<Rng> AND input_range<Rng> AND
copy_constructible<Fun> AND
detail::iter_transform_1_readable<Fun, Rng>)
constexpr iter_transform_view<all_t<Rng>, Fun> //
operator()(Rng && rng, Fun fun) const
{
return {all(static_cast<Rng &&>(rng)), std::move(fun)};
}
template(typename Rng1, typename Rng2, typename Fun)(
requires viewable_range<Rng1> AND input_range<Rng1> AND
viewable_range<Rng2> AND input_range<Rng2> AND
copy_constructible<Fun> AND
common_with<range_difference_t<Rng1>, range_difference_t<Rng1>> AND
detail::iter_transform_2_readable<Fun, Rng1, Rng2>)
constexpr iter_transform2_view<all_t<Rng1>, all_t<Rng2>, Fun> //
operator()(Rng1 && rng1, Rng2 && rng2, Fun fun) const
{
return {all(static_cast<Rng1 &&>(rng1)),
all(static_cast<Rng2 &&>(rng2)),
std::move(fun)};
}
};
struct iter_transform_fn : iter_transform_base_fn
{
using iter_transform_base_fn::operator();
template<typename Fun>
constexpr auto operator()(Fun fun) const
{
return make_view_closure(
bind_back(iter_transform_base_fn{}, std::move(fun)));
}
};
/// \relates iter_transform_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(iter_transform_fn, iter_transform)
// Don't forget to update views::for_each whenever this set
// of concepts changes
// clang-format off
/// \concept transformable_range_
/// \brief The \c transformable_range_ concept
template(typename Rng, typename Fun)(
concept (transformable_range_)(Rng, Fun),
regular_invocable<Fun &, range_reference_t<Rng>> AND
(!std::is_void<indirect_result_t<Fun &, iterator_t<Rng>>>::value)
);
/// \concept transformable_range
/// \brief The \c transformable_range concept
template<typename Rng, typename Fun>
CPP_concept transformable_range =
viewable_range<Rng> && input_range<Rng> &&
copy_constructible<Fun> &&
CPP_concept_ref(views::transformable_range_, Rng, Fun);
/// \concept transformable_ranges_
/// \brief The \c transformable_ranges_ concept
template(typename Rng1, typename Rng2, typename Fun)(
concept (transformable_ranges_)(Rng1, Rng2, Fun),
regular_invocable<Fun &, range_reference_t<Rng1>, range_reference_t<Rng2>> AND
(!std::is_void<
indirect_result_t<Fun &, iterator_t<Rng1>, iterator_t<Rng2>>>::value)
);
/// \concept transformable_ranges
/// \brief The \c transformable_ranges concept
template<typename Rng1, typename Rng2, typename Fun>
CPP_concept transformable_ranges =
viewable_range<Rng1> && input_range<Rng1> &&
viewable_range<Rng2> && input_range<Rng2> &&
copy_constructible<Fun> &&
CPP_concept_ref(views::transformable_ranges_, Rng1, Rng2, Fun);
// clang-format on
struct transform_base_fn
{
template(typename Rng, typename Fun)(
requires transformable_range<Rng, Fun>)
constexpr transform_view<all_t<Rng>, Fun> operator()(Rng && rng, Fun fun)
const
{
return {all(static_cast<Rng &&>(rng)), std::move(fun)};
}
template(typename Rng1, typename Rng2, typename Fun)(
requires transformable_ranges<Rng1, Rng2, Fun>)
constexpr transform2_view<all_t<Rng1>, all_t<Rng2>, Fun> //
operator()(Rng1 && rng1, Rng2 && rng2, Fun fun) const
{
return {all(static_cast<Rng1 &&>(rng1)),
all(static_cast<Rng2 &&>(rng2)),
std::move(fun)};
}
};
/// # ranges::views::transform
/// The transform view takes in a function `T -> U` and converts an input
/// range of `T` into an output range of `U` by calling the function on every
/// element of the input range.
///
/// ## Example
/// \snippet example/view/transform.cpp transform example
///
/// ### Output
/// \include example/view/transform_golden.txt
///
/// ## Syntax
/// ```cpp
/// auto output_range = input_range | ranges::views::transform(transform_func);
/// ```
///
/// ## Parameters
/// <pre><b>transform_func</b></pre>
/// - Maps an input value to an output value (`transform_func(T) -> U`)
///
/// <pre><b>input_range</b></pre>
/// - The range of elements to transform
/// - Reference type: `T`
///
/// <pre><b>output_range</b></pre>
/// - The range of output values
/// - Reference type: `U`
/// - Value type: `decay_t<U>`
/// - This range will have the same category as the input range (excluding
/// contiguous ranges). Contiguous ranges are reduced to random access ranges.
///
struct transform_fn : transform_base_fn
{
using transform_base_fn::operator();
template<typename Fun>
constexpr auto operator()(Fun fun) const
{
return make_view_closure(bind_back(transform_base_fn{}, std::move(fun)));
}
};
/// \relates transform_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(transform_fn, transform)
} // namespace views
namespace cpp20
{
namespace views
{
using ranges::views::transform;
}
template(typename Rng, typename F)(
requires input_range<Rng> AND copy_constructible<F> AND view_<Rng> AND
std::is_object<F>::value AND
regular_invocable<F &, iter_reference_t<iterator_t<Rng>>>)
using transform_view = ranges::transform_view<Rng, F>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::iter_transform_view)
RANGES_SATISFY_BOOST_RANGE(::ranges::transform_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/intersperse.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_INTERSPERSE_HPP
#define RANGES_V3_VIEW_INTERSPERSE_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng>
struct intersperse_view
: view_adaptor<intersperse_view<Rng>, Rng,
(range_cardinality<Rng>::value > 0)
? static_cast<cardinality>(range_cardinality<Rng>::value * 2 - 1)
: range_cardinality<Rng>::value>
{
intersperse_view() = default;
constexpr intersperse_view(Rng rng, range_value_t<Rng> val)
: intersperse_view::view_adaptor{detail::move(rng)}
, val_(detail::move(val))
{}
CPP_auto_member
constexpr auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
auto const n = ranges::size(this->base());
return n ? n * 2 - 1 : 0;
}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires sized_range<Rng>)
{
auto const n = ranges::size(this->base());
return n ? n * 2 - 1 : 0;
}
private:
friend range_access;
template<bool Const>
struct cursor_adaptor : adaptor_base
{
private:
friend struct cursor_adaptor<!Const>;
using CRng = meta::const_if_c<Const, Rng>;
bool toggle_ = false;
range_value_t<Rng> val_;
public:
cursor_adaptor() = default;
constexpr explicit cursor_adaptor(range_value_t<Rng> const & val)
: val_{val}
{}
template(bool Other)(
requires Const AND CPP_NOT(Other)) //
cursor_adaptor(cursor_adaptor<Other> that)
: toggle_(that.toggle_)
, val_(std::move(that.val_))
{}
template<typename View>
constexpr iterator_t<CRng> begin(View & view)
{
auto first = ranges::begin(view.base());
toggle_ = first != ranges::end(view.base());
return first;
}
constexpr range_value_t<Rng> read(iterator_t<CRng> const & it) const
{
return toggle_ ? *it : val_;
}
CPP_member
constexpr auto equal(iterator_t<CRng> const & it0,
iterator_t<CRng> const & it1,
cursor_adaptor const & other) const //
-> CPP_ret(bool)(
requires sentinel_for<iterator_t<CRng>, iterator_t<CRng>>)
{
return it0 == it1 && toggle_ == other.toggle_;
}
constexpr void next(iterator_t<CRng> & it)
{
if(toggle_)
++it;
toggle_ = !toggle_;
}
CPP_member
constexpr auto prev(iterator_t<CRng> & it) //
-> CPP_ret(void)(
requires bidirectional_range<CRng>)
{
toggle_ = !toggle_;
if(toggle_)
--it;
}
CPP_member
constexpr auto distance_to(iterator_t<CRng> const & it,
iterator_t<CRng> const & other_it,
cursor_adaptor const & other) const
-> CPP_ret(range_difference_t<Rng>)(
requires sized_sentinel_for<iterator_t<CRng>, iterator_t<CRng>>)
{
return (other_it - it) * 2 + (other.toggle_ - toggle_);
}
CPP_member
constexpr auto advance(iterator_t<CRng> & it, range_difference_t<CRng> n) //
-> CPP_ret(void)(
requires random_access_range<CRng>)
{
ranges::advance(it, n >= 0 ? (n + toggle_) / 2 : (n - !toggle_) / 2);
if(n % 2 != 0)
toggle_ = !toggle_;
}
};
template<bool Const>
struct sentinel_adaptor : adaptor_base
{
private:
using CRng = meta::const_if_c<Const, Rng>;
public:
sentinel_adaptor() = default;
template(bool Other)(
requires Const AND CPP_NOT(Other)) //
sentinel_adaptor(sentinel_adaptor<Other>)
{}
static constexpr bool empty(iterator_t<CRng> const & it,
cursor_adaptor<Const> const &,
sentinel_t<CRng> const & sent)
{
return it == sent;
}
};
constexpr cursor_adaptor<false> begin_adaptor()
{
return cursor_adaptor<false>{val_};
}
CPP_member
constexpr auto begin_adaptor() const //
-> CPP_ret(cursor_adaptor<true>)(
requires range<Rng const>)
{
return cursor_adaptor<true>{val_};
}
CPP_member
constexpr auto end_adaptor() //
-> CPP_ret(cursor_adaptor<false>)(
requires common_range<Rng> && (!single_pass_iterator_<iterator_t<Rng>>))
{
return cursor_adaptor<false>{val_};
}
CPP_member
constexpr auto end_adaptor() noexcept //
-> CPP_ret(sentinel_adaptor<false>)(
requires (!common_range<Rng>) || single_pass_iterator_<iterator_t<Rng>>)
{
return {};
}
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng>> AND
common_range<meta::const_if_c<Const, Rng>> AND
(!single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng>>>)) //
constexpr cursor_adaptor<Const> end_adaptor() const
{
return cursor_adaptor<true>{val_};
}
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng>> AND
(!common_range<meta::const_if_c<Const, Rng>> ||
single_pass_iterator_<iterator_t<meta::const_if_c<Const, Rng>>>)) //
constexpr sentinel_adaptor<Const> end_adaptor() const noexcept
{
return {};
}
range_value_t<Rng> val_;
};
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<intersperse_view<Rng>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
intersperse_view(Rng &&, range_value_t<Rng>)
-> intersperse_view<views::all_t<Rng>>;
#endif
namespace views
{
struct intersperse_base_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng> AND
convertible_to<range_reference_t<Rng>, range_value_t<Rng>> AND
semiregular<range_value_t<Rng>>)
constexpr intersperse_view<all_t<Rng>> //
operator()(Rng && rng, range_value_t<Rng> val) const
{
return {all(static_cast<Rng &&>(rng)), std::move(val)};
}
};
struct intersperse_fn : intersperse_base_fn
{
using intersperse_base_fn::operator();
template(typename T)(
requires copyable<T>)
constexpr auto operator()(T t) const
{
return make_view_closure(bind_back(intersperse_base_fn{}, std::move(t)));
}
};
/// \relates intersperse_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(intersperse_fn, intersperse)
} // namespace views
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::intersperse_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/tail.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_TAIL_HPP
#define RANGES_V3_VIEW_TAIL_HPP
#include <type_traits>
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
namespace detail
{
template<typename T>
constexpr T prev_or_zero_(T n)
{
return n == 0 ? T(0) : T(n - 1);
}
} // namespace detail
/// \addtogroup group-views
/// @{
template<typename Rng>
struct tail_view
: view_interface<tail_view<Rng>,
(range_cardinality<Rng>::value >= 0)
? detail::prev_or_zero_(range_cardinality<Rng>::value)
: range_cardinality<Rng>::value>
{
private:
Rng rng_;
public:
tail_view() = default;
tail_view(Rng rng)
: rng_(static_cast<Rng &&>(rng))
{
CPP_assert(input_range<Rng>);
}
iterator_t<Rng> begin()
{
return next(ranges::begin(rng_), 1, ranges::end(rng_));
}
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng>>)
iterator_t<meta::const_if_c<Const, Rng>> begin() const
{
return next(ranges::begin(rng_), 1, ranges::end(rng_));
}
sentinel_t<Rng> end()
{
return ranges::end(rng_);
}
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng>>)
sentinel_t<meta::const_if_c<Const, Rng>> end() const
{
return ranges::end(rng_);
}
// Strange cast to bool in the requires clause is to work around gcc bug.
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires(bool(sized_range<Rng>)))
{
using size_type = range_size_t<Rng>;
return range_cardinality<Rng>::value >= 0
? detail::prev_or_zero_((size_type)range_cardinality<Rng>::value)
: detail::prev_or_zero_(ranges::size(rng_));
}
CPP_auto_member
constexpr auto CPP_fun(size)()(const //
requires(bool(sized_range<Rng const>)))
{
using size_type = range_size_t<Rng>;
return range_cardinality<Rng>::value >= 0
? detail::prev_or_zero_((size_type)range_cardinality<Rng>::value)
: detail::prev_or_zero_(ranges::size(rng_));
}
Rng base() const
{
return rng_;
}
};
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<tail_view<Rng>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng)(
requires viewable_range<Rng>)
tail_view(Rng &&)
->tail_view<views::all_t<Rng>>;
#endif
namespace views
{
struct tail_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng>)
meta::if_c<range_cardinality<Rng>::value == 0,
all_t<Rng>,
tail_view<all_t<Rng>>> //
operator()(Rng && rng) const
{
return all(static_cast<Rng &&>(rng));
}
};
/// \relates tail_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<tail_fn>, tail)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::tail_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/iota.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_IOTA_HPP
#define RANGES_V3_VIEW_IOTA_HPP
#include <climits>
#include <cstdint>
#include <limits>
#include <type_traits>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/iterator/diffmax_t.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/delimit.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/detail/prologue.hpp>
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_UNSIGNED_MATH
RANGES_DIAGNOSTIC_IGNORE_TRUNCATION
namespace ranges
{
/// \cond
namespace detail
{
template<std::size_t N, typename = void>
struct promote_as_signed_
{
// This shouldn't cause us to LOSE precision, but maybe it doesn't
// net us any either.
static_assert(sizeof(std::intmax_t) * CHAR_BIT >= N,
"Possible extended integral type?");
using difference_type = diffmax_t;
};
template<std::size_t N>
struct promote_as_signed_<N, enable_if_t<(N < 16)>>
{
using difference_type = std::int_fast16_t;
};
template<std::size_t N>
struct promote_as_signed_<N, enable_if_t<(N >= 16 && N < 32)>>
{
using difference_type = std::int_fast32_t;
};
template<std::size_t N>
struct promote_as_signed_<N, enable_if_t<(N >= 32 && N < 64)>>
{
using difference_type = std::int_fast64_t;
};
template<typename I>
using iota_difference_t = typename meta::conditional_t<
std::is_integral<I>::value && sizeof(I) == sizeof(iter_difference_t<I>),
promote_as_signed_<sizeof(iter_difference_t<I>) * CHAR_BIT>,
with_difference_type_<iter_difference_t<I>>>::difference_type;
// clang-format off
/// \concept _decrementable_
/// \brief The \c _decrementable_ concept
template<typename I>
CPP_requires(_decrementable_,
requires(I i) //
(
--i,
i--,
concepts::requires_<same_as<I&, decltype(--i)>>,
concepts::requires_<same_as<I, decltype(i--)>>
));
/// \concept decrementable_
/// \brief The \c decrementable_ concept
template<typename I>
CPP_concept decrementable_ =
incrementable<I> &&
CPP_requires_ref(detail::_decrementable_, I);
/// \concept _advanceable_
/// \brief The \c _advanceable_ concept
template<typename I>
CPP_requires(_advanceable_,
requires(I i, I const j, iota_difference_t<I> const n) //
(
j - j,
i += n,
i -= n,
static_cast<I>(j - n),
static_cast<I>(j + n),
static_cast<I>(n + j),
// NOT TO SPEC:
// Unsigned integers are advanceable, but subtracting them results in
// an unsigned integral, which is not the same as the difference type,
// which is signed.
concepts::requires_<convertible_to<decltype(j - j), iota_difference_t<I>>>,
concepts::requires_<same_as<I&, decltype(i += n)>>,
concepts::requires_<same_as<I&, decltype(i -= n)>> //,
// concepts::requires_<convertible_to<decltype(i - n), I>>,
// concepts::requires_<convertible_to<decltype(i + n), I>>,
// concepts::requires_<convertible_to<decltype(n + i), I>>
));
/// \concept advanceable_
/// \brief The \c advanceable_ concept
template<typename I>
CPP_concept advanceable_ =
decrementable_<I> && totally_ordered<I> &&
CPP_requires_ref(detail::_advanceable_, I);
// clang-format on
template(typename I)(
requires (!unsigned_integral<I>)) //
void iota_advance_(I & i, iota_difference_t<I> n)
{
// TODO: bounds-check this
i += n;
}
template(typename Int)(
requires unsigned_integral<Int>)
void iota_advance_(Int & i, iota_difference_t<Int> n)
{
// TODO: bounds-check this
if(n >= 0)
i += static_cast<Int>(n);
else
i -= static_cast<Int>(-n);
}
template(typename I)(
requires advanceable_<I> AND (!integral<I>)) //
iota_difference_t<I> iota_distance_(I const & i, I const & s)
{
return static_cast<iota_difference_t<I>>(s - i);
}
template(typename Int)(
requires signed_integral<Int>)
iota_difference_t<Int> iota_distance_(Int i0, Int i1)
{
// TODO: bounds-check this
return static_cast<iota_difference_t<Int>>(
static_cast<iota_difference_t<Int>>(i1) -
static_cast<iota_difference_t<Int>>(i0));
}
template(typename Int)(
requires unsigned_integral<Int>)
iota_difference_t<Int> iota_distance_(Int i0, Int i1)
{
// TODO: bounds-check this
return (i0 > i1) ? static_cast<iota_difference_t<Int>>(
-static_cast<iota_difference_t<Int>>(i0 - i1))
: static_cast<iota_difference_t<Int>>(i1 - i0);
}
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
/// An iota view in a closed range
template<typename From, typename To /* = From */>
struct RANGES_EMPTY_BASES closed_iota_view
: view_facade<closed_iota_view<From, To>, finite>
{
private:
friend range_access;
From from_ = From();
RANGES_NO_UNIQUE_ADDRESS To to_ = To();
struct cursor
{
using difference_type = detail::iota_difference_t<From>;
private:
friend range_access;
From from_ = From();
RANGES_NO_UNIQUE_ADDRESS To to_ = To();
bool done_ = false;
From read() const
{
RANGES_EXPECT(!done_);
return from_;
}
void next()
{
RANGES_EXPECT(!done_);
if(from_ == to_)
done_ = true;
else
++from_;
}
bool equal(default_sentinel_t) const
{
return done_;
}
CPP_member
auto equal(cursor const & that) const //
-> CPP_ret(bool)(
requires equality_comparable<From>)
{
return that.from_ == from_ && that.done_ == done_;
}
CPP_member
auto prev() //
-> CPP_ret(void)(
requires detail::decrementable_<From>)
{
if(done_)
done_ = false;
else
--from_;
}
CPP_member
auto advance(difference_type n) //
-> CPP_ret(void)(
requires detail::advanceable_<From>)
{
if(n > 0)
{
RANGES_ENSURE(detail::iota_distance_(from_, to_) >= n - !done_);
detail::iota_advance_(
from_,
n - (done_ = (detail::iota_distance_(from_, to_) <= n - !done_)));
}
else if(n < 0)
detail::iota_advance_(from_, n + std::exchange(done_, false));
}
CPP_member
auto distance_to(cursor const & that) const //
-> CPP_ret(difference_type)(
requires detail::advanceable_<From>)
{
using D = difference_type;
return static_cast<D>(detail::iota_distance_(from_, that.from_)) +
((D)that.done_ - (D)done_);
}
CPP_member
auto distance_to(default_sentinel_t) const //
-> CPP_ret(difference_type)(
requires sized_sentinel_for<To, From>)
{
return difference_type(to_ - from_) + !done_;
}
public:
cursor() = default;
constexpr cursor(From from, To to, bool done = false)
: from_(std::move(from))
, to_(std::move(to))
, done_(done)
{}
};
cursor begin_cursor() const
{
return {from_, to_};
}
CPP_member
auto end_cursor() const //
-> CPP_ret(cursor)(
requires same_as<From, To>)
{
return {to_, to_, true};
}
CPP_member
auto end_cursor() const //
-> CPP_ret(default_sentinel_t)(
requires (!same_as<From, To>))
{
return {};
}
constexpr void check_bounds_(std::true_type)
{
RANGES_EXPECT(from_ <= to_);
}
constexpr void check_bounds_(std::false_type)
{}
public:
closed_iota_view() = default;
constexpr closed_iota_view(meta::id_t<From> from, meta::id_t<To> to)
: from_(std::move(from))
, to_(std::move(to))
{
check_bounds_(meta::bool_<totally_ordered_with<From, To>>{});
}
};
template<typename From, typename To>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<closed_iota_view<From, To>> =
true;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename From, typename To)(
requires weakly_incrementable<From> AND copyable<To> AND
(!integral<From> || !integral<To> ||
std::is_signed<From>::value == std::is_signed<To>::value)) //
closed_iota_view(From, To)
->closed_iota_view<From, To>;
#endif
template<typename From, typename To /* = unreachable_sentinel_t*/>
struct RANGES_EMPTY_BASES iota_view
: view_facade<iota_view<From, To>,
same_as<To, unreachable_sentinel_t>
? infinite
: std::is_integral<From>::value && std::is_integral<To>::value
? finite
: unknown>
{
private:
friend range_access;
From from_ = From();
RANGES_NO_UNIQUE_ADDRESS To to_ = To();
struct cursor;
struct sentinel
{
private:
friend struct cursor;
RANGES_NO_UNIQUE_ADDRESS To to_;
public:
sentinel() = default;
constexpr explicit sentinel(To to)
: to_(std::move(to))
{}
};
struct cursor
{
using difference_type = detail::iota_difference_t<From>;
private:
friend range_access;
From from_;
From read() const
{
return from_;
}
void next()
{
++from_;
}
bool equal(sentinel const & that) const
{
return from_ == that.to_;
}
CPP_member
auto equal(cursor const & that) const //
-> CPP_ret(bool)(
requires equality_comparable<From>)
{
return that.from_ == from_;
}
CPP_member
auto prev() //
-> CPP_ret(void)(
requires detail::decrementable_<From>)
{
--from_;
}
CPP_member
auto advance(difference_type n) //
-> CPP_ret(void)(
requires detail::advanceable_<From>)
{
detail::iota_advance_(from_, n);
}
// Not to spec: TODO the relational operators will effectively be constrained
// with Advanceable, but they should be constrained with totally_ordered.
// Reimplement iota_view without view_facade or basic_iterator.
CPP_member
auto distance_to(cursor const & that) const //
-> CPP_ret(difference_type)(
requires detail::advanceable_<From>)
{
return detail::iota_distance_(from_, that.from_);
}
// Extension: see https://github.com/ericniebler/stl2/issues/613
CPP_member
auto distance_to(sentinel const & that) const //
-> CPP_ret(difference_type)(
requires sized_sentinel_for<To, From>)
{
return that.to_ - from_;
}
public:
cursor() = default;
constexpr explicit cursor(From from)
: from_(std::move(from))
{}
};
cursor begin_cursor() const
{
return cursor{from_};
}
CPP_auto_member
auto CPP_fun(end_cursor)()(const //
requires(same_as<To, unreachable_sentinel_t>))
{
return unreachable;
}
CPP_auto_member
auto CPP_fun(end_cursor)()(const //
requires(!same_as<To, unreachable_sentinel_t>))
{
return meta::conditional_t<same_as<From, To>, cursor, sentinel>{to_};
}
constexpr void check_bounds_(std::true_type)
{
RANGES_EXPECT(from_ <= to_);
}
constexpr void check_bounds_(std::false_type)
{}
public:
#ifdef RANGES_WORKAROUND_MSVC_934264
constexpr
#endif // RANGES_WORKAROUND_MSVC_934264
iota_view() = default;
constexpr explicit iota_view(From from)
: from_(std::move(from))
{}
constexpr iota_view(meta::id_t<From> from, meta::id_t<To> to)
: from_(std::move(from))
, to_(std::move(to))
{
check_bounds_(meta::bool_<totally_ordered_with<From, To>>{});
}
};
template<typename From, typename To>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<iota_view<From, To>> = true;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename From, typename To)(
requires weakly_incrementable<From> AND copyable<To> AND
(!integral<From> || !integral<To> ||
std::is_signed<From>::value == std::is_signed<To>::value)) //
iota_view(From, To)
->iota_view<From, To>;
#endif
namespace views
{
struct iota_fn
{
template(typename From)(
requires weakly_incrementable<From>)
iota_view<From> operator()(From value) const
{
return iota_view<From>{std::move(value)};
}
template(typename From, typename To)(
requires weakly_incrementable<From> AND copyable<To> AND
detail::weakly_equality_comparable_with_<From, To> AND
(!integral<From> || !integral<To> ||
std::is_signed<From>::value == std::is_signed<To>::value)) //
iota_view<From, To> operator()(From from, To to) const
{
return {std::move(from), std::move(to)};
}
};
struct closed_iota_fn
{
template(typename From, typename To)(
requires weakly_incrementable<From> AND copyable<To> AND
detail::weakly_equality_comparable_with_<From, To> AND
(!integral<From> || !integral<To> ||
std::is_signed<From>::value == std::is_signed<To>::value)) //
closed_iota_view<From, To> operator()(From from, To to) const
{
return {std::move(from), std::move(to)};
}
};
/// \relates iota_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(iota_fn, iota)
/// \relates closed_iota_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(closed_iota_fn, closed_iota)
/// # ranges::views::ints
/// The ints view returns a range of monotonically increasing ints.
///
/// ## Example
/// \snippet example/view/ints.cpp ints example
///
/// ### Output
/// \include example/view/ints_golden.txt
///
/// ## Syntax
/// ```cpp
/// auto output_range = ranges::views::ints(lower_bound, upper_bound);
/// ```
///
/// ## Parameters
/// <pre><b>lower_bound</b></pre>
/// - Optional lower bound
///
/// <pre><b>upper_bound</b></pre>
/// - Exclusive upper bound
/// - Required when `lower_bound` is specified
/// - To create an infinite range with a `lower_bound`, use
/// `ranges::unreachable` as the `upper_bound`
///
/// <pre><b>output_range</b></pre>
/// - Range of monotonically increasing ints
/// - When an `upper_bound` is not specified, the range is quasi-infinite
///
struct ints_fn : iota_view<int>
{
ints_fn() = default;
template(typename Val)(
requires integral<Val>)
RANGES_DEPRECATED(
"This potentially confusing API is deprecated. Prefer to "
"explicitly specify the upper bound as with ranges::unreachable, as in "
"views::ints( n, unreachable )")
constexpr iota_view<Val> operator()(Val value) const //
{
return iota_view<Val>{value};
}
template(typename Val)(
requires integral<Val>)
constexpr iota_view<Val> operator()(Val value, unreachable_sentinel_t) const
{
return iota_view<Val>{value};
}
template(typename Val)(
requires integral<Val>)
constexpr iota_view<Val, Val> operator()(Val from, Val to) const
{
return {from, to};
}
};
/// \relates ints_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(ints_fn, ints)
} // namespace views
namespace cpp20
{
namespace views
{
using ranges::views::iota;
}
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::closed_iota_view)
RANGES_SATISFY_BOOST_RANGE(::ranges::iota_view)
RANGES_DIAGNOSTIC_POP
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/generate.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_GENERATE_HPP
#define RANGES_V3_VIEW_GENERATE_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/unreachable_sentinel.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename G>
struct generate_view : view_facade<generate_view<G>, infinite>
{
private:
friend range_access;
using result_t = invoke_result_t<G &>;
semiregular_box_t<G> gen_;
detail::non_propagating_cache<result_t> val_;
struct cursor
{
private:
generate_view * view_;
public:
cursor() = default;
explicit cursor(generate_view * view)
: view_(view)
{}
result_t && read() const
{
if(!view_->val_)
view_->val_.emplace(view_->gen_());
return static_cast<result_t &&>(static_cast<result_t &>(*view_->val_));
}
void next()
{
if(view_->val_)
view_->val_.reset();
else
static_cast<void>(view_->gen_());
}
};
cursor begin_cursor()
{
return cursor{this};
}
unreachable_sentinel_t end_cursor() const
{
return {};
}
public:
generate_view() = default;
explicit generate_view(G g)
: gen_(std::move(g))
{}
result_t & cached()
{
return *val_;
}
};
namespace views
{
struct generate_fn
{
template(typename G)(
requires invocable<G &> AND copy_constructible<G> AND
std::is_object<detail::decay_t<invoke_result_t<G &>>>::value AND
constructible_from<detail::decay_t<invoke_result_t<G &>>,
invoke_result_t<G &>> AND
assignable_from<detail::decay_t<invoke_result_t<G &>> &,
invoke_result_t<G &>>)
generate_view<G> operator()(G g) const
{
return generate_view<G>{std::move(g)};
}
};
/// \relates generate_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(generate_fn, generate)
} // namespace views
/// \@}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::generate_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/group_by.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_GROUP_BY_HPP
#define RANGES_V3_VIEW_GROUP_BY_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/algorithm/find_if_not.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/subrange.hpp>
#include <range/v3/view/take_while.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/config.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
// TODO group_by could support Input ranges by keeping mutable state in
// the range itself. The group_by view would then be mutable-only and
// Input.
/// \addtogroup group-views
/// @{
template<typename Rng, typename Fun>
struct group_by_view
: view_facade<group_by_view<Rng, Fun>,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
{
private:
friend range_access;
Rng rng_;
// cached version of the end of the first subrange / start of the second subrange
detail::non_propagating_cache<iterator_t<Rng>> second_;
semiregular_box_t<Fun> fun_;
struct pred
{
iterator_t<Rng> first_;
semiregular_box_ref_or_val_t<Fun, false> fun_;
bool operator()(range_reference_t<Rng> r) const
{
return invoke(fun_, *first_, r);
}
};
struct cursor
{
private:
friend range_access;
friend group_by_view;
iterator_t<Rng> cur_;
iterator_t<Rng> next_cur_;
sentinel_t<Rng> last_;
semiregular_box_ref_or_val_t<Fun, false> fun_;
struct mixin : basic_mixin<cursor>
{
mixin() = default;
#ifndef _MSC_VER
using basic_mixin<cursor>::basic_mixin;
#else
constexpr explicit mixin(cursor && cur)
: basic_mixin<cursor>(static_cast<cursor &&>(cur))
{}
constexpr explicit mixin(cursor const & cur)
: basic_mixin<cursor>(cur)
{}
#endif
iterator_t<Rng> base() const
{
return this->get().cur_;
}
};
#ifdef _MSC_VER
template<typename I = iterator_t<Rng>>
subrange<I> read() const
{
return {cur_, next_cur_};
}
#else
subrange<iterator_t<Rng>> read() const
{
return {cur_, next_cur_};
}
#endif
void next()
{
cur_ = next_cur_;
next_cur_ = cur_ != last_
? find_if_not(ranges::next(cur_), last_, pred{cur_, fun_})
: cur_;
}
bool equal(default_sentinel_t) const
{
return cur_ == last_;
}
bool equal(cursor const & that) const
{
return cur_ == that.cur_;
}
cursor(semiregular_box_ref_or_val_t<Fun, false> fun, iterator_t<Rng> first,
iterator_t<Rng> next_cur, sentinel_t<Rng> last)
: cur_(first)
, next_cur_(next_cur)
, last_(last)
, fun_(fun)
{}
public:
cursor() = default;
};
cursor begin_cursor()
{
auto b = ranges::begin(rng_);
auto e = ranges::end(rng_);
if(!second_)
{
second_ = b != e ? find_if_not(ranges::next(b), e, pred{b, fun_}) : b;
}
return {fun_, b, *second_, e};
}
public:
group_by_view() = default;
constexpr group_by_view(Rng rng, Fun fun)
: rng_(std::move(rng))
, fun_(std::move(fun))
{}
Rng base() const
{
return rng_;
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Fun)(
requires copy_constructible<Fun>)
group_by_view(Rng &&, Fun)
->group_by_view<views::all_t<Rng>, Fun>;
#endif
namespace views
{
struct group_by_base_fn
{
template(typename Rng, typename Fun)(
requires viewable_range<Rng> AND forward_range<Rng> AND
indirect_relation<Fun, iterator_t<Rng>>)
RANGES_DEPRECATED(
"views::group_by is deprecated. Please use views::chunk_by instead. "
"Note that views::chunk_by evaluates the predicate between adjacent "
"elements.")
constexpr group_by_view<all_t<Rng>, Fun> operator()(Rng && rng, Fun fun) const
{
return {all(static_cast<Rng &&>(rng)), std::move(fun)};
}
};
struct group_by_fn : group_by_base_fn
{
using group_by_base_fn::operator();
template<typename Fun>
RANGES_DEPRECATED(
"views::group_by is deprecated. Please use views::chunk_by instead. "
"Note that views::chunk_by evaluates the predicate between adjacent "
"elements.")
constexpr auto operator()(Fun fun) const
{
return make_view_closure(bind_back(group_by_base_fn{}, std::move(fun)));
}
};
/// \relates group_by_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(group_by_fn, group_by)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::group_by_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/repeat.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_REPEAT_HPP
#define RANGES_V3_VIEW_REPEAT_HPP
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/unreachable_sentinel.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
// Ordinarily, a view shouldn't contain its elements. This is so that copying
// and assigning ranges is O(1), and also so that in the event of element
// mutation, all the copies of the range see the mutation the same way. The
// repeat_view *does* own its lone element, though. This is OK because:
// - O(N) copying is fine when N==1 as it is in this case, and
// - The element is immutable, so there is no potential for incorrect
// semantics.
template<typename Val>
struct repeat_view : view_facade<repeat_view<Val>, infinite>
{
private:
semiregular_box_t<Val> value_;
friend range_access;
struct cursor
{
private:
Val const * value_;
std::ptrdiff_t n_ = 0;
public:
cursor() = default;
explicit cursor(Val const & value)
: value_(std::addressof(value))
{}
Val const & read() const noexcept
{
return *value_;
}
bool equal(cursor const & that) const
{
return n_ == that.n_;
}
void next()
{
++n_;
}
void prev()
{
--n_;
}
void advance(std::ptrdiff_t d)
{
n_ += d;
}
std::ptrdiff_t distance_to(cursor const & that) const
{
return that.n_ - n_;
}
};
cursor begin_cursor() const
{
return cursor{value_};
}
unreachable_sentinel_t end_cursor() const
{
return unreachable;
}
public:
repeat_view() = default;
constexpr explicit repeat_view(Val value)
: value_(detail::move(value))
{}
};
namespace views
{
struct repeat_fn
{
template(typename Val)(
requires copy_constructible<Val>)
repeat_view<Val> operator()(Val value) const
{
return repeat_view<Val>{std::move(value)};
}
};
/// \relates repeat_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(repeat_fn, repeat)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::repeat_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/take_last.hpp | /// \file
// Range v3 library
//
// Copyright Barry Revzin 2019-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_TAKE_LAST_HPP
#define RANGES_V3_VIEW_TAKE_LAST_HPP
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/operations.hpp>
#include <range/v3/view/drop_exactly.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
namespace views
{
struct take_last_base_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND sized_range<Rng>)
auto operator()(Rng && rng, range_difference_t<Rng> n) const
{
auto sz = ranges::distance(rng);
return drop_exactly(static_cast<Rng &&>(rng), sz > n ? sz - n : 0);
}
};
struct take_last_fn : take_last_base_fn
{
using take_last_base_fn::operator();
template(typename Int)(
requires detail::integer_like_<Int>)
constexpr auto operator()(Int n) const
{
return make_view_closure(bind_back(take_last_base_fn{}, n));
}
};
/// \relates take_last_fn
RANGES_INLINE_VARIABLE(take_last_fn, take_last)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/join.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_JOIN_HPP
#define RANGES_V3_VIEW_JOIN_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/range_for.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/utility/variant.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/single.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
// Compute the cardinality of a joined range
constexpr cardinality join_cardinality_(
cardinality Outer, cardinality Inner,
cardinality Joiner = static_cast<cardinality>(0)) noexcept
{
return Outer == infinite || Inner == infinite ||
(Joiner == infinite && Outer != 0 && Outer != 1)
? infinite
: Outer == unknown || Inner == unknown ||
(Joiner == unknown && Outer != 0 && Outer != 1)
? unknown
: Outer == finite || Inner == finite ||
(Joiner == finite && Outer != 0 && Outer != 1)
? finite
: static_cast<cardinality>(
Outer * Inner +
(Outer == 0 ? 0 : (Outer - 1) * Joiner));
}
template<typename Range>
constexpr cardinality join_cardinality() noexcept
{
return detail::join_cardinality_(
range_cardinality<Range>::value,
range_cardinality<range_reference_t<Range>>::value);
}
template<typename Range, typename JoinRange>
constexpr cardinality join_cardinality() noexcept
{
return detail::join_cardinality_(
range_cardinality<Range>::value,
range_cardinality<range_reference_t<Range>>::value,
range_cardinality<JoinRange>::value);
}
template<typename Inner>
struct store_inner_
{
non_propagating_cache<std::remove_cv_t<Inner>> inner_ = {};
template<typename OuterIt>
constexpr auto && update_inner_(OuterIt && it)
{
return inner_.emplace_deref(it);
}
constexpr Inner & get_inner_(ignore_t) noexcept
{
return *inner_;
}
};
struct pass_thru_inner_
{
// Intentionally promote xvalues to lvalues here:
template<typename OuterIt>
static constexpr auto && update_inner_(OuterIt && it) noexcept(noexcept(*it))
{
return *it;
}
template<typename OuterIt>
static constexpr decltype(auto) get_inner_(OuterIt && outer_it)
{
return *outer_it;
}
};
template<typename Rng>
using join_view_inner =
meta::conditional_t<!std::is_reference<range_reference_t<Rng>>::value,
store_inner_<range_reference_t<Rng>>, pass_thru_inner_>;
// clang-format off
/// \concept has_member_arrow_
/// \brief The \c has_member_arrow_ concept
template<typename I>
CPP_requires(has_member_arrow_,
requires(I i) //
(
i.operator->()
));
/// \concept has_arrow_
/// \brief The \c has_arrow_ concept
template<typename I>
CPP_concept has_arrow_ =
input_iterator<I> &&
(std::is_pointer<I>::value || CPP_requires_ref(detail::has_member_arrow_, I));
// clang-format on
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
// Join a range of ranges
template<typename Rng>
struct RANGES_EMPTY_BASES join_view
: view_facade<join_view<Rng>, detail::join_cardinality<Rng>()>
, private detail::join_view_inner<Rng>
{
CPP_assert(input_range<Rng> && view_<Rng>);
CPP_assert(input_range<range_reference_t<Rng>>);
CPP_member
constexpr CPP_ctor(join_view)()( //
noexcept(std::is_nothrow_default_constructible<Rng>::value) //
requires default_constructible<Rng>)
{}
explicit join_view(Rng rng)
: outer_(views::all(std::move(rng)))
{}
// Not to spec
CPP_member
static constexpr auto size() //
-> CPP_ret(std::size_t)(
requires (detail::join_cardinality<Rng>() >= 0))
{
return static_cast<std::size_t>(detail::join_cardinality<Rng>());
}
// Not to spec
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires(detail::join_cardinality<Rng>() < 0) &&
(range_cardinality<Rng>::value >= 0) &&
forward_range<Rng> &&
sized_range<range_reference_t<Rng>>)
{
range_size_t<range_reference_t<Rng>> n = 0;
RANGES_FOR(auto && inner, outer_)
n += ranges::size(inner);
return n;
}
// // ericniebler/stl2#605
constexpr Rng base() const
{
return outer_;
}
private:
friend range_access;
Rng outer_{};
template<bool Const>
struct cursor
{
private:
using Parent = meta::conditional_t<Const, join_view const, join_view>;
using COuter = meta::conditional_t<Const, Rng const, Rng>;
using CInner = range_reference_t<COuter>;
using ref_is_glvalue = std::is_reference<CInner>;
Parent * rng_ = nullptr;
iterator_t<COuter> outer_it_{};
iterator_t<CInner> inner_it_{};
void satisfy()
{
for(; outer_it_ != ranges::end(rng_->outer_); ++outer_it_)
{
auto && inner = rng_->update_inner_(outer_it_);
inner_it_ = ranges::begin(inner);
if(inner_it_ != ranges::end(inner))
return;
}
if(RANGES_CONSTEXPR_IF(ref_is_glvalue::value))
inner_it_ = iterator_t<CInner>();
}
public:
using single_pass = meta::bool_<single_pass_iterator_<iterator_t<COuter>> ||
single_pass_iterator_<iterator_t<CInner>> ||
!ref_is_glvalue::value>;
cursor() = default;
template<typename BeginOrEnd>
constexpr cursor(Parent * rng, BeginOrEnd begin_or_end)
: rng_{rng}
, outer_it_(begin_or_end(rng->outer_))
{
satisfy();
}
template(bool Other)(
requires Const AND CPP_NOT(Other) AND
convertible_to<iterator_t<Rng>, iterator_t<COuter>> AND
convertible_to<iterator_t<range_reference_t<Rng>>,
iterator_t<CInner>>)
constexpr cursor(cursor<Other> that)
: rng_(that.rng_)
, outer_it_(std::move(that.outer_it_))
, inner_it_(std::move(that.inner_it_))
{}
CPP_member
constexpr auto arrow() //
-> CPP_ret(iterator_t<CInner>)(
requires detail::has_arrow_<iterator_t<CInner>>)
{
return inner_it_;
}
constexpr bool equal(default_sentinel_t) const
{
return outer_it_ == ranges::end(rng_->outer_);
}
CPP_member
constexpr auto equal(cursor const & that) const //
-> CPP_ret(bool)(
requires ref_is_glvalue::value && //
equality_comparable<iterator_t<COuter>> && //
equality_comparable<iterator_t<CInner>>)
{
return outer_it_ == that.outer_it_ && inner_it_ == that.inner_it_;
}
constexpr void next()
{
auto && inner_rng = rng_->get_inner_(outer_it_);
if(++inner_it_ == ranges::end(inner_rng))
{
++outer_it_;
satisfy();
}
}
CPP_member
constexpr auto prev() //
-> CPP_ret(void)(
requires ref_is_glvalue::value && //
bidirectional_range<COuter> && //
bidirectional_range<CInner> && //
common_range<CInner>) // ericniebler/stl2#606
{
if(outer_it_ == ranges::end(rng_->outer_))
inner_it_ = ranges::end(*--outer_it_);
while(inner_it_ == ranges::begin(*outer_it_))
inner_it_ = ranges::end(*--outer_it_);
--inner_it_;
}
// clang-format off
constexpr auto CPP_auto_fun(read)()(const)
(
return *inner_it_
)
constexpr auto CPP_auto_fun(move)()(const)
(
return iter_move(inner_it_)
)
// clang-format on
};
static constexpr bool use_const_always() noexcept
{
return simple_view<Rng>() && std::is_reference<range_reference_t<Rng>>::value;
}
struct end_cursor_fn
{
constexpr auto operator()(join_view * this_, std::true_type) const
{
return cursor<use_const_always()>{this_, ranges::end};
}
constexpr auto operator()(join_view *, std::false_type) const
{
return default_sentinel_t{};
}
};
struct cend_cursor_fn
{
constexpr auto operator()(join_view const * this_, std::true_type) const
{
return cursor<true>{this_, ranges::end};
}
constexpr auto operator()(join_view const *, std::false_type) const
{
return default_sentinel_t{};
}
};
constexpr cursor<use_const_always()> begin_cursor()
{
return {this, ranges::begin};
}
template(bool Const = true)(
requires Const AND input_range<meta::const_if_c<Const, Rng>> AND
std::is_reference<range_reference_t<meta::const_if_c<Const, Rng>>>::value)
constexpr cursor<Const> begin_cursor() const
{
return {this, ranges::begin};
}
constexpr auto end_cursor()
{
using cond =
meta::bool_<std::is_reference<range_reference_t<Rng>>::value &&
forward_range<Rng> && forward_range<range_reference_t<Rng>> &&
common_range<Rng> && common_range<range_reference_t<Rng>>>;
return end_cursor_fn{}(this, cond{});
}
template(bool Const = true)(
requires Const AND input_range<meta::const_if_c<Const, Rng>> AND
std::is_reference<range_reference_t<meta::const_if_c<Const, Rng>>>::value)
constexpr auto end_cursor() const
{
using CRng = meta::const_if_c<Const, Rng>;
using cond =
meta::bool_<std::is_reference<range_reference_t<CRng>>::value &&
forward_range<CRng> &&
forward_range<range_reference_t<CRng>> &&
common_range<CRng> && common_range<range_reference_t<CRng>>>;
return cend_cursor_fn{}(this, cond{});
}
};
// Join a range of ranges, inserting a range of values between them.
// TODO: Support const iteration when range_reference_t<Rng> is a true reference.
template<typename Rng, typename ValRng>
struct join_with_view
: view_facade<join_with_view<Rng, ValRng>, detail::join_cardinality<Rng, ValRng>()>
, private detail::join_view_inner<Rng>
{
CPP_assert(input_range<Rng>);
CPP_assert(input_range<range_reference_t<Rng>>);
CPP_assert(forward_range<ValRng>);
CPP_assert(
common_with<range_value_t<range_reference_t<Rng>>, range_value_t<ValRng>>);
CPP_assert(semiregular<common_type_t<range_value_t<range_reference_t<Rng>>,
range_value_t<ValRng>>>);
join_with_view() = default;
join_with_view(Rng rng, ValRng val)
: outer_(views::all(std::move(rng)))
, val_(views::all(std::move(val)))
{}
CPP_member
static constexpr auto size() //
-> CPP_ret(std::size_t)(
requires (detail::join_cardinality<Rng, ValRng>() >= 0))
{
return static_cast<std::size_t>(detail::join_cardinality<Rng, ValRng>());
}
CPP_auto_member
auto CPP_fun(size)()(const //
requires(detail::join_cardinality<Rng, ValRng>() < 0) &&
(range_cardinality<Rng>::value >= 0) && forward_range<Rng> &&
sized_range<range_reference_t<Rng>> && sized_range<ValRng>)
{
range_size_t<range_reference_t<Rng>> n = 0;
RANGES_FOR(auto && inner, outer_)
n += ranges::size(inner);
return n + (range_cardinality<Rng>::value == 0
? 0
: ranges::size(val_) * (range_cardinality<Rng>::value - 1));
}
private:
friend range_access;
using Outer = views::all_t<Rng>;
// Intentionally promote xvalues to lvalues here:
using Inner = views::all_t<range_reference_t<Outer> &>;
Outer outer_{};
views::all_t<ValRng> val_{};
class cursor
{
join_with_view * rng_ = nullptr;
iterator_t<Outer> outer_it_{};
variant<iterator_t<ValRng>, iterator_t<Inner>> cur_{};
void satisfy()
{
while(true)
{
if(cur_.index() == 0)
{
if(ranges::get<0>(cur_) != ranges::end(rng_->val_))
break;
// Intentionally promote xvalues to lvalues here:
auto && inner = rng_->update_inner_(outer_it_);
ranges::emplace<1>(cur_, ranges::begin(inner));
}
else
{
auto && inner = rng_->get_inner_(outer_it_);
if(ranges::get<1>(cur_) != ranges::end(inner))
break;
if(++outer_it_ == ranges::end(rng_->outer_))
break;
ranges::emplace<0>(cur_, ranges::begin(rng_->val_));
}
}
}
public:
using value_type = common_type_t<range_value_t<Inner>, range_value_t<ValRng>>;
using reference =
common_reference_t<range_reference_t<Inner>, range_reference_t<ValRng>>;
using rvalue_reference = common_reference_t<range_rvalue_reference_t<Inner>,
range_rvalue_reference_t<ValRng>>;
using single_pass = std::true_type;
cursor() = default;
cursor(join_with_view * rng)
: rng_{rng}
, outer_it_(ranges::begin(rng->outer_))
{
if(outer_it_ != ranges::end(rng->outer_))
{
auto && inner = rng_->update_inner_(outer_it_);
ranges::emplace<1>(cur_, ranges::begin(inner));
satisfy();
}
}
bool equal(default_sentinel_t) const
{
return outer_it_ == ranges::end(rng_->outer_);
}
void next()
{
// visit(cur_, [](auto& it){ ++it; });
if(cur_.index() == 0)
{
auto & it = ranges::get<0>(cur_);
RANGES_ASSERT(it != ranges::end(rng_->val_));
++it;
}
else
{
auto & it = ranges::get<1>(cur_);
#ifndef NDEBUG
auto && inner = rng_->get_inner_(outer_it_);
RANGES_ASSERT(it != ranges::end(inner));
#endif
++it;
}
satisfy();
}
reference read() const
{
// return visit(cur_, [](auto& it) -> reference { return *it; });
if(cur_.index() == 0)
return *ranges::get<0>(cur_);
else
return *ranges::get<1>(cur_);
}
rvalue_reference move() const
{
// return visit(cur_, [](auto& it) -> rvalue_reference { return
// iter_move(it); });
if(cur_.index() == 0)
return iter_move(ranges::get<0>(cur_));
else
return iter_move(ranges::get<1>(cur_));
}
};
cursor begin_cursor()
{
return {this};
}
};
namespace views
{
/// \cond
// Don't forget to update views::for_each whenever this set
// of concepts changes
// clang-format off
/// \concept joinable_range_
/// \brief The \c joinable_range_ concept
template(typename Rng)(
concept (joinable_range_)(Rng),
input_range<range_reference_t<Rng>>
);
/// \concept joinable_range
/// \brief The \c joinable_range concept
template<typename Rng>
CPP_concept joinable_range =
viewable_range<Rng> && input_range<Rng> &&
CPP_concept_ref(views::joinable_range_, Rng);
/// \concept joinable_with_range_
/// \brief The \c joinable_with_range_ concept
template(typename Rng, typename ValRng)(
concept (joinable_with_range_)(Rng, ValRng),
common_with<
range_value_t<ValRng>,
range_value_t<range_reference_t<Rng>>> AND
semiregular<
common_type_t<
range_value_t<ValRng>,
range_value_t<range_reference_t<Rng>>>> AND
common_reference_with<
range_reference_t<ValRng>,
range_reference_t<range_reference_t<Rng>>> AND
common_reference_with<
range_rvalue_reference_t<ValRng>,
range_rvalue_reference_t<range_reference_t<Rng>>>
);
/// \concept joinable_with_range
/// \brief The \c joinable_with_range concept
template<typename Rng, typename ValRng>
CPP_concept joinable_with_range =
joinable_range<Rng> &&
viewable_range<ValRng> && forward_range<ValRng> &&
CPP_concept_ref(views::joinable_with_range_, Rng, ValRng);
// clang-format on
/// \endcond
struct cpp20_join_fn
{
template(typename Rng)(
requires joinable_range<Rng>)
join_view<all_t<Rng>> operator()(Rng && rng) const
{
return join_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
}
};
struct join_base_fn : cpp20_join_fn
{
private:
template<typename Rng>
using inner_value_t = range_value_t<range_reference_t<Rng>>;
public:
using cpp20_join_fn::operator();
template(typename Rng)(
requires joinable_with_range<Rng, single_view<inner_value_t<Rng>>>)
join_with_view<all_t<Rng>, single_view<inner_value_t<Rng>>> //
operator()(Rng && rng, inner_value_t<Rng> v) const
{
return {all(static_cast<Rng &&>(rng)), single(std::move(v))};
}
template(typename Rng, typename ValRng)(
requires joinable_with_range<Rng, ValRng>)
join_with_view<all_t<Rng>, all_t<ValRng>> //
operator()(Rng && rng, ValRng && val) const
{
return {all(static_cast<Rng &&>(rng)), all(static_cast<ValRng &&>(val))};
}
/// \cond
template<typename Rng, typename T>
invoke_result_t<join_base_fn, Rng, T &> //
operator()(Rng && rng, detail::reference_wrapper_<T> r) const
{
return (*this)(static_cast<Rng &&>(rng), r.get());
}
/// \endcond
};
struct join_bind_fn
{
template(typename T)(
requires (!joinable_range<T>)) // TODO: underconstrained
constexpr auto operator()(T && t)const
{
return make_view_closure(bind_back(join_base_fn{}, static_cast<T &&>(t)));
}
template(typename T)(
requires (!joinable_range<T &>) AND range<T &>)
constexpr auto operator()(T & t) const
{
return make_view_closure(bind_back(join_base_fn{},
detail::reference_wrapper_<T>(t)));
}
};
struct RANGES_EMPTY_BASES join_fn
: join_base_fn, join_bind_fn
{
using join_base_fn::operator();
using join_bind_fn::operator();
};
/// \relates join_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<join_fn>, join)
} // namespace views
/// @}
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng)(
requires views::joinable_range<Rng>)
explicit join_view(Rng &&)
->join_view<views::all_t<Rng>>;
template(typename Rng, typename ValRng)(
requires views::joinable_with_range<Rng, ValRng>)
explicit join_with_view(Rng &&, ValRng &&)
->join_with_view<views::all_t<Rng>, views::all_t<ValRng>>;
#endif
namespace cpp20
{
namespace views
{
RANGES_INLINE_VARIABLE(
ranges::views::view_closure<ranges::views::cpp20_join_fn>, join)
}
template(typename Rng)(
requires input_range<Rng> AND view_<Rng> AND
input_range<iter_reference_t<iterator_t<Rng>>>) //
using join_view = ranges::join_view<Rng>;
} // namespace cpp20
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::join_view)
RANGES_SATISFY_BOOST_RANGE(::ranges::join_with_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/addressof.hpp | /// \file
// Range v3 library
//
// Copyright Andrey Diduh 2019
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_ADDRESSOF_HPP
#define RANGES_V3_VIEW_ADDRESSOF_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/utility/addressof.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
namespace views
{
struct addressof_fn
{
private:
struct take_address
{
template<typename V>
constexpr V * operator()(V & value) const noexcept
{
return detail::addressof(value);
}
};
public:
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng> AND
std::is_lvalue_reference<range_reference_t<Rng>>::value) //
constexpr auto CPP_auto_fun(operator())(Rng && rng)(const) //
(
return transform(all(static_cast<Rng &&>(rng)), take_address{}) //
)
};
/// \relates addressof_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<addressof_fn>, addressof)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_VIEW_ADDRESSOF_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/ref.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_REF_HPP
#define RANGES_V3_VIEW_REF_HPP
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/addressof.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
template<typename Rng>
struct ref_view;
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<ref_view<Rng>> = true;
/// \addtogroup group-views
/// @{
template<typename Rng>
struct ref_view : view_interface<ref_view<Rng>, range_cardinality<Rng>::value>
{
private:
CPP_assert(range<Rng>);
static_assert(std::is_object<Rng>::value, "");
Rng * rng_ = nullptr; // exposition only
public:
constexpr ref_view() noexcept = default;
constexpr ref_view(Rng & rng) noexcept
: rng_(detail::addressof(rng))
{}
constexpr Rng & base() const noexcept
{
return *rng_;
}
constexpr iterator_t<Rng> begin() const noexcept(noexcept(ranges::begin(*rng_)))
{
return ranges::begin(*rng_);
}
constexpr sentinel_t<Rng> end() const noexcept(noexcept(ranges::end(*rng_)))
{
return ranges::end(*rng_);
}
CPP_member
constexpr auto empty() const noexcept(noexcept(ranges::empty(*rng_)))
-> CPP_ret(bool)(
requires detail::can_empty_<Rng>)
{
return ranges::empty(*rng_);
}
CPP_auto_member
constexpr auto CPP_fun(size)()(const //
noexcept(noexcept(ranges::size(*rng_))) //
requires sized_range<Rng>)
{
return ranges::size(*rng_);
}
CPP_auto_member
constexpr auto CPP_fun(data)()(const //
noexcept(noexcept(ranges::data(*rng_))) //
requires contiguous_range<Rng>)
{
return ranges::data(*rng_);
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename R)(
requires range<R>)
ref_view(R &) //
-> ref_view<R>;
#endif
namespace views
{
struct ref_fn
{
template(typename Rng)(
requires range<Rng>)
constexpr ref_view<Rng> operator()(Rng & rng) const noexcept
{
return ref_view<Rng>(rng);
}
template<typename Rng>
void operator()(Rng const && rng) const = delete;
};
/// \relates const_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(ref_fn, ref)
} // namespace views
namespace cpp20
{
template(typename Rng)(
requires std::is_object<Rng>::value) //
using ref_view = ranges::ref_view<Rng>;
}
} // namespace ranges
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::ref_view)
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/replace.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_REPLACE_HPP
#define RANGES_V3_VIEW_REPLACE_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/transform.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
template<typename Val1, typename Val2>
struct replacer_fn
{
private:
Val1 old_value_;
Val2 new_value_;
public:
replacer_fn() = default;
constexpr replacer_fn(Val1 old_value, Val2 new_value)
: old_value_(std::move(old_value))
, new_value_(std::move(new_value))
{}
template<typename I>
[[noreturn]] common_type_t<decay_t<unwrap_reference_t<Val2 const &>>,
iter_value_t<I>> &
operator()(copy_tag, I const &) const
{
RANGES_EXPECT(false);
}
template<typename I>
common_reference_t<unwrap_reference_t<Val2 const &>, iter_reference_t<I>>
operator()(I const & i) const
{
auto && x = *i;
if(x == unwrap_reference(old_value_))
return unwrap_reference(new_value_);
return ((decltype(x) &&)x);
}
template<typename I>
common_reference_t<unwrap_reference_t<Val2 const &>,
iter_rvalue_reference_t<I>>
operator()(move_tag, I const & i) const
{
auto && x = iter_move(i);
if(x == unwrap_reference(old_value_))
return unwrap_reference(new_value_);
return ((decltype(x) &&)x);
}
};
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
namespace views
{
struct replace_base_fn
{
template(typename Rng, typename Val1, typename Val2)(
requires viewable_range<Rng> AND input_range<Rng> AND
same_as<
detail::decay_t<unwrap_reference_t<Val1>>,
detail::decay_t<unwrap_reference_t<Val2>>> AND
equality_comparable_with<
detail::decay_t<unwrap_reference_t<Val1>>,
range_value_t<Rng>> AND
common_with<detail::decay_t<unwrap_reference_t<Val2 const &>>,
range_value_t<Rng>> AND
common_reference_with<unwrap_reference_t<Val2 const &>,
range_reference_t<Rng>> AND
common_reference_with<
unwrap_reference_t<Val2 const &>,
range_rvalue_reference_t<Rng>>)
constexpr replace_view< //
all_t<Rng>, //
detail::decay_t<Val1>, //
detail::decay_t<Val2>> //
operator()(Rng && rng, Val1 && old_value,
Val2 && new_value) const //
{
return {
all(static_cast<Rng &&>(rng)),
{static_cast<Val1 &&>(old_value), static_cast<Val2 &&>(new_value)}};
}
};
struct replace_fn : replace_base_fn
{
using replace_base_fn::operator();
template(typename Val1, typename Val2)(
requires same_as<detail::decay_t<unwrap_reference_t<Val1>>,
detail::decay_t<unwrap_reference_t<Val2>>>)
constexpr auto operator()(Val1 old_value, Val2 new_value) const
{
return make_view_closure(bind_back(
replace_base_fn{}, std::move(old_value), std::move(new_value)));
}
};
/// \relates replace_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(replace_fn, replace)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/drop_last.hpp | /// \file
// Range v3 library
//
// Copyright Andrey Diduh 2019
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_DROP_LAST_HPP
#define RANGES_V3_VIEW_DROP_LAST_HPP
#include <type_traits>
#include <meta/meta.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/counted_iterator.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
/// \cond
namespace detail
{
namespace drop_last_view
{
template<typename Rng>
range_size_t<Rng> get_size(Rng & rng, range_difference_t<Rng> n_)
{
RANGES_EXPECT(n_ >= 0);
range_size_t<Rng> const initial_size = ranges::size(rng);
range_size_t<Rng> const n = static_cast<range_size_t<Rng>>(n_);
return initial_size > n ? initial_size - n : 0;
}
template(typename Rng)(
requires random_access_range<Rng> AND sized_range<Rng>)
iterator_t<Rng> get_end(Rng & rng, range_difference_t<Rng> n, int)
{
return begin(rng) + static_cast<range_difference_t<Rng>>(
drop_last_view::get_size(rng, n));
}
template(typename Rng)(
requires bidirectional_range<Rng> AND common_range<Rng>)
iterator_t<Rng> get_end(Rng & rng, range_difference_t<Rng> n, long)
{
return prev(end(rng), n, begin(rng));
}
enum class mode_enum
{
bidi,
forward,
sized,
invalid
};
template<mode_enum Mode>
using mode_t = std::integral_constant<mode_enum, Mode>;
using mode_bidi = mode_t<mode_enum::bidi>;
using mode_forward = mode_t<mode_enum::forward>;
using mode_sized = mode_t<mode_enum::sized>;
using mode_invalid = mode_t<mode_enum::invalid>;
template<typename Rng>
constexpr mode_enum get_mode() noexcept
{
// keep range bound
// Sized Bidi O(N)
return (random_access_range<Rng> && view_<Rng> && sized_range<Rng>) ||
(bidirectional_range<Rng> && view_<Rng> &&
common_range<Rng>)
? mode_enum::bidi //
: sized_range<Rng> && view_<Rng> //
? mode_enum::sized //
: forward_range<Rng> && view_<Rng> //
? mode_enum::forward //
: mode_enum::invalid; //
// max performance
// Sized Bidi O(1)
// Sized Bidi use mode::sized instead of mode::bidi - thus become unbound.
/*return (random_access_range<Rng> && view_<Rng> && sized_range<Rng> &&
view_<Rng>) || (bidirectional_range<Rng> && view_<Rng> &&
common_range<Rng> && view_<Rng>) ? mode::bidi : sized_range<Rng> &&
view_<Rng> ? mode::sized : bidirectional_range<Rng> && view_<Rng> &&
common_range<Rng> && view_<Rng> ? mode::bidi : forward_range<Rng> &&
view_<Rng> ? mode::forward : mode::invalid;*/
}
template<typename Rng>
using mode_of = mode_t<drop_last_view::get_mode<Rng>()>;
} // namespace drop_last_view
} // namespace detail
/// \endcond
template<typename Rng, typename = detail::drop_last_view::mode_of<Rng>>
struct drop_last_view
{};
template<typename Rng>
struct drop_last_view<Rng, detail::drop_last_view::mode_bidi>
: view_interface<drop_last_view<Rng, detail::drop_last_view::mode_bidi>,
is_finite<Rng>::value
? finite
: range_cardinality<Rng>::value> // finite at best
{
CPP_assert(
(random_access_range<Rng> && view_<Rng> && sized_range<Rng>) ||
(bidirectional_range<Rng> && view_<Rng> && common_range<Rng>));
private:
friend range_access;
using difference_t = range_difference_t<Rng>;
Rng rng_;
difference_t n_;
detail::non_propagating_cache<iterator_t<Rng>> end_;
public:
drop_last_view() = default;
constexpr drop_last_view(Rng rng, difference_t n)
: rng_(std::move(rng))
, n_(n)
{
RANGES_EXPECT(n >= 0);
}
iterator_t<Rng> begin()
{
return ranges::begin(rng_);
}
sentinel_t<Rng> end()
{
if(!end_)
end_ = detail::drop_last_view::get_end(rng_, n_, 0);
return *end_;
}
template(typename CRng = Rng const)(
requires random_access_range<CRng> AND sized_range<CRng>)
iterator_t<CRng> begin() const
{
return ranges::begin(rng_);
}
template(typename CRng = Rng const)(
requires random_access_range<CRng> AND sized_range<CRng>)
iterator_t<CRng> end() const
{
return detail::drop_last_view::get_end(rng_, n_, 0);
}
CPP_auto_member
auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return detail::drop_last_view::get_size(rng_, n_);
}
CPP_auto_member
auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
return detail::drop_last_view::get_size(rng_, n_);
}
Rng & base()
{
return rng_;
}
Rng const & base() const
{
return rng_;
}
};
template<typename Rng>
struct drop_last_view<Rng, detail::drop_last_view::mode_forward>
: view_adaptor<drop_last_view<Rng, detail::drop_last_view::mode_forward>, Rng,
is_finite<Rng>::value
? finite
: range_cardinality<Rng>::value> // finite at best (but
// unknown is expected)
{
CPP_assert(forward_range<Rng> && view_<Rng>);
private:
friend range_access;
using difference_t = range_difference_t<Rng>;
difference_t n_;
detail::non_propagating_cache<iterator_t<Rng>> probe_begin;
struct adaptor : adaptor_base
{
iterator_t<Rng> probe_;
adaptor() = default;
adaptor(iterator_t<Rng> probe_first)
: probe_(std::move(probe_first))
{}
void next(iterator_t<Rng> & it)
{
++it;
++probe_;
}
};
struct sentinel_adaptor : adaptor_base
{
template<typename I, typename S>
bool empty(I const &, adaptor const & ia, S const & s) const
{
return ia.probe_ == s;
}
};
adaptor begin_adaptor()
{
if(!probe_begin)
probe_begin = next(begin(this->base()), n_, end(this->base()));
return {*probe_begin};
}
sentinel_adaptor end_adaptor()
{
return {};
}
public:
drop_last_view() = default;
constexpr drop_last_view(Rng rng, difference_t n)
: drop_last_view::view_adaptor(std::move(rng))
, n_(n)
{
RANGES_EXPECT(n >= 0);
}
CPP_auto_member
auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return detail::drop_last_view::get_size(this->base(), n_);
}
CPP_auto_member
auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
return detail::drop_last_view::get_size(this->base(), n_);
}
};
template<typename Rng>
struct drop_last_view<Rng, detail::drop_last_view::mode_sized>
: view_interface<drop_last_view<Rng, detail::drop_last_view::mode_sized>, finite>
{
CPP_assert(sized_range<Rng> && view_<Rng>);
private:
friend range_access;
using difference_t = range_difference_t<Rng>;
Rng rng_;
difference_t n_;
public:
drop_last_view() = default;
constexpr drop_last_view(Rng rng, difference_t n)
: rng_(std::move(rng))
, n_(n)
{
RANGES_EXPECT(n >= 0);
}
counted_iterator<iterator_t<Rng>> begin()
{
return {ranges::begin(rng_), static_cast<difference_t>(size())};
}
template(typename CRng = Rng const)(
requires sized_range<CRng>)
counted_iterator<iterator_t<CRng>> begin() const
{
return {ranges::begin(rng_), static_cast<difference_t>(size())};
}
default_sentinel_t end() const
{
return {};
}
range_size_t<Rng> size()
{
return detail::drop_last_view::get_size(this->base(), n_);
}
CPP_auto_member
auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
return detail::drop_last_view::get_size(this->base(), n_);
}
Rng & base()
{
return rng_;
}
Rng const & base() const
{
return rng_;
}
};
template<typename Rng, typename T>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<drop_last_view<Rng, T>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
drop_last_view(Rng &&, range_difference_t<Rng>)
-> drop_last_view<views::all_t<Rng>>;
#endif
namespace views
{
struct drop_last_base_fn
{
template(typename Rng)(
requires sized_range<Rng> || forward_range<Rng>)
constexpr auto operator()(Rng && rng, range_difference_t<Rng> n) const
-> drop_last_view<all_t<Rng>>
{
return {all(static_cast<Rng &&>(rng)), n};
}
};
struct drop_last_fn : drop_last_base_fn
{
using drop_last_base_fn::operator();
template(typename Int)(
requires detail::integer_like_<Int>)
constexpr auto operator()(Int n) const
{
return make_view_closure(bind_back(drop_last_base_fn{}, n));
}
};
RANGES_INLINE_VARIABLE(drop_last_fn, drop_last)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::drop_last_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/sliding.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
// Copyright Tobias Mayer 2016
// Copyright Casey Carter 2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_SLIDING_HPP
#define RANGES_V3_VIEW_SLIDING_HPP
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/counted.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace sliding_view_detail
{
enum class cache
{
none,
first,
last
};
template<typename Rng>
using caching = std::integral_constant<
cache, random_access_range<Rng> && sized_range<Rng>
? cache::none
: bidirectional_range<Rng> && common_range<Rng> ? cache::last
: cache::first>;
} // namespace sliding_view_detail
/// \endcond
template<typename Rng,
sliding_view_detail::cache = sliding_view_detail::caching<Rng>::value>
struct sliding_view;
/// \cond
namespace sliding_view_detail
{
template<typename Rng>
using uncounted_t =
decltype(ranges::uncounted(std::declval<iterator_t<Rng> &>()));
template<typename Rng, bool = (bool)random_access_range<Rng>>
struct trailing
{
trailing() = default;
constexpr trailing(Rng & rng)
: it_{uncounted(ranges::begin(rng))}
{}
constexpr uncounted_t<Rng> get(iterator_t<Rng> const &,
range_difference_t<Rng>) const
{
return it_;
}
void next()
{
++it_;
}
CPP_member
auto prev() //
-> CPP_ret(void)(
requires bidirectional_range<Rng>)
{
--it_;
}
private:
uncounted_t<Rng> it_;
};
template<typename Rng>
struct trailing<Rng, true>
{
trailing() = default;
constexpr trailing(Rng &) noexcept
{}
constexpr uncounted_t<Rng> get(iterator_t<Rng> const & it,
range_difference_t<Rng> n) const
{
return uncounted(it - (n - 1));
}
void next()
{}
void prev()
{}
};
template<typename Rng>
struct RANGES_EMPTY_BASES sv_base
: view_adaptor<sliding_view<Rng>, Rng,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
, private detail::non_propagating_cache<iterator_t<Rng>, sv_base<Rng>,
caching<Rng>::value != cache::none>
{
CPP_assert(forward_range<Rng>);
sv_base() = default;
sv_base(Rng rng, range_difference_t<Rng> n)
: sv_base::view_adaptor(std::move(rng))
, n_(n)
{
RANGES_ASSERT(0 < n_);
}
CPP_auto_member
auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
auto const count = ranges::size(this->base());
auto const n = static_cast<range_size_t<Rng const>>(n_);
return count < n ? 0 : count - n + 1;
}
CPP_auto_member
auto CPP_fun(size)()(
requires sized_range<Rng>)
{
auto const count = ranges::size(this->base());
auto const n = static_cast<range_size_t<Rng>>(n_);
return count < n ? 0 : count - n + 1;
}
protected:
range_difference_t<Rng> n_;
optional<iterator_t<Rng>> & cache() &
{
return static_cast<cache_t &>(*this);
}
optional<iterator_t<Rng>> const & cache() const &
{
return static_cast<cache_t const &>(*this);
}
private:
using cache_t = detail::non_propagating_cache<iterator_t<Rng>, sv_base<Rng>>;
};
} // namespace sliding_view_detail
/// \endcond
/// \addtogroup group-views
/// @{
template<typename Rng>
struct sliding_view<Rng, sliding_view_detail::cache::first>
: sliding_view_detail::sv_base<Rng>
{
private:
friend range_access;
iterator_t<Rng> get_first()
{
auto & first = this->cache();
if(!first)
{
first = ranges::next(
ranges::begin(this->base()), this->n_ - 1, ranges::end(this->base()));
}
return *first;
}
struct RANGES_EMPTY_BASES adaptor
: adaptor_base
, sliding_view_detail::trailing<Rng>
{
private:
using base_t = sliding_view_detail::trailing<Rng>;
range_difference_t<Rng> n_ = {};
public:
adaptor() = default;
adaptor(sliding_view * v)
: base_t{v->base()}
, n_{v->n_}
{}
iterator_t<Rng> begin(sliding_view & v)
{
return v.get_first();
}
auto read(iterator_t<Rng> const & it) const
-> decltype(views::counted(uncounted(it), n_))
{
return views::counted(base_t::get(it, n_), n_);
}
void next(iterator_t<Rng> & it)
{
++it;
base_t::next();
}
CPP_member
auto prev(iterator_t<Rng> & it) //
-> CPP_ret(void)(
requires bidirectional_range<Rng>)
{
base_t::prev();
--it;
}
CPP_member
auto advance(iterator_t<Rng> & it, range_difference_t<Rng> n)
-> CPP_ret(void)(
requires random_access_range<Rng>)
{
it += n;
}
};
adaptor begin_adaptor()
{
return {this};
}
meta::if_c<common_range<Rng>, adaptor, adaptor_base> end_adaptor()
{
return {this};
}
public:
using sliding_view::sv_base::sv_base;
};
template<typename Rng>
struct sliding_view<Rng, sliding_view_detail::cache::last>
: sliding_view_detail::sv_base<Rng>
{
private:
friend range_access;
iterator_t<Rng> get_last()
{
auto & last = this->cache();
if(!last)
{
last = ranges::prev(
ranges::end(this->base()), this->n_ - 1, ranges::begin(this->base()));
}
return *last;
}
struct adaptor : adaptor_base
{
private:
range_difference_t<Rng> n_ = {};
public:
adaptor() = default;
adaptor(sliding_view * v)
: n_{v->n_}
{}
iterator_t<Rng> end(sliding_view & v)
{
return v.get_last();
}
auto read(iterator_t<Rng> const & it) const
-> decltype(views::counted(uncounted(it), n_))
{
return views::counted(uncounted(it), n_);
}
};
adaptor begin_adaptor()
{
return {this};
}
adaptor end_adaptor()
{
return {this};
}
public:
using sliding_view::sv_base::sv_base;
};
template<typename Rng>
struct sliding_view<Rng, sliding_view_detail::cache::none>
: sliding_view_detail::sv_base<Rng>
{
private:
friend range_access;
template<bool Const>
struct adaptor : adaptor_base
{
private:
friend adaptor<!Const>;
using CRng = meta::const_if_c<Const, Rng>;
range_difference_t<Rng> n_ = 0;
public:
adaptor() = default;
adaptor(range_difference_t<Rng> n)
: n_(n)
{}
template(bool Other)(
requires Const AND CPP_NOT(Other)) //
adaptor(adaptor<Other> that)
: n_(that.n_)
{}
iterator_t<CRng> end(meta::const_if_c<Const, sliding_view> & v) const
{
auto const sz = ranges::distance(v.base());
auto const offset = n_ - 1 < sz ? n_ - 1 : sz;
return ranges::begin(v.base()) + (sz - offset);
}
auto read(iterator_t<CRng> const & it) const
-> decltype(views::counted(uncounted(it), n_))
{
return views::counted(uncounted(it), n_);
}
};
adaptor<simple_view<Rng>()> begin_adaptor()
{
return {this->n_};
}
CPP_member
auto begin_adaptor() const //
-> CPP_ret(adaptor<true>)(
requires range<Rng const>)
{
return {this->n_};
}
adaptor<simple_view<Rng>()> end_adaptor()
{
return {this->n_};
}
CPP_member
auto end_adaptor() const //
-> CPP_ret(adaptor<true>)(
requires range<Rng const>)
{
return {this->n_};
}
public:
using sliding_view::sv_base::sv_base;
};
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<sliding_view<Rng>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
sliding_view(Rng &&, range_difference_t<Rng>)
-> sliding_view<views::all_t<Rng>>;
#endif
namespace views
{
// In: range<T>
// Out: range<range<T>>, where each inner range has $n$ elements.
struct sliding_base_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND forward_range<Rng>)
constexpr sliding_view<all_t<Rng>> //
operator()(Rng && rng, range_difference_t<Rng> n) const
{
return {all(static_cast<Rng &&>(rng)), n};
}
};
struct sliding_fn : sliding_base_fn
{
using sliding_base_fn::operator();
template<typename Int>
constexpr auto CPP_fun(operator())(Int n)(const //
requires detail::integer_like_<Int>)
{
return make_view_closure(bind_back(sliding_base_fn{}, n));
}
};
/// \relates sliding_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(sliding_fn, sliding)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/take_while.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_TAKE_WHILE_HPP
#define RANGES_V3_VIEW_TAKE_WHILE_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/compose.hpp>
#include <range/v3/functional/indirect.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/utility/semiregular_box.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng, typename Pred>
struct iter_take_while_view
: view_adaptor<iter_take_while_view<Rng, Pred>, Rng,
is_finite<Rng>::value ? finite : unknown>
{
private:
friend range_access;
RANGES_NO_UNIQUE_ADDRESS semiregular_box_t<Pred> pred_;
template<bool IsConst>
struct sentinel_adaptor : adaptor_base
{
private:
friend struct sentinel_adaptor<!IsConst>;
using CRng = meta::const_if_c<IsConst, Rng>;
RANGES_NO_UNIQUE_ADDRESS semiregular_box_ref_or_val_t<Pred, IsConst> pred_;
public:
sentinel_adaptor() = default;
sentinel_adaptor(semiregular_box_ref_or_val_t<Pred, IsConst> pred)
: pred_(std::move(pred))
{}
template(bool Other)(
requires IsConst AND CPP_NOT(Other)) //
sentinel_adaptor(sentinel_adaptor<Other> that)
: pred_(std::move(that.pred_))
{}
bool empty(iterator_t<CRng> const & it, sentinel_t<CRng> const & last) const
{
return it == last || !invoke(pred_, it);
}
};
sentinel_adaptor<false> end_adaptor()
{
return {pred_};
}
template(bool Const = true)(
requires Const AND range<meta::const_if_c<Const, Rng>> AND
invocable<Pred const &, iterator_t<meta::const_if_c<Const, Rng>>>)
sentinel_adaptor<Const> end_adaptor() const
{
return {pred_};
}
public:
iter_take_while_view() = default;
constexpr iter_take_while_view(Rng rng, Pred pred)
: iter_take_while_view::view_adaptor{std::move(rng)}
, pred_(std::move(pred))
{}
};
template<typename Rng, typename Pred>
struct take_while_view : iter_take_while_view<Rng, indirected<Pred>>
{
take_while_view() = default;
constexpr take_while_view(Rng rng, Pred pred)
: iter_take_while_view<Rng, indirected<Pred>>{std::move(rng),
indirect(std::move(pred))}
{}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Fun)(
requires copy_constructible<Fun>)
take_while_view(Rng &&, Fun)
-> take_while_view<views::all_t<Rng>, Fun>;
#endif
namespace views
{
struct iter_take_while_base_fn
{
template(typename Rng, typename Pred)(
requires viewable_range<Rng> AND input_range<Rng> AND
predicate<Pred &, iterator_t<Rng>> AND copy_constructible<Pred>)
constexpr iter_take_while_view<all_t<Rng>, Pred> //
operator()(Rng && rng, Pred pred) const
{
return {all(static_cast<Rng &&>(rng)), std::move(pred)};
}
};
struct iter_take_while_fn : iter_take_while_base_fn
{
using iter_take_while_base_fn::operator();
template<typename Pred>
constexpr auto operator()(Pred pred) const
{
return make_view_closure(
bind_back(iter_take_while_base_fn{}, std::move(pred)));
}
};
struct take_while_base_fn
{
template(typename Rng, typename Pred)(
requires viewable_range<Rng> AND input_range<Rng> AND
indirect_unary_predicate<Pred &, iterator_t<Rng>>)
constexpr take_while_view<all_t<Rng>, Pred> //
operator()(Rng && rng, Pred pred) const
{
return {all(static_cast<Rng &&>(rng)), std::move(pred)};
}
template(typename Rng, typename Pred, typename Proj)(
requires viewable_range<Rng> AND input_range<Rng> AND
indirect_unary_predicate<composed<Pred, Proj> &, iterator_t<Rng>>)
constexpr take_while_view<all_t<Rng>, composed<Pred, Proj>> //
operator()(Rng && rng, Pred pred, Proj proj) const
{
return {all(static_cast<Rng &&>(rng)),
compose(std::move(pred), std::move(proj))};
}
};
struct take_while_bind_fn
{
template<typename Pred>
constexpr auto operator()(Pred pred) const // TODO: underconstrained
{
return make_view_closure(
bind_back(take_while_base_fn{}, std::move(pred)));
}
template(typename Pred, typename Proj)(
requires (!range<Pred>)) // TODO: underconstrained
constexpr auto operator()(Pred && pred, Proj proj) const
{
return make_view_closure(bind_back(
take_while_base_fn{}, static_cast<Pred &&>(pred), std::move(proj)));
}
};
struct RANGES_EMPTY_BASES take_while_fn
: take_while_base_fn, take_while_bind_fn
{
using take_while_base_fn::operator();
using take_while_bind_fn::operator();
};
/// \relates iter_take_while_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(iter_take_while_fn, iter_take_while)
/// \relates take_while_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(take_while_fn, take_while)
} // namespace views
namespace cpp20
{
namespace views
{
using ranges::views::take_while;
}
template(typename Rng, typename Pred)(
requires viewable_range<Rng> AND input_range<Rng> AND
predicate<Pred &, iterator_t<Rng>> AND copy_constructible<Pred>)
using take_while_view = ranges::take_while_view<Rng, Pred>;
} // namespace cpp20
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::iter_take_while_view)
RANGES_SATISFY_BOOST_RANGE(::ranges::take_while_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/cycle.hpp | /// \file cycle.hpp
// Range v3 library
//
// Copyright Eric Niebler 2013-present
// Copyright Gonzalo Brito Gadeschi 2015
// Copyright Casey Carter 2015
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_CYCLE_HPP
#define RANGES_V3_VIEW_CYCLE_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/iterator/unreachable_sentinel.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/primitives.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/box.hpp>
#include <range/v3/utility/get.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng, bool /* = (bool) is_infinite<Rng>() */>
struct RANGES_EMPTY_BASES cycled_view
: view_facade<cycled_view<Rng>, infinite>
, private detail::non_propagating_cache<iterator_t<Rng>, cycled_view<Rng>,
!common_range<Rng>>
{
private:
CPP_assert(forward_range<Rng> && !is_infinite<Rng>::value);
friend range_access;
Rng rng_;
using cache_t = detail::non_propagating_cache<iterator_t<Rng>, cycled_view<Rng>,
!common_range<Rng>>;
template<bool IsConst>
struct cursor
{
private:
friend struct cursor<!IsConst>;
template<typename T>
using constify_if = meta::const_if_c<IsConst, T>;
using cycled_view_t = constify_if<cycled_view>;
using CRng = constify_if<Rng>;
using iterator = iterator_t<CRng>;
cycled_view_t * rng_{};
iterator it_{};
std::intmax_t n_ = 0;
iterator get_end_(std::true_type, bool = false) const
{
return ranges::end(rng_->rng_);
}
template<bool CanBeEmpty = false>
iterator get_end_(std::false_type, meta::bool_<CanBeEmpty> = {}) const
{
auto & end_ = static_cast<cache_t &>(*rng_);
RANGES_EXPECT(CanBeEmpty || end_);
if(CanBeEmpty && !end_)
end_ = ranges::next(it_, ranges::end(rng_->rng_));
return *end_;
}
void set_end_(std::true_type) const
{}
void set_end_(std::false_type) const
{
auto & end_ = static_cast<cache_t &>(*rng_);
if(!end_)
end_ = it_;
}
public:
cursor() = default;
cursor(cycled_view_t * rng)
: rng_(rng)
, it_(ranges::begin(rng->rng_))
{}
template(bool Other)(
requires IsConst AND CPP_NOT(Other)) //
cursor(cursor<Other> that)
: rng_(that.rng_)
, it_(std::move(that.it_))
{}
// clang-format off
auto CPP_auto_fun(read)()(const)
(
return *it_
)
// clang-format on
CPP_member
auto equal(cursor const & pos) const //
-> CPP_ret(bool)(
requires equality_comparable<iterator>)
{
RANGES_EXPECT(rng_ == pos.rng_);
return n_ == pos.n_ && it_ == pos.it_;
}
void next()
{
auto const last = ranges::end(rng_->rng_);
RANGES_EXPECT(it_ != last);
if(++it_ == last)
{
++n_;
this->set_end_(meta::bool_<(bool)common_range<CRng>>{});
it_ = ranges::begin(rng_->rng_);
}
}
CPP_member
auto prev() //
-> CPP_ret(void)(
requires bidirectional_range<CRng>)
{
if(it_ == ranges::begin(rng_->rng_))
{
RANGES_EXPECT(n_ > 0); // decrementing the begin iterator?!
--n_;
it_ = this->get_end_(meta::bool_<(bool)common_range<CRng>>{});
}
--it_;
}
template(typename Diff)(
requires random_access_range<CRng> AND
detail::integer_like_<Diff>)
void advance(Diff n)
{
auto const first = ranges::begin(rng_->rng_);
auto const last = this->get_end_(meta::bool_<(bool)common_range<CRng>>{},
meta::bool_<true>());
auto const dist = last - first;
auto const d = it_ - first;
auto const off = (d + n) % dist;
n_ += (d + n) / dist;
RANGES_EXPECT(n_ >= 0);
using D = range_difference_t<Rng>;
it_ = first + static_cast<D>(off < 0 ? off + dist : off);
}
CPP_auto_member
auto CPP_fun(distance_to)(cursor const & that)(const //
requires sized_sentinel_for<iterator, iterator>)
{
RANGES_EXPECT(that.rng_ == rng_);
auto const first = ranges::begin(rng_->rng_);
auto const last = this->get_end_(meta::bool_<(bool)common_range<Rng>>{},
meta::bool_<true>());
auto const dist = last - first;
return (that.n_ - n_) * dist + (that.it_ - it_);
}
};
CPP_member
auto begin_cursor() //
-> CPP_ret(cursor<false>)(
requires (!simple_view<Rng>() || !common_range<Rng const>))
{
return {this};
}
CPP_member
auto begin_cursor() const //
-> CPP_ret(cursor<true>)(
requires common_range<Rng const>)
{
return {this};
}
unreachable_sentinel_t end_cursor() const
{
return unreachable;
}
public:
cycled_view() = default;
/// \pre <tt>!empty(rng)</tt>
explicit cycled_view(Rng rng)
: rng_(std::move(rng))
{
RANGES_EXPECT(!ranges::empty(rng_));
}
};
template<typename Rng>
struct cycled_view<Rng, true> : identity_adaptor<Rng>
{
CPP_assert(is_infinite<Rng>::value);
using identity_adaptor<Rng>::identity_adaptor;
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
cycled_view(Rng &&) //
-> cycled_view<views::all_t<Rng>>;
#endif
namespace views
{
/// Returns an infinite range that endlessly repeats the source
/// range.
struct cycle_fn
{
/// \pre <tt>!empty(rng)</tt>
template(typename Rng)(
requires viewable_range<Rng> AND forward_range<Rng>)
cycled_view<all_t<Rng>> operator()(Rng && rng) const
{
return cycled_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
}
};
/// \relates cycle_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<cycle_fn>, cycle)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::cycled_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/unbounded.hpp | //
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_UNBOUNDED_HPP
#define RANGES_V3_VIEW_UNBOUNDED_HPP
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/unreachable_sentinel.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename I>
struct unbounded_view : view_interface<unbounded_view<I>, infinite>
{
private:
I it_;
public:
unbounded_view() = default;
constexpr explicit unbounded_view(I it)
: it_(detail::move(it))
{}
constexpr I begin() const
{
return it_;
}
constexpr unreachable_sentinel_t end() const
{
return {};
}
};
template<typename I>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<unbounded_view<I>> = true;
namespace views
{
struct unbounded_fn
{
template(typename I)(
requires input_iterator<I>)
constexpr unbounded_view<I> operator()(I it) const
{
return unbounded_view<I>{detail::move(it)};
}
};
/// \relates unbounded_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(unbounded_fn, unbounded)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::unbounded_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/indirect.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_INDIRECT_HPP
#define RANGES_V3_VIEW_INDIRECT_HPP
#include <iterator>
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/move.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/adaptor.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng>
struct indirect_view : view_adaptor<indirect_view<Rng>, Rng>
{
private:
friend range_access;
template<bool IsConst>
struct adaptor : adaptor_base
{
friend adaptor<!IsConst>;
using CRng = meta::const_if_c<IsConst, Rng>;
adaptor() = default;
template(bool Other)(
requires IsConst && CPP_NOT(Other)) //
constexpr adaptor(adaptor<Other>) noexcept
{}
// clang-format off
constexpr auto CPP_auto_fun(read)(iterator_t<CRng> const &it)(const)
(
return **it
)
constexpr auto CPP_auto_fun(iter_move)(iterator_t<CRng> const &it)(const)
(
return ranges::iter_move(*it)
)
// clang-format on
};
CPP_member
constexpr auto begin_adaptor() noexcept //
-> CPP_ret(adaptor<false>)(
requires (!simple_view<Rng>()))
{
return {};
}
CPP_member
constexpr auto begin_adaptor() const noexcept //
-> CPP_ret(adaptor<true>)(
requires range<Rng const>)
{
return {};
}
CPP_member
constexpr auto end_adaptor() noexcept //
-> CPP_ret(adaptor<false>)(
requires (!simple_view<Rng>()))
{
return {};
}
CPP_member
constexpr auto end_adaptor() const noexcept //
-> CPP_ret(adaptor<true>)(
requires range<Rng const>)
{
return {};
}
public:
indirect_view() = default;
constexpr explicit indirect_view(Rng rng)
: indirect_view::view_adaptor{detail::move(rng)}
{}
CPP_auto_member
constexpr auto CPP_fun(size)()(const //
requires sized_range<Rng const>)
{
return ranges::size(this->base());
}
CPP_auto_member
constexpr auto CPP_fun(size)()(
requires sized_range<Rng>)
{
return ranges::size(this->base());
}
};
template<typename Rng>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<indirect_view<Rng>> = //
enable_borrowed_range<Rng>;
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template<typename Rng>
indirect_view(Rng &&) //
-> indirect_view<views::all_t<Rng>>;
#endif
namespace views
{
struct indirect_fn
{
template(typename Rng)(
requires viewable_range<Rng> AND input_range<Rng> AND
// We shouldn't need to strip references to test if something
// is readable. https://github.com/ericniebler/stl2/issues/594
// indirectly_readable<range_reference_t<Rng>>)
((bool)indirectly_readable<range_value_t<Rng>>)) // Cast to bool needed
// for GCC (???))
constexpr auto operator()(Rng && rng) const
{
return indirect_view<all_t<Rng>>{all(static_cast<Rng &&>(rng))};
}
};
/// \relates indirect_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<indirect_fn>, indirect)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::indirect_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/c_str.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_C_STR_HPP
#define RANGES_V3_VIEW_C_STR_HPP
#include <type_traits>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/unreachable_sentinel.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/delimit.hpp>
#include <range/v3/view/subrange.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
template<typename T>
struct is_char_type_ : std::false_type
{};
template<>
struct is_char_type_<char> : std::true_type
{};
template<>
struct is_char_type_<wchar_t> : std::true_type
{};
template<>
struct is_char_type_<char16_t> : std::true_type
{};
template<>
struct is_char_type_<char32_t> : std::true_type
{};
template<typename T>
using is_char_type = is_char_type_<meta::_t<std::remove_cv<T>>>;
} // namespace detail
/// \endcond
/// \addtogroup group-views
/// @{
namespace views
{
/// View a `\0`-terminated C string (e.g. from a const char*) as a
/// range.
struct c_str_fn
{
// Fixed-length
template(typename Char, std::size_t N)(
requires detail::is_char_type<Char>::value) //
ranges::subrange<Char *> operator()(Char (&sz)[N]) const
{
return {&sz[0], &sz[N - 1]};
}
// Null-terminated
template(typename Char)(
requires detail::is_char_type<Char>::value) //
ranges::delimit_view<
ranges::subrange<Char *, ranges::unreachable_sentinel_t>,
meta::_t<std::remove_cv<Char>>> //
operator()(Char * sz) const volatile
{
using ch_t = meta::_t<std::remove_cv<Char>>;
return ranges::views::delimit(sz, ch_t(0));
}
};
/// \relates c_str_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(c_str_fn, c_str)
} // namespace views
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/enumerate.hpp | /// \file
// Range v3 library
//
// Copyright Casey Carter 2018-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_ENUMERATE_HPP
#define RANGES_V3_VIEW_ENUMERATE_HPP
#include <range/v3/core.hpp>
#include <range/v3/iterator/unreachable_sentinel.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/view/zip.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
// Counts from zero up.
// See https://github.com/ericniebler/range-v3/issues/1141
// for why we don't just use iota_view.
template<typename Size, typename Diff>
struct index_view : view_facade<index_view<Size, Diff>, infinite>
{
private:
friend range_access;
struct cursor
{
using difference_type = Diff;
private:
friend range_access;
Size index_{0};
Size read() const
{
return index_;
}
void next()
{
++index_;
}
bool equal(cursor const & that) const
{
return that.index_ == index_;
}
void prev()
{
--index_;
}
void advance(Diff n)
{
index_ += static_cast<Size>(n);
}
Diff distance_to(cursor const & that) const
{
return static_cast<Diff>(static_cast<Diff>(that.index_) -
static_cast<Diff>(index_));
}
public:
cursor() = default;
};
cursor begin_cursor() const
{
return cursor{};
}
unreachable_sentinel_t end_cursor() const
{
return unreachable;
}
public:
index_view() = default;
};
} // namespace detail
template<typename Size, typename Diff>
RANGES_INLINE_VAR constexpr bool enable_borrowed_range<detail::index_view<Size, Diff>> =
true;
/// \endcond
/// \addtogroup group-views
/// @{
namespace views
{
/// Lazily pairs each element in a source range with
/// its corresponding index.
struct enumerate_fn
{
template(typename Rng)(
requires viewable_range<Rng>)
auto operator()(Rng && rng) const
{
using D = range_difference_t<Rng>;
using S = detail::iter_size_t<iterator_t<Rng>>;
return zip(detail::index_view<S, D>(), all(static_cast<Rng &&>(rng)));
}
};
/// \relates enumerate_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(view_closure<enumerate_fn>, enumerate)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/tokenize.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_TOKENIZE_HPP
#define RANGES_V3_VIEW_TOKENIZE_HPP
#include <initializer_list>
#include <regex>
#include <type_traits>
#include <utility>
#include <vector>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/interface.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
template<typename Rng, typename Regex, typename SubMatchRange>
struct tokenize_view
: view_interface<tokenize_view<Rng, Regex, SubMatchRange>,
is_finite<Rng>::value ? finite : range_cardinality<Rng>::value>
{
private:
CPP_assert(bidirectional_range<Rng> && view_<Rng> && common_range<Rng>);
CPP_assert(semiregular<Regex>);
CPP_assert(semiregular<SubMatchRange>);
Rng rng_;
Regex rex_;
SubMatchRange subs_;
std::regex_constants::match_flag_type flags_;
template<bool Const>
using iterator_t =
std::regex_token_iterator<iterator_t<meta::const_if_c<Const, Rng>>>;
public:
tokenize_view() = default;
tokenize_view(Rng rng, Regex rex, SubMatchRange subs,
std::regex_constants::match_flag_type flags)
: rng_(std::move(rng))
, rex_(std::move(rex))
, subs_(std::move(subs))
, flags_(flags)
{}
iterator_t<simple_view<Rng>()> begin()
{
meta::const_if_c<simple_view<Rng>(), Rng> & rng = rng_;
return {ranges::begin(rng), ranges::end(rng), rex_, subs_, flags_};
}
template(bool Const = true)(
requires range<Rng const>)
iterator_t<Const> begin() const
{
return {ranges::begin(rng_), ranges::end(rng_), rex_, subs_, flags_};
}
iterator_t<simple_view<Rng>()> end()
{
return {};
}
template(bool Const = true)(
requires range<Rng const>)
iterator_t<Const> end() const
{
return {};
}
Rng base() const
{
return rng_;
}
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng, typename Regex, typename SubMatchRange)(
requires copy_constructible<Regex> AND copy_constructible<SubMatchRange>)
tokenize_view(Rng &&, Regex, SubMatchRange)
->tokenize_view<views::all_t<Rng>, Regex, SubMatchRange>;
#endif
namespace views
{
struct tokenize_base_fn
{
template(typename Rng, typename Regex)(
requires bidirectional_range<Rng> AND common_range<Rng> AND
same_as< //
range_value_t<Rng>, //
typename detail::decay_t<Regex>::value_type>)
tokenize_view<all_t<Rng>, detail::decay_t<Regex>, int> //
operator()(Rng && rng,
Regex && rex,
int sub = 0,
std::regex_constants::match_flag_type flags =
std::regex_constants::match_default) const //
{
return {all(static_cast<Rng &&>(rng)),
static_cast<Regex &&>(rex),
sub,
flags};
}
template(typename Rng, typename Regex)(
requires bidirectional_range<Rng> AND common_range<Rng> AND
same_as<range_value_t<Rng>,
typename detail::decay_t<Regex>::value_type>)
tokenize_view<all_t<Rng>, detail::decay_t<Regex>, std::vector<int>> //
operator()(Rng && rng,
Regex && rex,
std::vector<int> subs,
std::regex_constants::match_flag_type flags =
std::regex_constants::match_default) const //
{
return {all(static_cast<Rng &&>(rng)),
static_cast<Regex &&>(rex),
std::move(subs),
flags};
}
template(typename Rng, typename Regex)(
requires bidirectional_range<Rng> AND common_range<Rng> AND
same_as<range_value_t<Rng>,
typename detail::decay_t<Regex>::value_type>)
tokenize_view<all_t<Rng>,
detail::decay_t<Regex>,
std::initializer_list<int>> //
operator()(Rng && rng,
Regex && rex,
std::initializer_list<int> subs,
std::regex_constants::match_flag_type flags =
std::regex_constants::match_default) const //
{
return {all(static_cast<Rng &&>(rng)),
static_cast<Regex &&>(rex),
std::move(subs),
flags};
}
};
struct tokenize_fn : tokenize_base_fn
{
using tokenize_base_fn::operator();
template<typename Regex>
constexpr auto operator()(Regex && rex,
int sub = 0,
std::regex_constants::match_flag_type flags =
std::regex_constants::match_default) const
{
return make_view_closure(bind_back(
tokenize_base_fn{}, static_cast<Regex &&>(rex), sub, flags));
}
template<typename Regex>
auto operator()(Regex && rex,
std::vector<int> subs,
std::regex_constants::match_flag_type flags =
std::regex_constants::match_default) const
{
return bind_back(tokenize_base_fn{},
static_cast<Regex &&>(rex),
std::move(subs),
flags);
}
template<typename Regex>
constexpr auto operator()(Regex && rex,
std::initializer_list<int> subs,
std::regex_constants::match_flag_type flags =
std::regex_constants::match_default) const
{
return make_view_closure(bind_back(
tokenize_base_fn{}, static_cast<Regex &&>(rex), subs, flags));
}
};
/// \relates tokenize_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(tokenize_fn, tokenize)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::tokenize_view)
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/remove.hpp | /// \file
// Range v3 library
//
// Copyright Andrey Diduh 2019
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_REMOVE_HPP
#define RANGES_V3_VIEW_REMOVE_HPP
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/bind_back.hpp>
#include <range/v3/functional/comparisons.hpp>
#include <range/v3/view/remove_if.hpp>
#include <range/v3/view/view.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
namespace views
{
struct remove_base_fn
{
private:
template<typename Value>
struct pred_
{
Value value_;
template(typename T)(
requires equality_comparable_with<T, Value const &>)
bool operator()(T && other) const
{
return static_cast<T &&>(other) == value_;
}
};
public:
template(typename Rng, typename Value)(
requires move_constructible<Value> AND viewable_range<Rng> AND
input_range<Rng> AND
indirectly_comparable<iterator_t<Rng>, Value const *, equal_to>)
constexpr auto operator()(Rng && rng, Value value) const
{
return remove_if(static_cast<Rng &&>(rng),
pred_<Value>{std::move(value)});
}
template(typename Rng, typename Value, typename Proj)(
requires move_constructible<Value> AND viewable_range<Rng> AND
input_range<Rng> AND
indirectly_comparable<iterator_t<Rng>, Value const *, equal_to, Proj>)
constexpr auto operator()(Rng && rng, Value value, Proj proj) const
{
return remove_if(static_cast<Rng &&>(rng),
pred_<Value>{std::move(value)},
std::move(proj));
}
};
struct remove_bind_fn
{
template<typename Value>
constexpr auto operator()(Value value) const // TODO: underconstrained
{
return make_view_closure(bind_back(remove_base_fn{}, std::move(value)));
}
template(typename Value, typename Proj)(
requires (!range<Value>)) // TODO: underconstrained
constexpr auto operator()(Value && value, Proj proj) const
{
return make_view_closure(bind_back(
remove_base_fn{}, static_cast<Value &&>(value), std::move(proj)));
}
};
struct RANGES_EMPTY_BASES remove_fn
: remove_base_fn, remove_bind_fn
{
using remove_base_fn::operator();
using remove_bind_fn::operator();
};
/// \relates remove_fn
/// \ingroup group-views
RANGES_INLINE_VARIABLE(remove_fn, remove)
} // namespace views
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_VIEW_REMOVE_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/view/any_view.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
// Copyright Casey Carter 2017
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_VIEW_ANY_VIEW_HPP
#define RANGES_V3_VIEW_ANY_VIEW_HPP
#include <type_traits>
#include <typeinfo>
#include <utility>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/default_sentinel.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#include <range/v3/utility/addressof.hpp>
#include <range/v3/utility/memory.hpp>
#include <range/v3/view/all.hpp>
#include <range/v3/view/facade.hpp>
#include <range/v3/detail/prologue.hpp>
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_INCONSISTENT_OVERRIDE
RANGES_DIAGNOSTIC_SUGGEST_OVERRIDE
namespace ranges
{
/// \brief An enum that denotes the supported subset of range concepts supported by a
/// range.
enum class category
{
none = 0, ///<\brief No concepts met.
input = 1, ///<\brief satisfies ranges::concepts::input_range
forward = 3, ///<\brief satisfies ranges::concepts::forward_range
bidirectional = 7, ///<\brief satisfies ranges::concepts::bidirectional_range
random_access = 15, ///<\brief satisfies ranges::concepts::random_access_range
mask = random_access, ///<\brief Mask away any properties other than iterator
///< category
sized = 16, ///<\brief satisfies ranges::concepts::sized_range
};
/** \name Binary operators for ranges::category
* \relates ranges::category
* \{
*/
constexpr category operator&(category lhs, category rhs) noexcept
{
return static_cast<category>(
static_cast<meta::_t<std::underlying_type<category>>>(lhs) &
static_cast<meta::_t<std::underlying_type<category>>>(rhs));
}
constexpr category operator|(category lhs, category rhs) noexcept
{
return static_cast<category>(
static_cast<meta::_t<std::underlying_type<category>>>(lhs) |
static_cast<meta::_t<std::underlying_type<category>>>(rhs));
}
constexpr category operator^(category lhs, category rhs) noexcept
{
return static_cast<category>(
static_cast<meta::_t<std::underlying_type<category>>>(lhs) ^
static_cast<meta::_t<std::underlying_type<category>>>(rhs));
}
constexpr category operator~(category lhs) noexcept
{
return static_cast<category>(
~static_cast<meta::_t<std::underlying_type<category>>>(lhs));
}
constexpr category & operator&=(category & lhs, category rhs) noexcept
{
return (lhs = lhs & rhs);
}
constexpr category & operator|=(category & lhs, category rhs) noexcept
{
return (lhs = lhs | rhs);
}
constexpr category & operator^=(category & lhs, category rhs) noexcept
{
return (lhs = lhs ^ rhs);
}
//!\}
/// \brief For a given range, return a ranges::category enum with the satisfied
/// concepts.
template<typename Rng>
constexpr category get_categories() noexcept
{
return (input_range<Rng> ? category::input : category::none) |
(forward_range<Rng> ? category::forward : category::none) |
(bidirectional_range<Rng> ? category::bidirectional : category::none) |
(random_access_range<Rng> ? category::random_access : category::none) |
(sized_range<Rng> ? category::sized : category::none);
}
/// \cond
namespace detail
{
// workaround the fact that typeid ignores cv-qualifiers
template<typename>
struct rtti_tag
{};
struct any_ref
{
any_ref() = default;
template<typename T>
constexpr any_ref(T & obj) noexcept
: obj_(detail::addressof(obj))
#ifndef NDEBUG
, info_(&typeid(rtti_tag<T>))
#endif
{}
template<typename T>
T & get() const noexcept
{
RANGES_ASSERT(obj_ && info_ && *info_ == typeid(rtti_tag<T>));
return *const_cast<T *>(static_cast<T const volatile *>(obj_));
}
private:
void const volatile * obj_ = nullptr;
#ifndef NDEBUG
std::type_info const * info_ = nullptr;
#endif
};
template<typename Base>
struct cloneable : Base
{
using Base::Base;
virtual ~cloneable() override = default;
cloneable() = default;
cloneable(cloneable const &) = delete;
cloneable & operator=(cloneable const &) = delete;
virtual std::unique_ptr<cloneable> clone() const = 0;
};
// clang-format off
/// \concept any_compatible_range_
/// \brief The \c any_compatible_range_ concept
template(typename Rng, typename Ref)(
concept (any_compatible_range_)(Rng, Ref),
convertible_to<range_reference_t<Rng>, Ref>
);
/// \concept any_compatible_range
/// \brief The \c any_compatible_range concept
template<typename Rng, typename Ref>
CPP_concept any_compatible_range =
CPP_concept_ref(detail::any_compatible_range_, Rng, Ref);
// clang-format on
template<typename Rng, typename = void>
struct any_view_sentinel_impl
: private box<sentinel_t<Rng>, any_view_sentinel_impl<Rng>>
{
private:
using box_t = typename any_view_sentinel_impl::box;
public:
any_view_sentinel_impl() = default;
any_view_sentinel_impl(Rng & rng)
: box_t(ranges::end(rng))
{}
void init(Rng & rng) noexcept
{
box_t::get() = ranges::end(rng);
}
sentinel_t<Rng> const & get(Rng &) const noexcept
{
return box_t::get();
}
};
template<typename Rng>
struct any_view_sentinel_impl<
Rng, meta::void_<decltype(ranges::end(std::declval<Rng const &>()))>>
{
any_view_sentinel_impl() = default;
any_view_sentinel_impl(Rng &) noexcept
{}
void init(Rng &) noexcept
{}
sentinel_t<Rng> get(Rng & rng) const noexcept
{
return ranges::end(rng);
}
};
template<typename Ref, bool Sized = false>
struct any_input_view_interface
{
virtual ~any_input_view_interface() = default;
virtual void init() = 0;
virtual bool done() = 0;
virtual Ref read() const = 0;
virtual void next() = 0;
};
template<typename Ref>
struct any_input_view_interface<Ref, true> : any_input_view_interface<Ref, false>
{
virtual std::size_t size() = 0;
};
template<typename Ref>
struct any_input_cursor
{
using single_pass = std::true_type;
any_input_cursor() = default;
constexpr any_input_cursor(any_input_view_interface<Ref> & view) noexcept
: view_{detail::addressof(view)}
{}
Ref read() const
{
return view_->read();
}
void next()
{
view_->next();
}
bool equal(any_input_cursor const &) const noexcept
{
return true;
}
bool equal(default_sentinel_t) const
{
return !view_ || view_->done();
}
private:
any_input_view_interface<Ref> * view_ = nullptr;
};
template<typename Rng, typename Ref, bool Sized = false>
struct RANGES_EMPTY_BASES any_input_view_impl
: any_input_view_interface<Ref, Sized>
, private any_view_sentinel_impl<Rng>
{
CPP_assert(any_compatible_range<Rng, Ref>);
CPP_assert(!Sized || (bool)sized_range<Rng>);
explicit any_input_view_impl(Rng rng)
: rng_{std::move(rng)}
{}
any_input_view_impl(any_input_view_impl const &) = delete;
any_input_view_impl & operator=(any_input_view_impl const &) = delete;
private:
using sentinel_box_t = any_view_sentinel_impl<Rng>;
virtual void init() override
{
sentinel_box_t::init(rng_);
current_ = ranges::begin(rng_);
}
virtual bool done() override
{
return current_ == sentinel_box_t::get(rng_);
}
virtual Ref read() const override
{
return *current_;
}
virtual void next() override
{
++current_;
}
std::size_t size() // override-ish
{
return static_cast<std::size_t>(ranges::size(rng_));
}
RANGES_NO_UNIQUE_ADDRESS Rng rng_;
RANGES_NO_UNIQUE_ADDRESS iterator_t<Rng> current_{};
};
template<typename Ref, category Cat = category::forward, typename enable = void>
struct any_cursor_interface;
template<typename Ref, category Cat>
struct any_cursor_interface<
Ref, Cat, meta::if_c<(Cat & category::mask) == category::forward>>
{
virtual ~any_cursor_interface() = default;
virtual any_ref iter()
const = 0; // returns a const ref to the cursor's wrapped iterator
virtual Ref read() const = 0;
virtual bool equal(any_cursor_interface const &) const = 0;
virtual void next() = 0;
};
template<typename Ref, category Cat>
struct any_cursor_interface<
Ref, Cat, meta::if_c<(Cat & category::mask) == category::bidirectional>>
: any_cursor_interface<Ref, (Cat & ~category::mask) | category::forward>
{
virtual void prev() = 0;
};
template<typename Ref, category Cat>
struct any_cursor_interface<
Ref, Cat, meta::if_c<(Cat & category::mask) == category::random_access>>
: any_cursor_interface<Ref, (Cat & ~category::mask) | category::bidirectional>
{
virtual void advance(std::ptrdiff_t) = 0;
virtual std::ptrdiff_t distance_to(any_cursor_interface const &) const = 0;
};
template<typename Ref, category Cat>
using any_cloneable_cursor_interface = cloneable<any_cursor_interface<Ref, Cat>>;
template<typename I, typename Ref, category Cat>
struct any_cursor_impl : any_cloneable_cursor_interface<Ref, Cat>
{
CPP_assert(convertible_to<iter_reference_t<I>, Ref>);
CPP_assert((Cat & category::forward) == category::forward);
any_cursor_impl() = default;
any_cursor_impl(I it)
: it_{std::move(it)}
{}
private:
using Forward =
any_cursor_interface<Ref, (Cat & ~category::mask) | category::forward>;
I it_;
any_ref iter() const override
{
return it_;
}
Ref read() const override
{
return *it_;
}
bool equal(Forward const & that_) const override
{
auto & that = polymorphic_downcast<any_cursor_impl const &>(that_);
return that.it_ == it_;
}
void next() override
{
++it_;
}
std::unique_ptr<any_cloneable_cursor_interface<Ref, Cat>> clone()
const override
{
return detail::make_unique<any_cursor_impl>(it_);
}
void prev() // override (sometimes; it's complicated)
{
--it_;
}
void advance(std::ptrdiff_t n) // override-ish
{
it_ += n;
}
std::ptrdiff_t distance_to(
any_cursor_interface<Ref, Cat> const & that_) const // override-ish
{
auto & that = polymorphic_downcast<any_cursor_impl const &>(that_);
return static_cast<std::ptrdiff_t>(that.it_ - it_);
}
};
struct fully_erased_view
{
virtual bool at_end(
any_ref) = 0; // any_ref is a const ref to a wrapped iterator
// to be compared to the erased view's last sentinel
protected:
~fully_erased_view() = default;
};
struct any_sentinel
{
any_sentinel() = default;
constexpr explicit any_sentinel(fully_erased_view & view) noexcept
: view_{&view}
{}
private:
template<typename, category>
friend struct any_cursor;
fully_erased_view * view_ = nullptr;
};
template<typename Ref, category Cat>
struct any_cursor
{
private:
CPP_assert((Cat & category::forward) == category::forward);
std::unique_ptr<any_cloneable_cursor_interface<Ref, Cat>> ptr_;
template<typename Rng>
using impl_t = any_cursor_impl<iterator_t<Rng>, Ref, Cat>;
public:
any_cursor() = default;
template(typename Rng)(
requires (!same_as<detail::decay_t<Rng>, any_cursor>) AND
forward_range<Rng> AND
any_compatible_range<Rng, Ref>)
explicit any_cursor(Rng && rng)
: ptr_{detail::make_unique<impl_t<Rng>>(begin(rng))}
{}
any_cursor(any_cursor &&) = default;
any_cursor(any_cursor const & that)
: ptr_{that.ptr_ ? that.ptr_->clone() : nullptr}
{}
any_cursor & operator=(any_cursor &&) = default;
any_cursor & operator=(any_cursor const & that)
{
ptr_ = (that.ptr_ ? that.ptr_->clone() : nullptr);
return *this;
}
Ref read() const
{
RANGES_EXPECT(ptr_);
return ptr_->read();
}
bool equal(any_cursor const & that) const
{
RANGES_EXPECT(!ptr_ == !that.ptr_);
return !ptr_ || ptr_->equal(*that.ptr_);
}
bool equal(any_sentinel const & that) const
{
RANGES_EXPECT(!ptr_ == !that.view_);
return !ptr_ || that.view_->at_end(ptr_->iter());
}
void next()
{
RANGES_EXPECT(ptr_);
ptr_->next();
}
CPP_member
auto prev() //
-> CPP_ret(void)(
requires (category::bidirectional == (Cat & category::bidirectional)))
{
RANGES_EXPECT(ptr_);
ptr_->prev();
}
CPP_member
auto advance(std::ptrdiff_t n) //
-> CPP_ret(void)(
requires (category::random_access == (Cat & category::random_access)))
{
RANGES_EXPECT(ptr_);
ptr_->advance(n);
}
CPP_member
auto distance_to(any_cursor const & that) const //
-> CPP_ret(std::ptrdiff_t)(
requires (category::random_access == (Cat & category::random_access)))
{
RANGES_EXPECT(!ptr_ == !that.ptr_);
return !ptr_ ? 0 : ptr_->distance_to(*that.ptr_);
}
};
template<typename Ref, category Cat,
bool = (Cat & category::sized) == category::sized>
struct any_view_interface : fully_erased_view
{
CPP_assert((Cat & category::forward) == category::forward);
virtual ~any_view_interface() = default;
virtual any_cursor<Ref, Cat> begin_cursor() = 0;
};
template<typename Ref, category Cat>
struct any_view_interface<Ref, Cat, true> : any_view_interface<Ref, Cat, false>
{
virtual std::size_t size() = 0;
};
template<typename Ref, category Cat>
using any_cloneable_view_interface = cloneable<any_view_interface<Ref, Cat>>;
template<typename Rng, typename Ref, category Cat>
struct RANGES_EMPTY_BASES any_view_impl
: any_cloneable_view_interface<Ref, Cat>
, private box<Rng, any_view_impl<Rng, Ref, Cat>>
, private any_view_sentinel_impl<Rng>
{
CPP_assert((Cat & category::forward) == category::forward);
CPP_assert(any_compatible_range<Rng, Ref>);
CPP_assert((Cat & category::sized) == category::none ||
(bool)sized_range<Rng>);
any_view_impl() = default;
any_view_impl(Rng rng)
: range_box_t{std::move(rng)}
, sentinel_box_t{range_box_t::get()}
// NB: initialization order dependence
{}
private:
using range_box_t = box<Rng, any_view_impl>;
using sentinel_box_t = any_view_sentinel_impl<Rng>;
any_cursor<Ref, Cat> begin_cursor() override
{
return any_cursor<Ref, Cat>{range_box_t::get()};
}
bool at_end(any_ref it_) override
{
auto & it = it_.get<iterator_t<Rng> const>();
return it == sentinel_box_t::get(range_box_t::get());
}
std::unique_ptr<any_cloneable_view_interface<Ref, Cat>> clone() const override
{
return detail::make_unique<any_view_impl>(range_box_t::get());
}
std::size_t size() // override-ish
{
return static_cast<std::size_t>(ranges::size(range_box_t::get()));
}
};
} // namespace detail
/// \endcond
/// \brief A type-erased view
/// \ingroup group-views
template<typename Ref, category Cat = category::input, typename enable = void>
struct any_view
: view_facade<any_view<Ref, Cat>,
(Cat & category::sized) == category::sized ? finite : unknown>
{
friend range_access;
CPP_assert((Cat & category::forward) == category::forward);
any_view() = default;
template(typename Rng)(
requires //
(!same_as<detail::decay_t<Rng>, any_view>) AND
input_range<Rng> AND
detail::any_compatible_range<Rng, Ref>)
any_view(Rng && rng)
: any_view(static_cast<Rng &&>(rng),
meta::bool_<(get_categories<Rng>() & Cat) == Cat>{})
{}
any_view(any_view &&) = default;
any_view(any_view const & that)
: ptr_{that.ptr_ ? that.ptr_->clone() : nullptr}
{}
any_view & operator=(any_view &&) = default;
any_view & operator=(any_view const & that)
{
ptr_ = (that.ptr_ ? that.ptr_->clone() : nullptr);
return *this;
}
CPP_member
auto size() //
-> CPP_ret(std::size_t)(
requires (category::sized == (Cat & category::sized)))
{
return ptr_ ? ptr_->size() : 0;
}
private:
template<typename Rng>
using impl_t = detail::any_view_impl<views::all_t<Rng>, Ref, Cat>;
template<typename Rng>
any_view(Rng && rng, std::true_type)
: ptr_{detail::make_unique<impl_t<Rng>>(views::all(static_cast<Rng &&>(rng)))}
{}
template<typename Rng>
any_view(Rng &&, std::false_type)
{
static_assert(
(get_categories<Rng>() & Cat) == Cat,
"The range passed to any_view() does not model the requested category");
}
detail::any_cursor<Ref, Cat> begin_cursor()
{
return ptr_ ? ptr_->begin_cursor() : detail::value_init{};
}
detail::any_sentinel end_cursor() noexcept
{
return detail::any_sentinel{*ptr_};
}
std::unique_ptr<detail::any_cloneable_view_interface<Ref, Cat>> ptr_;
};
// input and not forward
template<typename Ref, category Cat>
struct any_view<Ref, Cat, meta::if_c<(Cat & category::forward) == category::input>>
: view_facade<any_view<Ref, Cat, void>,
(Cat & category::sized) == category::sized ? finite : unknown>
{
friend range_access;
any_view() = default;
template(typename Rng)(
requires //
(!same_as<detail::decay_t<Rng>, any_view>) AND
input_range<Rng> AND
detail::any_compatible_range<Rng, Ref>)
any_view(Rng && rng)
: ptr_{std::make_shared<impl_t<Rng>>(views::all(static_cast<Rng &&>(rng)))}
{}
CPP_member
auto size() //
-> CPP_ret(std::size_t)(
requires (category::sized == (Cat & category::sized)))
{
return ptr_ ? ptr_->size() : 0;
}
private:
template<typename Rng>
using impl_t =
detail::any_input_view_impl<views::all_t<Rng>, Ref,
(Cat & category::sized) == category::sized>;
detail::any_input_cursor<Ref> begin_cursor()
{
if(!ptr_)
return {};
ptr_->init();
return detail::any_input_cursor<Ref>{*ptr_};
}
std::shared_ptr<detail::any_input_view_interface<Ref, (Cat & category::sized) ==
category::sized>>
ptr_;
};
#if RANGES_CXX_DEDUCTION_GUIDES >= RANGES_CXX_DEDUCTION_GUIDES_17
template(typename Rng)(
requires view_<Rng>)
any_view(Rng &&)
->any_view<range_reference_t<Rng>, get_categories<Rng>()>;
#endif
template<typename Ref>
using any_input_view RANGES_DEPRECATED(
"Use any_view<Ref, category::input> instead.") = any_view<Ref, category::input>;
template<typename Ref>
using any_forward_view RANGES_DEPRECATED(
"Use any_view<Ref, category::forward> instead.") =
any_view<Ref, category::forward>;
template<typename Ref>
using any_bidirectional_view RANGES_DEPRECATED(
"Use any_view<Ref, category::bidirectional> instead.") =
any_view<Ref, category::bidirectional>;
template<typename Ref>
using any_random_access_view RANGES_DEPRECATED(
"Use any_view<Ref, category::random_access> instead.") =
any_view<Ref, category::random_access>;
} // namespace ranges
#include <range/v3/detail/satisfy_boost_range.hpp>
RANGES_SATISFY_BOOST_RANGE(::ranges::any_view)
RANGES_DIAGNOSTIC_POP
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/detail/config.hpp | // Range v3 library
//
// Copyright Eric Niebler 2013-present
// Copyright Casey Carter 2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_DETAIL_CONFIG_HPP
#define RANGES_V3_DETAIL_CONFIG_HPP
// Grab some version information.
#ifndef __has_include
#include <iosfwd>
#elif __has_include(<version>)
#include <version>
#else
#include <iosfwd>
#endif
#if(defined(NDEBUG) && !defined(RANGES_ENSURE_MSG)) || \
(!defined(NDEBUG) && !defined(RANGES_ASSERT) && \
((defined(__GNUC__) && !defined(__clang__) && \
(__GNUC__ < 5 || defined(__MINGW32__))) || \
defined(_MSVC_STL_VERSION)))
#include <cstdio>
#include <cstdlib>
namespace ranges
{
namespace detail
{
template<typename = void>
[[noreturn]] void assert_failure(char const * file, int line, char const * msg)
{
std::fprintf(stderr, "%s(%d): %s\n", file, line, msg);
std::abort();
}
} // namespace detail
} // namespace ranges
#endif
#ifndef RANGES_ASSERT
// Always use our hand-rolled assert implementation on older GCCs, which do
// not allow assert to be used in a constant expression, and on MSVC whose
// assert is not marked [[noreturn]].
#if !defined(NDEBUG) && ((defined(__GNUC__) && !defined(__clang__) && \
(__GNUC__ < 5 || defined(__MINGW32__))) || \
defined(_MSVC_STL_VERSION))
#define RANGES_ASSERT(...) \
static_cast<void>((__VA_ARGS__) \
? void(0) \
: ::ranges::detail::assert_failure( \
__FILE__, __LINE__, "assertion failed: " #__VA_ARGS__))
#else
#include <cassert>
#define RANGES_ASSERT assert
#endif
#endif
#include <meta/meta_fwd.hpp>
#ifndef RANGES_ASSUME
#if defined(__clang__) || defined(__GNUC__)
#define RANGES_ASSUME(COND) static_cast<void>((COND) ? void(0) : __builtin_unreachable())
#elif defined(_MSC_VER)
#define RANGES_ASSUME(COND) static_cast<void>(__assume(COND))
#else
#define RANGES_ASSUME(COND) static_cast<void>(COND)
#endif
#endif // RANGES_ASSUME
#ifndef RANGES_EXPECT
#ifdef NDEBUG
#define RANGES_EXPECT(COND) RANGES_ASSUME(COND)
#else // NDEBUG
#define RANGES_EXPECT(COND) RANGES_ASSERT(COND)
#endif // NDEBUG
#endif // RANGES_EXPECT
#ifndef RANGES_ENSURE_MSG
#if defined(NDEBUG)
#define RANGES_ENSURE_MSG(COND, MSG) \
static_cast<void>((COND) ? void(0) \
: ::ranges::detail::assert_failure( \
__FILE__, __LINE__, "ensure failed: " MSG))
#else
#define RANGES_ENSURE_MSG(COND, MSG) RANGES_ASSERT((COND) && MSG)
#endif
#endif
#ifndef RANGES_ENSURE
#define RANGES_ENSURE(...) RANGES_ENSURE_MSG((__VA_ARGS__), #__VA_ARGS__)
#endif
#define RANGES_DECLTYPE_AUTO_RETURN(...) \
->decltype(__VA_ARGS__) \
{ \
return (__VA_ARGS__); \
} \
/**/
#define RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT(...) \
noexcept(noexcept(decltype(__VA_ARGS__)(__VA_ARGS__)))->decltype(__VA_ARGS__) \
{ \
return (__VA_ARGS__); \
} \
/**/
#define RANGES_AUTO_RETURN_NOEXCEPT(...) \
noexcept(noexcept(decltype(__VA_ARGS__)(__VA_ARGS__))) \
{ \
return (__VA_ARGS__); \
} \
/**/
#define RANGES_DECLTYPE_NOEXCEPT(...) \
noexcept(noexcept(decltype(__VA_ARGS__)(__VA_ARGS__)))->decltype(__VA_ARGS__) /**/
// Non-portable forward declarations of standard containers
#define RANGES_BEGIN_NAMESPACE_STD META_BEGIN_NAMESPACE_STD
#define RANGES_END_NAMESPACE_STD META_END_NAMESPACE_STD
#define RANGES_BEGIN_NAMESPACE_VERSION META_BEGIN_NAMESPACE_VERSION
#define RANGES_END_NAMESPACE_VERSION META_END_NAMESPACE_VERSION
#define RANGES_BEGIN_NAMESPACE_CONTAINER META_BEGIN_NAMESPACE_CONTAINER
#define RANGES_END_NAMESPACE_CONTAINER META_END_NAMESPACE_CONTAINER
// Database of feature versions
#define RANGES_CXX_STATIC_ASSERT_11 200410L
#define RANGES_CXX_STATIC_ASSERT_14 RANGES_CXX_STATIC_ASSERT_11
#define RANGES_CXX_STATIC_ASSERT_17 201411L
#define RANGES_CXX_VARIABLE_TEMPLATES_11 0L
#define RANGES_CXX_VARIABLE_TEMPLATES_14 201304L
#define RANGES_CXX_VARIABLE_TEMPLATES_17 RANGES_CXX_VARIABLE_TEMPLATES_14
#define RANGES_CXX_ATTRIBUTE_DEPRECATED_11 0L
#define RANGES_CXX_ATTRIBUTE_DEPRECATED_14 201309L
#define RANGES_CXX_ATTRIBUTE_DEPRECATED_17 RANGES_CXX_ATTRIBUTE_DEPRECATED_14
#define RANGES_CXX_CONSTEXPR_11 200704L
#define RANGES_CXX_CONSTEXPR_14 201304L
#define RANGES_CXX_CONSTEXPR_17 201603L
#define RANGES_CXX_CONSTEXPR_20 201907L
#define RANGES_CXX_CONSTEXPR_LAMBDAS 201603L
#define RANGES_CXX_RANGE_BASED_FOR_11 200907L
#define RANGES_CXX_RANGE_BASED_FOR_14 RANGES_CXX_RANGE_BASED_FOR_11
#define RANGES_CXX_RANGE_BASED_FOR_17 201603L
#define RANGES_CXX_LIB_IS_FINAL_11 0L
#define RANGES_CXX_LIB_IS_FINAL_14 201402L
#define RANGES_CXX_LIB_IS_FINAL_17 RANGES_CXX_LIB_IS_FINAL_14
#define RANGES_CXX_RETURN_TYPE_DEDUCTION_11 0L
#define RANGES_CXX_RETURN_TYPE_DEDUCTION_14 201304L
#define RANGES_CXX_RETURN_TYPE_DEDUCTION_17 RANGES_CXX_RETURN_TYPE_DEDUCTION_14
#define RANGES_CXX_GENERIC_LAMBDAS_11 0L
#define RANGES_CXX_GENERIC_LAMBDAS_14 201304L
#define RANGES_CXX_GENERIC_LAMBDAS_17 RANGES_CXX_GENERIC_LAMBDAS_14
#define RANGES_CXX_STD_11 201103L
#define RANGES_CXX_STD_14 201402L
#define RANGES_CXX_STD_17 201703L
#define RANGES_CXX_THREAD_LOCAL_PRE_STANDARD \
200000L // Arbitrary number between 0 and C++11
#define RANGES_CXX_THREAD_LOCAL_11 RANGES_CXX_STD_11
#define RANGES_CXX_THREAD_LOCAL_14 RANGES_CXX_THREAD_LOCAL_11
#define RANGES_CXX_THREAD_LOCAL_17 RANGES_CXX_THREAD_LOCAL_14
#define RANGES_CXX_INLINE_VARIABLES_11 0L
#define RANGES_CXX_INLINE_VARIABLES_14 0L
#define RANGES_CXX_INLINE_VARIABLES_17 201606L
#define RANGES_CXX_COROUTINES_11 0L
#define RANGES_CXX_COROUTINES_14 0L
#define RANGES_CXX_COROUTINES_17 0L
#define RANGES_CXX_COROUTINES_TS1 201703L
#define RANGES_CXX_DEDUCTION_GUIDES_11 0L
#define RANGES_CXX_DEDUCTION_GUIDES_14 0L
#define RANGES_CXX_DEDUCTION_GUIDES_17 201606L
#define RANGES_CXX_IF_CONSTEXPR_11 0L
#define RANGES_CXX_IF_CONSTEXPR_14 0L
#define RANGES_CXX_IF_CONSTEXPR_17 201606L
#define RANGES_CXX_ALIGNED_NEW_11 0L
#define RANGES_CXX_ALIGNED_NEW_14 0L
#define RANGES_CXX_ALIGNED_NEW_17 201606L
// Implementation-specific diagnostic control
#if defined(_MSC_VER) && !defined(__clang__)
#define RANGES_DIAGNOSTIC_PUSH __pragma(warning(push))
#define RANGES_DIAGNOSTIC_POP __pragma(warning(pop))
#define RANGES_DIAGNOSTIC_IGNORE_PRAGMAS __pragma(warning(disable : 4068))
#define RANGES_DIAGNOSTIC_IGNORE(X) \
RANGES_DIAGNOSTIC_IGNORE_PRAGMAS __pragma(warning(disable : X))
#define RANGES_DIAGNOSTIC_IGNORE_SHADOWING RANGES_DIAGNOSTIC_IGNORE(4456)
#define RANGES_DIAGNOSTIC_IGNORE_INDENTATION
#define RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_INTERNAL
#define RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS RANGES_DIAGNOSTIC_IGNORE(4099)
#define RANGES_DIAGNOSTIC_IGNORE_GLOBAL_CONSTRUCTORS
#define RANGES_DIAGNOSTIC_IGNORE_SIGN_CONVERSION
#define RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_INTERNAL
#define RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_MEMBER
#define RANGES_DIAGNOSTIC_IGNORE_ZERO_LENGTH_ARRAY
#define RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT
#define RANGES_DIAGNOSTIC_IGNORE_CXX2A_COMPAT
#define RANGES_DIAGNOSTIC_IGNORE_FLOAT_EQUAL
#define RANGES_DIAGNOSTIC_IGNORE_FLOAT_CONVERSION
#define RANGES_DIAGNOSTIC_IGNORE_MISSING_BRACES
#define RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_FUNC_TEMPLATE
#define RANGES_DIAGNOSTIC_IGNORE_INCONSISTENT_OVERRIDE
#define RANGES_DIAGNOSTIC_IGNORE_RANGE_LOOP_ANALYSIS
#define RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS RANGES_DIAGNOSTIC_IGNORE(4996)
#define RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_THIS_CAPTURE
#define RANGES_DIAGNOSTIC_IGNORE_INIT_LIST_LIFETIME
// Ignores both "divide by zero" and "mod by zero":
#define RANGES_DIAGNOSTIC_IGNORE_DIVIDE_BY_ZERO RANGES_DIAGNOSTIC_IGNORE(4723 4724)
#define RANGES_DIAGNOSTIC_IGNORE_UNSIGNED_MATH RANGES_DIAGNOSTIC_IGNORE(4146)
#define RANGES_DIAGNOSTIC_IGNORE_TRUNCATION RANGES_DIAGNOSTIC_IGNORE(4244)
#define RANGES_DIAGNOSTIC_IGNORE_MULTIPLE_ASSIGNMENT_OPERATORS \
RANGES_DIAGNOSTIC_IGNORE(4522)
#define RANGES_DIAGNOSTIC_IGNORE_VOID_PTR_DEREFERENCE
#define RANGES_DIAGNOSTIC_KEYWORD_MACRO
#define RANGES_DIAGNOSTIC_SUGGEST_OVERRIDE
#define RANGES_CXX_VER _MSVC_LANG
#if _MSC_VER < 1920 || _MSVC_LANG < 201703L
#error range-v3 requires Visual Studio 2019 with the /std:c++17 (or /std:c++latest) and /permissive- options.
#endif
#if _MSC_VER < 1927
#define RANGES_WORKAROUND_MSVC_895622 // Error when phase 1 name binding finds only
// deleted function
#if _MSC_VER < 1925
#define RANGES_WORKAROUND_MSVC_779708 // ADL for operands of function type [No workaround]
#if _MSC_VER < 1923
#define RANGES_WORKAROUND_MSVC_573728 // rvalues of array types bind to lvalue references
// [no workaround]
#define RANGES_WORKAROUND_MSVC_934330 // Deduction guide not correctly preferred to copy
// deduction candidate [No workaround]
#if _MSC_VER < 1922
#define RANGES_WORKAROUND_MSVC_756601 // constexpr friend non-template erroneously
// rejected with C3615
#define RANGES_WORKAROUND_MSVC_793042 // T[0] sometimes accepted as a valid type in SFINAE
// context
#if _MSC_VER < 1921
#define RANGES_WORKAROUND_MSVC_785522 // SFINAE failure for error in immediate context
#define RANGES_WORKAROUND_MSVC_786376 // Assertion casting anonymous union member in
// trailing-return-type
#define RANGES_WORKAROUND_MSVC_787074 // Over-eager substitution of dependent type in
// non-instantiated nested class template
#define RANGES_WORKAROUND_MSVC_790554 // Assert for return type that uses dependent
// default non-type template argument
#endif // _MSC_VER < 1921
#endif // _MSC_VER < 1922
#endif // _MSC_VER < 1923
#endif // _MSC_VER < 1925
#endif // _MSC_VER < 1926
#if 1 // Fixed in 1920, but more bugs hiding behind workaround
#define RANGES_WORKAROUND_MSVC_701385 // Yet another alias expansion error
#endif
#define RANGES_WORKAROUND_MSVC_249830 // constexpr and arguments that aren't subject to
// lvalue-to-rvalue conversion
#define RANGES_WORKAROUND_MSVC_677925 // Bogus C2676 "binary '++': '_Ty' does not define
// this operator"
#define RANGES_WORKAROUND_MSVC_683388 // decltype(*i) is incorrectly an rvalue reference
// for pointer-to-array i
#define RANGES_WORKAROUND_MSVC_688606 // SFINAE failing to account for access control
// during specialization matching
#define RANGES_WORKAROUND_MSVC_786312 // Yet another mixed-pack-expansion failure
#define RANGES_WORKAROUND_MSVC_792338 // Failure to match specialization enabled via call
// to constexpr function
#define RANGES_WORKAROUND_MSVC_835948 // Silent bad codegen destroying sized_generator [No
// workaround]
#define RANGES_WORKAROUND_MSVC_934264 // Explicitly-defaulted inherited default
// constructor is not correctly implicitly constexpr
#if _MSVC_LANG <= 201703L
#define RANGES_WORKAROUND_MSVC_OLD_LAMBDA
#endif
#if _MSVC_LANG <= 201703L
#define RANGES_WORKAROUND_MSVC_UNUSABLE_SPAN // MSVC provides a <span> header that is
// guarded against use with std <= 17
#endif
#elif defined(__GNUC__) || defined(__clang__)
#define RANGES_PRAGMA(X) _Pragma(#X)
#define RANGES_DIAGNOSTIC_PUSH RANGES_PRAGMA(GCC diagnostic push)
#define RANGES_DIAGNOSTIC_POP RANGES_PRAGMA(GCC diagnostic pop)
#define RANGES_DIAGNOSTIC_IGNORE_PRAGMAS RANGES_PRAGMA(GCC diagnostic ignored "-Wpragmas")
#define RANGES_DIAGNOSTIC_IGNORE(X) \
RANGES_DIAGNOSTIC_IGNORE_PRAGMAS \
RANGES_PRAGMA(GCC diagnostic ignored "-Wunknown-pragmas") \
RANGES_PRAGMA(GCC diagnostic ignored "-Wunknown-warning-option") \
RANGES_PRAGMA(GCC diagnostic ignored X)
#define RANGES_DIAGNOSTIC_IGNORE_SHADOWING RANGES_DIAGNOSTIC_IGNORE("-Wshadow")
#define RANGES_DIAGNOSTIC_IGNORE_INDENTATION \
RANGES_DIAGNOSTIC_IGNORE("-Wmisleading-indentation")
#define RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_INTERNAL \
RANGES_DIAGNOSTIC_IGNORE("-Wundefined-internal")
#define RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS \
RANGES_DIAGNOSTIC_IGNORE("-Wmismatched-tags")
#define RANGES_DIAGNOSTIC_IGNORE_SIGN_CONVERSION \
RANGES_DIAGNOSTIC_IGNORE("-Wsign-conversion")
#define RANGES_DIAGNOSTIC_IGNORE_FLOAT_EQUAL RANGES_DIAGNOSTIC_IGNORE("-Wfloat-equal")
#define RANGES_DIAGNOSTIC_IGNORE_FLOAT_CONVERSION RANGES_DIAGNOSTIC_IGNORE("-Wfloat-conversion")
#define RANGES_DIAGNOSTIC_IGNORE_MISSING_BRACES \
RANGES_DIAGNOSTIC_IGNORE("-Wmissing-braces")
#define RANGES_DIAGNOSTIC_IGNORE_GLOBAL_CONSTRUCTORS \
RANGES_DIAGNOSTIC_IGNORE("-Wglobal-constructors")
#define RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_INTERNAL \
RANGES_DIAGNOSTIC_IGNORE("-Wunneeded-internal-declaration")
#define RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_MEMBER \
RANGES_DIAGNOSTIC_IGNORE("-Wunneeded-member-function")
#define RANGES_DIAGNOSTIC_IGNORE_ZERO_LENGTH_ARRAY \
RANGES_DIAGNOSTIC_IGNORE("-Wzero-length-array")
#define RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT RANGES_DIAGNOSTIC_IGNORE("-Wc++1z-compat")
#define RANGES_DIAGNOSTIC_IGNORE_CXX2A_COMPAT RANGES_DIAGNOSTIC_IGNORE("-Wc++2a-compat")
#define RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_FUNC_TEMPLATE \
RANGES_DIAGNOSTIC_IGNORE("-Wundefined-func-template")
#define RANGES_DIAGNOSTIC_IGNORE_INCONSISTENT_OVERRIDE \
RANGES_DIAGNOSTIC_IGNORE("-Winconsistent-missing-override")
#define RANGES_DIAGNOSTIC_IGNORE_RANGE_LOOP_ANALYSIS \
RANGES_DIAGNOSTIC_IGNORE("-Wrange-loop-analysis")
#define RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS \
RANGES_DIAGNOSTIC_IGNORE("-Wdeprecated-declarations")
#define RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_THIS_CAPTURE \
RANGES_DIAGNOSTIC_IGNORE("-Wdeprecated-this-capture")
#define RANGES_DIAGNOSTIC_IGNORE_INIT_LIST_LIFETIME \
RANGES_DIAGNOSTIC_IGNORE("-Winit-list-lifetime")
#define RANGES_DIAGNOSTIC_IGNORE_DIVIDE_BY_ZERO
#define RANGES_DIAGNOSTIC_IGNORE_UNSIGNED_MATH
#define RANGES_DIAGNOSTIC_IGNORE_TRUNCATION
#define RANGES_DIAGNOSTIC_IGNORE_MULTIPLE_ASSIGNMENT_OPERATORS
#define RANGES_DIAGNOSTIC_IGNORE_VOID_PTR_DEREFERENCE \
RANGES_DIAGNOSTIC_IGNORE("-Wvoid-ptr-dereference")
#define RANGES_DIAGNOSTIC_KEYWORD_MACRO RANGES_DIAGNOSTIC_IGNORE("-Wkeyword-macro")
#define RANGES_DIAGNOSTIC_SUGGEST_OVERRIDE RANGES_DIAGNOSTIC_IGNORE("-Wsuggest-override")
#define RANGES_WORKAROUND_CWG_1554
#ifdef __clang__
#if __clang_major__ < 4
#define RANGES_WORKAROUND_CLANG_23135 // constexpr leads to premature instantiation on
// clang-3.x
#endif
#if (__clang_major__ >= 7 && __clang_major__ <= 9) || defined(__apple_build_version__)
#define RANGES_WORKAROUND_CLANG_43400 // template friend is redefinition of itself
#endif
#else // __GNUC__
#if __GNUC__ == 7 || __GNUC__ == 8
#define RANGES_WORKAROUND_GCC_91525 /* Workaround strange GCC ICE */
#endif
#if __GNUC__ >= 9
#if __GNUC__ == 9 && __GNUC_MINOR__ < 3 && __cplusplus == RANGES_CXX_STD_17
#define RANGES_WORKAROUND_GCC_91923 // Failure-to-SFINAE with class type NTTP in C++17
#endif
#endif
#endif
#else
#define RANGES_DIAGNOSTIC_PUSH
#define RANGES_DIAGNOSTIC_POP
#define RANGES_DIAGNOSTIC_IGNORE_PRAGMAS
#define RANGES_DIAGNOSTIC_IGNORE_SHADOWING
#define RANGES_DIAGNOSTIC_IGNORE_INDENTATION
#define RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_INTERNAL
#define RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
#define RANGES_DIAGNOSTIC_IGNORE_GLOBAL_CONSTRUCTORS
#define RANGES_DIAGNOSTIC_IGNORE_SIGN_CONVERSION
#define RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_INTERNAL
#define RANGES_DIAGNOSTIC_IGNORE_UNNEEDED_MEMBER
#define RANGES_DIAGNOSTIC_IGNORE_ZERO_LENGTH_ARRAY
#define RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT
#define RANGES_DIAGNOSTIC_IGNORE_CXX2A_COMPAT
#define RANGES_DIAGNOSTIC_IGNORE_FLOAT_EQUAL
#define RANGES_DIAGNOSTIC_IGNORE_MISSING_BRACES
#define RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_FUNC_TEMPLATE
#define RANGES_DIAGNOSTIC_IGNORE_INCONSISTENT_OVERRIDE
#define RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_DECLARATIONS
#define RANGES_DIAGNOSTIC_IGNORE_DEPRECATED_THIS_CAPTURE
#define RANGES_DIAGNOSTIC_IGNORE_INIT_LIST_LIFETIME
#define RANGES_DIAGNOSTIC_IGNORE_DIVIDE_BY_ZERO
#define RANGES_DIAGNOSTIC_IGNORE_UNSIGNED_MATH
#define RANGES_DIAGNOSTIC_IGNORE_TRUNCATION
#define RANGES_DIAGNOSTIC_IGNORE_MULTIPLE_ASSIGNMENT_OPERATORS
#define RANGES_DIAGNOSTIC_IGNORE_VOID_PTR_DEREFERENCE
#define RANGES_DIAGNOSTIC_KEYWORD_MACRO
#define RANGES_DIAGNOSTIC_SUGGEST_OVERRIDE
#endif
// Configuration via feature-test macros, with fallback to __cplusplus
#ifndef RANGES_CXX_VER
#define RANGES_CXX_VER __cplusplus
#endif
#define RANGES_CXX_FEATURE_CONCAT2(y, z) RANGES_CXX_##y##_##z
#define RANGES_CXX_FEATURE_CONCAT(y, z) RANGES_CXX_FEATURE_CONCAT2(y, z)
#if RANGES_CXX_VER >= RANGES_CXX_STD_17
#define RANGES_CXX_STD RANGES_CXX_STD_17
#define RANGES_CXX_FEATURE(x) RANGES_CXX_FEATURE_CONCAT(x, 17)
#elif RANGES_CXX_VER >= RANGES_CXX_STD_14
#define RANGES_CXX_STD RANGES_CXX_STD_14
#define RANGES_CXX_FEATURE(x) RANGES_CXX_FEATURE_CONCAT(x, 14)
#else
#define RANGES_CXX_STD RANGES_CXX_STD_11
#define RANGES_CXX_FEATURE(x) RANGES_CXX_FEATURE_CONCAT(x, 11)
#endif
#ifndef RANGES_CXX_STATIC_ASSERT
#ifdef __cpp_static_assert
#define RANGES_CXX_STATIC_ASSERT __cpp_static_assert
#else
#define RANGES_CXX_STATIC_ASSERT RANGES_CXX_FEATURE(STATIC_ASSERT)
#endif
#endif
#ifndef RANGES_CXX_VARIABLE_TEMPLATES
#ifdef __cpp_variable_templates
#define RANGES_CXX_VARIABLE_TEMPLATES __cpp_variable_templates
#else
#define RANGES_CXX_VARIABLE_TEMPLATES RANGES_CXX_FEATURE(VARIABLE_TEMPLATES)
#endif
#endif
#if(defined(__cpp_lib_type_trait_variable_templates) && \
__cpp_lib_type_trait_variable_templates > 0) || \
RANGES_CXX_VER >= RANGES_CXX_STD_17
#define RANGES_CXX_TRAIT_VARIABLE_TEMPLATES 1
#else
#define RANGES_CXX_TRAIT_VARIABLE_TEMPLATES 0
#endif
#ifndef RANGES_CXX_ATTRIBUTE_DEPRECATED
#ifdef __has_cpp_attribute
#define RANGES_CXX_ATTRIBUTE_DEPRECATED __has_cpp_attribute(deprecated)
#elif defined(__cpp_attribute_deprecated)
#define RANGES_CXX_ATTRIBUTE_DEPRECATED __cpp_attribute_deprecated
#else
#define RANGES_CXX_ATTRIBUTE_DEPRECATED RANGES_CXX_FEATURE(ATTRIBUTE_DEPRECATED)
#endif
#endif
#ifndef RANGES_CXX_CONSTEXPR
#ifdef __cpp_constexpr
#define RANGES_CXX_CONSTEXPR __cpp_constexpr
#else
#define RANGES_CXX_CONSTEXPR RANGES_CXX_FEATURE(CONSTEXPR)
#endif
#endif
#ifndef RANGES_CXX_RANGE_BASED_FOR
#ifdef __cpp_range_based_for
#define RANGES_CXX_RANGE_BASED_FOR __cpp_range_based_for
#else
#define RANGES_CXX_RANGE_BASED_FOR RANGES_CXX_FEATURE(RANGE_BASED_FOR)
#endif
#endif
#ifndef RANGES_CXX_LIB_IS_FINAL
#include <type_traits>
#ifdef __cpp_lib_is_final
#define RANGES_CXX_LIB_IS_FINAL __cpp_lib_is_final
#else
#define RANGES_CXX_LIB_IS_FINAL RANGES_CXX_FEATURE(LIB_IS_FINAL)
#endif
#endif
#ifndef RANGES_CXX_RETURN_TYPE_DEDUCTION
#ifdef __cpp_return_type_deduction
#define RANGES_CXX_RETURN_TYPE_DEDUCTION __cpp_return_type_deduction
#else
#define RANGES_CXX_RETURN_TYPE_DEDUCTION RANGES_CXX_FEATURE(RETURN_TYPE_DEDUCTION)
#endif
#endif
#ifndef RANGES_CXX_GENERIC_LAMBDAS
#ifdef __cpp_generic_lambdas
#define RANGES_CXX_GENERIC_LAMBDAS __cpp_generic_lambdas
#else
#define RANGES_CXX_GENERIC_LAMBDAS RANGES_CXX_FEATURE(GENERIC_LAMBDAS)
#endif
#endif
#ifndef RANGES_CXX_THREAD_LOCAL
#if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED <= 70100
#define RANGES_CXX_THREAD_LOCAL 0
#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED) || \
(defined(__clang__) && (defined(__CYGWIN__) || defined(__apple_build_version__)))
// BUGBUG avoid unresolved __cxa_thread_atexit
#define RANGES_CXX_THREAD_LOCAL RANGES_CXX_THREAD_LOCAL_PRE_STANDARD
#else
#define RANGES_CXX_THREAD_LOCAL RANGES_CXX_FEATURE(THREAD_LOCAL)
#endif
#endif
#if !defined(RANGES_DEPRECATED) && !defined(RANGES_DISABLE_DEPRECATED_WARNINGS)
#if defined(__GNUC__) && !defined(__clang__)
// GCC's support for [[deprecated("message")]] is unusably buggy.
#define RANGES_DEPRECATED(MSG) __attribute__((deprecated(MSG)))
#elif RANGES_CXX_ATTRIBUTE_DEPRECATED && \
!((defined(__clang__) || defined(__GNUC__)) && RANGES_CXX_STD < RANGES_CXX_STD_14)
#define RANGES_DEPRECATED(MSG) [[deprecated(MSG)]]
#elif defined(__clang__) || defined(__GNUC__)
#define RANGES_DEPRECATED(MSG) __attribute__((deprecated(MSG)))
#endif
#endif
#ifndef RANGES_DEPRECATED
#define RANGES_DEPRECATED(MSG)
#endif
#if !defined(RANGES_DEPRECATED_HEADER) && !defined(RANGES_DISABLE_DEPRECATED_WARNINGS)
#ifdef __GNUC__
#define RANGES_DEPRECATED_HEADER(MSG) RANGES_PRAGMA(GCC warning MSG)
#elif defined(_MSC_VER)
#define RANGES_STRINGIZE_(MSG) #MSG
#define RANGES_STRINGIZE(MSG) RANGES_STRINGIZE_(MSG)
#define RANGES_DEPRECATED_HEADER(MSG) \
__pragma(message(__FILE__ "(" RANGES_STRINGIZE(__LINE__) ") : Warning: " MSG))
#endif
#else
#define RANGES_DEPRECATED_HEADER(MSG) /**/
#endif
// #ifndef RANGES_DEPRECATED_HEADER
// #define RANGES_DEPRECATED_HEADER(MSG)
// #endif
#ifndef RANGES_CXX_COROUTINES
#if defined(__cpp_coroutines) && defined(__has_include)
#if __has_include(<coroutine>)
#define RANGES_CXX_COROUTINES __cpp_coroutines
#define RANGES_COROUTINES_HEADER <coroutine>
#define RANGES_COROUTINES_NS std
#elif __has_include(<experimental/coroutine>)
#define RANGES_CXX_COROUTINES __cpp_coroutines
#define RANGES_COROUTINES_HEADER <experimental/coroutine>
#define RANGES_COROUTINES_NS std::experimental
#endif
#endif
#ifndef RANGES_CXX_COROUTINES
#define RANGES_CXX_COROUTINES RANGES_CXX_FEATURE(COROUTINES)
#endif
#endif
#ifdef NDEBUG
#define RANGES_NDEBUG_CONSTEXPR constexpr
#else
#define RANGES_NDEBUG_CONSTEXPR inline
#endif
#ifndef RANGES_CXX_INLINE_VARIABLES
#ifdef __cpp_inline_variables
#define RANGES_CXX_INLINE_VARIABLES __cpp_inline_variables
#elif defined(__clang__) && (__clang_major__ == 3 && __clang_minor__ == 9) && \
RANGES_CXX_VER > RANGES_CXX_STD_14
// Clang 3.9 supports inline variables in C++17 mode, but doesn't define
// __cpp_inline_variables
#define RANGES_CXX_INLINE_VARIABLES RANGES_CXX_INLINE_VARIABLES_17
#else
#define RANGES_CXX_INLINE_VARIABLES RANGES_CXX_FEATURE(INLINE_VARIABLES)
#endif // __cpp_inline_variables
#endif // RANGES_CXX_INLINE_VARIABLES
#if RANGES_CXX_INLINE_VARIABLES < RANGES_CXX_INLINE_VARIABLES_17 && \
!defined(RANGES_DOXYGEN_INVOKED)
#define RANGES_INLINE_VAR
#define RANGES_INLINE_VARIABLE(type, name) \
namespace \
{ \
constexpr auto & name = ::ranges::static_const<type>::value; \
}
#else // RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17
#define RANGES_INLINE_VAR inline
#define RANGES_INLINE_VARIABLE(type, name) \
inline constexpr type name{}; \
/**/
#endif // RANGES_CXX_INLINE_VARIABLES
#if defined(RANGES_DOXYGEN_INVOKED)
#define RANGES_DEFINE_CPO(type, name) \
inline constexpr type name{}; \
/**/
#elif RANGES_CXX_INLINE_VARIABLES < RANGES_CXX_INLINE_VARIABLES_17
#define RANGES_DEFINE_CPO(type, name) \
namespace \
{ \
constexpr auto & name = ::ranges::static_const<type>::value; \
} \
/**/
#else // RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17
#define RANGES_DEFINE_CPO(type, name) \
namespace _ \
{ \
inline constexpr type name{}; \
} \
using namespace _; \
/**/
#endif // RANGES_CXX_INLINE_VARIABLES
#ifndef RANGES_DOXYGEN_INVOKED
#define RANGES_HIDDEN_DETAIL(...) __VA_ARGS__
#else
#define RANGES_HIDDEN_DETAIL(...)
#endif
#ifndef RANGES_DOXYGEN_INVOKED
#define RANGES_ADL_BARRIER_FOR(S) S##_ns
#define RANGES_STRUCT_WITH_ADL_BARRIER(S) \
_ranges_adl_barrier_noop_; \
namespace RANGES_ADL_BARRIER_FOR(S) \
{ \
struct S; \
} \
using RANGES_ADL_BARRIER_FOR(S)::S; \
struct RANGES_ADL_BARRIER_FOR(S)::S /**/
#else
#define RANGES_ADL_BARRIER_FOR(S)
#define RANGES_STRUCT_WITH_ADL_BARRIER(S) S
#endif
#ifndef RANGES_DOXYGEN_INVOKED
#define RANGES_FUNC_BEGIN(NAME) \
struct NAME##_fn \
{
#define RANGES_FUNC_END(NAME) \
} \
; \
RANGES_INLINE_VARIABLE(NAME##_fn, NAME)
#define RANGES_FUNC(NAME) operator() RANGES_FUNC_CONST_ /**/
#define RANGES_FUNC_CONST_(...) (__VA_ARGS__) const
#else
#define RANGES_FUNC_BEGIN(NAME)
#define RANGES_FUNC_END(NAME)
#define RANGES_FUNC(NAME) NAME
#endif
#ifndef RANGES_CXX_DEDUCTION_GUIDES
#if defined(__clang__) && defined(__apple_build_version__)
// Apple's clang version doesn't do deduction guides very well.
#define RANGES_CXX_DEDUCTION_GUIDES 0
#elif defined(__cpp_deduction_guides)
#define RANGES_CXX_DEDUCTION_GUIDES __cpp_deduction_guides
#else
#define RANGES_CXX_DEDUCTION_GUIDES RANGES_CXX_FEATURE(DEDUCTION_GUIDES)
#endif // __cpp_deduction_guides
#endif // RANGES_CXX_DEDUCTION_GUIDES
// __VA_OPT__
#ifndef RANGES_CXX_VA_OPT
#if __cplusplus > 201703L
#define RANGES_CXX_THIRD_ARG_(A, B, C, ...) C
#define RANGES_CXX_VA_OPT_I_(...) RANGES_CXX_THIRD_ARG_(__VA_OPT__(, ), 1, 0, ?)
#define RANGES_CXX_VA_OPT RANGES_CXX_VA_OPT_I_(?)
#else
#define RANGES_CXX_VA_OPT 0
#endif
#endif // RANGES_CXX_VA_OPT
#ifndef RANGES_CXX_IF_CONSTEXPR
#ifdef __cpp_if_constexpr
#define RANGES_CXX_IF_CONSTEXPR __cpp_if_constexpr
#else
#define RANGES_CXX_IF_CONSTEXPR RANGES_CXX_FEATURE(IF_CONSTEXPR)
#endif
#endif // RANGES_CXX_IF_CONSTEXPR
// Its not enough for the compiler to support this; the stdlib must support it too.
#ifndef RANGES_CXX_ALIGNED_NEW
#if(!defined(_LIBCPP_VERSION) || \
(_LIBCPP_VERSION >= 4000 && !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION))) && \
(!defined(__GLIBCXX__) || (defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE >= 7))
#if defined(__cpp_aligned_new)
#define RANGES_CXX_ALIGNED_NEW __cpp_aligned_new
#else
#define RANGES_CXX_ALIGNED_NEW RANGES_CXX_FEATURE(ALIGNED_NEW)
#endif
#else // _LIBCPP_VERSION < 4000 || __GLIBCXX__ < 20170502
#define RANGES_CXX_ALIGNED_NEW 0L
#endif
#endif // RANGES_CXX_ALIGNED_NEW
#if defined(__clang__)
#define RANGES_IS_SAME(...) __is_same(__VA_ARGS__)
#elif defined(__GNUC__) && __GNUC__ >= 6
#define RANGES_IS_SAME(...) __is_same_as(__VA_ARGS__)
#elif RANGES_CXX_TRAIT_VARIABLE_TEMPLATES
#define RANGES_IS_SAME(...) std::is_same_v<__VA_ARGS__>
#else
#define RANGES_IS_SAME(...) std::is_same<__VA_ARGS__>::value
#endif
#if defined(__has_cpp_attribute) && __has_cpp_attribute(no_unique_address)
#define RANGES_NO_UNIQUE_ADDRESS [[no_unique_address]]
#else
#define RANGES_NO_UNIQUE_ADDRESS
#endif
#if defined(__clang__)
#if __has_attribute(no_sanitize)
#define RANGES_INTENDED_MODULAR_ARITHMETIC \
__attribute__((__no_sanitize__("unsigned-integer-overflow")))
#else
#define RANGES_INTENDED_MODULAR_ARITHMETIC
#endif
#else
#define RANGES_INTENDED_MODULAR_ARITHMETIC
#endif
#ifndef RANGES_CONSTEXPR_IF
#if RANGES_CXX_IF_CONSTEXPR >= RANGES_CXX_IF_CONSTEXPR_17
#define RANGES_CONSTEXPR_IF(...) false) \
{} else if constexpr(__VA_ARGS__
#else
#define RANGES_CONSTEXPR_IF(...) __VA_ARGS__
#endif
#endif // RANGES_CONSTEXPR_IF
#if !defined(RANGES_BROKEN_CPO_LOOKUP) && \
!defined(RANGES_DOXYGEN_INVOKED) && \
defined(RANGES_WORKAROUND_MSVC_895622)
#define RANGES_BROKEN_CPO_LOOKUP 1
#endif
#ifndef RANGES_BROKEN_CPO_LOOKUP
#define RANGES_BROKEN_CPO_LOOKUP 0
#endif
#ifndef RANGES_NODISCARD
#if defined(__has_cpp_attribute) && __has_cpp_attribute(nodiscard)
#if defined(__clang__) && __cplusplus < 201703L
// clang complains about using nodiscard in C++14 mode.
#define RANGES_NODISCARD \
RANGES_DIAGNOSTIC_PUSH \
RANGES_DIAGNOSTIC_IGNORE("-Wc++1z-extensions") \
[[nodiscard]] RANGES_DIAGNOSTIC_POP /**/
#else
#define RANGES_NODISCARD [[nodiscard]]
#endif
#else
#define RANGES_NODISCARD
#endif
#endif
#ifndef RANGES_EMPTY_BASES
#ifdef _MSC_VER
#define RANGES_EMPTY_BASES __declspec(empty_bases)
#else
#define RANGES_EMPTY_BASES
#endif
#endif
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/detail/epilogue.hpp | // Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_PROLOGUE_INCLUDED
#error "Including epilogue, but prologue not included!"
#endif
#undef RANGES_PROLOGUE_INCLUDED
#undef template
#undef AND
#undef declval
#pragma pop_macro("I")
RANGES_DIAGNOSTIC_POP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/detail/with_braced_init_args.hpp | // Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_DETAIL_WITH_BRACED_INIT_ARGS_HPP
#define RANGES_V3_DETAIL_WITH_BRACED_INIT_ARGS_HPP
#include <initializer_list>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
// Accepts initializer_lists as either the first or second parameter, or both,
// and forwards on to an implementation.
template<typename ImplFn>
struct with_braced_init_args : ImplFn
{
private:
constexpr ImplFn const & base() const
{
return *this;
}
public:
using ImplFn::operator();
template<typename V0, typename... Args>
constexpr invoke_result_t<ImplFn const &, std::initializer_list<V0>, Args...>
operator()(std::initializer_list<V0> && rng0, Args &&... args) const
{
return base()(static_cast<std::initializer_list<V0> &&>(rng0),
static_cast<Args &&>(args)...);
}
/// \overload
template<typename Rng0, typename V1, typename... Args>
constexpr invoke_result_t<ImplFn const &,
Rng0,
std::initializer_list<V1>,
Args...> //
operator()(Rng0 && rng0, std::initializer_list<V1> && rng1, Args &&... args)
const
{
return base()( //
static_cast<Rng0 &&>(rng0),
static_cast<std::initializer_list<V1> &&>(rng1),
static_cast<Args &&>(args)...);
}
/// \overload
template<typename V0, typename V1, typename... Args>
constexpr invoke_result_t<ImplFn const &,
std::initializer_list<V0>,
std::initializer_list<V1>,
Args...>
operator()(std::initializer_list<V0> && rng0,
std::initializer_list<V1> && rng1,
Args &&... args) const
{
return base()( //
static_cast<std::initializer_list<V0> &&>(rng0),
static_cast<std::initializer_list<V1> &&>(rng1),
static_cast<Args &&>(args)...);
}
};
} // namespace detail
/// \endcond
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/detail/prologue.hpp | // Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_DETAIL_PROLOGUE_HPP
#define RANGES_V3_DETAIL_PROLOGUE_HPP
#include <range/v3/detail/config.hpp>
#endif
#ifdef RANGES_PROLOGUE_INCLUDED
#error "Prologue already included!"
#endif
#define RANGES_PROLOGUE_INCLUDED
RANGES_DIAGNOSTIC_PUSH
#ifdef RANGES_FEWER_WARNINGS
RANGES_DIAGNOSTIC_IGNORE_UNDEFINED_INTERNAL
RANGES_DIAGNOSTIC_IGNORE_INDENTATION
RANGES_DIAGNOSTIC_IGNORE_CXX17_COMPAT
#endif
RANGES_DIAGNOSTIC_KEYWORD_MACRO
#define template(...) \
CPP_PP_IGNORE_CXX2A_COMPAT_BEGIN \
template<__VA_ARGS__ CPP_TEMPLATE_AUX_ \
#define AND CPP_and
/// \cond
#if defined(__cpp_noexcept_function_type) && __cpp_noexcept_function_type >= 201510
// noexcept is part of the type system
#define declval(...) static_cast<__VA_ARGS__(*)() noexcept>(nullptr)()
#else
// noexcept is not part of the type system
#define declval(...) static_cast<__VA_ARGS__(*)()>(nullptr)()
#endif
/// \cond
#pragma push_macro("I")
#undef I
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/detail/satisfy_boost_range.hpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_DETAIL_SATISFY_BOOST_RANGE_HPP
#define RANGES_V3_DETAIL_SATISFY_BOOST_RANGE_HPP
#include <meta/meta.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/range/traits.hpp>
#ifndef RANGES_DOXYGEN_INVOKED
namespace boost
{
/// \brief Boost Range specialisation point, for making Boost ranges out of range-v3
/// views
template<typename T, typename U>
struct range_mutable_iterator;
/// \brief Boost Range specialisation point, for making Boost ranges out of range-v3
/// views
template<typename T, typename U>
struct range_const_iterator;
/// \brief Boost Range specialisation point, for making Boost ranges out of range-v3
/// views
template<typename T>
struct range_value;
/// \brief Boost Range specialisation point, for making Boost ranges out of range-v3
/// views
template<typename T>
struct range_size;
} // namespace boost
/// \brief Macro specialising Boost Range metafunctions for the specified view
#define RANGES_SATISFY_BOOST_RANGE(view_name) \
namespace boost \
{ \
template<typename... Ts> \
struct range_mutable_iterator< \
view_name<Ts...>, \
::meta::if_c<(bool)::ranges::common_range<view_name<Ts...>>>> \
{ \
using type = ::ranges::iterator_t<view_name<Ts...>>; \
}; \
template<typename... Ts> \
struct range_const_iterator< \
view_name<Ts...>, \
::meta::if_c<(bool)::ranges::common_range<view_name<Ts...> const>>> \
{ \
using type = ::ranges::iterator_t<view_name<Ts...> const>; \
}; \
template<typename... Ts> \
struct range_value<view_name<Ts...>> \
{ \
using type = ::ranges::range_value_t<view_name<Ts...>>; \
}; \
template<typename... Ts> \
struct range_size<view_name<Ts...>> \
: ::meta::if_c<(bool)::ranges::common_range<view_name<Ts...>>, \
::meta::defer<::ranges::range_size_t, view_name<Ts...>>, \
::meta::nil_> \
{}; \
template<typename... Ts> \
struct range_size<view_name<Ts...> const> \
: ::meta::if_c<(bool)::ranges::common_range<view_name<Ts...> const>, \
::meta::defer<::ranges::range_size_t, view_name<Ts...> const>, \
::meta::nil_> \
{}; \
}
#else
#define RANGES_SATISFY_BOOST_RANGE(view_name)
#endif
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/detail/variant.hpp | // Range v3 library
//
// Copyright Eric Niebler 2014-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_DETAIL_VARIANT_HPP
#define RANGES_V3_DETAIL_VARIANT_HPP
#include <iterator>
#include <memory>
#include <new>
#include <stdexcept>
#include <tuple>
#include <type_traits>
#include <utility>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/compose.hpp>
#include <range/v3/functional/identity.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/iterator/traits.hpp>
#include <range/v3/utility/get.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
template<std::size_t I>
struct emplaced_index_t;
template<std::size_t I>
struct emplaced_index_t : meta::size_t<I>
{};
#if RANGES_CXX_INLINE_VARIABLES < RANGES_CXX_INLINE_VARIABLES_17
namespace
{
template<std::size_t I>
constexpr auto & emplaced_index = static_const<emplaced_index_t<I>>::value;
}
#else // RANGES_CXX_INLINE_VARIABLES >= RANGES_CXX_INLINE_VARIABLES_17
template<std::size_t I>
inline constexpr emplaced_index_t<I> emplaced_index{};
#endif // RANGES_CXX_INLINE_VARIABLES
struct bad_variant_access : std::logic_error
{
explicit bad_variant_access(std::string const & what_arg)
: std::logic_error(what_arg)
{}
explicit bad_variant_access(char const * what_arg)
: std::logic_error(what_arg)
{}
};
template<typename T, std::size_t Index>
struct indexed_element
{
private:
std::add_pointer_t<T> t_;
public:
constexpr explicit indexed_element(T & t) noexcept
: t_(std::addressof(t))
{}
constexpr T & get() const noexcept
{
return *t_;
}
};
template<typename T, std::size_t Index>
struct indexed_element<T &&, Index>
{
private:
T * t_;
public:
constexpr explicit indexed_element(T && t) noexcept
: t_(std::addressof(t))
{}
constexpr T && get() const noexcept
{
return static_cast<T &&>(*t_);
}
};
template<std::size_t Index>
struct indexed_element<void, Index>
{
void get() const noexcept
{}
};
/// \cond
namespace detail
{
struct indexed_element_fn;
template(typename I, typename S, typename O)(
requires (!sized_sentinel_for<S, I>)) //
O uninitialized_copy(I first, S last, O out)
{
for(; first != last; ++first, ++out)
::new((void *)std::addressof(*out)) iter_value_t<O>(*first);
return out;
}
template(typename I, typename S, typename O)(
requires sized_sentinel_for<S, I>)
O uninitialized_copy(I first, S last, O out)
{
return std::uninitialized_copy_n(first, (last - first), out);
}
template<typename I, typename O>
O uninitialized_copy(I first, I last, O out)
{
return std::uninitialized_copy(first, last, out);
}
template<typename T, typename Index>
struct indexed_datum
{
private:
template<typename, typename>
friend struct indexed_datum;
T datum_;
public:
CPP_member
constexpr CPP_ctor(indexed_datum)()( //
noexcept(std::is_nothrow_default_constructible<T>::value) //
requires default_constructible<T>)
: datum_{}
{}
template(typename... Ts)(
requires constructible_from<T, Ts...> AND (sizeof...(Ts) != 0)) //
constexpr indexed_datum(Ts &&... ts) noexcept(
std::is_nothrow_constructible<T, Ts...>::value)
: datum_(static_cast<Ts &&>(ts)...)
{}
template(typename U)(
requires (!same_as<T, U>) AND convertible_to<U, T>)
constexpr indexed_datum(indexed_datum<U, Index> that) //
noexcept(std::is_nothrow_constructible<T, U>::value) //
: datum_(std::move(that.datum_))
{}
constexpr auto ref() noexcept
{
return indexed_element<T, Index::value>{datum_};
}
constexpr auto ref() const noexcept
{
return indexed_element<T const, Index::value>{datum_};
}
constexpr T & get() noexcept
{
return datum_;
}
constexpr T const & get() const noexcept
{
return datum_;
}
};
template<typename T, std::size_t N, typename Index>
struct indexed_datum<T[N], Index>;
template<typename T, typename Index>
struct indexed_datum<T &, Index>
{
private:
template<typename, typename>
friend struct indexed_datum;
T * t_;
public:
constexpr indexed_datum(T & t) noexcept
: t_(std::addressof(t))
{}
constexpr T & get() const noexcept
{
return *t_;
}
constexpr auto ref() const noexcept
{
return indexed_element<T &, Index::value>{*t_};
}
};
template<typename T, typename Index>
struct indexed_datum<T &&, Index>
{
private:
template<typename, typename>
friend struct indexed_datum;
T * t_;
public:
constexpr indexed_datum(T && t) noexcept
: t_(std::addressof(t))
{}
constexpr T && get() const noexcept
{
return static_cast<T &&>(*t_);
}
constexpr auto ref() const noexcept
{
return indexed_element<T &&, Index::value>{static_cast<T &&>(*t_)};
}
};
template<typename Index>
struct indexed_datum<void, Index>
{
void get() const noexcept
{}
constexpr indexed_element<void, Index::value> ref() const noexcept
{
return {};
}
};
template<std::size_t Index, typename... Ts>
using variant_datum_t =
detail::indexed_datum<meta::at_c<meta::list<Ts...>, Index>,
meta::size_t<Index>>;
using variant_nil = indexed_datum<void, meta::npos>;
template<typename Ts,
bool Trivial = meta::apply<
meta::quote<meta::and_>,
meta::transform<Ts, meta::quote<std::is_trivially_destructible>>>::
type::value>
struct variant_data_
{
using type = indexed_datum<void, meta::npos>;
};
template<typename T, typename... Ts>
struct variant_data_<meta::list<T, Ts...>, true>
{
struct type
{
using head_t = T;
using tail_t = meta::_t<variant_data_<meta::list<Ts...>>>;
union
{
head_t head;
tail_t tail;
};
type() noexcept
{}
template<typename... Args>
constexpr type(meta::size_t<0>, Args &&... args) noexcept(
std::is_nothrow_constructible<head_t, Args...>::value)
: head{((Args &&) args)...}
{}
template<std::size_t N, typename... Args>
constexpr type(meta::size_t<N>, Args &&... args) noexcept(
std::is_nothrow_constructible<tail_t, meta::size_t<N - 1>,
Args...>::value)
: tail{meta::size_t<N - 1>{}, ((Args &&) args)...}
{}
};
};
template<typename T, typename... Ts>
struct variant_data_<meta::list<T, Ts...>, false>
{
struct type
{
using head_t = T;
using tail_t = meta::_t<variant_data_<meta::list<Ts...>>>;
union
{
head_t head;
tail_t tail;
};
type() noexcept
{}
~type()
{}
template<typename... Args>
constexpr type(meta::size_t<0>, Args &&... args) noexcept(
std::is_nothrow_constructible<head_t, Args...>::value)
: head{((Args &&) args)...}
{}
template<std::size_t N, typename... Args>
constexpr type(meta::size_t<N>, Args &&... args) noexcept(
std::is_nothrow_constructible<tail_t, meta::size_t<N - 1>,
Args...>::value)
: tail{meta::size_t<N - 1>{}, ((Args &&) args)...}
{}
};
};
template<typename... Ts>
using variant_data = meta::_t<variant_data_<meta::transform<
meta::list<Ts...>, meta::as_list<meta::make_index_sequence<sizeof...(Ts)>>,
meta::quote<indexed_datum>>>>;
inline std::size_t variant_move_copy_(std::size_t, variant_nil, variant_nil)
{
return 0;
}
template<typename Data0, typename Data1>
std::size_t variant_move_copy_(std::size_t n, Data0 & self, Data1 && that)
{
using Head = typename Data0::head_t;
return 0 == n
? ((void)::new((void *)&self.head) Head(((Data1 &&) that).head), 0)
: variant_move_copy_(n - 1, self.tail, ((Data1 &&) that).tail) + 1;
}
constexpr bool variant_equal_(std::size_t, variant_nil, variant_nil)
{
return true;
}
template<typename Data0, typename Data1>
constexpr bool variant_equal_(std::size_t n, Data0 const & self,
Data1 const & that)
{
return n == 0 ? self.head.get() == that.head.get()
: variant_equal_(n - 1, self.tail, that.tail);
}
template<typename Fun, typename Proj = indexed_element_fn>
constexpr int variant_visit_(std::size_t, variant_nil, Fun, Proj = {})
{
return (RANGES_EXPECT(false), 0);
}
template<typename Data, typename Fun, typename Proj = indexed_element_fn>
constexpr int variant_visit_(std::size_t n, Data & self, Fun fun, Proj proj = {})
{
return 0 == n ? ((void)invoke(fun, invoke(proj, self.head)), 0)
: detail::variant_visit_(
n - 1, self.tail, detail::move(fun), detail::move(proj));
}
struct get_datum_fn
{
template<typename T>
decltype(auto) operator()(T && t) const noexcept
{
return t.get();
}
};
struct indexed_element_fn
{
template<typename T>
decltype(auto) operator()(T && t) const noexcept
{
return t.ref();
}
};
struct empty_variant_tag
{};
struct variant_core_access
{
template<typename... Ts>
static constexpr variant_data<Ts...> & data(variant<Ts...> & var) noexcept
{
return var.data_();
}
template<typename... Ts>
static constexpr variant_data<Ts...> const & data(
variant<Ts...> const & var) noexcept
{
return var.data_();
}
template<typename... Ts>
static constexpr variant_data<Ts...> && data(variant<Ts...> && var) noexcept
{
return detail::move(var.data_());
}
template<typename... Ts>
static variant<Ts...> make_empty(meta::id<variant<Ts...>> = {}) noexcept
{
return variant<Ts...>{empty_variant_tag{}};
}
};
struct delete_fn
{
template<typename T>
void operator()(T const & t) const noexcept
{
t.~T();
}
};
template<std::size_t N, typename... Ts>
struct construct_fn
{
std::tuple<Ts...> args_;
template<typename U, std::size_t... Is>
void construct_(U & u, meta::index_sequence<Is...>) noexcept(
std::is_nothrow_constructible<U, Ts...>::value)
{
::new((void *)std::addressof(u))
U(static_cast<Ts &&>(std::get<Is>(args_))...);
}
construct_fn(Ts &&... ts) noexcept(
std::is_nothrow_constructible<std::tuple<Ts...>, Ts...>::value)
: args_{static_cast<Ts &&>(ts)...}
{}
template<typename U, std::size_t M>
[[noreturn]] meta::if_c<N != M> operator()(
indexed_datum<U, meta::size_t<M>> &) noexcept
{
RANGES_EXPECT(false);
}
template<typename U>
meta::if_<std::is_object<U>> operator()(
indexed_datum<U, meta::size_t<N>> &
u) noexcept(std::is_nothrow_constructible<U, Ts...>::value)
{
this->construct_(u.get(), meta::make_index_sequence<sizeof...(Ts)>{});
}
template<typename U>
meta::if_<meta::not_<std::is_object<U>>> operator()(
indexed_datum<U, meta::size_t<N>> &
u) noexcept(std::is_nothrow_constructible<detail::decay_t<U>,
Ts...>::value)
{
this->construct_(u, meta::make_index_sequence<sizeof...(Ts)>{});
}
};
template<typename T, std::size_t N>
struct get_fn
{
T ** t_;
template<typename U, std::size_t M>
[[noreturn]] meta::if_c<M != N> operator()(indexed_element<U, M>) const
{
throw bad_variant_access("bad variant access");
}
template<typename U>
void operator()(indexed_element<U, N> t) const noexcept
{
*t_ = std::addressof(t.get());
}
template<typename U>
void operator()(indexed_element<U &&, N> t) const noexcept
{
U && u = t.get();
*t_ = std::addressof(u);
}
void operator()(indexed_element<void, N>) const noexcept
{}
};
template<typename Variant, std::size_t N>
struct emplace_fn
{
Variant * var_;
// clang-format off
template<typename...Ts>
auto CPP_auto_fun(operator())(Ts &&...ts) (const)
(
return var_->template emplace<N>(static_cast<Ts &&>(ts)...)
)
// clang-format on
};
template<typename Fun, typename Variant>
struct variant_visitor
{
Fun fun_;
Variant * var_;
// clang-format off
template<typename U, std::size_t N>
auto CPP_auto_fun(operator())(indexed_element<U, N> u)
(
return compose(emplace_fn<Variant, N>{var_}, fun_)(u)
)
// clang-format on
};
template<typename Variant, typename Fun>
variant_visitor<Fun, Variant> make_variant_visitor(
Variant & var,
Fun fun) noexcept(std::is_nothrow_move_constructible<Fun>::value)
{
return {detail::move(fun), &var};
}
template<typename To, typename From>
struct unique_visitor;
template<typename... To, typename... From>
struct unique_visitor<variant<To...>, variant<From...>>
{
variant<To...> * var_;
template<typename T, std::size_t N>
void operator()(indexed_element<T, N> t) const
{
using E = meta::at_c<meta::list<From...>, N>;
static_assert(RANGES_IS_SAME(T const, E const),
"Is indexed_element broken?");
using F = meta::find<meta::list<To...>, E>;
static constexpr std::size_t M = sizeof...(To) - F::size();
compose(emplace_fn<variant<To...>, M>{var_}, get_datum_fn{})(t);
}
};
template<typename T>
constexpr T & variant_deref_(T * t) noexcept
{
return *t;
}
inline void variant_deref_(void const volatile *) noexcept
{}
template<typename Variant>
struct variant_get
{
//////////////////////////////////////////////////////////////////////////////
// get
template<std::size_t N>
friend meta::_t<
std::add_lvalue_reference<meta::at_c<meta::as_list<Variant>, N>>>
get(Variant & var)
{
using elem_t = meta::_t<
std::remove_reference<meta::at_c<meta::as_list<Variant>, N>>>;
elem_t * elem = nullptr;
auto & data_var = detail::variant_core_access::data(var);
detail::variant_visit_(
var.index(), data_var, detail::get_fn<elem_t, N>{&elem});
return detail::variant_deref_(elem);
}
template<std::size_t N>
friend meta::_t<
std::add_lvalue_reference<meta::at_c<meta::as_list<Variant>, N> const>>
get(Variant const & var)
{
using elem_t = meta::_t<
std::remove_reference<meta::at_c<meta::as_list<Variant>, N> const>>;
elem_t * elem = nullptr;
auto & data_var = detail::variant_core_access::data(var);
detail::variant_visit_(
var.index(), data_var, detail::get_fn<elem_t, N>{&elem});
return detail::variant_deref_(elem);
}
template<std::size_t N>
friend meta::_t<
std::add_rvalue_reference<meta::at_c<meta::as_list<Variant>, N>>>
get(Variant && var)
{
using elem_t = meta::_t<
std::remove_reference<meta::at_c<meta::as_list<Variant>, N>>>;
elem_t * elem = nullptr;
auto & data_var = detail::variant_core_access::data(var);
detail::variant_visit_(
var.index(), data_var, detail::get_fn<elem_t, N>{&elem});
using res_t = meta::_t<
std::add_rvalue_reference<meta::at_c<meta::as_list<Variant>, N>>>;
return static_cast<res_t>(detail::variant_deref_(elem));
}
};
template<typename Variant,
bool Trivial = std::is_trivially_destructible<meta::apply<
meta::quote<variant_data>, meta::as_list<Variant>>>::value>
struct variant_base : variant_get<Variant>
{
~variant_base()
{
static_cast<Variant *>(this)->clear_();
}
};
template<typename... Ts>
struct variant_base<variant<Ts...>, true> : variant_get<variant<Ts...>>
{};
template<typename Fun, typename Types, typename Indices, typename = void>
struct variant_visit_results
{};
template<typename Fun, typename... Ts, std::size_t... Is>
struct variant_visit_results<
Fun, meta::list<Ts...>, meta::index_sequence<Is...>,
meta::void_<invoke_result_t<Fun &, indexed_element<Ts, Is>>...>>
{
using type = variant<invoke_result_t<Fun &, indexed_element<Ts, Is>>...>;
};
template<typename Fun, typename... Ts>
using variant_visit_results_t =
meta::_t<variant_visit_results<Fun, meta::list<Ts...>,
meta::make_index_sequence<sizeof...(Ts)>>>;
} // namespace detail
/// \endcond
/// \addtogroup group-utility
/// @{
template<typename... Ts>
struct variant
: private detail::variant_data<Ts...>
, private detail::variant_base<variant<Ts...>>
{
private:
friend detail::variant_core_access;
template<typename...>
friend struct variant;
friend detail::variant_base<variant, false>;
template<std::size_t Index>
using datum_t = detail::variant_datum_t<Index, Ts...>;
template<typename T>
using add_const_t = meta::if_<std::is_void<T>, void, T const>;
using unbox_fn = detail::get_datum_fn;
detail::variant_data<Ts...> & data_() & noexcept
{
return *this;
}
detail::variant_data<Ts...> const & data_() const & noexcept
{
return *this;
}
detail::variant_data<Ts...> && data_() && noexcept
{
return static_cast<detail::variant_data<Ts...> &&>(*this);
}
std::size_t index_;
void clear_() noexcept
{
if(valid())
{
detail::variant_visit_(index_, data_(), detail::delete_fn{}, identity{});
index_ = (std::size_t)-1;
}
}
template<typename That>
void assign_(That && that)
{
if(that.valid())
index_ = detail::variant_move_copy_(
that.index_, data_(), ((That &&) that).data_());
}
constexpr variant(detail::empty_variant_tag) noexcept
: detail::variant_data<Ts...>{}
, index_((std::size_t)-1)
{}
template(typename... Args)(
requires (sizeof...(Args) == sizeof...(Ts))) //
static constexpr bool all_convertible_to(int) noexcept
{
return and_v<convertible_to<Args, Ts>...>;
}
template<typename... Args>
static constexpr bool all_convertible_to(long) noexcept
{
return false;
}
public:
CPP_member
constexpr CPP_ctor(variant)()( //
noexcept(std::is_nothrow_default_constructible<datum_t<0>>::value) //
requires default_constructible<datum_t<0>>)
: variant{emplaced_index<0>}
{}
template(std::size_t N, typename... Args)(
requires constructible_from<datum_t<N>, Args...>)
constexpr variant(emplaced_index_t<N>, Args &&... args) noexcept(
std::is_nothrow_constructible<datum_t<N>, Args...>::value)
: detail::variant_data<Ts...>{meta::size_t<N>{}, static_cast<Args &&>(args)...}
, index_(N)
{}
template(std::size_t N, typename T, typename... Args)(
requires constructible_from<datum_t<N>, std::initializer_list<T> &,
Args...>)
constexpr variant(
emplaced_index_t<N>, std::initializer_list<T> il,
Args &&... args) noexcept(std::
is_nothrow_constructible<
datum_t<N>, std::initializer_list<T> &,
Args...>::value)
: detail::variant_data<Ts...>{meta::size_t<N>{},
il,
static_cast<Args &&>(args)...}
, index_(N)
{}
template(std::size_t N)(
requires constructible_from<datum_t<N>, meta::nil_>)
constexpr variant(emplaced_index_t<N>, meta::nil_)
noexcept(std::is_nothrow_constructible<datum_t<N>, meta::nil_>::value)
: detail::variant_data<Ts...>{meta::size_t<N>{}, meta::nil_{}}
, index_(N)
{}
variant(variant && that)
: detail::variant_data<Ts...>{}
, index_(detail::variant_move_copy_(that.index(), data_(),
std::move(that.data_())))
{}
variant(variant const & that)
: detail::variant_data<Ts...>{}
, index_(detail::variant_move_copy_(that.index(), data_(), that.data_()))
{}
template(typename... Args)(
requires (!same_as<variant<Args...>, variant>) AND
(all_convertible_to<Args...>(0))) //
variant(variant<Args...> that)
: detail::variant_data<Ts...>{}
, index_(detail::variant_move_copy_(that.index(), data_(),
std::move(that.data_())))
{}
variant & operator=(variant && that)
{
// TODO do a simple move assign when index()==that.index()
this->clear_();
this->assign_(detail::move(that));
return *this;
}
variant & operator=(variant const & that)
{
// TODO do a simple copy assign when index()==that.index()
this->clear_();
this->assign_(that);
return *this;
}
template(typename... Args)(
requires (!same_as<variant<Args...>, variant>) AND
(all_convertible_to<Args...>(0)))
variant & operator=(variant<Args...> that)
{
// TODO do a simple copy assign when index()==that.index() //
this->clear_();
this->assign_(that);
return *this;
}
static constexpr std::size_t size() noexcept
{
return sizeof...(Ts);
}
template(std::size_t N, typename... Args)(
requires constructible_from<datum_t<N>, Args...>)
void emplace(Args &&... args)
{
this->clear_();
detail::construct_fn<N, Args &&...> fn{static_cast<Args &&>(args)...};
detail::variant_visit_(N, data_(), std::ref(fn), identity{});
index_ = N;
}
constexpr bool valid() const noexcept
{
return index() != (std::size_t)-1;
}
constexpr std::size_t index() const noexcept
{
return index_;
}
template<typename Fun>
detail::variant_visit_results_t<composed<Fun, unbox_fn>, Ts...> visit(Fun fun)
{
detail::variant_visit_results_t<composed<Fun, unbox_fn>, Ts...> res{
detail::empty_variant_tag{}};
detail::variant_visit_(index_,
data_(),
detail::make_variant_visitor(
res, compose(detail::move(fun), unbox_fn{})));
return res;
}
template<typename Fun>
detail::variant_visit_results_t<composed<Fun, unbox_fn>, add_const_t<Ts>...>
visit(Fun fun) const
{
detail::variant_visit_results_t<composed<Fun, unbox_fn>, add_const_t<Ts>...>
res{detail::empty_variant_tag{}};
detail::variant_visit_(index_,
data_(),
detail::make_variant_visitor(
res, compose(detail::move(fun), unbox_fn{})));
return res;
}
template<typename Fun>
detail::variant_visit_results_t<Fun, Ts...> visit_i(Fun fun)
{
detail::variant_visit_results_t<Fun, Ts...> res{detail::empty_variant_tag{}};
detail::variant_visit_(
index_, data_(), detail::make_variant_visitor(res, detail::move(fun)));
return res;
}
template<typename Fun>
detail::variant_visit_results_t<Fun, add_const_t<Ts>...> visit_i(Fun fun) const
{
detail::variant_visit_results_t<Fun, add_const_t<Ts>...> res{
detail::empty_variant_tag{}};
detail::variant_visit_(
index_, data_(), detail::make_variant_visitor(res, detail::move(fun)));
return res;
}
};
template(typename... Ts, typename... Us)(
requires and_v<equality_comparable_with<Ts, Us>...>)
bool operator==(variant<Ts...> const & lhs, variant<Us...> const & rhs)
{
return (!lhs.valid() && !rhs.valid()) ||
(lhs.index() == rhs.index() &&
detail::variant_equal_(lhs.index(),
detail::variant_core_access::data(lhs),
detail::variant_core_access::data(rhs)));
}
template(typename... Ts, typename... Us)(
requires and_v<equality_comparable_with<Ts, Us>...>)
bool operator!=(variant<Ts...> const & lhs, variant<Us...> const & rhs)
{
return !(lhs == rhs);
}
//////////////////////////////////////////////////////////////////////////////////////
// emplace
template(std::size_t N, typename... Ts, typename... Args)(
requires constructible_from<detail::variant_datum_t<N, Ts...>, Args...>)
void emplace(variant<Ts...> & var, Args &&... args)
{
var.template emplace<N>(static_cast<Args &&>(args)...);
}
//////////////////////////////////////////////////////////////////////////////////////
// variant_unique
template<typename Var>
struct variant_unique
{};
template<typename... Ts>
struct variant_unique<variant<Ts...>>
{
using type = meta::apply<meta::quote<variant>, meta::unique<meta::list<Ts...>>>;
};
template<typename Var>
using variant_unique_t = meta::_t<variant_unique<Var>>;
//////////////////////////////////////////////////////////////////////////////////////
// unique_variant
template<typename... Ts>
variant_unique_t<variant<Ts...>> unique_variant(variant<Ts...> const & var)
{
using From = variant<Ts...>;
using To = variant_unique_t<From>;
auto res = detail::variant_core_access::make_empty(meta::id<To>{});
var.visit_i(detail::unique_visitor<To, From>{&res});
RANGES_EXPECT(res.valid());
return res;
}
/// @}
} // namespace ranges
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS
namespace std
{
template<typename... Ts>
struct tuple_size<::ranges::variant<Ts...>> : tuple_size<tuple<Ts...>>
{};
template<size_t I, typename... Ts>
struct tuple_element<I, ::ranges::variant<Ts...>> : tuple_element<I, tuple<Ts...>>
{};
} // namespace std
RANGES_DIAGNOSTIC_POP
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/detail/adl_get.hpp | // Range v3 library
//
// Copyright Casey Carter 2018
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
#ifndef RANGES_V3_DETAIL_ADL_GET_HPP
#define RANGES_V3_DETAIL_ADL_GET_HPP
#include <cstddef>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \cond
namespace detail
{
namespace _adl_get_
{
template<typename>
void get();
template<std::size_t I, typename TupleLike>
constexpr auto adl_get(TupleLike && t) noexcept
-> decltype(get<I>(static_cast<TupleLike &&>(t)))
{
return get<I>(static_cast<TupleLike &&>(t));
}
template<typename T, typename TupleLike>
constexpr auto adl_get(TupleLike && t) noexcept
-> decltype(get<T>(static_cast<TupleLike &&>(t)))
{
return get<T>(static_cast<TupleLike &&>(t));
}
} // namespace _adl_get_
using _adl_get_::adl_get;
} // namespace detail
namespace _tuple_wrapper_
{
template<typename TupleLike>
struct forward_tuple_interface : TupleLike
{
forward_tuple_interface() = default;
using TupleLike::TupleLike;
#if !defined(__clang__) || __clang_major__ > 3
CPP_member
constexpr CPP_ctor(forward_tuple_interface)(TupleLike && base)( //
noexcept(std::is_nothrow_move_constructible<TupleLike>::value) //
requires move_constructible<TupleLike>)
: TupleLike(static_cast<TupleLike &&>(base))
{}
CPP_member
constexpr CPP_ctor(forward_tuple_interface)(TupleLike const & base)( //
noexcept(std::is_nothrow_copy_constructible<TupleLike>::value) //
requires copy_constructible<TupleLike>)
: TupleLike(base)
{}
#else
// Clang 3.x have a problem with inheriting constructors
// that causes the declarations in the preceeding PP block to get
// instantiated too early.
template(typename B = TupleLike)(
requires move_constructible<B>)
constexpr forward_tuple_interface(TupleLike && base) noexcept(
std::is_nothrow_move_constructible<TupleLike>::value)
: TupleLike(static_cast<TupleLike &&>(base))
{}
template(typename B = TupleLike)(
requires copy_constructible<B>)
constexpr forward_tuple_interface(TupleLike const & base) noexcept(
std::is_nothrow_copy_constructible<TupleLike>::value)
: TupleLike(base)
{}
#endif
// clang-format off
template<std::size_t I, typename U = TupleLike>
friend constexpr auto CPP_auto_fun(get)(
forward_tuple_interface<TupleLike> &wb)
(
return detail::adl_get<I>(static_cast<U &>(wb))
)
template<std::size_t I, typename U = TupleLike>
friend constexpr auto CPP_auto_fun(get)(
forward_tuple_interface<TupleLike> const &wb)
(
return detail::adl_get<I>(static_cast<U const &>(wb))
)
template<std::size_t I, typename U = TupleLike>
friend constexpr auto CPP_auto_fun(get)(
forward_tuple_interface<TupleLike> &&wb)
(
return detail::adl_get<I>(static_cast<U &&>(wb))
)
template<std::size_t I, typename U = TupleLike>
friend constexpr auto CPP_auto_fun(get)(
forward_tuple_interface<TupleLike> const &&wb)
(
return detail::adl_get<I>(static_cast<U const &&>(wb))
)
template<typename T, typename U = TupleLike>
friend constexpr auto CPP_auto_fun(get)(
forward_tuple_interface<TupleLike> &wb)
(
return detail::adl_get<T>(static_cast<U &>(wb))
)
template<typename T, typename U = TupleLike>
friend constexpr auto CPP_auto_fun(get)(
forward_tuple_interface<TupleLike> const &wb)
(
return detail::adl_get<T>(static_cast<U const &>(wb))
)
template<typename T, typename U = TupleLike>
friend constexpr auto CPP_auto_fun(get)(
forward_tuple_interface<TupleLike> &&wb)
(
return detail::adl_get<T>(static_cast<U &&>(wb))
)
template<typename T, typename U = TupleLike>
friend constexpr auto CPP_auto_fun(get)(
forward_tuple_interface<TupleLike> const &&wb)
(
return detail::adl_get<T>(static_cast<U const &&>(wb))
)
// clang-format on
};
} // namespace _tuple_wrapper_
/// \endcond
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif // RANGES_V3_DETAIL_ADL_GET_HPP
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/detail/range_access.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2014-present
// Copyright Casey Carter 2016
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_DETAIL_RANGE_ACCESS_HPP
#define RANGES_V3_DETAIL_RANGE_ACCESS_HPP
#include <cstddef>
#include <utility>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/iterator/concepts.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-views
/// @{
struct range_access
{
/// \cond
private:
template<typename T>
static std::false_type single_pass_2_(long);
template<typename T>
static typename T::single_pass single_pass_2_(int);
template<typename T>
struct single_pass_
{
using type = decltype(range_access::single_pass_2_<T>(42));
};
template<typename T>
static std::false_type contiguous_2_(long);
template<typename T>
static typename T::contiguous contiguous_2_(int);
template<typename T>
struct contiguous_
{
using type = decltype(range_access::contiguous_2_<T>(42));
};
template<typename T>
static basic_mixin<T> mixin_base_2_(long);
template<typename T>
static typename T::mixin mixin_base_2_(int);
template<typename Cur>
struct mixin_base_
{
using type = decltype(range_access::mixin_base_2_<Cur>(42));
};
public:
template<typename Cur>
using single_pass_t = meta::_t<single_pass_<Cur>>;
template<typename Cur>
using contiguous_t = meta::_t<contiguous_<Cur>>;
template<typename Cur>
using mixin_base_t = meta::_t<mixin_base_<Cur>>;
// clang-format off
template<typename Rng>
static constexpr auto CPP_auto_fun(begin_cursor)(Rng &rng)
(
return rng.begin_cursor()
)
template<typename Rng>
static constexpr auto CPP_auto_fun(end_cursor)(Rng &rng)
(
return rng.end_cursor()
)
template<typename Rng>
static constexpr auto CPP_auto_fun(begin_adaptor)(Rng &rng)
(
return rng.begin_adaptor()
)
template<typename Rng>
static constexpr auto CPP_auto_fun(end_adaptor)(Rng &rng)
(
return rng.end_adaptor()
)
template<typename Cur>
static constexpr auto CPP_auto_fun(read)(Cur const &pos)
(
return pos.read()
)
template<typename Cur>
static constexpr auto CPP_auto_fun(arrow)(Cur const &pos)
(
return pos.arrow()
)
template<typename Cur>
static constexpr auto CPP_auto_fun(move)(Cur const &pos)
(
return pos.move()
)
template<typename Cur, typename T>
static constexpr auto CPP_auto_fun(write)(Cur &pos, T &&t)
(
return pos.write((T &&) t)
)
template<typename Cur>
static constexpr auto CPP_auto_fun(next)(Cur & pos)
(
return pos.next()
)
template<typename Cur, typename O>
static constexpr auto CPP_auto_fun(equal)(Cur const &pos, O const &other)
(
return pos.equal(other)
)
template<typename Cur>
static constexpr auto CPP_auto_fun(prev)(Cur & pos)
(
return pos.prev()
)
template<typename Cur, typename D>
static constexpr auto CPP_auto_fun(advance)(Cur & pos, D n)
(
return pos.advance(n)
)
template<typename Cur, typename O>
static constexpr auto CPP_auto_fun(distance_to)(Cur const &pos, O const &other)
(
return pos.distance_to(other)
)
private:
template<typename Cur>
using sized_cursor_difference_t = decltype(
range_access::distance_to(std::declval<Cur>(), std::declval<Cur>()));
// clang-format on
template<typename T>
static std::ptrdiff_t cursor_difference_2_(detail::ignore_t);
template<typename T>
static sized_cursor_difference_t<T> cursor_difference_2_(long);
template<typename T>
static typename T::difference_type cursor_difference_2_(int);
template<typename T>
using cursor_reference_t = decltype(std::declval<T const &>().read());
template<typename T>
static meta::id<uncvref_t<cursor_reference_t<T>>> cursor_value_2_(long);
template<typename T>
static meta::id<typename T::value_type> cursor_value_2_(int);
#ifdef RANGES_WORKAROUND_CWG_1554
template<typename Cur>
struct cursor_difference
{
using type = decltype(range_access::cursor_difference_2_<Cur>(42));
};
template<typename Cur>
struct cursor_value : decltype(range_access::cursor_value_2_<Cur>(42))
{};
#endif // RANGES_WORKAROUND_CWG_1554
public:
#ifdef RANGES_WORKAROUND_CWG_1554
template<typename Cur>
using cursor_difference_t = meta::_t<cursor_difference<Cur>>;
template<typename Cur>
using cursor_value_t = meta::_t<cursor_value<Cur>>;
#else // ^^^ workaround ^^^ / vvv no workaround vvv
template<typename Cur>
using cursor_difference_t = decltype(range_access::cursor_difference_2_<Cur>(42));
template<typename Cur>
using cursor_value_t = meta::_t<decltype(range_access::cursor_value_2_<Cur>(42))>;
#endif // RANGES_WORKAROUND_CWG_1554
template<typename Cur>
static constexpr Cur & pos(basic_iterator<Cur> & it) noexcept
{
return it.pos();
}
template<typename Cur>
static constexpr Cur const & pos(basic_iterator<Cur> const & it) noexcept
{
return it.pos();
}
template<typename Cur>
static constexpr Cur && pos(basic_iterator<Cur> && it) noexcept
{
return detail::move(it.pos());
}
template<typename Cur>
static constexpr Cur cursor(basic_iterator<Cur> it)
{
return std::move(it.pos());
}
/// endcond
};
/// @}
/// \cond
namespace detail
{
//
// Concepts that the range cursor must model
// clang-format off
//
/// \concept cursor
/// \brief The \c cursor concept
template<typename T>
CPP_concept cursor =
copyable<T> && copyable<range_access::mixin_base_t<T>> &&
constructible_from<range_access::mixin_base_t<T>, T> &&
constructible_from<range_access::mixin_base_t<T>, T const &>;
// Axiom: mixin_base_t<T> has a member get(), accessible to derived classes,
// which perfectly-returns the contained cursor object and does not throw
// exceptions.
/// \concept has_cursor_next_
/// \brief The \c has_cursor_next_ concept
template<typename T>
CPP_requires(has_cursor_next_,
requires(T & t)
(
range_access::next(t)
));
/// \concept has_cursor_next
/// \brief The \c has_cursor_next concept
template<typename T>
CPP_concept has_cursor_next = CPP_requires_ref(detail::has_cursor_next_, T);
/// \concept sentinel_for_cursor_
/// \brief The \c sentinel_for_cursor_ concept
template<typename S, typename C>
CPP_requires(sentinel_for_cursor_,
requires(S & s, C & c) //
(
range_access::equal(c, s),
concepts::requires_<convertible_to<decltype(
range_access::equal(c, s)), bool>>
));
/// \concept sentinel_for_cursor
/// \brief The \c sentinel_for_cursor concept
template<typename S, typename C>
CPP_concept sentinel_for_cursor =
semiregular<S> &&
cursor<C> &&
CPP_requires_ref(detail::sentinel_for_cursor_, S, C);
/// \concept readable_cursor_
/// \brief The \c readable_cursor_ concept
template<typename T>
CPP_requires(readable_cursor_,
requires(T & t) //
(
range_access::read(t)
));
/// \concept readable_cursor
/// \brief The \c readable_cursor concept
template<typename T>
CPP_concept readable_cursor = CPP_requires_ref(detail::readable_cursor_, T);
/// \concept has_cursor_arrow_
/// \brief The \c has_cursor_arrow_ concept
template<typename T>
CPP_requires(has_cursor_arrow_,
requires(T const & t) //
(
range_access::arrow(t)
));
/// \concept has_cursor_arrow
/// \brief The \c has_cursor_arrow concept
template<typename T>
CPP_concept has_cursor_arrow = CPP_requires_ref(detail::has_cursor_arrow_, T);
/// \concept writable_cursor_
/// \brief The \c writable_cursor_ concept
template<typename T, typename U>
CPP_requires(writable_cursor_,
requires(T & t, U && u) //
(
range_access::write(t, (U &&) u)
));
/// \concept writable_cursor
/// \brief The \c writable_cursor concept
template<typename T, typename U>
CPP_concept writable_cursor =
CPP_requires_ref(detail::writable_cursor_, T, U);
/// \concept sized_sentinel_for_cursor_
/// \brief The \c sized_sentinel_for_cursor_ concept
template<typename S, typename C>
CPP_requires(sized_sentinel_for_cursor_,
requires(S & s, C & c) //
(
range_access::distance_to(c, s),
concepts::requires_<signed_integer_like_<decltype(
range_access::distance_to(c, s))>>
)
);
/// \concept sized_sentinel_for_cursor
/// \brief The \c sized_sentinel_for_cursor concept
template<typename S, typename C>
CPP_concept sized_sentinel_for_cursor =
sentinel_for_cursor<S, C> &&
CPP_requires_ref(detail::sized_sentinel_for_cursor_, S, C);
/// \concept output_cursor
/// \brief The \c output_cursor concept
template<typename T, typename U>
CPP_concept output_cursor =
writable_cursor<T, U> && cursor<T>;
/// \concept input_cursor
/// \brief The \c input_cursor concept
template<typename T>
CPP_concept input_cursor =
readable_cursor<T> && cursor<T> && has_cursor_next<T>;
/// \concept forward_cursor
/// \brief The \c forward_cursor concept
template<typename T>
CPP_concept forward_cursor =
input_cursor<T> && default_constructible<T> && sentinel_for_cursor<T, T> &&
!range_access::single_pass_t<uncvref_t<T>>::value;
/// \concept bidirectional_cursor_
/// \brief The \c bidirectional_cursor_ concept
template<typename T>
CPP_requires(bidirectional_cursor_,
requires(T & t) //
(
range_access::prev(t)
));
/// \concept bidirectional_cursor
/// \brief The \c bidirectional_cursor concept
template<typename T>
CPP_concept bidirectional_cursor =
forward_cursor<T> &&
CPP_requires_ref(detail::bidirectional_cursor_, T);
/// \concept random_access_cursor_
/// \brief The \c random_access_cursor_ concept
template<typename T>
CPP_requires(random_access_cursor_,
requires(T & t) //
(
range_access::advance(t, range_access::distance_to(t, t))
));
/// \concept random_access_cursor
/// \brief The \c random_access_cursor concept
template<typename T>
CPP_concept random_access_cursor =
bidirectional_cursor<T> && //
sized_sentinel_for_cursor<T, T> && //
CPP_requires_ref(detail::random_access_cursor_, T);
template(class T)(
requires std::is_lvalue_reference<T>::value)
void is_lvalue_reference(T&&);
/// \concept contiguous_cursor_
/// \brief The \c contiguous_cursor_ concept
template<typename T>
CPP_requires(contiguous_cursor_,
requires(T & t) //
(
detail::is_lvalue_reference(range_access::read(t))
));
/// \concept contiguous_cursor
/// \brief The \c contiguous_cursor concept
template<typename T>
CPP_concept contiguous_cursor =
random_access_cursor<T> && //
range_access::contiguous_t<uncvref_t<T>>::value && //
CPP_requires_ref(detail::contiguous_cursor_, T);
// clang-format on
template<typename Cur, bool IsReadable>
RANGES_INLINE_VAR constexpr bool is_writable_cursor_ = true;
template<typename Cur>
RANGES_INLINE_VAR constexpr bool is_writable_cursor_<Cur, true> =
(bool) writable_cursor<Cur, range_access::cursor_value_t<Cur>>;
template<typename Cur>
RANGES_INLINE_VAR constexpr bool is_writable_cursor_v =
is_writable_cursor_<Cur, (bool)readable_cursor<Cur>>;
} // namespace detail
/// \endcond
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/functional/on.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_FUNCTIONAL_ON_HPP
#define RANGES_V3_FUNCTIONAL_ON_HPP
#include <concepts/concepts.hpp>
#include <range/v3/detail/config.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-functional
/// @{
template<typename Fn1, typename Fn2>
struct transformed
{
private:
RANGES_NO_UNIQUE_ADDRESS
Fn1 first_;
RANGES_NO_UNIQUE_ADDRESS
Fn2 second_;
public:
transformed() = default;
constexpr transformed(Fn1 fn1, Fn2 fn2)
: first_(static_cast<Fn1 &&>(fn1))
, second_(static_cast<Fn2 &&>(fn2))
{}
// clang-format off
template<typename... Args>
auto CPP_auto_fun(operator())(Args &&... args)
(
return invoke(first_, invoke(second_, static_cast<Args &&>(args)...))
)
template<typename... Args>
auto CPP_auto_fun(operator())(Args &&... args)(const)
(
return invoke((Fn1 const &)first_,
invoke((Fn2 const &)second_, static_cast<Args &&>(args))...)
)
// clang-format on
};
struct on_fn
{
template<typename Fn1, typename Fn2>
constexpr transformed<Fn1, Fn2> operator()(Fn1 fn1, Fn2 fn2) const
{
return transformed<Fn1, Fn2>{detail::move(fn1), detail::move(fn2)};
}
};
/// \ingroup group-functional
/// \sa `on_fn`
RANGES_INLINE_VARIABLE(on_fn, on)
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/functional/not_fn.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_FUNCTIONAL_NOT_FN_HPP
#define RANGES_V3_FUNCTIONAL_NOT_FN_HPP
#include <type_traits>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/concepts.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-functional
/// @{
template<typename FD>
struct logical_negate
{
private:
CPP_assert(same_as<FD, detail::decay_t<FD>> && move_constructible<FD>);
RANGES_NO_UNIQUE_ADDRESS FD pred_;
public:
CPP_member
constexpr CPP_ctor(logical_negate)()( //
noexcept(std::is_nothrow_default_constructible<FD>::value) //
requires default_constructible<FD>)
{}
template(typename T)(
requires (!same_as<detail::decay_t<T>, logical_negate>) AND
constructible_from<FD, T>)
constexpr explicit logical_negate(T && pred)
: pred_(static_cast<T &&>(pred))
{}
template(typename... Args)(
requires predicate<FD &, Args...>)
constexpr bool operator()(Args &&... args) &
{
return !invoke(pred_, static_cast<Args &&>(args)...);
}
/// \overload
template(typename... Args)(
requires predicate<FD const &, Args...>)
constexpr bool operator()(Args &&... args) const &
{
return !invoke(pred_, static_cast<Args &&>(args)...);
}
/// \overload
template(typename... Args)(
requires predicate<FD, Args...>)
constexpr bool operator()(Args &&... args) &&
{
return !invoke(static_cast<FD &&>(pred_), static_cast<Args &&>(args)...);
}
};
struct not_fn_fn
{
template(typename Pred)(
requires move_constructible<detail::decay_t<Pred>> AND
constructible_from<detail::decay_t<Pred>, Pred>)
constexpr logical_negate<detail::decay_t<Pred>> operator()(Pred && pred) const
{
return logical_negate<detail::decay_t<Pred>>{(Pred &&) pred};
}
};
/// \ingroup group-functional
/// \sa `not_fn_fn`
RANGES_INLINE_VARIABLE(not_fn_fn, not_fn)
namespace cpp20
{
using ranges::not_fn;
}
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/functional/bind.hpp |
/// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_FUNCTIONAL_BIND_HPP
#define RANGES_V3_FUNCTIONAL_BIND_HPP
#include <functional>
#include <type_traits>
#include <meta/meta.hpp>
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-functional
/// @{
template<typename T,
typename U = meta::if_<
std::is_lvalue_reference<T>,
std::reference_wrapper<meta::_t<std::remove_reference<T>>>, T &&>>
U bind_forward(meta::_t<std::remove_reference<T>> & t) noexcept
{
return static_cast<U>(t);
}
template<typename T>
T && bind_forward(meta::_t<std::remove_reference<T>> && t) noexcept
{
// This is to catch way sketchy stuff like: forward<int const &>(42)
static_assert(!std::is_lvalue_reference<T>::value, "You didn't just do that!");
return static_cast<T &&>(t);
}
template<typename T>
struct bind_element
: meta::if_c<RANGES_IS_SAME(detail::decay_t<T>, T), meta::id<T>,
bind_element<detail::decay_t<T>>>
{};
template<typename T>
struct bind_element<std::reference_wrapper<T>>
{
using type = T &;
};
template<typename T>
struct bind_element<reference_wrapper<T>>
{
using type = typename reference_wrapper<T>::reference;
};
template<typename T>
using bind_element_t = meta::_t<bind_element<T>>;
template<typename Bind>
struct protector
{
private:
Bind bind_;
public:
protector() = default;
protector(Bind b)
: bind_(std::move(b))
{}
// clang-format off
template<typename...Ts>
auto CPP_auto_fun(operator())(Ts &&...ts)
(
return bind_(static_cast<Ts &&>(ts)...)
)
/// \overload
template<typename...Ts>
auto CPP_auto_fun(operator())(Ts &&...ts) (const)
(
return bind_(static_cast<Ts &&>(ts)...)
)
// clang-format on
};
struct protect_fn
{
template(typename F)(
requires std::is_bind_expression<uncvref_t<F>>::value) //
protector<uncvref_t<F>> operator()(F && f) const
{
return {static_cast<F &&>(f)};
}
/// \overload
template(typename F)(
requires (!std::is_bind_expression<uncvref_t<F>>::value)) //
F operator()(F && f) const
{
return static_cast<F &&>(f);
}
};
/// Protect a callable so that it can be safely used in a bind expression without
/// accidentally becoming a "nested" bind.
/// \ingroup group-functional
/// \sa `protect_fn`
RANGES_INLINE_VARIABLE(protect_fn, protect)
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
0 | repos/range-v3/include/range/v3 | repos/range-v3/include/range/v3/functional/pipeable.hpp | /// \file
// Range v3 library
//
// Copyright Eric Niebler 2013-present
//
// Use, modification and distribution is subject to the
// Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//
#ifndef RANGES_V3_FUNCTIONAL_PIPEABLE_HPP
#define RANGES_V3_FUNCTIONAL_PIPEABLE_HPP
#include <concepts/concepts.hpp>
#include <range/v3/range_fwd.hpp>
#include <range/v3/functional/compose.hpp>
#include <range/v3/functional/concepts.hpp>
#include <range/v3/utility/static_const.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
/// \addtogroup group-functional
/// @{
struct pipeable_base;
template<typename T>
RANGES_INLINE_VAR constexpr bool is_pipeable_v = META_IS_BASE_OF(pipeable_base, T);
template<typename T>
RANGES_INLINE_VAR constexpr bool is_pipeable_v<T &> = META_IS_BASE_OF(pipeable_base,
T);
template<typename T>
RANGES_INLINE_VAR constexpr bool is_pipeable_v<T &&> = META_IS_BASE_OF(pipeable_base,
T);
template<typename T>
using is_pipeable = meta::bool_<is_pipeable_v<T>>;
struct make_pipeable_fn
{
template<typename Fun, typename PipeableBase = pipeable_base>
constexpr auto operator()(Fun fun) const
{
struct local
: Fun
, PipeableBase
{
constexpr explicit local(Fun && f)
: Fun(static_cast<Fun &&>(f))
{}
};
return local{static_cast<Fun &&>(fun)};
}
};
/// \ingroup group-functional
/// \sa `make_pipeable_fn`
RANGES_INLINE_VARIABLE(make_pipeable_fn, make_pipeable)
struct pipeable_access
{
template<typename Pipeable>
struct impl : Pipeable
{
using Pipeable::pipe;
};
};
struct pipeable_base
{
private:
friend pipeable_access;
// Evaluate the pipe with an argument
template(typename Arg, typename Pipe)(
requires (!is_pipeable_v<Arg>) AND is_pipeable_v<Pipe> AND
invocable<Pipe, Arg>) // clang-format off
friend constexpr auto operator|(Arg &&arg, Pipe pipe) // clang-format off
{
return static_cast<Pipe &&>(pipe)(static_cast<Arg &&>(arg));
}
// Compose two pipes
template(typename Pipe0, typename Pipe1)(
requires is_pipeable_v<Pipe0> AND is_pipeable_v<Pipe1>) // clang-format off
friend constexpr auto operator|(Pipe0 pipe0, Pipe1 pipe1) // clang-format on
{
return make_pipeable(compose(detail::move(pipe1), detail::move(pipe0)));
}
template<typename Arg, typename Pipe>
friend auto operator|=(Arg & arg, Pipe pipe) //
-> CPP_broken_friend_ret(Arg &)(
requires (is_pipeable_v<Pipe>) &&
(!is_pipeable_v<Arg>) && invocable<Pipe, Arg &>)
{
static_cast<Pipe &&>(pipe)(arg);
return arg;
}
// Default Pipe behavior just passes the argument to the pipe's function call
// operator
// clang-format off
template<typename Arg, typename Pipe>
static constexpr auto CPP_auto_fun(pipe)(Arg && arg, Pipe p)
(
return static_cast<Pipe &&>(p)(static_cast<Arg &&>(arg))
)
// clang-format on
};
template<typename>
using pipeable RANGES_DEPRECATED("Please use pipeable_base instead") = pipeable_base;
/// \endcond
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
|
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.