Horizon
Modules | Classes | Typedefs | Functions | Variables
Range

Core range functionality. More...

Modules

 Range Concepts
 Range concepts.
 

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)
 \concept container_ More...
 
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))>>))
 \concept reservable_ More...
 
template<typename C , typename I >
 ranges::CPP_requires (reservable_with_assign_, requires(C &c, I i)(c.assign(i, i)))
 \concept reservable_with_assign_ More...
 
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)))
 \concept erasable_range_ More...
 
 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
 \concept semi_container More...
 
template<typename T >
CPP_concept ranges::container
 \concept container More...
 
template<typename C >
CPP_concept ranges::reservable
 \concept reservable More...
 
template<typename C , typename I >
CPP_concept ranges::reservable_with_assign
 \concept reservable_with_assign More...
 
template<typename C >
CPP_concept ranges::random_access_reservable
 \concept random_access_reservable More...
 
template<typename T >
CPP_concept ranges::lvalue_container_like
 \concept lvalue_container_like More...
 
template<typename Rng , typename I , typename S >
CPP_concept ranges::erasable_range
 \concept erasable_range More...
 

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.

Function Documentation

◆ CPP_requires() [1/3]

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))   
)

\concept erasable_range_

The erasable_range_ concept

◆ CPP_requires() [2/3]

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))>>)   
)

\concept reservable_

The reservable_ concept

◆ CPP_requires() [3/3]

template<typename C , typename I >
ranges::CPP_requires ( reservable_with_assign_  ,
requires(C &c, I i)(c.assign(i, i))   
)

\concept reservable_with_assign_

The reservable_with_assign_ concept

◆ template()

ranges::template ( typename T  )
noexcept

\concept container_

\concept sized_range_

\concept common_range_

\concept contiguous_range_

\concept random_access_range_

\concept bidirectional_range_

\concept forward_range_

\concept input_range_

\concept lvalue_container_like_

The container_ concept std::vector is a container, std::array is not

The lvalue_container_like_ concept

The input_range_ concept

The forward_range_ concept

The bidirectional_range_ concept

The random_access_range_ concept

The contiguous_range_ concept

The common_range_ concept

The sized_range_ concept

Variable Documentation

◆ container

template<typename T >
CPP_concept ranges::container
Initial value:
=
semi_container<T> &&
CPP_concept_ref(ranges::container_, T)

\concept container

The container concept

◆ 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)

\concept erasable_range

The erasable_range concept

◆ 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)

\concept lvalue_container_like

The lvalue_container_like concept

◆ random_access_reservable

template<typename C >
CPP_concept ranges::random_access_reservable
Initial value:
=
reservable<C> && random_access_range<C>

\concept random_access_reservable

The random_access_reservable concept

◆ reservable

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

\concept reservable

The reservable concept

◆ 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)

\concept reservable_with_assign

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>> &&
!view_<T>

\concept semi_container

The semi_container concept std::array is a semi_container, native arrays are not.