Range-v3
Range algorithms, views, and actions for the Standard Library
Classes | Typedefs | Functions | Variables
Core

Description

Core range functionality.

Classes

struct  ranges::v3::adaptor_base
 
struct  ranges::v3::adaptor_cursor< BaseIter, Adapt >
 
struct  ranges::v3::adaptor_sentinel< BaseSent, Adapt >
 
struct  ranges::v3::at_fn
 
struct  ranges::v3::back_fn
 
struct  ranges::v3::bidirectional_iterator_tag
 
struct  ranges::v3::dangling< I >
 A wrapper for an iterator or a sentinel into a range that may no longer be valid. More...
 
struct  ranges::v3::distance_compare_fn
 
struct  ranges::v3::distance_fn
 
struct  ranges::v3::empty_fn
 
struct  ranges::v3::enumerate_fn
 
struct  ranges::v3::forward_iterator_tag
 
struct  ranges::v3::front_fn
 
struct  ranges::v3::get_unsafe_fn
 
struct  ranges::v3::getlines_fn
 
struct  ranges::v3::getlines_range
 
struct  ranges::v3::input_iterator_tag
 
struct  ranges::v3::istream_range< Val >
 
struct  ranges::v3::iterator_range< I, S >
 
struct  ranges::v3::make_iterator_range_fn
 
struct  ranges::v3::random_access_iterator_tag
 
struct  ranges::v3::range_cardinality< Rng, Void >
 
struct  ranges::v3::safe_begin_fn
 
struct  ranges::v3::safe_end_fn
 
struct  ranges::v3::sanitize_fn
 
struct  ranges::v3::sized_iterator_range< I, S >
 
struct  ranges::v3::view_adaptor< Derived, BaseRng, Cardinality >
 
struct  ranges::v3::view_facade< Derived, Cardinality >
 
struct  ranges::v3::view_interface< Derived, Cardinality >
 

Typedefs

template<typename D >
using ranges::v3::adaptor_cursor_t = adaptor_cursor< detail::adapted_iterator_t< D >, detail::begin_adaptor_t< D >>
 
template<typename D >
using ranges::v3::adaptor_sentinel_t = meta::if_< meta::and_< Same< detail::adapted_iterator_t< D >, detail::adapted_sentinel_t< D >>, Same< detail::begin_adaptor_t< D >, detail::end_adaptor_t< D >>>, adaptor_cursor< detail::adapted_iterator_t< D >, detail::begin_adaptor_t< D >>, adaptor_sentinel< detail::adapted_sentinel_t< D >, detail::end_adaptor_t< D >>>
 
template<typename Derived >
using ranges::v3::base_range_t = meta::_t< range_access::base_range< Derived >>
 
template<typename I >
using ranges::v3::iterator_category_t = concepts::InputIterator::category_t< I >
 
template<typename I >
using ranges::v3::iterator_common_reference = meta::defer< iterator_common_reference_t, I >
 
template<typename I >
using ranges::v3::iterator_common_reference_t = concepts::Readable::common_reference_t< I >
 
template<typename I >
using ranges::v3::iterator_difference = meta::defer< iterator_difference_t, I >
 
template<typename I >
using ranges::v3::iterator_difference_t = concepts::WeaklyIncrementable::difference_t< I >
 
template<typename I >
using ranges::v3::iterator_reference = meta::defer< iterator_reference_t, I >
 
template<typename I >
using ranges::v3::iterator_reference_t = concepts::Readable::reference_t< I >
 
template<typename I >
using ranges::v3::iterator_rvalue_reference = meta::defer< iterator_rvalue_reference_t, I >
 
template<typename I >
using ranges::v3::iterator_rvalue_reference_t = concepts::Readable::rvalue_reference_t< I >
 
template<typename I >
using ranges::v3::iterator_size = meta::defer< iterator_size_t, I >
 
template<typename I >
using ranges::v3::iterator_size_t = meta::_t< std::make_unsigned< iterator_difference_t< I >>>
 
template<typename I >
using ranges::v3::iterator_value = meta::defer< iterator_value_t, I >
 
template<typename I >
using ranges::v3::iterator_value_t = concepts::Readable::value_t< I >
 
template<typename Rng >
using ranges::v3::range_category = meta::defer< range_category_t, Rng >
 
template<typename Rng >
using ranges::v3::range_category_t = concepts::InputRange::category_t< Rng >
 
template<typename Rng >
using ranges::v3::range_common_iterator_t = common_iterator< range_iterator_t< Rng >, range_sentinel_t< Rng >>
 
template<typename Rng >
using ranges::v3::range_common_reference = meta::defer< range_common_reference_t, Rng >
 
template<typename Rng >
using ranges::v3::range_common_reference_t = concepts::InputRange::common_reference_t< Rng >
 
template<typename Rng >
using ranges::v3::range_difference = meta::defer< range_difference_t, Rng >
 
template<typename Rng >
using ranges::v3::range_difference_t = concepts::Range::difference_t< Rng >
 
