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_fn >	adjacent_filter {}

constexpr view< adjacent_remove_if_fn >	adjacent_remove_if {}

constexpr all_fn	all {}

constexpr view< bounded_fn >	bounded {}

constexpr c_str_fn	c_str {}

constexpr view< chunk_fn >	chunk {}

constexpr closed_indices_fn	closed_indices {}

constexpr closed_iota_fn	closed_iota {}

constexpr concat_fn	concat {}

constexpr view< const_fn >	const_ {}

constexpr counted_fn	counted {}

constexpr view< cycle_fn >	cycle {}

constexpr delimit_fn	delimit {}

constexpr view< drop_fn >	drop {}

constexpr view< drop_exactly_fn >	drop_exactly {}

constexpr view< drop_while_fn >	drop_while {}

constexpr filter_fn	filter {}

constexpr view< for_each_fn >	for_each {}

constexpr generate_fn	generate {}

constexpr generate_n_fn	generate_n {}

constexpr view< group_by_fn >	group_by {}

constexpr indices_fn	indices {}

constexpr view< indirect_fn >	indirect {}

constexpr view< intersperse_fn >	intersperse {}

constexpr ints_fn	ints {}

constexpr iota_fn	iota {}

constexpr view< iter_take_while_fn >	iter_take_while {}

constexpr view< iter_transform_fn >	iter_transform {}

constexpr iter_zip_with_fn	iter_zip_with {}

constexpr view< join_fn >	join {}

constexpr view< keys_fn >	keys {}

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_fn >	move {}

constexpr view< partial_sum_fn >	partial_sum {}

constexpr view< remove_if_fn >	remove_if {}

constexpr repeat_fn	repeat {}

constexpr repeat_n_fn	repeat_n {}

constexpr view< replace_fn >	replace {}

constexpr view< replace_if_fn >	replace_if {}

constexpr view< reverse_fn >	reverse {}

constexpr view< sample_fn >	sample {}

constexpr view< set_difference_fn >	set_difference {}

constexpr view< set_intersection_fn >	set_intersection {}

constexpr view< set_symmetric_difference_fn >	set_symmetric_difference {}

constexpr view< set_union_fn >	set_union {}

constexpr shared_fn	shared {}

constexpr single_fn	single {}

constexpr view< slice_fn >	slice {}

constexpr view< sliding_fn >	sliding {}

constexpr view< split_fn >	split {}

constexpr view< stride_fn >	stride {}

constexpr view< tail_fn >	tail {}

constexpr view< take_fn >	take {}

constexpr view< take_exactly_fn >	take_exactly {}

constexpr view< take_while_fn >	take_while {}

constexpr tokenize_fn	tokenize {}

constexpr view< transform_fn >	transform {}

constexpr unbounded_fn	unbounded {}

constexpr view< unique_fn >	unique {}

constexpr view< 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 {}

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

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

Precondition: RandomAccessRange<Rng>()

References ranges::v3::advance.

◆ 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