Range-v3
Range algorithms, views, and actions for the Standard Library
Views

Description

Lazy, non-owning, non-mutating, composable range views.

Classes

struct  ranges::adaptor_base
 
struct  ranges::adaptor_cursor< BaseIter, Adapt >
 
struct  ranges::adaptor_sentinel< BaseSent, Adapt >
 
struct  ranges::adjacent_filter_view< Rng, Pred >
 
struct  ranges::adjacent_remove_if_view< Rng, Pred >
 
struct  ranges::any_view< Ref, Cat, enable >
 A type-erased view. More...
 
struct  ranges::base_adaptor_sentinel< BaseSent, Adapt >
 
struct  ranges::chunk_view< Rng >
 
struct  ranges::chunk_view_< Rng, IsForwardRange >
 
struct  ranges::chunk_view_< Rng, false >
 
struct  ranges::closed_iota_view< From, To >
 An iota view in a closed range. More...
 
struct  ranges::common_view< Rng, bool >
 
struct  ranges::common_view< Rng, true >
 
struct  ranges::concat_view< Rngs >
 
struct  ranges::const_view< Rng >
 
struct  ranges::counted_view< I >
 
struct  ranges::cycled_view< Rng, bool >
 
struct  ranges::cycled_view< Rng, true >
 
struct  ranges::delimit_view< Rng, Val >
 
struct  ranges::drop_exactly_view< Rng >
 
struct  ranges::drop_view< Rng >
 
struct  ranges::drop_while_view< Rng, Pred >
 
struct  ranges::exclusive_scan_view< Rng, T, Fun >
 
struct  ranges::filter_view< Rng, Pred >
 
struct  ranges::generate_n_view< G >
 
struct  ranges::generate_view< G >
 
struct  ranges::getlines_fn
 
struct  ranges::getlines_view
 
struct  ranges::group_by_view< Rng, Fun >
 
struct  ranges::identity_adaptor< Rng >
 
struct  ranges::intersperse_view< Rng >
 
struct  ranges::iota_view< From, To >
 
struct  ranges::istream_view< Val >
 
struct  ranges::iter_take_while_view< Rng, Pred >
 
struct  ranges::iter_transform2_view< Rng1, Rng2, Fun >
 
struct  ranges::iter_transform_view< Rng, Fun >
 
struct  ranges::iter_zip_with_view< Fun, Rngs >
 
struct  ranges::join_view< Rng >
 
struct  ranges::join_with_view< Rng, ValRng >
 
struct  ranges::make_subrange_fn
 
struct  ranges::move_view< Rng >
 
struct  ranges::partial_sum_view< Rng, Fun >
 
struct  ranges::ref_view< Rng >
 
struct  ranges::remove_if_view< Rng, Pred >
 
struct  ranges::repeat_n_view< Val >
 
struct  ranges::repeat_view< Val >
 
struct  ranges::reverse_view< Rng >
 
struct  ranges::reverse_view< reverse_view< Rng > >
 
class  ranges::sample_view< Rng, URNG >
 
struct  ranges::single_view< T >
 
struct  ranges::slice_view< Rng >
 
struct  ranges::sliding_view< Rng, sliding_view_detail::cache::first >
 
struct  ranges::sliding_view< Rng, sliding_view_detail::cache::last >
 
struct  ranges::sliding_view< Rng, sliding_view_detail::cache::none >
 
struct  ranges::split_view< V, Pattern >
 
struct  ranges::split_when_view< Rng, Fun >
 
struct  ranges::stride_view< Rng >
 
struct  ranges::subrange< I, S, K >
 
struct  ranges::tail_view< Rng >
 
struct  ranges::take_while_view< Rng, Pred >
 
struct  ranges::tokenize_view< Rng, Regex, SubMatchRange >
 
struct  ranges::transform2_view< Rng1, Rng2, Fun >
 
struct  ranges::transform_view< Rng, Fun >
 
struct  ranges::trim_view< Rng, Pred >
 
struct  ranges::unbounded_view< I >
 
struct  ranges::view_adaptor< Derived, BaseRng, Cardinality >
 
struct  ranges::view_facade< Derived, Cardinality >
 A utility for constructing a view from a (derived) type that implements begin and end cursors. More...
 
