Utility

Description

Utility classes.

Modules
	Concepts
	Concept-checking classes and utilities.

Classes
struct	ranges::v3::adl_advance_detail::advance_fn
struct	ranges::v3::as_function_fn
struct	ranges::v3::aux::copy_fn
struct	ranges::v3::aux::move_fn
struct	ranges::v3::back_inserter_fn
struct	ranges::v3::basic_common_reference< T, U, TQual, UQual >
	Users can specialize this to hook the CommonReference concept. More...
struct	ranges::v3::basic_iterator< Cur, S >
struct	ranges::v3::basic_mixin< T >
struct	ranges::v3::basic_sentinel< S >
struct	ranges::v3::bind_element< T >
struct	ranges::v3::bind_element< reference_wrapper< T, RValue > >
struct	ranges::v3::bind_element< std::reference_wrapper< T > >
struct	ranges::v3::bitwise_or
class	ranges::v3::box< Element, Tag, box_compress >
class	ranges::v3::box< Element, Tag, detail::box_compress::coalesce >
class	ranges::v3::box< Element, Tag, detail::box_compress::ebo >
struct	ranges::v3::coerce< T >
struct	ranges::v3::coerce< T & >
struct	ranges::v3::coerce< T && >
struct	ranges::v3::coerce< T const >
struct	ranges::v3::common_reference< Ts >
	Users can specialize this to hook the CommonReference concept. More...
struct	ranges::v3::common_reference< T >
struct	ranges::v3::common_reference< T, U >
struct	ranges::v3::common_reference< T, U, Vs... >
struct	ranges::v3::common_type< Ts >
	Users should specialize this to hook the Common concept until std gets a SFINAE-friendly std::common_type and there's some sane way to deal with cv and ref qualifiers. More...
struct	ranges::v3::common_type< T >
struct	ranges::v3::common_type< T, U >
struct	ranges::v3::common_type< T, U, Vs... >
struct	ranges::v3::compose_fn
struct	ranges::v3::composed< Second, First >
struct	ranges::v3::constant< T, v >
struct	ranges::v3::convert_to< T >
struct	ranges::v3::default_end_cursor
struct	ranges::v3::equal_to
struct	ranges::v3::front_inserter_fn
struct	ranges::v3::get_cursor_fn
	Get a cursor from a basic_iterator. More...
struct	ranges::v3::ident
struct	ranges::v3::indirect_fn
struct	ranges::v3::indirected< Fn >
struct	ranges::v3::is_indirectly_swappable< T, U >
struct	ranges::v3::is_nothrow_indirectly_swappable< T, U >
struct	ranges::v3::is_nothrow_swappable< T, U >
struct	ranges::v3::is_pipeable< T >
struct	ranges::v3::is_pipeable< T & >
struct	ranges::v3::is_reference_wrapper< T >
struct	ranges::v3::is_reference_wrapper< reference_wrapper< T, RValue > >
struct	ranges::v3::is_reference_wrapper< std::reference_wrapper< T > >
struct	ranges::v3::is_swappable< T, U >
struct	ranges::v3::iter_distance_compare_fn
struct	ranges::v3::iter_distance_fn
struct	ranges::v3::iter_enumerate_fn
struct	ranges::v3::iter_move_fn
struct	ranges::v3::iter_size_fn
struct	ranges::v3::iter_swap_fn
struct	ranges::v3::less
struct	ranges::v3::logical_negate_< FD >
struct	ranges::v3::make_move_iterator_fn
struct	ranges::v3::make_move_sentinel_fn
struct	ranges::v3::make_pipeable_fn
struct	ranges::v3::make_tuple_fn
struct	ranges::v3::minus
struct	ranges::v3::move_into_fn
struct	ranges::v3::move_sentinel< S >
struct	ranges::v3::multiplies
struct	ranges::v3::mutable_< T >
struct	ranges::v3::mutable_< std::atomic< T > >
struct	ranges::v3::next_fn
struct	ranges::v3::not_equal_to
struct	ranges::v3::not_fn_fn
struct	ranges::v3::on_fn
struct	ranges::v3::ordered_less
struct	ranges::v3::overload_fn
struct	ranges::v3::overloaded< First, Rest... >
struct	ranges::v3::overloaded<>
struct	ranges::v3::pipeable< Derived >
struct	ranges::v3::pipeable_access
struct	ranges::v3::pipeable_access::impl< Pipeable >
struct	ranges::v3::pipeable_base
struct	ranges::v3::plus
struct	ranges::v3::prev_fn
struct	ranges::v3::protect_fn
struct	ranges::v3::raw_storage_iterator< O, Val >
struct	ranges::v3::ref_fn
struct	ranges::v3::reference_of< T >
struct	ranges::v3::reference_of< reference_wrapper< T, RValue > >
struct	ranges::v3::reference_of< std::reference_wrapper< T > >
struct	ranges::v3::reference_of< T & >
struct	ranges::v3::reference_of< T && >
struct	ranges::v3::reference_of< T const >
struct	ranges::v3::reference_wrapper< T, RValue >
struct	ranges::v3::rref_fn
struct	ranges::v3::semiregular< T >
struct	ranges::v3::static_const< T >
struct	ranges::v3::transformed< Fn1, Fn2 >
struct	ranges::v3::tuple_apply_fn
struct	ranges::v3::tuple_foldl_fn
struct	ranges::v3::tuple_for_each_fn
struct	ranges::v3::tuple_transform_fn
struct	ranges::v3::unreachable
struct	ranges::v3::unwrap_reference_fn
struct	ranges::v3::with_braced_init_args< ImplFn >

