Range

Core range functionality. More...

Topics
	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
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
	ranges::constructible_from< uncvref_t< T >, detail::movable_input_iterator< range_value_t< T > >, detail::movable_input_iterator< range_value_t< T > > >
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
	ranges::implicitly_convertible_to< detail::is_lvalue_container_like_t< T >, std::true_type >
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

common_iterator_t

template<typename I, typename S>

using ranges::common_iterator_t

Initial value:

 meta::conditional_t<std::is_same<I, S>::value, I,
                                                detail::common_iterator_impl_t<I, S>>

iterator_t

template<typename Rng>

using ranges::iterator_t = 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>