Range

Core range functionality. More...

Modules
	Range Concepts
	Range concepts.

Concepts
concept	ranges::semi_container
	The semi_container concept std::array is a semi_container, native arrays are not.
concept	ranges::container_
	The container_ concept std::vector is a container, std::array is not.
concept	ranges::container
	The container concept.
concept	ranges::reservable_
	The reservable_ concept.
concept	ranges::reservable
	The reservable concept.
concept	ranges::reservable_with_assign_
	The reservable_with_assign_ concept.
concept	ranges::reservable_with_assign
	The reservable_with_assign concept.
concept	ranges::random_access_reservable
	The random_access_reservable concept.
concept	ranges::lvalue_container_like_
	The lvalue_container_like_ concept.
concept	ranges::lvalue_container_like
	The lvalue_container_like concept.
concept	ranges::erasable_range_
	The erasable_range_ concept.
concept	ranges::erasable_range
	The erasable_range concept.

Classes
struct	ranges::at_fn
	Checked indexed range access. More...
struct	ranges::back_fn
struct	ranges::dangling
	A placeholder for an iterator or a sentinel into a range that may no longer be valid. More...
struct	ranges::front_fn
struct	ranges::index_fn
	Unchecked indexed range access. More...
struct	ranges::range_cardinality< Rng, Void >

Typedefs
template<typename I , typename S >
using	ranges::common_iterator_t = meta::conditional_t< std::is_same< I, S >::value, I, detail::common_iterator_impl_t< I, S > >
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_value_t = iter_value_t< iterator_t< Rng > >

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.
template<template< typename... > class ContT, typename Rng , typename C = meta::invoke<detail::from_range<ContT>, Rng>> requires range<Rng> && detail::convertible_to_cont<Rng, C>
auto	ranges::to (Rng &&rng) -> C
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Cont , typename Rng > requires range<Rng> && detail::convertible_to_cont<Rng, Cont>
auto	ranges::to (Rng &&rng) -> Cont
	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.
constexpr back_fn	ranges::back {}
constexpr _begin_::fn	ranges::begin {}
constexpr _cbegin_::fn	ranges::cbegin {}
constexpr _cdata_::fn	ranges::cdata {}
constexpr _cend_::fn	ranges::cend {}
constexpr _crbegin_::fn	ranges::crbegin {}
constexpr _crend_::fn	ranges::crend {}
constexpr _empty_::fn	ranges::empty {}
constexpr _end_::fn	ranges::end {}
constexpr front_fn	ranges::front {}
constexpr index_fn	ranges::index {}
	Unchecked indexed range access.
constexpr _rbegin_::fn	ranges::rbegin {}
constexpr _rend_::fn	ranges::rend {}
constexpr _size_::fn	ranges::size {}
constexpr detail::to_container_fn< detail::from_range< std::vector > >	ranges::to_vector {}

Detailed Description

Core range functionality.

Function Documentation

to()

template<template< typename... > class ContT>

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.

References ranges::to().

Referenced by ranges::to(), ranges::to(), and ranges::to().

Variable Documentation

at

constexpr at_fn ranges::at {}

constexpr

#include <range/v3/range/operations.hpp>

Checked indexed range access.

See also

at_fn

back

constexpr back_fn ranges::back {}

constexpr

#include <range/v3/range/operations.hpp>

See also

back_fn

begin

constexpr _begin_::fn ranges::begin {}

constexpr

#include <range/v3/range/access.hpp>

Parameters

r

Returns

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.

Referenced by ranges::copy(), ranges::copy_backward(), ranges::fill(), ranges::generate(), ranges::move(), ranges::move_backward(), ranges::front_fn::operator()(), ranges::index_fn::operator()(), ranges::at_fn::operator()(), ranges::reverse(), ranges::reverse_copy(), ranges::rotate(), ranges::rotate_copy(), ranges::sample(), ranges::sample(), ranges::sample(), and ranges::shuffle().

cbegin

constexpr _cbegin_::fn ranges::cbegin {}

constexpr

#include <range/v3/range/access.hpp>

Parameters

r

Returns

The result of calling ranges::begin with a const-qualified reference to r.

cdata

constexpr _cdata_::fn ranges::cdata {}

constexpr

#include <range/v3/range/primitives.hpp>

Parameters

r

Returns

The result of calling ranges::data with a const-qualified (lvalue or rvalue) reference to r.

cend

constexpr _cend_::fn ranges::cend {}

constexpr

#include <range/v3/range/access.hpp>

Parameters

r

Returns

The result of calling ranges::end with a const-qualified reference to r.

crbegin

constexpr _crbegin_::fn ranges::crbegin {}

constexpr

#include <range/v3/range/access.hpp>

Parameters

r

Returns

The result of calling ranges::rbegin with a const-qualified reference to r.

crend

constexpr _crend_::fn ranges::crend {}

constexpr

#include <range/v3/range/access.hpp>

Parameters

r

Returns

The result of calling ranges::rend with a const-qualified reference to r.

empty

constexpr _empty_::fn ranges::empty {}

constexpr

#include <range/v3/range/primitives.hpp>

Returns

true if and only if range contains no elements.

Referenced by ranges::view_interface< Derived, Cardinality >::operator bool().

end

constexpr _end_::fn ranges::end {}

constexpr

#include <range/v3/range/access.hpp>

Parameters

r

Returns

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.

Referenced by ranges::copy(), ranges::copy_backward(), ranges::fill(), ranges::generate(), ranges::move(), ranges::move_backward(), ranges::back_fn::operator()(), ranges::reverse(), ranges::reverse_copy(), ranges::rotate(), ranges::rotate_copy(), ranges::sample(), ranges::sample(), and ranges::shuffle().

front

constexpr front_fn ranges::front {}

constexpr

#include <range/v3/range/operations.hpp>

See also

front_fn

index

constexpr index_fn ranges::index {}

constexpr

#include <range/v3/range/operations.hpp>

Unchecked indexed range access.

See also

index_fn

rbegin

constexpr _rbegin_::fn ranges::rbegin {}

constexpr

#include <range/v3/range/access.hpp>

Parameters

r

Returns

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.

rend

constexpr _rend_::fn ranges::rend {}

constexpr

#include <range/v3/range/access.hpp>

Parameters

r

Returns

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.

size

constexpr _size_::fn ranges::size {}

constexpr

#include <range/v3/range/primitives.hpp>

Returns

For a given expression E of type T, ranges::size(E) is equivalent to:

• +extent_v<T> if T is an array type.
• Otherwise, +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.
• Otherwise, +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:

  template<class T> void size(T&&) = delete;

  and does not include a declaration of ranges::size, and disable_sized_range<std::remove_cvref_t<T>> is false.
• Otherwise, 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>.
• Otherwise, ranges::size(E) is ill-formed.