Range-v3
Range algorithms, views, and actions for the Standard Library
 
Loading...
Searching...
No Matches
Range

Core range functionality More...

Topics

 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
 
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

Typedef Documentation

◆ common_iterator_t

template<typename I , typename S >
using ranges::common_iterator_t

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

Initial value:
detail::common_iterator_impl_t<I, S>>
typename detail::_cond< If >::template invoke< Then, Else > conditional_t
Select one type or another depending on a compile-time Boolean.
Definition meta.hpp:1148

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

at_fn ranges::at {}
constexpr

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

Checked indexed range access.

See also
at_fn

◆ back

back_fn ranges::back {}
constexpr

◆ begin

_begin_::fn ranges::begin {}
constexpr

◆ cbegin

_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

_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

_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

_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

_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

_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

_end_::fn ranges::end {}
constexpr

◆ front

front_fn ranges::front {}
constexpr

◆ index

index_fn ranges::index {}
constexpr

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

Unchecked indexed range access.

See also
index_fn

◆ rbegin

_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

_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

_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;
    constexpr _size_::fn size
    Definition primitives.hpp:186
    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.

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