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

Description

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

Classes

struct  boost::range_const_iterator< ::ranges::v3::generate_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::generate_view< Ts... > const >()> >
 
struct  boost::range_const_iterator< ::ranges::v3::intersperse_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::intersperse_view< Ts... > const >()> >
 
struct  boost::range_mutable_iterator< ::ranges::v3::generate_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::generate_view< Ts... > >()> >
 
struct  boost::range_mutable_iterator< ::ranges::v3::intersperse_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::intersperse_view< Ts... > >()> >
 
struct  boost::range_size< ::ranges::v3::generate_view< Ts... > >
 
struct  boost::range_size< ::ranges::v3::generate_view< Ts... > const >
 
struct  boost::range_size< ::ranges::v3::intersperse_view< Ts... > >
 
struct  boost::range_size< ::ranges::v3::intersperse_view< Ts... > const >
 
struct  boost::range_value< ::ranges::v3::generate_view< Ts... > >
 
struct  boost::range_value< ::ranges::v3::intersperse_view< Ts... > >
 
struct  ranges::v3::adjacent_filter_view< Rng, Pred >
 
struct  ranges::v3::adjacent_remove_if_view< Rng, Pred >
 
struct  ranges::v3::any_view< Ref, Cat, enable >
 A type-erased view. More...
 
struct  ranges::v3::bounded_view< Rng >
 
struct  ranges::v3::chunk_view< Rng, bool >
 
struct  ranges::v3::chunk_view< Rng, false >
 
struct  ranges::v3::closed_iota_view< From, To >
 An iota view in a closed range with non-random access iota value type. More...
 
struct  ranges::v3::concat_view< Rngs >
 
struct  ranges::v3::const_view< Rng >
 
struct  ranges::v3::counted_view< I >
 
struct  ranges::v3::cycled_view< Rng >
 
struct  ranges::v3::delimit_view< Rng, Val >
 
struct  ranges::v3::drop_exactly_view< Rng >
 
struct  ranges::v3::drop_view< Rng >
 
struct  ranges::v3::drop_while_view< Rng, Pred >
 
struct  ranges::v3::generate_n_view< G >
 
struct  ranges::v3::generate_view< G >
 
struct  ranges::v3::group_by_view< Rng, Fun >
 
struct  ranges::v3::indirect_view< Rng >
 
struct  ranges::v3::interleave_view< Rngs >
 Flattens a range of ranges by iterating the inner ranges in round-robin fashion. More...
 
struct  ranges::v3::interleave_view< Rngs >::cursor
 
struct  ranges::v3::intersperse_view< Rng >
 
struct  ranges::v3::iota_view< From, To >
 
struct  ranges::v3::iota_view< From, void >
 
struct  ranges::v3::iter_take_while_view< Rng, Pred >
 
struct  ranges::v3::iter_transform2_view< Rng1, Rng2, Fun >
 
struct  ranges::v3::iter_transform_view< Rng, Fun >
 
struct  ranges::v3::iter_zip_with_view< Fun, Rngs >
 
struct  ranges::v3::join_view< Rng, ValRng >
 
struct  ranges::v3::join_view< Rng, void >
 
struct  ranges::v3::move_view< Rng >
 
struct  ranges::v3::partial_sum_view< Rng, Fun >
 
struct  ranges::v3::remove_if_view< Rng, Pred >
 
struct  ranges::v3::repeat_n_view< Val >
 
struct  ranges::v3::repeat_view< Val >
 
struct  ranges::v3::reverse_view< Rng >
 
class  ranges::v3::sample_view< Rng, URNG >
 
struct  ranges::v3::single_view< Val >
 
struct  ranges::v3::slice_view< Rng >
 
struct  ranges::v3::sliding_view< Rng, sliding_view_detail::cache::first >
 
struct  ranges::v3::sliding_view< Rng, sliding_view_detail::cache::last >
 
struct  ranges::v3::sliding_view< Rng, sliding_view_detail::cache::none >
 
struct  ranges::v3::split_view< Rng, Fun >
 
struct  ranges::v3::stride_view< Rng >
 
struct  ranges::v3::tail_view< Rng >
 
struct  ranges::v3::take_while_view< Rng, Pred >
 
struct  ranges::v3::tokenize_view< Rng, Regex, SubMatchRange >
 
