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

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

Concepts

concept  ranges::cartesian_produce_view_can_const
 The cartesian_produce_view_can_const concept.
 
concept  ranges::cartesian_produce_view_can_size_
 The cartesian_produce_view_can_size_ concept.
 
concept  ranges::cartesian_produce_view_can_size
 The cartesian_produce_view_can_size concept.
 
concept  ranges::cartesian_produce_view_can_distance_
 The cartesian_produce_view_can_distance_ concept.
 
concept  ranges::cartesian_produce_view_can_distance
 The cartesian_produce_view_can_distance concept.
 
concept  ranges::cartesian_produce_view_can_random_
 The cartesian_produce_view_can_random_ concept.
 
concept  ranges::cartesian_produce_view_can_random
 The cartesian_produce_view_can_random concept.
 
concept  ranges::cartesian_produce_view_can_bidi_
 The cartesian_produce_view_can_bidi_ concept.
 
concept  ranges::cartesian_produce_view_can_bidi
 The cartesian_produce_view_can_bidi concept.
 
concept  ranges::simple_view_impl_
 The simple_view_impl_ concept.
 
concept  ranges::simple_view_
 The simple_view_ concept.
 
concept  ranges::invocable_view_closure_
 The invocable_view_closure_ concept.
 
concept  ranges::invocable_view_closure
 The invocable_view_closure concept.
 

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::cache1_view< Rng >
 
struct  ranges::cartesian_product_view< Views >
 
struct  ranges::chunk_by_view< Rng, Fun >
 
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_last_view< Rng, typename >
 
struct  ranges::drop_last_view< Rng, detail::drop_last_view::mode_bidi >
 
struct  ranges::drop_last_view< Rng, detail::drop_last_view::mode_forward >
 
struct  ranges::drop_last_view< Rng, detail::drop_last_view::mode_sized >
 
struct  ranges::drop_view< Rng >
 
struct  ranges::drop_while_view< Rng, Pred >
 
struct  ranges::empty_view< T >
 
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::lazy_yield_if_fn
 
struct  ranges::make_subrange_fn
 
struct  ranges::make_view_closure_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::span< T, N >
 
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_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_base_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::ref_fn
 
struct  ranges::yield_fn
 
struct  ranges::yield_from_fn
 
struct  ranges::yield_if_fn
 
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 R >
using ranges::borrowed_subrange_t = detail::maybe_dangling_< R, subrange< iterator_t< R > > >
 
template<typename Rng >
using ranges::cpp20::ref_view = ranges::ref_view< Rng >
 
template<typename R >
using ranges::safe_subrange_t = borrowed_subrange_t< R >
 
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 >
using ranges::set_difference_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_difference_cursor, detail::set_difference_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)>
 
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 >
using ranges::set_intersection_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_intersection_cursor, detail::set_intersection_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)>
 
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 >
using ranges::set_symmetric_difference_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_symmetric_difference_cursor, detail::set_symmetric_difference_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)>
 
template<typename Rng1 , typename Rng2 , typename C , typename P1 , typename P2 >
using ranges::set_union_view = detail::set_algorithm_view< Rng1, Rng2, C, P1, P2, detail::set_union_cursor, detail::set_union_cardinality(range_cardinality< Rng1 >::value, range_cardinality< Rng2 >::value)>
 
template<typename Rng >
using ranges::take_exactly_view = detail::take_exactly_view_< Rng >
 

Enumerations

enum class  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
 
template<typename T , detail::span_index_t N>
span< unsigned char const, detail::byte_size< T >(N)> ranges::as_bytes (span< T, N > s) noexcept
 
template<typename T , detail::span_index_t N>
span< unsigned char, detail::byte_size< T >(N)> ranges::as_writeable_bytes (span< T, N > s) noexcept
 
constexpr Rng & ranges::ref_view< Rng >::base () const noexcept
 
constexpr iterator_t< Rng > ranges::ref_view< Rng >::begin () const noexcept(noexcept(ranges::begin(*rng_)))
 
template<typename View >
constexpr iterator_t< CRng > ranges::intersperse_view< Rng >::cursor_adaptor< Const >::begin (View &view)
 
result_t & ranges::generate_view< G >::cached ()
 
 ranges::generate_view< G >::cursor::cursor (generate_view *view)
 
template<bool Other>
requires Const
&&Other ranges::intersperse_view< Rng >::cursor_adaptor< Const >::cursor_adaptor (cursor_adaptor< Other > that)
 
