Range-v3: Range

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

Modules | Concepts | Classes | Typedefs | Functions | Variables
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. More...
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. 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 {}
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. More...
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().

## 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::view_interface< Derived, Cardinality >::empty(), and ranges::sample().

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

## ◆ 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::view_interface< Derived, Cardinality >::empty(), and ranges::sample().

## ◆ 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;
    meta::size
    meta::size_t< L::size()> size
    An integral constant wrapper that is the size of the meta::list L.
    Definition: meta.hpp:1696
    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.