struct  ranges::v3::transform2_view< Rng1, Rng2, Fun >
 
struct  ranges::v3::transform_view< Rng, Fun >
 
struct  ranges::v3::unbounded_view< I >
 
struct  ranges::v3::view::c_str_fn
 View a \0-terminated C string (e.g. from a const char*) as a range. More...
 
struct  ranges::v3::view::generate_fn
 
struct  ranges::v3::view::intersperse_fn
 
struct  ranges::v3::view::linear_distribute_fn
 Distributes n values linearly in the closed interval [from, to]. More...
 
struct  ranges::v3::view::linear_distribute_view< T >
 
struct  ranges::v3::view::make_view_fn
 
struct  ranges::v3::view::view< View >
 
struct  ranges::v3::view::view_access
 
struct  ranges::v3::view::view_access::impl< View >
 
struct  ranges::v3::zip_view< Rngs >
 
struct  ranges::v3::zip_with_view< Fun, Rngs >
 

Typedefs

template<typename G >
using ranges::v3::view::generate_fn::Concept = meta::and_< Invocable< G & >, MoveConstructible< G >, std::is_object< detail::decay_t< result_of_t< G &()> >>, Constructible< detail::decay_t< result_of_t< G &()> >, result_of_t< G &()> >, Assignable< detail::decay_t< result_of_t< G &()> > &, result_of_t< G &()> >>
 
template<typename Rng , typename T = range_value_type_t<Rng>>
using ranges::v3::view::intersperse_fn::Constraint = meta::and_< InputRange< Rng >, ConvertibleTo< T, range_value_type_t< Rng > >, ConvertibleTo< range_reference_t< Rng >, range_value_type_t< Rng > >, SemiRegular< range_value_type_t< Rng > >>
 
template<typename Rng >
using ranges::v3::take_exactly_view = detail::take_exactly_view_< Rng >
 
using boost::range_const_iterator< ::ranges::v3::generate_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::generate_view< Ts... > const >()> >::type = ::ranges::iterator_t< ::ranges::v3::generate_view< Ts... > const >
 
using boost::range_value< ::ranges::v3::generate_view< Ts... > >::type = ::ranges::range_value_type_t< ::ranges::v3::generate_view< Ts... > >
 
using boost::range_mutable_iterator< ::ranges::v3::generate_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::generate_view< Ts... > >()> >::type = ::ranges::iterator_t< ::ranges::v3::generate_view< Ts... > >
 
using boost::range_const_iterator< ::ranges::v3::intersperse_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::intersperse_view< Ts... > const >()> >::type = ::ranges::iterator_t< ::ranges::v3::intersperse_view< Ts... > const >
 
using boost::range_value< ::ranges::v3::intersperse_view< Ts... > >::type = ::ranges::range_value_type_t< ::ranges::v3::intersperse_view< Ts... > >
 
using boost::range_mutable_iterator< ::ranges::v3::intersperse_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::intersperse_view< Ts... > >()> >::type = ::ranges::iterator_t< ::ranges::v3::intersperse_view< Ts... > >
 
template<typename Rng >
using ranges::v3::view::ViewableRange = meta::and_< Range< Rng >, meta::or_< std::is_lvalue_reference< Rng >, View< uncvref_t< Rng > >> >
 

Functions

void ranges::v3::intersperse_view< Rng >::cursor_adaptor::advance (iterator_t< Rng > &it, range_difference_type_t< Rng > n) noexcept(noexcept(ranges::advance(it, n)))
 
template<typename View >
iterator_t< Rng > ranges::v3::intersperse_view< Rng >::cursor_adaptor::begin (View &view) noexcept(std::is_nothrow_move_constructible< iterator_t< Rng >>::value &&noexcept(ranges::begin(view.base()) !=ranges::end(view.base())))
 
template<typename... Ts, typename V = View>
static auto ranges::v3::view::view_access::impl< View >::bind (Ts &&...ts) -> decltype(V::bind(static_cast< Ts &&>(ts)...))
 
result_t & ranges::v3::generate_view< G >::cached ()
 
 ranges::v3::generate_view< G >::cursor::cursor (generate_view &view)
 
constexpr ranges::v3::intersperse_view< Rng >::cursor_adaptor::cursor_adaptor (intersperse_view const &view) noexcept(std::is_nothrow_copy_constructible< range_value_type_t< Rng >>::value)
 