constexpr ranges::intersperse_view< Rng >::cursor_adaptor< Const >::cursor_adaptor (range_value_t< Rng > const &val)
 
constexpr auto ranges::ref_view< Rng >::data () const noexcept(noexcept(ranges::data(*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 >
 
constexpr auto ranges::ref_view< Rng >::empty () const noexcept(noexcept(ranges::empty(*rng_))) -> bool
 
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< Rng > ranges::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
 
 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 >
requires copy_constructible<Val> && default_constructible<Val>
istream_view< Val > ranges::istream (std::istream &sin)
 
constexpr ranges::views::linear_distribute_view< T >::linear_distribute_view (T from, T to, std::ptrdiff_t n) noexcept
 
template<typename ElementType >
constexpr span< ElementType > ranges::make_span (ElementType *first, ElementType *last) noexcept
 
template<typename ElementType >
constexpr span< ElementType > ranges::make_span (ElementType *ptr, detail::span_index_t cnt) noexcept
 
template<typename Rng >
requires contiguous_range<Rng> && (range_cardinality<Rng>::value < cardinality())
constexpr span< detail::element_t< Rng > > ranges::make_span (Rng &&rng) noexcept(noexcept(ranges::data(rng), ranges::size(rng)))
 
void ranges::generate_view< G >::cursor::next ()
 
constexpr void ranges::intersperse_view< Rng >::cursor_adaptor< Const >::next (iterator_t< CRng > &it)
 
template<typename Char >
requires detail::is_char_type<Char>
::value ranges::delimit_view< ranges::subrange< Char *, ranges::unreachable_sentinel_t >, meta::_t< std::remove_cv< Char > > > ranges::views::c_str_fn::operator() (Char *sz) const volatile
 
template<typename Char , std::size_t N>
requires detail::is_char_type<Char>
::value ranges::subrange< Char * > ranges::views::c_str_fn::operator() (Char(&sz)[N]) const
 
template<typename 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 & > > generate_view< G > ranges::views::generate_fn::operator() (G g) const
 
template<typename Rng >
requires viewable_range<Rng> && input_range<Rng> && convertible_to<range_reference_t<Rng>, range_value_t<Rng>> && semiregular<range_value_t<Rng>>
constexpr intersperse_view< all_t< Rng > > ranges::views::intersperse_base_fn::operator() (Rng &&rng, range_value_t< Rng > val) const
 
template<typename Rng >
requires range<Rng>
constexpr ref_view< Rng > ranges::views::ref_fn::operator() (Rng &rng) const noexcept
 
template<typename Rng >
void ranges::views::ref_fn::operator() (Rng const &&rng) const =delete
 
template<typename T >
requires std::is_arithmetic<T>
::value constexpr auto ranges::views::linear_distribute_fn::operator() (T from, T to, std::ptrdiff_t n) const
 
template<typename T >
requires copyable<T>
constexpr auto ranges::views::intersperse_fn::operator() (T t) const
 
constexpr auto ranges::intersperse_view< Rng >::cursor_adaptor< Const >::prev (iterator_t< CRng > &it) -> void
 
result_t && ranges::generate_view< G >::cursor::read () const
 
constexpr range_value_t< Rng > ranges::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 >)
 
template<typename Rng >
constexpr bool ranges::simple_view () noexcept
 
constexpr auto ranges::intersperse_view< Rng >::size ()
 
constexpr auto ranges::intersperse_view< Rng >::size () const
 
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_)))
 

Variables

constexpr view_closure< addressof_fn > addressof {}
 
constexpr adjacent_filter_fn adjacent_filter {}
 
constexpr adjacent_remove_if_fn adjacent_remove_if {}
 
constexpr view_closure< all_fn > all {}
 
constexpr c_str_fn c_str {}
 
constexpr view_closure< cache1_fn > cache1 {}
 
constexpr chunk_fn chunk {}
 
constexpr chunk_by_fn chunk_by {}
 
constexpr closed_indices_fn closed_indices {}
 
constexpr closed_iota_fn closed_iota {}
 
constexpr view_closure< common_fn > common {}
 
constexpr concat_fn concat {}
 
constexpr view_closure< const_fn > const_ {}
 
constexpr counted_fn counted {}
 
constexpr view_closure< cycle_fn > cycle {}
 
constexpr delimit_fn delimit {}
 
