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 >
	A type-erased view. More...

struct	ranges::v3::bounded_view< Rng >

struct	ranges::v3::chunk_view< Rng >

struct	ranges::v3::chunk_view< Rng >::adaptor

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, D >

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::for_each_view< Rng, F >

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::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::lazy_yield_if_fn

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::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::adjacent_filter_fn

struct	ranges::v3::view::adjacent_remove_if_fn

struct	ranges::v3::view::all_fn

struct	ranges::v3::view::bounded_fn

struct	ranges::v3::view::c_str_fn

struct	ranges::v3::view::chunk_fn

struct	ranges::v3::view::closed_ints_fn

struct	ranges::v3::view::closed_iota_fn

struct	ranges::v3::view::concat_fn

struct	ranges::v3::view::const_fn

struct	ranges::v3::view::counted_fn

struct	ranges::v3::view::cycle_fn

struct	ranges::v3::view::delimit_fn

struct	ranges::v3::view::delimit_impl_fn

struct	ranges::v3::view::drop_exactly_fn

struct	ranges::v3::view::drop_fn

struct	ranges::v3::view::drop_while_fn

struct	ranges::v3::view::for_each_fn

struct	ranges::v3::view::generate_fn

struct	ranges::v3::view::generate_n_fn

struct	ranges::v3::view::group_by_fn

struct	ranges::v3::view::indirect_fn

struct	ranges::v3::view::intersperse_fn

struct	ranges::v3::view::ints_fn

struct	ranges::v3::view::iota_fn

struct	ranges::v3::view::iter_take_while_fn

struct	ranges::v3::view::iter_transform_fn

struct	ranges::v3::view::iter_zip_with_fn

struct	ranges::v3::view::join_fn

struct	ranges::v3::view::keys_fn

struct	ranges::v3::view::make_view_fn

struct	ranges::v3::view::move_fn

struct	ranges::v3::view::partial_sum_fn

struct	ranges::v3::view::remove_if_fn

struct	ranges::v3::view::repeat_fn

struct	ranges::v3::view::repeat_n_fn

struct	ranges::v3::view::replace_fn

struct	ranges::v3::view::replace_if_fn

struct	ranges::v3::view::reverse_fn

class	ranges::v3::view::sample_fn

struct	ranges::v3::view::single_fn

struct	ranges::v3::view::slice_fn

struct	ranges::v3::view::split_fn

struct	ranges::v3::view::stride_fn

struct	ranges::v3::view::tail_fn

struct	ranges::v3::view::take_exactly_fn

struct	ranges::v3::view::take_while_fn

struct	ranges::v3::view::tokenize_fn

struct	ranges::v3::view::tokenizer_impl_fn

struct	ranges::v3::view::transform_fn

struct	ranges::v3::view::unbounded_fn

struct	ranges::v3::view::unique_fn

struct	ranges::v3::view::values_fn

struct	ranges::v3::view::view< View >

struct	ranges::v3::view::view_access

struct	ranges::v3::view::view_access::impl< View >

struct	ranges::v3::view::zip_fn

struct	ranges::v3::view::zip_with_fn

struct	ranges::v3::yield_fn

struct	ranges::v3::yield_from_fn

struct	ranges::v3::yield_if_fn

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_< Function< G >, meta::not_< Same< void, concepts::Function::result_t< G >>>>

template<typename Rng , typename T = range_value_t<Rng>>
using	ranges::v3::view::intersperse_fn::Concept = meta::and_< InputRange< Rng >, ConvertibleTo< T, range_value_t< Rng >>, ConvertibleTo< range_reference_t< Rng >, range_value_t< Rng >>, SemiRegular< range_value_t< Rng >>>

using	ranges::v3::generate_view< G >::cursor::single_pass = std::true_type

template<typename Rng >
using	ranges::v3::take_exactly_view = detail::take_exactly_view_< Rng >

using	boost::range_mutable_iterator< ::ranges::v3::generate_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::generate_view< Ts... > >()> >::type = ::ranges::range_iterator_t< ::ranges::v3::generate_view< Ts... >>

using	boost::range_const_iterator< ::ranges::v3::generate_view< Ts... >, ::meta::if_c<(bool)::ranges::BoundedRange< ::ranges::v3::generate_view< Ts... > const >()> >::type = ::ranges::range_iterator_t< ::ranges::v3::generate_view< Ts... > const >

using	boost::range_value< ::ranges::v3::generate_view< Ts... > >::type = ::ranges::range_value_t< ::ranges::v3::generate_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::range_iterator_t< ::ranges::v3::intersperse_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::range_iterator_t< ::ranges::v3::intersperse_view< Ts... > const >

using	boost::range_value< ::ranges::v3::intersperse_view< Ts... > >::type = ::ranges::range_value_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< Rng >>>

Functions
void	ranges::v3::intersperse_view< Rng >::cursor_adaptor::advance (range_iterator_t< Rng > &it, range_difference_t< Rng > n)

template<typename... Ts, typename V = View>
static auto	ranges::v3::view::view_access::impl< View >::bind (Ts &&...ts) -> decltype(V::bind(std::forward< Ts >(ts)...))

result_t &	ranges::v3::generate_view< G >::cached ()

	ranges::v3::generate_view< G >::cursor::cursor (generate_view &view)

	ranges::v3::intersperse_view< Rng >::cursor_adaptor::cursor_adaptor (range_value_t< Rng > val, bool at_end)

range_difference_t< Rng >	ranges::v3::intersperse_view< Rng >::cursor_adaptor::distance_to (range_iterator_t< Rng > it, range_iterator_t< Rng > other_it, cursor_adaptor const &other) const