struct  ranges::view_interface< Derived, Cardinality >
 
struct  ranges::views::c_str_fn
 View a \0-terminated C string (e.g. from a const char*) as a range. More...
 
struct  ranges::views::generate_fn
 
struct  ranges::views::intersperse_fn
 
struct  ranges::views::linear_distribute_fn
 Distributes n values linearly in the closed interval [from, to]. More...
 
struct  ranges::views::linear_distribute_view< T >
 
struct  ranges::views::make_view_fn
 
struct  ranges::views::ref_fn
 
struct  ranges::views::view< View >
 
struct  ranges::views::view_access
 
struct  ranges::views::view_access::impl< View >
 
struct  ranges::zip_view< Rngs >
 
struct  ranges::zip_with_view< Fun, Rngs >
 

Typedefs

template<typename D >
using ranges::adaptor_cursor_t = adaptor_cursor< detail::adapted_iterator_t< D >, detail::begin_adaptor_t< D > >
 
template<typename D >
using ranges::adaptor_sentinel_t = meta::if_c< same_as< detail::adapted_iterator_t< D >, detail::adapted_sentinel_t< D > > &&same_as< detail::begin_adaptor_t< D >, detail::end_adaptor_t< D > >, adaptor_cursor_t< D >, adaptor_sentinel< detail::adapted_sentinel_t< D >, detail::end_adaptor_t< D > >>
 
template<typename Rng >
using ranges::cpp20::ref_view = ranges::ref_view< Rng >
 
template<typename R >
using ranges::safe_subrange_t = detail::maybe_dangling_< R, subrange< iterator_t< R > >>
 
template<typename Rng >
using ranges::take_exactly_view = detail::take_exactly_view_< Rng >
 

Enumerations

enum  subrange_kind : bool { unsized, sized }
 

Functions

constexpr auto ranges::intersperse_view< Rng >::cursor_adaptor< Const >::advance (iterator_t< CRng > &it, range_difference_t< CRng > n) -> void requires random_access_range< CRng >
 
constexpr Rngranges::ref_view< Rng >::base () const noexcept
 
template<typename View >
constexpr iterator_t< CRng > ranges::intersperse_view< Rng >::cursor_adaptor< Const >::begin (View &view)
 
constexpr iterator_t< Rngranges::ref_view< Rng >::begin () const noexcept(noexcept(ranges::begin(*rng_)))
 
template<typename... Ts, typename V = View>
static constexpr auto ranges::views::view_access::impl< View >::bind (Ts &&... ts) noexcept(noexcept(decltype(V::bind(static_cast< Ts &&>(ts)...))(V::bind(static_cast< Ts &&>(ts)...)))) -> decltype(V::bind(static_cast< Ts &&>(ts)...))
 
result_t & ranges::generate_view< G >::cached ()
 
 ranges::generate_view< G >::cursor::cursor (generate_view *view)
 
constexpr ranges::intersperse_view< Rng >::cursor_adaptor< Const >::cursor_adaptor (range_value_t< Rng > const &val)
 
template<bool Other>
requires Const &&!Other ranges::intersperse_view< Rng >::cursor_adaptor< Const >::cursor_adaptor (cursor_adaptor< Other > that)
 
constexpr auto ranges::ref_view< Rng >::data () const noexcept(noexcept(ranges::data(*rng_))) requires contiguous_range< Rng >
 
constexpr auto ranges::intersperse_view< Rng >::cursor_adaptor< Const >::distance_to (iterator_t< CRng > const &it, iterator_t< CRng > const &other_it, cursor_adaptor const &other) const -> range_difference_t< Rng > requires sized_sentinel_for< iterator_t< CRng >, iterator_t< CRng >>
 
constexpr auto ranges::ref_view< Rng >::empty () const noexcept(noexcept(ranges::empty(*rng_))) -> bool requires detail::can_empty_< Rng >
 
static constexpr bool ranges::intersperse_view< Rng >::sentinel_adaptor< Const >::empty (iterator_t< CRng > const &it, cursor_adaptor< Const > const &, sentinel_t< CRng > const &sent)
 
constexpr sentinel_t< Rngranges::ref_view< Rng >::end () const noexcept(noexcept(ranges::end(*rng_)))
 
