Range-v3 Range algorithms, views, and actions for the Standard Library |

Modules | Classes | Typedefs | Functions | Variables
Range

## Description

Core range functionality.

## Modules
| Range Concepts

## Classes
struct | ranges::at_fn
| Checked indexed range access. More...
struct | ranges::back_fn
struct | ranges::dangling
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. More...
template<template< typename... > class ContT, typename Rng >
auto | ranges::to (Rng &&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. More...

## Variables
constexpr at_fn | ranges::at {}
| Checked indexed range access. More...
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 {}
template<typename T >
concept | ranges::container
template<typename T >
concept | ranges::container__concept_ = constructible_from< uncvref_t<T>, detail::movable_input_iterator<range_value_t<T>>, detail::movable_input_iterator<range_value_t<T>>>
constexpr _crbegin_::fn | ranges::crbegin {}
constexpr _crend_::fn | ranges::crend {}
constexpr _empty_::fn | ranges::empty {}
constexpr _end_::fn | ranges::end {}
template<typename Rng , typename I , typename S >
concept | ranges::erasable_range
template<typename Rng , typename I , typename S >
concept | ranges::erasable_range__requires_ = CPP_REQUIRES_requires `(Rng && rng, I first, S last) ( ranges::erase((Rng &&) rng, first, last) )
constexpr front_fn | ranges::front {}
constexpr index_fn | ranges::index {}
| Unchecked indexed range access. More...
template<typename T >
concept | ranges::lvalue_container_like
template<typename T >
concept | ranges::lvalue_container_like__concept_ = implicitly_convertible_to<detail::is_lvalue_container_like_t<T>, std::true_type>
template<typename C >
concept | ranges::random_access_reservable
constexpr _rbegin_::fn | ranges::rbegin {}
constexpr _rend_::fn | ranges::rend {}
template<typename C >
concept | ranges::reservable__requires_
template<typename C , typename I >
concept | ranges::reservable_with_assign__requires_
template<typename T >
concept | ranges::semi_container
constexpr _size_::fn | ranges::size {}
constexpr detail::to_container_fn< detail::from_range< std::vector > > | ranges::to_vector {}

## Function Documentation

## ◆ to() [1/2]

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.

Referenced by ranges::actions::slice_fn::operator()(), and ranges::views::ints_fn::operator()().

## ◆ to() [2/2]

template<template< typename... > class ContT, typename Rng >

auto ranges::to | ( | Rng && | 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.

Precondition
  requires `range<Rng> && detail::convertible_to_cont<Rng, ContT<range_value_t<Rng>>>`
  requires `range<Rng> && detail::convertible_to_cont<Rng, Cont>`

## 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::tokenize_view< Rng, Regex, SubMatchRange >::begin(), ranges::take_view< Rng >::begin(), ranges::drop_last_view< Rng, detail::drop_last_view::mode_sized >::begin(), ranges::common_view< Rng, bool >::end(), ranges::drop_last_view< Rng, detail::drop_last_view::mode_bidi >::end(), ranges::group_by_view(), ranges::view_interface< drop_last_view< Rng, detail::drop_last_view::mode_sized >, finite >::operator bool(), ranges::views::drop_exactly_base_fn::operator()(), ranges::views::drop_base_fn::operator()(), ranges::views::split_base_fn::operator()(), ranges::span< T, N >::operator==(), ranges::sample(), ranges::set_intersection(), and ranges::subrange< I, S, K >::subrange().

## ◆ 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.

## ◆ container

template<typename T >

concept ranges::container

`#include <range/v3/action/concepts.hpp>`

Initial value:
=
semi_container<T> &&
ranges::container__concept_<T>

## ◆ 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.

## ◆ 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::tokenize_view< Rng, Regex, SubMatchRange >::begin(), ranges::drop_exactly_view< Rng >::begin(), ranges::group_by_view(), ranges::view_interface< drop_last_view< Rng, detail::drop_last_view::mode_sized >, finite >::operator bool(), ranges::views::drop_exactly_base_fn::operator()(), ranges::sample(), ranges::set_intersection(), ranges::experimental::shared_view< Rng >::size(), ranges::tail_view< Rng >::size(), ranges::iter_transform2_view< Rng1, Rng2, indirected< Fun > >::size(), ranges::split_view(), and ranges::subrange< I, S, K >::subrange().

## ◆ erasable_range

template<typename Rng , typename I , typename S >

concept ranges::erasable_range

`#include <range/v3/action/erase.hpp>`

Initial value:
=
range<Rng> && ranges::erasable_range__requires_<Rng, I, S>

## ◆ 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`

## ◆ lvalue_container_like

template<typename T >

concept ranges::lvalue_container_like

`#include <range/v3/action/concepts.hpp>`

Initial value:
=
forward_range<T> &&
ranges::lvalue_container_like__concept_<T>

## ◆ random_access_reservable

template<typename C >

concept ranges::random_access_reservable

`#include <range/v3/action/concepts.hpp>`

Initial value:
=
reservable<C> && random_access_range<C>

## ◆ 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`.

## ◆ reservable__requires_

template<typename C >

concept ranges::reservable__requires_

`#include <range/v3/action/concepts.hpp>`

Initial value:
= CPP_REQUIRES_requires `(C & c, C const & cc)
template<typename C>
concept reservable =
container<C> && sized_range<C> && ranges::reservable__requires_<C>

## ◆ reservable_with_assign__requires_

template<typename C , typename I >

concept ranges::reservable_with_assign__requires_

`#include <range/v3/action/concepts.hpp>`

Initial value:
= CPP_REQUIRES_requires `(C & c, I i)
template<typename C, typename I>
concept reservable_with_assign =
reservable<C> &&
input_iterator<I> &&
ranges::reservable_with_assign__requires_<C, I>

## ◆ semi_container

template<typename T >

concept ranges::semi_container

`#include <range/v3/action/concepts.hpp>`

Initial value:
=
forward_range<T> && default_constructible<uncvref_t<T>> &&
movable<uncvref_t<T>> &&
!view_<T>

## ◆ 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.

meta::size
meta::size_t< L::size()> size
An integral constant wrapper that is the size of the meta::list L.
Definition: meta.hpp:1320