Range-v3
Range algorithms, views, and actions for the Standard Library
 
Loading...
Searching...
No Matches
Utility

Utility classes More...

Classes

struct  concepts::basic_common_reference< T, U, TQual, UQual >
 Users can specialize this to hook the common_reference_with concept. More...
 
struct  concepts::common_reference< Ts >
 Users can specialize this to hook the common_reference_with concept. More...
 
struct  concepts::common_reference< T >
 
struct  concepts::common_reference< T, U >
 
struct  concepts::common_reference< T, U, Vs... >
 
struct  concepts::common_type< Ts >
 Users should specialize this to hook the common_with 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  concepts::common_type< T >
 
struct  concepts::common_type< T, U >
 
struct  concepts::common_type< T, U, Vs... >
 
struct  concepts::is_nothrow_swappable< T >
 
struct  concepts::is_nothrow_swappable_with< T, U >
 
struct  concepts::is_swappable< T >
 
struct  concepts::is_swappable_with< T, U >
 
struct  ranges::aux::move_fn
 
class  ranges::box< Element, Tag, box_compress >
 
class  ranges::box< Element, Tag, detail::box_compress::coalesce >
 
class  ranges::box< Element, Tag, detail::box_compress::ebo >
 
struct  ranges::in_place_t
 
struct  ranges::indirectly_readable_traits< iterator_wrapper< I > >
 
struct  ranges::iterator_wrapper< I >
 
struct  ranges::make_tuple_fn
 
struct  ranges::raw_buffer< Val >
 
struct  ranges::raw_storage_iterator< O, Val >
 
struct  ranges::semiregular_box< T >
 
struct  ranges::semiregular_box< T & >
 
struct  ranges::semiregular_box< T && >
 
struct  ranges::static_const< T >
 
struct  ranges::tuple_apply_fn
 
struct  ranges::tuple_foldl_fn
 
struct  ranges::tuple_for_each_fn
 
struct  ranges::tuple_transform_fn
 

Typedefs

template<typename... Ts>
using concepts::common_reference_t = typename common_reference<Ts...>::type
 
template<typename... Ts>
using concepts::common_type_t = typename common_type<Ts...>::type
 
template<typename R >
using ranges::aux::move_t
 
template<typename T , bool IsConst = false>
using ranges::semiregular_box_ref_or_val_t
 
template<typename T >
using ranges::semiregular_box_t = meta::if_c<(bool)semiregular<T>, T, semiregular_box<T>>
 
template<typename Tup >
using ranges::tuple_indices_t
 

Functions

template<std::size_t I, typename Element , detail::box_compress BC>
constexpr Element && ranges::get (box< Element, meta::size_t< I >, BC > &&b) noexcept
 
template<std::size_t I, typename Element , detail::box_compress BC>
constexpr Element & ranges::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::get (box< Element, meta::size_t< I >, BC > const &b) noexcept
 
template<typename Tag , typename Element , detail::box_compress BC>
constexpr Element && ranges::get (box< Element, Tag, BC > &&b) noexcept
 
template<typename Tag , typename Element , detail::box_compress BC>
constexpr Element & ranges::get (box< Element, Tag, BC > &b) noexcept
 
template<typename Tag , typename Element , detail::box_compress BC>
constexpr Element const & ranges::get (box< Element, Tag, BC > const &b) noexcept
 
template<typename I >
requires input_or_output_iterator<I>
iterator_wrapper< I > ranges::iter_ref (I &i)
 
template<typename Val >
raw_buffer< Val > ranges::make_raw_buffer (Val *val)
 

Variables

constexpr bind_back_fn ranges::bind_back {}
 
constexpr copy_fn ranges::aux::copy {}
 
constexpr make_common_pair_fn ranges::make_common_pair {}
 
constexpr make_common_tuple_fn ranges::make_common_tuple {}
 
constexpr make_compressed_pair_fn ranges::make_compressed_pair {}
 
constexpr make_compressed_tuple_fn ranges::make_compressed_tuple {}
 
constexpr make_tuple_fn ranges::make_tuple {}
 
constexpr move_fn ranges::aux::move {}
 
constexpr uncvref_t< decltype(concepts::swap)> swap {}
 
constexpr tuple_apply_fn ranges::tuple_apply {}
 
constexpr tuple_foldl_fn ranges::tuple_foldl {}
 
constexpr tuple_for_each_fn ranges::tuple_for_each {}
 
constexpr tuple_transform_fn ranges::tuple_transform {}
 
static constexpr T ranges::static_const< T >::value {}
 

Friends

template<typename T >
requires constructible_from<detail::decay_t<T>, T>
constexpr auto ranges::aux::copy_fn::operator| (T &&t, copy_fn) -> detail::decay_t< T >
 
template<typename T >
constexpr decltype(auto) ranges::aux::move_fn::operator| (T &&t, move_fn move) noexcept
 

Detailed Description

Utility classes

Typedef Documentation

◆ move_t

template<typename R >
using ranges::aux::move_t

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

Initial value:
detail::decay_t<R>>
typename T::type _t
Type alias for T::type.
Definition meta.hpp:141
_t< detail::_if_< bool_< If >, Args... > > if_c
Select one type or another depending on a compile-time Boolean.
Definition meta.hpp:1244
See also
move_fn

◆ semiregular_box_ref_or_val_t

template<typename T , bool IsConst = false>
using ranges::semiregular_box_ref_or_val_t

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

Initial value:
(bool)semiregular<T>,
meta::if_c<IsConst || std::is_empty<T>::value, T, reference_wrapper<T>>,
reference_wrapper<
meta::if_c<IsConst, semiregular_box<T> const, semiregular_box<T>>>>

◆ tuple_indices_t

template<typename Tup >
using ranges::tuple_indices_t

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

Initial value:
std::tuple_size<typename std::remove_reference<Tup>::type>::value>
_t< detail::make_indices_< N, index_sequence< 0 >, detail::strategy_(1, N)> > make_index_sequence
Generate index_sequence containing integer constants [0,1,2,...,N-1].
Definition meta.hpp:472

Variable Documentation

◆ bind_back

bind_back_fn ranges::bind_back {}
constexpr

◆ copy

copy_fn ranges::aux::copy {}
constexpr

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

See also
copy_fn

◆ make_common_pair

make_common_pair_fn ranges::make_common_pair {}
constexpr

◆ make_common_tuple

make_common_tuple_fn ranges::make_common_tuple {}
constexpr

◆ make_compressed_pair

make_compressed_pair_fn ranges::make_compressed_pair {}
constexpr

◆ make_compressed_tuple

make_compressed_tuple_fn ranges::make_compressed_tuple {}
constexpr

◆ make_tuple

make_tuple_fn ranges::make_tuple {}
constexpr

◆ move

move_fn ranges::aux::move {}
related

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

See also
move_fn

◆ tuple_apply

◆ tuple_foldl

tuple_foldl_fn ranges::tuple_foldl {}
constexpr

◆ tuple_for_each

tuple_for_each_fn ranges::tuple_for_each {}
constexpr

◆ tuple_transform

tuple_transform_fn ranges::tuple_transform {}
constexpr

◆ value

template<typename T >
T ranges::static_const< T >::value {}
staticconstexpr
See also
static_const

Friends

◆ operator| [1/2]

template<typename T >
requires constructible_from<detail::decay_t<T>, T>
auto operator| ( T && t,
copy_fn  ) -> detail::decay_t<T>
friend

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

See also
copy_fn

◆ operator| [2/2]

template<typename T >
decltype(auto) operator| ( T && t,
move_fn move )
friend

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

See also
move_fn