constexpr auto ranges::intersperse_view< Rng >::cursor_adaptor< Const >::equal (iterator_t< CRng > const &it0, iterator_t< CRng > const &it1, cursor_adaptor const &other) const -> bool requires sentinel_for< iterator_t< CRng >, iterator_t< CRng >>
 
 ranges::generate_view< G >::generate_view (G g)
 
constexpr ranges::intersperse_view< Rng >::intersperse_view (Rng rng, range_value_t< Rng > val)
 
template<typename Val >
auto ranges::istream (std::istream &sin) -> istream_view< Val > requires copy_constructible< Val > &&default_constructible< Val >
 
constexpr ranges::views::linear_distribute_view< T >::linear_distribute_view (T from, T to__, std::ptrdiff_t n) noexcept
 
void ranges::generate_view< G >::cursor::next ()
 
constexpr void ranges::intersperse_view< Rng >::cursor_adaptor< Const >::next (iterator_t< CRng > &it)
 
template<typename Char , std::size_t N>
auto ranges::views::c_str_fn::operator() (Char(&sz)[N]) const -> ranges::subrange< Char *> requires detail::is_char_type< Char >::value
 
template<typename Char >
auto ranges::views::c_str_fn::operator() (Char *sz) const volatile -> ranges::delimit_view< ranges::subrange< Char *, ranges::unreachable_sentinel_t >, meta::_t< std::remove_cv< Char >>> requires detail::is_char_type< Char >::value
 
template<typename Fun >
constexpr view< Fun > ranges::views::make_view_fn::operator() (Fun fun) const
 
template<typename G >
auto ranges::views::generate_fn::operator() (G g) const -> generate_view< G > requires invocable< G &> &&copy_constructible< G > &&std::is_object< detail::decay_t< invoke_result_t< G &>>>::value &&constructible_from< detail::decay_t< invoke_result_t< G &>>, invoke_result_t< G &>> &&assignable_from< detail::decay_t< invoke_result_t< G &>> &, invoke_result_t< G &>>
 
template<typename Rng >
constexpr auto ranges::views::ref_fn::operator() (Rng &rng) const noexcept -> ref_view< Rng > requires range< Rng >
 
template<typename Rng , typename... Rest>
constexpr auto ranges::views::view< View >::operator() (Rng &&rng, Rest &&... rest) const -> invoke_result_t< View const &, Rng, Rest... > requires viewable_range< Rng > &&invocable< View const &, Rng, Rest... >
 
template<typename Rng >
void ranges::views::ref_fn::operator() (Rng const &&rng) const =delete
 