template<typename Rng , typename Pred >
constexpr bool ranges::disable_sized_range< drop_while_view< Rng, Pred > >
 
template<typename Rng , typename Pred >
constexpr bool ranges::disable_sized_range< trim_view< Rng, Pred > > = true
 
constexpr drop_fn drop {}
 
constexpr drop_exactly_fn drop_exactly {}
 
constexpr drop_while_fn drop_while {}
 
constexpr detail::span_index_t ranges::dynamic_extent = -1
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< chunk_view< Rng > >
 
template<typename From , typename To >
constexpr bool ranges::enable_borrowed_range< closed_iota_view< From, To > >
 
template<typename Rng , bool B>
constexpr bool ranges::enable_borrowed_range< common_view< Rng, B > >
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< const_view< Rng > >
 
template<typename I >
constexpr bool ranges::enable_borrowed_range< counted_view< I > > = true
 
template<typename Rng , typename Val >
constexpr bool ranges::enable_borrowed_range< delimit_view< Rng, Val > >
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< drop_exactly_view< Rng > >
 
template<typename Rng , typename T >
constexpr bool ranges::enable_borrowed_range< drop_last_view< Rng, T > >
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< drop_view< Rng > >
 
template<typename Rng , typename Pred >
constexpr bool ranges::enable_borrowed_range< drop_while_view< Rng, Pred > >
 
template<typename T >
constexpr bool ranges::enable_borrowed_range< empty_view< T > > = true
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< intersperse_view< Rng > >
 
template<typename From , typename To >
constexpr bool ranges::enable_borrowed_range< iota_view< From, To > > = true
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< keys_range_view< Rng > >
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< move_view< Rng > >
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< reverse_view< Rng > >
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< slice_view< Rng > >
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< sliding_view< Rng > >
 
template<typename T , detail::span_index_t N>
constexpr bool ranges::enable_borrowed_range< span< T, N > > = true
 
template<typename I , typename S , subrange_kind K>
constexpr bool ranges::enable_borrowed_range< subrange< I, S, K > > = true
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< tail_view< Rng > >
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< take_view< Rng > >
 
template<typename Rng , typename Pred >
constexpr bool ranges::enable_borrowed_range< trim_view< Rng, Pred > >
 
template<typename I >
constexpr bool ranges::enable_borrowed_range< unbounded_view< I > > = true
 
template<typename Rng >
constexpr bool ranges::enable_borrowed_range< values_view< Rng > >
 
template<typename... Rng>
constexpr bool ranges::enable_borrowed_range< zip_view< Rng... > >
 
constexpr view_closure< enumerate_fn > enumerate {}
 
constexpr exclusive_scan_fn exclusive_scan {}
 
static constexpr index_type ranges::span< T, N >::extent = N
 
constexpr filter_fn filter {}
 
constexpr generate_fn generate {}
 
constexpr generate_n_fn generate_n {}
 
constexpr getlines_fn ranges::getlines {}
 
constexpr group_by_fn group_by {}
 
constexpr indices_fn indices {}
 
constexpr intersperse_fn intersperse {}
 
constexpr ints_fn ints {}
 
constexpr iota_fn iota {}
 
constexpr iter_take_while_fn iter_take_while {}
 
constexpr iter_transform_fn iter_transform {}
 
constexpr iter_zip_with_fn iter_zip_with {}
 
constexpr view_closure< join_fn > join {}
 
constexpr view_closure< keys_fn > keys {}
 
constexpr lazy_yield_if_fn lazy_yield_if {}
 
constexpr linear_distribute_fn linear_distribute {}
 
constexpr make_subrange_fn make_subrange {}
 
constexpr make_view_closure_fn ranges::make_view_closure {}
 
constexpr view_closure< move_fn > move {}
 
constexpr view_closure< partial_sum_fn > partial_sum {}
 
constexpr ref_fn ref {}
 
constexpr remove_fn remove {}
 
constexpr remove_if_fn remove_if {}
 
constexpr repeat_fn repeat {}
 
constexpr repeat_n_fn repeat_n {}
 
constexpr replace_fn replace {}
 
constexpr replace_if_fn replace_if {}
 
constexpr view_closure< reverse_fn > reverse {}
 
constexpr sample_fn sample {}
 
constexpr shared_closure< shared_fn > shared {}
 
constexpr single_fn single {}
 
constexpr slice_fn slice {}
 
