Core range functionality.
Modules | |
Range Concepts | |
Range concepts. | |
Classes | |
struct | ranges::at_fn |
Checked indexed range access. More... | |
struct | ranges::back_fn |
struct | ranges::bidirectional_range_tag |
struct | ranges::common_range_tag |
struct | ranges::contiguous_range_tag |
struct | ranges::dangling |
A placeholder for an iterator or a sentinel into a range that may no longer be valid. More... | |
struct | ranges::forward_range_tag |
struct | ranges::front_fn |
struct | ranges::index_fn |
Unchecked indexed range access. More... | |
struct | ranges::input_range_tag |
struct | ranges::random_access_range_tag |
struct | ranges::range_cardinality< Rng, Void > |
struct | ranges::range_tag |
struct | ranges::sized_range_tag |
Typedefs | |
template<typename I , typename S > | |
using | ranges::common_iterator_t = detail::if_then_t< std::is_same< I, S >::value, I, detail::common_iterator_impl_t< I, S > > |
template<typename Rng > | |
using | ranges::common_range_tag_of = std::enable_if_t< range< Rng >, detail::if_then_t< common_range< Rng >, common_range_tag, range_tag > > |
template<typename Rng > | |
using | ranges::range_common_iterator_t = common_iterator_t< iterator_t< Rng >, sentinel_t< Rng > > |
template<typename Rng > | |
using | ranges::range_common_reference_t = iter_common_reference_t< iterator_t< Rng > > |
template<typename Rng > | |
using | ranges::range_difference_t = iter_difference_t< iterator_t< Rng > > |
template<typename Rng > | |
using | ranges::range_reference_t = iter_reference_t< iterator_t< Rng > > |
template<typename Rng > | |
using | ranges::range_rvalue_reference_t = iter_rvalue_reference_t< iterator_t< Rng > > |
template<typename Rng > | |
using | ranges::range_size_t = decltype(ranges::size(std::declval< Rng & >())) |
template<typename Rng > | |
using | ranges::range_tag_of = std::enable_if_t< range< Rng >, detail::if_then_t< contiguous_range< Rng >, contiguous_range_tag, detail::if_then_t< random_access_range< Rng >, random_access_range_tag, detail::if_then_t< bidirectional_range< Rng >, bidirectional_range_tag, detail::if_then_t< forward_range< Rng >, forward_range_tag, detail::if_then_t< input_range< Rng >, input_range_tag, range_tag > >> >> > |
template<typename Rng > | |
using | ranges::range_value_t = iter_value_t< iterator_t< Rng > > |
template<typename Rng > | |
using | ranges::sized_range_tag_of = std::enable_if_t< range< Rng >, detail::if_then_t< sized_range< Rng >, sized_range_tag, range_tag > > |
Functions | |
template<template< typename... > class ContT> | |
auto | ranges::to () -> detail::to_container_fn< detail::from_range< ContT >> |
For initializing a container of the specified type with the elements of an Range. More... | |
template<template< typename... > class ContT, typename Rng > | |
auto | ranges::to (Rng &&rng) -> ContT< range_value_t< Rng >> requires range< Rng > &&detail::convertible_to_cont< Rng, ContT< range_value_t< Rng >>> |
Variables | |
constexpr at_fn | ranges::at {} |
Checked indexed range access. More... | |
constexpr back_fn | ranges::back {} |
constexpr _begin_::fn | ranges::begin {} |
template<typename T > | |
concept | ranges::bidirectional_range |
template<typename T > | |
concept | ranges::bidirectional_range_ = bidirectional_iterator<iterator_t<T>> |
constexpr _cbegin_::fn | ranges::cbegin {} |
constexpr _cdata_::fn | ranges::cdata {} |
constexpr _cend_::fn | ranges::cend {} |
template<typename T > | |
concept | ranges::common_range |
template<typename T > | |
concept | ranges::common_range_ = same_as<iterator_t<T>, sentinel_t<T>> |
template<typename T > | |
concept | ranges::container |
template<typename T > | |
concept | ranges::contiguous_range |
template<typename T > | |
concept | ranges::contiguous_range_ = contiguous_iterator<iterator_t<T>> && same_as<detail::data_t<T>, std::add_pointer_t<iter_reference_t<iterator_t<T>>>> |
constexpr _crbegin_::fn | ranges::crbegin {} |
constexpr _crend_::fn | ranges::crend {} |
constexpr _empty_::fn | ranges::empty {} |
template<typename T > | |
constexpr bool | ranges::enable_view |
constexpr _end_::fn | ranges::end {} |
template<typename Rng , typename I , typename S > | |
concept | ranges::erasable_range |
template<typename T > | |
concept | ranges::forward_range |
template<typename T > | |
concept | ranges::forward_range_ = forward_iterator<iterator_t<T>> |
template<typename T > | |
concept | ranges::forwarding_range_ |
constexpr front_fn | ranges::front {} |
constexpr index_fn | ranges::index {} |
Unchecked indexed range access. More... | |
template<typename T > | |
concept | ranges::input_range |
template<typename T > | |
concept | ranges::input_range_ = input_iterator<iterator_t<T>> |
template<typename T > | |
concept | ranges::lvalue_container_like |
template<typename T > | |
concept | ranges::lvalue_container_like_ = implicitly_convertible_to<detail::is_lvalue_container_like_t<T>, std::true_type> |
template<typename T , typename V > | |
concept | ranges::output_range |
template<typename T , typename V > | |
concept | ranges::output_range_ = output_iterator<iterator_t<T>, V> |
template<typename T > | |
concept | ranges::random_access_range |
template<typename T > | |
concept | ranges::random_access_range_ = random_access_iterator<iterator_t<T>> |
template<typename C > | |
concept | ranges::random_access_reservable |
template<typename T > | |
concept | ranges::range |
template<typename T > | |
concept | ranges::range_impl_ |
Range concepts below. More... | |
constexpr _rbegin_::fn | ranges::rbegin {} |
constexpr _rend_::fn | ranges::rend {} |
template<typename C > | |
concept | ranges::reservable |
template<typename C , typename I > | |
concept | ranges::reservable_with_assign |
template<typename T > | |
concept | ranges::semi_container |
constexpr _size_::fn | ranges::size {} |
template<typename T > | |
concept | ranges::sized_range |
template<typename T > | |
concept | ranges::sized_range_ = detail::integer_like_<range_size_t<T>> |
constexpr detail::to_container_fn< detail::from_range< std::vector > > | ranges::to_vector {} |
template<typename T > | |
concept | ranges::view_ |
View concepts below. More... | |
template<typename T > | |
concept | ranges::viewable_range |
auto ranges::to | ( | ) | -> detail::to_container_fn< meta::id< Cont >> |
#include <range/v3/range/conversion.hpp>
For initializing a container of the specified type with the elements of an Range.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
auto ranges::to | ( | Rng && | rng | ) | -> ContT<range_value_t<Rng>> requires range<Rng> && detail::convertible_to_cont<Rng, ContT<range_value_t<Rng>>> |
#include <range/v3/range/conversion.hpp>
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
constexpr at_fn ranges::at {} |
constexpr back_fn ranges::back {} |
#include <range/v3/range/operations.hpp>
back_fn
constexpr _begin_::fn ranges::begin {} |
#include <range/v3/range/access.hpp>
r |
r
, if r
is an array. Otherwise, r.begin()
if that expression is well-formed and returns an input_or_output_iterator. Otherwise, begin(r)
if that expression returns an input_or_output_iterator. concept ranges::bidirectional_range |
#include <range/v3/range/concepts.hpp>
constexpr _cbegin_::fn ranges::cbegin {} |
#include <range/v3/range/access.hpp>
r |
ranges::begin
with a const-qualified reference to r. constexpr _cdata_::fn ranges::cdata {} |
#include <range/v3/range/primitives.hpp>
r |
ranges::data
with a const-qualified (lvalue or rvalue) reference to r
. constexpr _cend_::fn ranges::cend {} |
#include <range/v3/range/access.hpp>
r |
ranges::end
with a const-qualified reference to r. concept ranges::common_range |
#include <range/v3/range/concepts.hpp>
concept ranges::container |
#include <range/v3/action/concepts.hpp>
concept ranges::contiguous_range |
#include <range/v3/range/concepts.hpp>
constexpr _crbegin_::fn ranges::crbegin {} |
#include <range/v3/range/access.hpp>
r |
ranges::rbegin
with a const-qualified reference to r. constexpr _crend_::fn ranges::crend {} |
#include <range/v3/range/access.hpp>
r |
ranges::rend
with a const-qualified reference to r. constexpr _empty_::fn ranges::empty {} |
#include <range/v3/range/primitives.hpp>
constexpr bool ranges::enable_view |
#include <range/v3/range/concepts.hpp>
constexpr _end_::fn ranges::end {} |
#include <range/v3/range/access.hpp>
r |
r+size
(r), if r
is an array. Otherwise, r.end()
if that expression is well-formed and returns an input_or_output_iterator. Otherwise, end(r)
if that expression returns an input_or_output_iterator. concept ranges::erasable_range |
#include <range/v3/action/erase.hpp>
concept ranges::forward_range |
#include <range/v3/range/concepts.hpp>
concept ranges::forwarding_range_ |
#include <range/v3/range/concepts.hpp>
constexpr front_fn ranges::front {} |
#include <range/v3/range/operations.hpp>
front_fn
constexpr index_fn ranges::index {} |
concept ranges::input_range |
#include <range/v3/range/concepts.hpp>
concept ranges::lvalue_container_like |
#include <range/v3/action/concepts.hpp>
concept ranges::output_range |
#include <range/v3/range/concepts.hpp>
concept ranges::random_access_range |
#include <range/v3/range/concepts.hpp>
concept ranges::random_access_reservable |
#include <range/v3/action/concepts.hpp>
concept ranges::range |
#include <range/v3/range/concepts.hpp>
concept ranges::range_impl_ |
#include <range/v3/range/concepts.hpp>
Range concepts below.
constexpr _rbegin_::fn ranges::rbegin {} |
#include <range/v3/range/access.hpp>
r |
make_reverse_iterator(r + ranges::size(r))
if r is an array. Otherwise, r.rbegin()
if that expression is well-formed and returns an input_or_output_iterator. Otherwise, make_reverse_iterator(ranges::end(r))
if ranges::begin(r)
and ranges::end(r)
are both well-formed and have the same type that satisfies bidirectional_iterator
. constexpr _rend_::fn ranges::rend {} |
#include <range/v3/range/access.hpp>
r |
make_reverse_iterator(r)
if r
is an array. Otherwise, r.rend()
if that expression is well-formed and returns a type that satisfies sentinel_for<S, I>
where I
is the type of ranges::rbegin(r)
. Otherwise, make_reverse_iterator(ranges::begin(r))
if ranges::begin(r)
and ranges::end(r)
are both well-formed and have the same type that satisfies bidirectional_iterator
. concept ranges::reservable |
#include <range/v3/action/concepts.hpp>
concept ranges::reservable_with_assign |
#include <range/v3/action/concepts.hpp>
concept ranges::semi_container |
#include <range/v3/action/concepts.hpp>
constexpr _size_::fn ranges::size {} |
#include <range/v3/range/primitives.hpp>
E
of type T
, ranges::size(E)
is equivalent to:+extent_v<T>
if T
is an array type.+E.size()
if it is a valid expression and its type I
models integral
and disable_sized_range<std::remove_cvref_t<T>>
is false.+size(E)
if it is a valid expression and its type I
models integral
with overload resolution performed in a context that includes the declaration: ranges::size
, and disable_sized_range<std::remove_cvref_t<T>>
is false.static_cast<U>(ranges::end(E) - ranges::begin(E))
where U
is std::make_unsigned_t<iter_difference_t<iterator_t<T>>>
if iter_difference_t<iterator_t<T>>
satisfies integral
and iter_difference_t<iterator_t<T>>
otherwise; except that E
is evaluated once, if it is a valid expression and the types I
and S
of ranges::begin(E)
and ranges::end(E)
model sized_sentinel_for<S, I>
and forward_iterator<I>
.ranges::size(E)
is ill-formed. concept ranges::sized_range |
#include <range/v3/range/concepts.hpp>
concept ranges::view_ |
#include <range/v3/range/concepts.hpp>
View concepts below.
concept ranges::viewable_range |
#include <range/v3/range/concepts.hpp>