constexpr range_difference_type_t< Rng > ranges::v3::intersperse_view< Rng >::cursor_adaptor::distance_to (iterator_t< Rng > const &it, iterator_t< Rng > const &other_it, cursor_adaptor const &other) const noexcept(noexcept(other_it - it))
 
static constexpr bool ranges::v3::intersperse_view< Rng >::sentinel_adaptor::empty (iterator_t< Rng > const &it, cursor_adaptor const &, sentinel_t< Rng > const &sent) noexcept(noexcept(decltype(it==sent)(it==sent)))
 
constexpr bool ranges::v3::intersperse_view< Rng >::cursor_adaptor::equal (iterator_t< Rng > const &it0, iterator_t< Rng > const &it1, cursor_adaptor const &other) const noexcept(noexcept(it0==it1))
 
 ranges::v3::generate_view< G >::generate_view (G g)
 
constexpr ranges::v3::intersperse_view< Rng >::intersperse_view (Rng rng, range_value_type_t< Rng > val) noexcept(std::is_nothrow_constructible< typename intersperse_view::view_adaptor, Rng >::value &&std::is_nothrow_move_constructible< range_value_type_t< Rng >>::value)
 
 ranges::v3::view::linear_distribute_view< T >::linear_distribute_view (T from, T to__, std::ptrdiff_t n) noexcept
 
void ranges::v3::generate_view< G >::cursor::next ()
 
void ranges::v3::intersperse_view< Rng >::cursor_adaptor::next (iterator_t< Rng > &it) noexcept(noexcept(++it))
 
template<typename Fun >
view< Fun > ranges::v3::view::make_view_fn::operator() (Fun fun) const
 
template<typename Char , std::size_t N, requires = (detail::is_char_type<Char>())>
ranges::iterator_range< Char * > ranges::v3::view::c_str_fn::operator() (Char(&sz)[N]) const
 
template<typename Char , requires = (detail::is_char_type<Char>())>
ranges::delimit_view< ranges::iterator_range< Char *, ranges::unreachable >, meta::_t< std::remove_cv< Char > > > ranges::v3::view::c_str_fn::operator() (Char *sz) const volatile
 