template<typename Rng >
using ranges::v3::range_iterator = meta::defer< range_iterator_t, Rng >
 
template<typename Rng >
using ranges::v3::range_iterator_t = concepts::Range::iterator_t< Rng >
 
template<typename Rng >
using ranges::v3::range_reference = meta::defer< range_reference_t, Rng >
 
template<typename Rng >
using ranges::v3::range_reference_t = concepts::InputRange::reference_t< Rng >
 
template<typename Rng >
using ranges::v3::range_rvalue_reference = meta::defer< range_rvalue_reference_t, Rng >
 
template<typename Rng >
using ranges::v3::range_rvalue_reference_t = concepts::InputRange::rvalue_reference_t< Rng >
 
template<typename Rng >
using ranges::v3::range_safe_iterator_t = decltype(ranges::safe_begin(std::declval< Rng >()))
 
template<typename Rng >
using ranges::v3::range_safe_sentinel_t = decltype(ranges::safe_end(std::declval< Rng >()))
 
template<typename Rng >
using ranges::v3::range_sentinel = meta::defer< range_sentinel_t, Rng >
 
template<typename Rng >
using ranges::v3::range_sentinel_t = concepts::Range::sentinel_t< Rng >
 
template<typename Rng >
using ranges::v3::range_size = meta::defer< range_size_t, Rng >
 
template<typename Rng >
using ranges::v3::range_size_t = meta::_t< std::make_unsigned< range_difference_t< Rng >>>
 
template<typename Rng >
using ranges::v3::range_value = meta::defer< range_value_t, Rng >
 
template<typename Rng >
using ranges::v3::range_value_t = concepts::InputRange::value_t< Rng >
 
template<typename RangeFacade >
using ranges::v3::view_facade_t = meta::_t< range_access::view_facade< RangeFacade >>
 

Functions

template<std::size_t N, typename I , typename S , requires = (N < 2)>
constexpr auto ranges::v3::get (sized_iterator_range< I, S > const &p) -> decltype(ranges::get< N >(static_cast< iterator_range< I, S > const & >(p)))
 Tuple-like access for sized_iterator_range
 
template<typename Val >
istream_range< Val > ranges::v3::istream (std::istream &sin)
 
template<template< typename... > class ContT>
detail::to_container_fn< meta::quote< ContT > > ranges::v3::to_ ()
 For initializing a container of the specified type with the elements of an Range.
 
template<template< typename... > class ContT, typename Rng , typename Cont = meta::invoke<meta::quote<ContT>, range_value_t<Rng>>, requires = (Range<Rng>() && detail::ConvertibleToContainer<Rng, Cont>())>
Cont ranges::v3::to_ (Rng &&rng)
 
template<template< typename... > class ContT, typename T , typename Cont = meta::invoke<meta::quote<ContT>, T>, requires = (detail::ConvertibleToContainer<std::initializer_list<T>, Cont>())>
Cont ranges::v3::to_ (std::initializer_list< T > list)
 
template<typename Cont , typename Rng , requires = (Range<Rng>() && detail::ConvertibleToContainer<Rng, Cont>())>
Cont ranges::v3::to_ (Rng &&rng)
 
template<typename Cont , typename T , requires = (detail::ConvertibleToContainer<std::initializer_list<T>, Cont>())>
Cont ranges::v3::to_ (std::initializer_list< T > list)
 

Variables

constexpr at_fn ranges::v3::at {}
 
constexpr back_fn ranges::v3::back {}
 
constexpr begin_fn ranges::v3::begin {}
 
constexpr cbegin_fn ranges::v3::cbegin {}
 
constexpr cend_fn ranges::v3::cend {}
 
constexpr crbegin_fn ranges::v3::crbegin {}
 
constexpr crend_fn ranges::v3::crend {}
 
constexpr distance_fn ranges::v3::distance {}
 
constexpr distance_compare_fn ranges::v3::distance_compare {}
 
constexpr empty_fn ranges::v3::empty {}
 
constexpr end_fn ranges::v3::end {}
 
constexpr enumerate_fn ranges::v3::enumerate {}
 
constexpr front_fn ranges::v3::front {}
 
constexpr get_unsafe_fn ranges::v3::get_unsafe {}
 
constexpr getlines_fn ranges::v3::getlines {}
 
constexpr make_iterator_range_fn ranges::v3::make_iterator_range {}
 
constexpr rbegin_fn ranges::v3::rbegin {}
 
constexpr rend_fn ranges::v3::rend {}
 
constexpr safe_begin_fn ranges::v3::safe_begin {}
 
constexpr safe_end_fn ranges::v3::safe_end {}
 
constexpr sanitize_fn ranges::v3::sanitize {}
 
constexpr adl_size_detail::size_fn ranges::v3::size {}
 
constexpr detail::to_container_fn< meta::quote< std::vector > > ranges::v3::to_vector {}
 

Function Documentation

template<template< typename... > class ContT, typename Rng , typename Cont = meta::invoke<meta::quote<ContT>, range_value_t<Rng>>, requires = (Range<Rng>() && detail::ConvertibleToContainer<Rng, Cont>())>
Cont ranges::v3::to_ ( Rng &&  rng)