constexpr sliding_fn sliding {}
 
constexpr split_fn split {}
 
constexpr split_when_fn split_when {}
 
constexpr stride_fn stride {}
 
constexpr view_closure< tail_fn > tail {}
 
constexpr take_exactly_fn take_exactly {}
 
constexpr take_while_fn take_while {}
 
constexpr tokenize_fn tokenize {}
 
constexpr transform_fn transform {}
 
constexpr trim_fn trim {}
 
constexpr unbounded_fn unbounded {}
 
constexpr view_closure< unique_fn > unique {}
 
constexpr view_closure< values_fn > values {}
 
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 {}
 

Detailed Description

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

Variable Documentation

◆ disable_sized_range< drop_while_view< Rng, Pred > >

template<typename Rng , typename Pred >
constexpr bool ranges::disable_sized_range< drop_while_view< Rng, Pred > >
constexpr

#include <range/v3/view/drop_while.hpp>

Initial value:
=
true

◆ enable_borrowed_range< chunk_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< chunk_view< Rng > >
constexpr

#include <range/v3/view/chunk.hpp>

Initial value:
=
enable_borrowed_range<Rng> && forward_range<Rng>
ranges::forward_range
The forward_range concept.
Definition: concepts.hpp:106

◆ enable_borrowed_range< closed_iota_view< From, To > >

template<typename From , typename To >
constexpr bool ranges::enable_borrowed_range< closed_iota_view< From, To > >
constexpr

#include <range/v3/view/iota.hpp>

Initial value:
=
true

◆ enable_borrowed_range< common_view< Rng, B > >

template<typename Rng , bool B>
constexpr bool ranges::enable_borrowed_range< common_view< Rng, B > >
constexpr

#include <range/v3/view/common.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< const_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< const_view< Rng > >
constexpr

#include <range/v3/view/const.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< delimit_view< Rng, Val > >

template<typename Rng , typename Val >
constexpr bool ranges::enable_borrowed_range< delimit_view< Rng, Val > >
constexpr

#include <range/v3/view/delimit.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< drop_exactly_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< drop_exactly_view< Rng > >
constexpr

#include <range/v3/view/drop_exactly.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< drop_last_view< Rng, T > >

template<typename Rng , typename T >
constexpr bool ranges::enable_borrowed_range< drop_last_view< Rng, T > >
constexpr

#include <range/v3/view/drop_last.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< drop_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< drop_view< Rng > >
constexpr

#include <range/v3/view/drop.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< drop_while_view< Rng, Pred > >

template<typename Rng , typename Pred >
constexpr bool ranges::enable_borrowed_range< drop_while_view< Rng, Pred > >
constexpr

#include <range/v3/view/drop_while.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< intersperse_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< intersperse_view< Rng > >
constexpr

#include <range/v3/view/intersperse.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< keys_range_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< keys_range_view< Rng > >
constexpr

#include <range/v3/view/map.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< move_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< move_view< Rng > >
constexpr

#include <range/v3/view/move.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< reverse_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< reverse_view< Rng > >
constexpr

#include <range/v3/view/reverse.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< slice_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< slice_view< Rng > >
constexpr

#include <range/v3/view/slice.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< sliding_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< sliding_view< Rng > >
constexpr

#include <range/v3/view/sliding.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< tail_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< tail_view< Rng > >
constexpr

#include <range/v3/view/tail.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< take_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< take_view< Rng > >
constexpr

#include <range/v3/view/take.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< trim_view< Rng, Pred > >

template<typename Rng , typename Pred >
constexpr bool ranges::enable_borrowed_range< trim_view< Rng, Pred > >
constexpr

#include <range/v3/view/trim.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< values_view< Rng > >

template<typename Rng >
constexpr bool ranges::enable_borrowed_range< values_view< Rng > >
constexpr

#include <range/v3/view/map.hpp>

Initial value:
=
enable_borrowed_range<Rng>

◆ enable_borrowed_range< zip_view< Rng... > >

template<typename... Rng>
constexpr bool ranges::enable_borrowed_range< zip_view< Rng... > >
constexpr

#include <range/v3/view/zip.hpp>

Initial value:
=
and_v<enable_borrowed_range<Rng>...>

◆ make_view_closure

constexpr make_view_closure_fn ranges::make_view_closure {}
constexpr

#include <range/v3/view/view.hpp>

See also
make_view_closure_fn