Horizon
Loading...
Searching...
No Matches
Modules | Namespaces | Concepts | Classes | Typedefs | Functions | Variables
Range

Core range functionality. More...

Modules

 Range Concepts
 Range concepts.
 

Namespaces

namespace  ranges::cpp20
 

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

Typedefs

template<typename Rng >
using ranges::iterator_t = decltype(begin(declval(Rng &)))
 
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_difference_t = iter_difference_t< iterator_t< Rng > >
 
template<typename Rng >
using ranges::range_value_t = iter_value_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_common_reference_t = iter_common_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_common_iterator_t = common_iterator_t< iterator_t< Rng >, sentinel_t< Rng > >
 

Functions

 ranges::template (typename T)(concept(container_)(T)
 
template<typename C >
 ranges::CPP_requires (reservable_, requires(C &c, C const &cc)(c.reserve(ranges::size(c)), cc.capacity(), cc.max_size(), concepts::requires_< same_as< decltype(cc.capacity()), decltype(ranges::size(c))> >, concepts::requires_< same_as< decltype(cc.max_size()), decltype(ranges::size(c))> >))
 
template<typename C , typename I >
 ranges::CPP_requires (reservable_with_assign_, requires(C &c, I i)(c.assign(i, i)))
 
template<typename Rng , typename I , typename S >
 ranges::CPP_requires (erasable_range_, requires(Rng &&rng, I first, S last)(ranges::erase((Rng &&) rng, first, last)))
 
 ranges::RANGES_INLINE_VARIABLE (detail::to_container_fn< detail::from_range< std::vector > >, to_vector) template< template< typename... > class ContT > auto to(RANGES_HIDDEN_DETAIL(detail
 For initializing a container of the specified type with the elements of an Range.
 

Variables

template<typename T >
CPP_concept ranges::semi_container
 
template<typename T >
CPP_concept ranges::container
 
template<typename C >
CPP_concept ranges::reservable
 
template<typename C , typename I >
CPP_concept ranges::reservable_with_assign
 
template<typename C >
CPP_concept ranges::random_access_reservable
 
template<typename T >
CPP_concept ranges::lvalue_container_like
 
template<typename Rng , typename I , typename S >
CPP_concept ranges::erasable_range
 

Detailed Description

Core range functionality.

Typedef Documentation

◆ iterator_t

template<typename Rng >
using ranges::iterator_t = typedef decltype(begin(declval(Rng &)))
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.
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.
Parameters
r
Returns
The result of calling ranges::begin with a const-qualified reference to r.
Parameters
r
Returns
The result of calling ranges::end with a const-qualified reference to r.
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.
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.
Parameters
r
Returns
The result of calling ranges::rbegin with a const-qualified reference to r.
Parameters
r
Returns
The result of calling ranges::rend with a const-qualified reference to r.

Variable Documentation

◆ container

template<typename T >
CPP_concept ranges::container
Initial value:
=
CPP_concept_ref(ranges::container_, T)
The container_ concept std::vector is a container, std::array is not.
The semi_container concept std::array is a semi_container, native arrays are not.

◆ erasable_range

template<typename Rng , typename I , typename S >
CPP_concept ranges::erasable_range
Initial value:
=
range<Rng> && CPP_requires_ref(ranges::erasable_range_, Rng, I, S)
The erasable_range_ concept.
The range concept.

◆ lvalue_container_like

template<typename T >
CPP_concept ranges::lvalue_container_like
Initial value:
=
CPP_concept_ref(ranges::lvalue_container_like_, T)
The forward_range concept.
The lvalue_container_like_ concept.

◆ random_access_reservable

template<typename C >
CPP_concept ranges::random_access_reservable
Initial value:
=
The random_access_range concept.
The reservable concept.

◆ reservable

template<typename C >
CPP_concept ranges::reservable
Initial value:
=
container<C> && sized_range<C> && CPP_requires_ref(ranges::reservable_, C)
The container concept.
The reservable_ concept.
The sized_range concept.

◆ reservable_with_assign

template<typename C , typename I >
CPP_concept ranges::reservable_with_assign
Initial value:
=
CPP_requires_ref(ranges::reservable_with_assign_, C, I)
The input_iterator concept.
The reservable_with_assign_ concept.

◆ semi_container

template<typename T >
CPP_concept ranges::semi_container
Initial value:
=
forward_range<T> && default_constructible<uncvref_t<T>> &&
movable<uncvref_t<T>> &&
The view_ concept.