template<typename T , requires = (std::is_arithmetic<T>())>
constexpr auto ranges::v3::view::linear_distribute_fn::operator() (T from, T to, std::ptrdiff_t n) const noexcept(noexcept(decltype(linear_distribute_view< T >{from, to, n})(linear_distribute_view< T >{from, to, n}))) -> decltype(linear_distribute_view< T >
 
template<typename G , requires = (Concept<G>())>
generate_view< G > ranges::v3::view::generate_fn::operator() (G g) const
 
template<typename Rng , typename... Rest, requires = (ViewConcept<Rng, Rest...>())>
auto ranges::v3::view::view< View >::operator() (Rng &&rng, Rest &&... rest) const -> decltype(view_(static_cast< Rng &&>(rng), static_cast< Rest &&>(rest)...))
 
template<typename... Ts, typename V = View>
auto ranges::v3::view::view< View >::operator() (Ts &&... ts) const -> decltype(make_view(view_access::impl< V >::bind(view_, static_cast< Ts &&>(ts)...)))
 
template<typename Rng , requires = (Constraint<Rng>())>
constexpr auto ranges::v3::view::intersperse_fn::operator() (Rng &&rng, range_value_type_t< Rng > val) const noexcept(noexcept(decltype(intersperse_view< all_t< Rng >>{all(static_cast< Rng &&>(rng)), std::move(val)})(intersperse_view< all_t< Rng >>{all(static_cast< Rng &&>(rng)), std::move(val)}))) -> decltype(intersperse_view< all_t< Rng >>
 
void ranges::v3::intersperse_view< Rng >::cursor_adaptor::prev (iterator_t< Rng > &it) noexcept(noexcept(--it))
 
result_t ranges::v3::generate_view< G >::cursor::read () const
 
constexpr range_value_type_t< Rng > ranges::v3::intersperse_view< Rng >::cursor_adaptor::read (iterator_t< Rng > const &it) const noexcept(noexcept(range_value_type_t< Rng >(*it)) &&std::is_nothrow_copy_constructible< range_value_type_t< Rng >>::value)
 
constexpr range_size_type_t< Rng > ranges::v3::intersperse_view< Rng >::size () const noexcept(noexcept(ranges::size(std::declval< Rng const &>())))
 
range_size_type_t< Rng > ranges::v3::intersperse_view< Rng >::size () noexcept(noexcept(ranges::size(std::declval< Rng &>())))
 
constexpr std::size_t ranges::v3::view::linear_distribute_view< T >::size () const noexcept
 
 ranges::v3::view::view< View >::view (View a)
 

Variables

constexpr view< adjacent_filter_fnadjacent_filter {}
 
constexpr view< adjacent_remove_if_fnadjacent_remove_if {}
 
constexpr all_fn all {}
 
constexpr view< bounded_fnbounded {}
 
constexpr c_str_fn c_str {}
 
constexpr view< chunk_fnchunk {}
 
constexpr closed_indices_fn closed_indices {}
 
constexpr closed_iota_fn closed_iota {}
 
constexpr concat_fn concat {}
 
constexpr view< const_fnconst_ {}
 
constexpr counted_fn counted {}
 
constexpr view< cycle_fncycle {}
 
constexpr delimit_fn delimit {}
 
constexpr view< drop_fndrop {}
 
constexpr view< drop_exactly_fndrop_exactly {}
 
constexpr view< drop_while_fndrop_while {}
 
constexpr filter_fn filter {}
 
constexpr view< for_each_fnfor_each {}
 
constexpr generate_fn generate {}
 
constexpr generate_n_fn generate_n {}
 
constexpr view< group_by_fngroup_by {}
 
constexpr indices_fn indices {}
 
constexpr view< indirect_fnindirect {}
 
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_view_fn ranges::v3::view::make_view {}
 
constexpr view< move_fnmove {}
 
constexpr view< partial_sum_fnpartial_sum {}
 
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_fnslice {}
 
constexpr view< sliding_fnsliding {}
 
constexpr view< split_fnsplit {}
 
constexpr view< stride_fnstride {}
 
constexpr view< tail_fntail {}
 
constexpr view< take_fntake {}
 
constexpr view< take_exactly_fntake_exactly {}
 
constexpr view< take_while_fntake_while {}
 
constexpr tokenize_fn tokenize {}
 
constexpr view< transform_fntransform {}
 
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 {}
 

Function Documentation

◆ advance()

template<typename Rng >
void ranges::v3::intersperse_view< Rng >::cursor_adaptor::advance ( iterator_t< Rng > &  it,
range_difference_type_t< Rng >  n 
)
noexcept

◆ distance_to()

template<typename Rng >
constexpr range_difference_type_t<Rng> ranges::v3::intersperse_view< Rng >::cursor_adaptor::distance_to ( iterator_t< Rng > const &  it,
iterator_t< Rng > const &  other_it,
cursor_adaptor const &  other 
) const
noexcept

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

Precondition
SizedSentinel<iterator_t<Rng> iterator_t<Rng>>())

◆ equal()

template<typename Rng >
constexpr bool ranges::v3::intersperse_view< Rng >::cursor_adaptor::equal ( iterator_t< Rng > const &  it0,
iterator_t< Rng > const &  it1,
cursor_adaptor const &  other 
) const
noexcept

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

Precondition
Sentinel<iterator_t<Rng> iterator_t<Rng>>())

References ranges::v3::next.

◆ prev()

template<typename Rng >
void ranges::v3::intersperse_view< Rng >::cursor_adaptor::prev ( iterator_t< Rng > &  it)
noexcept

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

Precondition
BidirectionalRange<Rng>()

◆ size() [1/2]

template<typename Rng >
constexpr range_size_type_t<Rng> ranges::v3::intersperse_view< Rng >::size ( ) const
noexcept

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

Precondition
SizedRange<Rng const>()

◆ size() [2/2]

template<typename Rng >
range_size_type_t<Rng> ranges::v3::intersperse_view< Rng >::size ( )
noexcept

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

Precondition
!SizedRange<Rng const>="">() && SizedRange<Rng>()

References ranges::v3::view_facade< Derived, Cardinality >::begin(), ranges::v3::begin, and ranges::v3::end.

Variable Documentation

◆ make_view

constexpr make_view_fn ranges::v3::view::make_view {}