Typedefs
template<typename Cont >
using	ranges::v3::back_insert_iterator = basic_iterator< detail::back_insert_cursor< Cont >>
template<typename T >
using	ranges::v3::bind_element_t = meta::_t< bind_element< T >>
template<typename Cont >
using	ranges::v3::front_insert_iterator = basic_iterator< detail::front_insert_cursor< Cont >>
template<typename T >
using	ranges::v3::function_type = decltype(as_function(std::declval< T >()))
template<typename T >
using	ranges::v3::is_reference_wrapper_t = meta::_t< is_reference_wrapper< T >>
template<typename Pred >
using	ranges::v3::logical_negate = logical_negate_< detail::decay_t< function_type< Pred >>>
template<typename R >
using	ranges::v3::aux::move_t = meta::if_< std::is_reference< R >, meta::_t< std::remove_reference< R >> &&, detail::decay_t< R >>
template<typename T >
using	ranges::v3::ref_t = decltype(ref(std::declval< T >()))
template<typename T >
using	ranges::v3::reference_of_t = meta::_t< reference_of< T >>
template<typename T >
using	ranges::v3::rref_t = decltype(rref(std::declval< T >()))
template<typename T , bool IsConst = false>
using	ranges::v3::semiregular_ref_or_val_t = meta::if_< SemiRegular< T >, meta::if_c< IsConst, T, reference_wrapper< T > >, reference_wrapper< meta::if_c< IsConst, semiregular< T > const, semiregular< T >>>>
template<typename T >
using	ranges::v3::semiregular_t = meta::if_< SemiRegular< T >, T, semiregular< T >>
template<typename Tup >
using	ranges::v3::tuple_indices_t = meta::make_index_sequence< std::tuple_size< typename std::remove_reference< Tup >::type >::value >
template<typename T >
using	ranges::v3::unwrap_reference_t = decltype(unwrap_reference(std::declval< T >()))