template<typename... Ts, typename V = View>
constexpr auto ranges::views::view< View >::operator() (Ts &&... ts) return make_view(view_access
 
template<typename Rng >
constexpr auto ranges::views::intersperse_fn::operator() (Rng &&rng, range_value_t< Rng > val) const -> intersperse_view< all_t< Rng >> requires viewable_range< Rng > &&input_range< Rng > &&convertible_to< range_reference_t< Rng >, range_value_t< Rng >> &&semiregular< range_value_t< Rng >>
 
constexpr auto ranges::intersperse_view< Rng >::cursor_adaptor< Const >::prev (iterator_t< CRng > &it) -> void requires bidirectional_range< CRng >
 
result_t && ranges::generate_view< G >::cursor::read () const
 
constexpr range_value_t< Rngranges::intersperse_view< Rng >::cursor_adaptor< Const >::read (iterator_t< CRng > const &it) const
 
constexpr ranges::ref_view< Rng >::ref_view (Rng &rng) noexcept
 
template<bool Other>
requires Const &&!Other ranges::intersperse_view< Rng >::sentinel_adaptor< Const >::sentinel_adaptor (sentinel_adaptor< Other >)
 
constexpr auto ranges::intersperse_view< Rng >::size () const requires sized_range< Rng const >
 
constexpr auto ranges::intersperse_view< Rng >::size () requires sized_range< Rng >
 
constexpr std::size_t ranges::views::linear_distribute_view< T >::size () const noexcept
 
constexpr auto ranges::ref_view< Rng >::size () const noexcept(noexcept(ranges::size(*rng_))) requires sized_range< Rng >
 
constexpr ranges::views::view< View >::view (View a) noexcept(std::is_nothrow_move_constructible< View >::value)
 

Variables

constexpr view< addressof_fnaddressof {}
 
constexpr view< adjacent_filter_fnadjacent_filter {}
 
constexpr view< adjacent_remove_if_fnadjacent_remove_if {}
 
constexpr all_fn all {}
 
constexpr c_str_fn c_str {}
 
constexpr view< chunk_fnchunk {}
 
constexpr closed_indices_fn closed_indices {}
 
constexpr closed_iota_fn closed_iota {}
 
constexpr view< common_fncommon {}
 
constexpr concat_fn concat {}
 
constexpr view< const_fnconst_ {}
 
constexpr counted_fn counted {}
 
constexpr view< cycle_fncycle {}
 
constexpr delimit_fn delimit {}
 
template<typename Rng , typename Pred >
constexpr bool ranges::disable_sized_range< trim_view< Rng, Pred > > = true
 
constexpr view< drop_fndrop {}
 
constexpr view< drop_exactly_fndrop_exactly {}
 
constexpr view< drop_while_fndrop_while {}
 
constexpr view< enumerate_fnenumerate {}
 
constexpr view< exclusive_scan_fnexclusive_scan {}
 
constexpr view< filter_fnfilter {}
 
constexpr view< for_each_fnfor_each {}
 
constexpr generate_fn generate {}
 
constexpr generate_n_fn generate_n {}
 
constexpr getlines_fn ranges::getlines {}
 
constexpr view< group_by_fngroup_by {}
 
constexpr indices_fn indices {}
 
constexpr view< intersperse_fnintersperse {}
 
constexpr ints_fn ints {}
 
constexpr iota_fn iota {}
 
constexpr view< iter_take_while_fniter_take_while {}
 
constexpr view< iter_transform_fniter_transform {}
 
constexpr iter_zip_with_fn iter_zip_with {}
 
constexpr view< join_fnjoin {}
 
constexpr view< keys_fnkeys {}
 
constexpr lazy_yield_if_fn lazy_yield_if {}
 
constexpr linear_distribute_fn linear_distribute {}
 
constexpr make_subrange_fn make_subrange {}
 
constexpr make_view_fn ranges::views::make_view {}
 
constexpr view< move_fnmove {}
 
constexpr view< partial_sum_fnpartial_sum {}
 
constexpr view< ref_fnref {}
 
constexpr view< remove_fnremove {}
 
constexpr view< remove_if_fnremove_if {}
 
constexpr repeat_fn repeat {}
 
constexpr repeat_n_fn repeat_n {}
 
constexpr view< replace_fnreplace {}
 
constexpr view< replace_if_fnreplace_if {}
 
constexpr view< reverse_fnreverse {}
 
constexpr view< sample_fnsample {}
 
constexpr view< set_difference_fnset_difference {}
 
constexpr view< set_intersection_fnset_intersection {}
 
constexpr view< set_symmetric_difference_fnset_symmetric_difference {}
 
constexpr view< set_union_fnset_union {}
 
constexpr shared_fn shared {}
 
constexpr single_fn single {}
 
constexpr view< slice_fn > slice {}
 
constexpr view< sliding_fnsliding {}
 
constexpr view< split_fnsplit {}
 
constexpr view< split_when_fnsplit_when {}
 
constexpr view< stride_fnstride {}
 
constexpr view< tail_fntail {}
 
constexpr view< take_fntake {}
 
constexpr view< take_exactly_fntake_exactly {}
 
constexpr view< take_last_fntake_last {}
 
constexpr view< take_while_fntake_while {}
 
constexpr tokenize_fn tokenize {}
 
constexpr view< transform_fntransform {}
 
constexpr view< trim_fntrim {}
 
constexpr unbounded_fn unbounded {}
 
constexpr view< unique_fnunique {}
 
constexpr view< values_fnvalues {}
 
constexpr yield_fn yield {}
 
constexpr yield_from_fn yield_from {}
 
constexpr yield_if_fn yield_if {}
 
constexpr zip_fn zip {}
 
constexpr zip_with_fn zip_with {}
 

Friends

struct ranges::intersperse_view< Rng >::cursor_adaptor< Const >::cursor_adaptor<!Const >
 

Variable Documentation

◆ make_view

constexpr make_view_fn ranges::views::make_view {}