constexpr bool	ranges::v3::generate_view< G >::cursor::done () const

bool	ranges::v3::intersperse_view< Rng >::sentinel_adaptor::empty (range_iterator_t< Rng > it, cursor_adaptor const &, range_sentinel_t< Rng > sent) const

bool	ranges::v3::intersperse_view< Rng >::cursor_adaptor::equal (range_iterator_t< Rng > it0, range_iterator_t< Rng > it1, cursor_adaptor const &other) const

	ranges::v3::generate_view< G >::generate_view (G g)

result_t	ranges::v3::generate_view< G >::cursor::get () const

range_value_t< Rng >	ranges::v3::intersperse_view< Rng >::cursor_adaptor::get (range_iterator_t< Rng > it) const

	ranges::v3::intersperse_view< Rng >::intersperse_view (Rng rng, range_value_t< Rng > val)

void	ranges::v3::generate_view< G >::cursor::next ()

void	ranges::v3::intersperse_view< Rng >::cursor_adaptor::next (range_iterator_t< Rng > &it)

template<std::size_t N>
ranges::iterator_range< char * >	ranges::v3::view::c_str_fn::operator() (char(&sz)[N]) const

template<std::size_t N>
ranges::iterator_range< char const * >	ranges::v3::view::c_str_fn::operator() (char const (&sz)[N]) const

template<std::size_t N>
ranges::iterator_range< wchar_t * >	ranges::v3::view::c_str_fn::operator() (wchar_t(&sz)[N]) const

template<std::size_t N>
ranges::iterator_range< wchar_t const * >	ranges::v3::view::c_str_fn::operator() (wchar_t const (&sz)[N]) const

template<std::size_t N>
ranges::iterator_range< char16_t * >	ranges::v3::view::c_str_fn::operator() (char16_t(&sz)[N]) const

template<std::size_t N>
ranges::iterator_range< char16_t const * >	ranges::v3::view::c_str_fn::operator() (char16_t const (&sz)[N]) const

template<typename Fun >
view< Fun >	ranges::v3::view::make_view_fn::operator() (Fun fun) const

template<std::size_t N>
ranges::iterator_range< char32_t * >	ranges::v3::view::c_str_fn::operator() (char32_t(&sz)[N]) const

template<std::size_t N>
ranges::iterator_range< char32_t const * >	ranges::v3::view::c_str_fn::operator() (char32_t const (&sz)[N]) const

ranges::delimit_view< ranges::iterator_range< char *, ranges::unreachable >, char >	ranges::v3::view::c_str_fn::operator() (char *sz) const

ranges::delimit_view< ranges::iterator_range< char const *, ranges::unreachable >, char >	ranges::v3::view::c_str_fn::operator() (char const *sz) const

ranges::delimit_view< ranges::iterator_range< wchar_t *, ranges::unreachable >, wchar_t >	ranges::v3::view::c_str_fn::operator() (wchar_t *sz) const

ranges::delimit_view< ranges::iterator_range< wchar_t const *, ranges::unreachable >, wchar_t >	ranges::v3::view::c_str_fn::operator() (wchar_t const *sz) const

ranges::delimit_view< ranges::iterator_range< char16_t *, ranges::unreachable >, char16_t >	ranges::v3::view::c_str_fn::operator() (char16_t *sz) const

template<typename G , requires = (Concept<G>())>
generate_view< G >	ranges::v3::view::generate_fn::operator() (G g) const

ranges::delimit_view< ranges::iterator_range< char16_t const *, ranges::unreachable >, char16_t >	ranges::v3::view::c_str_fn::operator() (char16_t const *sz) const

ranges::delimit_view< ranges::iterator_range< char32_t *, ranges::unreachable >, char32_t >	ranges::v3::view::c_str_fn::operator() (char32_t *sz) const

ranges::delimit_view< ranges::iterator_range< char32_t const *, ranges::unreachable >, char32_t >	ranges::v3::view::c_str_fn::operator() (char32_t const *sz) const

template<typename Rng , typename... Rest, requires = (ViewConcept<Rng, Rest...>())>
auto	ranges::v3::view::view< View >::operator() (Rng &&rng, Rest &&...rest) const -> decltype(view_(std::forward< Rng >(rng), std::forward< 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_, std::forward< Ts >(ts)...)))

template<typename Rng , requires = (Concept<Rng>())>
intersperse_view< all_t< Rng > >	ranges::v3::view::intersperse_fn::operator() (Rng &&rng, range_value_t< Rng > val) const

void	ranges::v3::intersperse_view< Rng >::cursor_adaptor::prev (range_iterator_t< Rng > &it)

range_size_t< Rng >	ranges::v3::intersperse_view< Rng >::size () const

	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_ints_fn	closed_ints {}

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 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 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 single_fn	single {}

constexpr view< slice_fn >	slice {}

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

Friends
struct	ranges::v3::generate_view< G >::range_access

Function Documentation

template<typename Rng >

void ranges::v3::intersperse_view< Rng >::cursor_adaptor::advance	(	range_iterator_t< Rng > &	it,
		range_difference_t< Rng >	n
	)

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

Precondition: RandomAccessRange<Rng>()

References ranges::v3::advance.

template<typename Rng >

range_difference_t<Rng> ranges::v3::intersperse_view< Rng >::cursor_adaptor::distance_to	(	range_iterator_t< Rng >	it,
		range_iterator_t< Rng >	other_it,
		cursor_adaptor const &	other
	)		const