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:

=
        semi_container<T> &&
        CPP_concept_ref(ranges::container_, T)

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)

lvalue_container_like

template<typename T >

CPP_concept ranges::lvalue_container_like

Initial value:

=
        forward_range<T> &&
        CPP_concept_ref(ranges::lvalue_container_like_, T)

random_access_reservable

template<typename C >

CPP_concept ranges::random_access_reservable

Initial value:

=
        reservable<C> && random_access_range<C>

reservable

template<typename C >

CPP_concept ranges::reservable

Initial value:

=
        container<C> && sized_range<C> && CPP_requires_ref(ranges::reservable_, C)

reservable_with_assign

template<typename C , typename I >

CPP_concept ranges::reservable_with_assign

Initial value:

=
        reservable<C> && 
        input_iterator<I> && 
        CPP_requires_ref(ranges::reservable_with_assign_, C, I)

semi_container

template<typename T >

CPP_concept ranges::semi_container

Initial value:

=
        forward_range<T> && default_constructible<uncvref_t<T>> &&
        movable<uncvref_t<T>> &&
        !view_<T>