Functions
template<typename T >
constexpr T *	ranges::v3::_nullptr_v ()
template<typename T , typename U = meta::if_< std::is_lvalue_reference<T>, std::reference_wrapper<meta::_t<std::remove_reference<T>>>, T &&>>
U	ranges::v3::bind_forward (meta::_t< std::remove_reference< T >> &t) noexcept
template<typename T >
T &&	ranges::v3::bind_forward (meta::_t< std::remove_reference< T >> &&t) noexcept
template<typename T >
T &	ranges::v3::get (meta::id_t< T > &value)
template<typename T >
T const &	ranges::v3::get (meta::id_t< T > const &value)
template<typename T >
T &&	ranges::v3::get (meta::id_t< T > &&value)
template<typename T >
T &	ranges::v3::get (meta::id_t< semiregular< T >> &t)
template<typename T >
T const &	ranges::v3::get (meta::id_t< semiregular< T >> const &t)
template<typename T >
T &&	ranges::v3::get (meta::id_t< semiregular< T >> &&t)
template<typename Tag , typename Element , detail::box_compress BC>
Element &	ranges::v3::get (box< Element, Tag, BC > &b) noexcept
template<typename Tag , typename Element , detail::box_compress BC>
constexpr Element const &	ranges::v3::get (box< Element, Tag, BC > const &b) noexcept
template<typename Tag , typename Element , detail::box_compress BC>
Element &&	ranges::v3::get (box< Element, Tag, BC > &&b) noexcept
template<std::size_t I, typename Element , detail::box_compress BC>
Element &	ranges::v3::get (box< Element, meta::size_t< I >, BC > &b) noexcept
template<std::size_t I, typename Element , detail::box_compress BC>
constexpr Element const &	ranges::v3::get (box< Element, meta::size_t< I >, BC > const &b) noexcept
template<std::size_t I, typename Element , detail::box_compress BC>
Element &&	ranges::v3::get (box< Element, meta::size_t< I >, BC > &&b) noexcept
template<typename I , requires = (Iterator<I>())>
counted_iterator< I >	ranges::v3::make_counted_iterator (I i, iterator_difference_t< I > n)
template<typename V , typename I , typename D >
counted_iterator< raw_storage_iterator< I, V >, detail::external_count< D > >	ranges::v3::make_counted_raw_storage_iterator (I i, D &d)
template<typename I >
reverse_iterator< I >	ranges::v3::make_reverse_iterator (I i)
template<typename I , typename S , requires = (Sentinel<S, I>())>
bool	ranges::v3::operator!= (move_iterator< S > const &i, move_sentinel< S > const &s)
template<typename I , typename S , requires = (Sentinel<S, I>())>
bool	ranges::v3::operator!= (move_sentinel< S > const &s, move_iterator< S > const &i)
template<typename Cur , typename Sent , requires = (!Same<range_access::InputCursor, detail::cursor_concept_t<Cur>>())>
basic_iterator< Cur, Sent >	ranges::v3::operator++ (basic_iterator< Cur, Sent > &it, int)
template<typename I , typename S , requires = (Sentinel<S, I>())>
bool	ranges::v3::operator== (move_iterator< I > const &i, move_sentinel< S > const &s)
template<typename I , typename S , requires = (Sentinel<S, I>())>
bool	ranges::v3::operator== (move_sentinel< S > const &s, move_iterator< S > const &i)
template<typename T , requires = (Constructible<detail::decay_t<T>, T &&>())>
detail::decay_t< T >	ranges::v3::aux::operator| (T &&t, copy_fn)
template<typename T >
meta::_t< std::remove_reference< T > > &&	ranges::v3::aux::operator| (T &&t, move_fn move) noexcept
template<typename Arg , typename Pipe , requires = (!is_pipeable<Arg>() && is_pipeable<Pipe>())>
auto	ranges::v3::operator| (Arg &&arg, Pipe pipe) -> decltype(pipeable_access::impl< Pipe >::pipe(std::forward< Arg >(arg), pipe))
template<typename Pipe0 , typename Pipe1 , requires = (is_pipeable<Pipe0>() && is_pipeable<Pipe1>())>
auto	ranges::v3::operator| (Pipe0 pipe0, Pipe1 pipe1) -> decltype(make_pipeable(detail::composed_pipe< Pipe0, Pipe1 >

Variables
constexpr adl_advance_detail::advance_fn	ranges::v3::advance {}
constexpr as_function_fn	ranges::v3::as_function {}
constexpr back_inserter_fn	ranges::v3::back_inserter {}
constexpr compose_fn	ranges::v3::compose {}
constexpr copy_fn	ranges::v3::aux::copy {}
constexpr front_inserter_fn	ranges::v3::front_inserter {}
constexpr get_cursor_fn	ranges::v3::get_cursor {}
constexpr indirect_fn	ranges::v3::indirect {}
constexpr adl_swap_detail::indirect_swap_fn	indirect_swap {}
constexpr iter_distance_fn	ranges::v3::iter_distance {}
constexpr iter_distance_compare_fn	ranges::v3::iter_distance_compare {}
constexpr iter_enumerate_fn	ranges::v3::iter_enumerate {}
constexpr iter_move_fn	ranges::v3::iter_move {}
constexpr iter_size_fn	ranges::v3::iter_size {}
constexpr iter_swap_fn	ranges::v3::iter_swap {}
constexpr make_common_pair_fn	ranges::v3::make_common_pair {}
constexpr make_common_tuple_fn	ranges::v3::make_common_tuple {}
constexpr make_move_iterator_fn	ranges::v3::make_move_iterator {}
constexpr make_move_sentinel_fn	ranges::v3::make_move_sentinel {}
constexpr make_pipeable_fn	ranges::v3::make_pipeable {}
constexpr make_tuple_fn	ranges::v3::make_tuple {}
constexpr move_fn	ranges::v3::aux::move {}
constexpr move_into_fn	ranges::v3::move_into {}
constexpr next_fn	ranges::v3::next {}
constexpr not_fn_fn	ranges::v3::not_fn {}
constexpr on_fn	ranges::v3::on {}
constexpr overload_fn	ranges::v3::overload {}
constexpr prev_fn	ranges::v3::prev {}
constexpr protect_fn	ranges::v3::protect {}
	Protect a callable so that it can be safely used in a bind expression without accidentally becoming a "nested" bind. More...
constexpr adl_uncounted_recounted_detail::recounted_fn	ranges::v3::recounted {}
constexpr ref_fn	ranges::v3::ref {}
constexpr rref_fn	ranges::v3::rref {}
constexpr adl_swap_detail::swap_fn	swap {}
constexpr tuple_apply_fn	ranges::v3::tuple_apply {}
constexpr tuple_foldl_fn	ranges::v3::tuple_foldl {}
constexpr tuple_for_each_fn	ranges::v3::tuple_for_each {}
constexpr tuple_transform_fn	ranges::v3::tuple_transform {}
constexpr adl_uncounted_recounted_detail::uncounted_fn	ranges::v3::uncounted {}
constexpr unwrap_reference_fn	ranges::v3::unwrap_reference {}
static constexpr T	ranges::v3::static_const< T >::value {}

Typedef Documentation

template<typename R >

using ranges::v3::aux::move_t = typedef meta::if_< std::is_reference<R>, meta::_t<std::remove_reference<R>> &&, detail::decay_t<R>>

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

See also

move_fn

Function Documentation

template<typename T , requires = (Constructible<detail::decay_t<T>, T &&>())>

detail::decay_t<T> ranges::v3::aux::operator|	(	T &&	t,
		copy_fn
	)

#include <range/v3/utility/copy.hpp>

See also

copy_fn

template<typename T >

meta::_t<std::remove_reference<T> >&& ranges::v3::aux::operator| ( T &&  t, move_fn  move  )

noexcept

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

See also

move_fn

References ranges::v3::aux::move.

Variable Documentation

constexpr adl_advance_detail::advance_fn ranges::v3::advance {}

#include <range/v3/utility/iterator.hpp>

See also

advance_fn

Referenced by ranges::v3::intersperse_view< Rng >::cursor_adaptor::advance(), ranges::v3::chunk_view< Rng >::adaptor::advance(), ranges::v3::basic_iterator< Cur, S >::operator+=(), ranges::v3::basic_iterator< Cur, S >::operator-=(), and ranges::v3::chunk_view< Rng >::adaptor::prev().

constexpr as_function_fn ranges::v3::as_function {}

#include <range/v3/utility/functional.hpp>

See also

make_invokable_fn

constexpr back_inserter_fn ranges::v3::back_inserter {}

#include <range/v3/utility/iterator.hpp>

See also

back_inserter_fn

constexpr compose_fn ranges::v3::compose {}

#include <range/v3/utility/functional.hpp>

See also

compose_fn

constexpr copy_fn ranges::v3::aux::copy {}

#include <range/v3/utility/copy.hpp>

See also

copy_fn

constexpr front_inserter_fn ranges::v3::front_inserter {}

#include <range/v3/utility/iterator.hpp>

See also

front_inserter_fn

constexpr get_cursor_fn ranges::v3::get_cursor {}

#include <range/v3/utility/basic_iterator.hpp>

See also

get_cursor_fn

constexpr indirect_fn ranges::v3::indirect {}

related

#include <range/v3/utility/functional.hpp>

See also

indirect_fn

constexpr adl_swap_detail::indirect_swap_fn indirect_swap {}

#include <range/v3/utility/swap.hpp>

constexpr iter_distance_fn ranges::v3::iter_distance {}

#include <range/v3/utility/iterator.hpp>

See also

iter_distance_fn

constexpr iter_distance_compare_fn ranges::v3::iter_distance_compare {}

#include <range/v3/utility/iterator.hpp>

See also

iter_distance_compare_fn

constexpr iter_enumerate_fn ranges::v3::iter_enumerate {}

#include <range/v3/utility/iterator.hpp>

See also

iter_enumerate_fn

constexpr iter_move_fn ranges::v3::iter_move {}

#include <range/v3/utility/iterator.hpp>

See also

iter_move_fn

constexpr iter_size_fn ranges::v3::iter_size {}

#include <range/v3/utility/iterator.hpp>

See also

iter_size_fn

constexpr iter_swap_fn ranges::v3::iter_swap {}

#include <range/v3/utility/iterator.hpp>

See also

iter_swap_fn

constexpr make_common_pair_fn ranges::v3::make_common_pair {}

#include <range/v3/utility/common_tuple.hpp>

See also

make_common_pair_fn

constexpr make_common_tuple_fn ranges::v3::make_common_tuple {}

#include <range/v3/utility/common_tuple.hpp>

See also

make_common_tuple_fn

constexpr make_pipeable_fn ranges::v3::make_pipeable {}

#include <range/v3/utility/functional.hpp>

See also

make_pipeable_fn

constexpr make_tuple_fn ranges::v3::make_tuple {}

#include <range/v3/utility/tuple_algorithm.hpp>

See also

make_tuple_fn

constexpr move_fn ranges::v3::aux::move {}

related

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

See also

move_fn

Referenced by ranges::v3::aux::operator|().

constexpr move_into_fn ranges::v3::move_into {}

#include <range/v3/utility/iterator.hpp>

See also

move_into_fn

constexpr next_fn ranges::v3::next {}

#include <range/v3/utility/iterator.hpp>

See also

next_fn

Referenced by ranges::v3::tail_view< Rng >::begin().

constexpr not_fn_fn ranges::v3::not_fn {}

#include <range/v3/utility/functional.hpp>

See also

not_fn_fn

constexpr on_fn ranges::v3::on {}

#include <range/v3/utility/functional.hpp>

See also

on_fn

constexpr overload_fn ranges::v3::overload {}

#include <range/v3/utility/functional.hpp>

See also

overload_fn

constexpr prev_fn ranges::v3::prev {}

#include <range/v3/utility/iterator.hpp>

See also

prev_fn

Referenced by ranges::v3::view_interface< stride_view< Rng >, Cardinality >::back(), ranges::v3::back_fn::operator()(), and ranges::v3::basic_iterator< Cur, S >::operator--().

constexpr protect_fn ranges::v3::protect {}

#include <range/v3/utility/functional.hpp>

Protect a callable so that it can be safely used in a bind expression without accidentally becoming a "nested" bind.

See also

protect_fn

constexpr ref_fn ranges::v3::ref {}

#include <range/v3/utility/functional.hpp>

See also

ref_fn

constexpr rref_fn ranges::v3::rref {}

#include <range/v3/utility/functional.hpp>

See also

rref_fn

constexpr adl_swap_detail::swap_fn swap {}

#include <range/v3/utility/swap.hpp>

constexpr tuple_apply_fn ranges::v3::tuple_apply {}

#include <range/v3/utility/tuple_algorithm.hpp>

See also

tuple_apply_fn

constexpr tuple_foldl_fn ranges::v3::tuple_foldl {}

#include <range/v3/utility/tuple_algorithm.hpp>

See also

tuple_foldl_fn

Referenced by ranges::v3::iter_zip_with_view< detail::indirect_zip_fn_, Rngs... >::size(), and ranges::v3::concat_view< Rngs >::size().

constexpr tuple_for_each_fn ranges::v3::tuple_for_each {}

#include <range/v3/utility/tuple_algorithm.hpp>

See also

tuple_for_each_fn

constexpr tuple_transform_fn ranges::v3::tuple_transform {}

#include <range/v3/utility/tuple_algorithm.hpp>

See also

tuple_transform_fn

Referenced by ranges::v3::iter_zip_with_view< detail::indirect_zip_fn_, Rngs... >::size(), and ranges::v3::concat_view< Rngs >::size().

constexpr unwrap_reference_fn ranges::v3::unwrap_reference {}

#include <range/v3/utility/functional.hpp>

See also

unwrap_reference_fn

template<typename T >

constexpr T ranges::v3::static_const< T >::value {}

static

See also

static_const