Core range functionality.
Modules | |
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 |
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 >>> |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. | |
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<detail::from_range<ContT>> |
#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.
|
constexpr |
|
constexpr |
#include <range/v3/range/operations.hpp>
back_fn
|
constexpr |
#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 |
#include <range/v3/range/access.hpp>
r |
ranges::begin
with a const-qualified reference to r.
|
constexpr |
#include <range/v3/range/primitives.hpp>
r |
ranges::data
with a const-qualified (lvalue or rvalue) reference to r
.
|
constexpr |
#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 |
#include <range/v3/range/access.hpp>
r |
ranges::rbegin
with a const-qualified reference to r.
|
constexpr |
#include <range/v3/range/access.hpp>
r |
ranges::rend
with a const-qualified reference to r.
|
constexpr |
#include <range/v3/range/primitives.hpp>
|
constexpr |
#include <range/v3/range/concepts.hpp>
|
constexpr |
#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 |
#include <range/v3/range/operations.hpp>
front_fn
|
constexpr |
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 |
#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 |
#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 |
#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>