#include <range/v3/to_container.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<template< typename... > class ContT, typename T , typename Cont = meta::invoke<meta::quote<ContT>, T>, requires = (detail::ConvertibleToContainer<std::initializer_list<T>, Cont>())>
Cont ranges::v3::to_ ( std::initializer_list< T >  list)

#include <range/v3/to_container.hpp>

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::ConvertibleToContainer<Rng, Cont>())>
Cont ranges::v3::to_ ( Rng &&  rng)

#include <range/v3/to_container.hpp>

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 T , requires = (detail::ConvertibleToContainer<std::initializer_list<T>, Cont>())>
Cont ranges::v3::to_ ( std::initializer_list< T >  list)

#include <range/v3/to_container.hpp>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Variable Documentation

constexpr at_fn ranges::v3::at {}

#include <range/v3/at.hpp>

See also
at_fn
constexpr back_fn ranges::v3::back {}

#include <range/v3/back.hpp>

See also
back_fn
constexpr begin_fn ranges::v3::begin {}

#include <range/v3/begin_end.hpp>

Returns
The result of an unqualified call to the begin free function

Referenced by ranges::v3::tail_view< Rng >::begin(), ranges::v3::tokenize_view< Rng, Regex, SubMatchRange >::begin(), ranges::v3::empty_fn::operator()(), ranges::v3::front_fn::operator()(), ranges::v3::at_fn::operator()(), and ranges::v3::safe_begin_fn::operator()().

constexpr cbegin_fn ranges::v3::cbegin {}

#include <range/v3/begin_end.hpp>

Returns
The result of an unqualified call to the begin free function with a const-qualified argument.
constexpr cend_fn ranges::v3::cend {}

#include <range/v3/begin_end.hpp>

Returns
The result of an unqualified call to the end free function with a const-qualified argument.
constexpr crbegin_fn ranges::v3::crbegin {}

#include <range/v3/begin_end.hpp>

Returns
The result of an unqualified call to the rbegin free function with a const-qualified argument.
constexpr crend_fn ranges::v3::crend {}

#include <range/v3/begin_end.hpp>

Returns
The result of an unqualified call to the rend free function with a const-qualified argument.
constexpr distance_fn ranges::v3::distance {}

#include <range/v3/distance.hpp>

See also
distance_fn

Referenced by ranges::v3::chunk_view< Rng >::size().

constexpr distance_compare_fn ranges::v3::distance_compare {}

#include <range/v3/distance.hpp>

See also
distance_compare_fn
constexpr empty_fn ranges::v3::empty {}

#include <range/v3/empty.hpp>

See also
empty_fn
constexpr end_fn ranges::v3::end {}

#include <range/v3/begin_end.hpp>

Returns
The result of an unqualified call to the end free function

Referenced by ranges::v3::view_interface< stride_view< Rng >, Cardinality >::back(), ranges::v3::tokenize_view< Rng, Regex, SubMatchRange >::begin(), ranges::v3::tail_view< Rng >::end(), ranges::v3::empty_fn::operator()(), ranges::v3::back_fn::operator()(), and ranges::v3::safe_end_fn::operator()().

constexpr enumerate_fn ranges::v3::enumerate {}

#include <range/v3/distance.hpp>

See also
enumerate_fn
constexpr front_fn ranges::v3::front {}

#include <range/v3/front.hpp>

See also
front_fn
constexpr get_unsafe_fn ranges::v3::get_unsafe {}

#include <range/v3/utility/dangling.hpp>

Returns
t.get_unsafe() if t is an instance of ranges::dangling; otherwise, return t.
constexpr make_iterator_range_fn ranges::v3::make_iterator_range {}

#include <range/v3/iterator_range.hpp>

See also
make_iterator_range_fn
constexpr rbegin_fn ranges::v3::rbegin {}

#include <range/v3/begin_end.hpp>

Returns
The result of an unqualified call to the rbegin free function
constexpr rend_fn ranges::v3::rend {}

#include <range/v3/begin_end.hpp>

Returns
The result of an unqualified call to the rend free function
constexpr safe_begin_fn ranges::v3::safe_begin {}

#include <range/v3/begin_end.hpp>

Returns
begin(rng) if rng is an lvalue; otherwise, it returns begin(rng) wrapped in ranges::dangling.
constexpr safe_end_fn ranges::v3::safe_end {}

#include <range/v3/begin_end.hpp>

Returns
end(rng) if rng is an lvalue; otherwise, it returns end(rng) wrapped in ranges::dangling.
constexpr sanitize_fn ranges::v3::sanitize {}

#include <range/v3/utility/dangling.hpp>

Returns
the result of replacing all ranges::dangling<T> objects with ranges::dangling<void>, introspecting std::pair and std::tuple objects recursively.
constexpr adl_size_detail::size_fn ranges::v3::size {}

#include <range/v3/size.hpp>

Returns
The result of an unqualified call to size