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

Description

Utility classes.

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::iterator_wrapper< I >
 
struct  ranges::make_tuple_fn
 
struct  ranges::raw_buffer< Val >
 
struct  ranges::raw_storage_iterator< O, Val >
 
struct  ranges::readable_traits< iterator_wrapper< I > >
 
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 = meta::if_c< std::is_reference< R >::value, meta::_t< std::remove_reference< R > > &&, detail::decay_t< R > >
 
template<typename T , bool IsConst = false>
using ranges::semiregular_box_ref_or_val_t = meta::if_c<(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 > >> >
 
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 = meta::make_index_sequence< std::tuple_size< typename std::remove_reference< Tup >::type >::value >
 

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 Elementranges::get (box< Element, meta::size_t< I >, BC > &b) noexcept
 
template<std::size_t I, typename Element , detail::box_compress BC>
constexpr const Elementranges::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 Elementranges::get (box< Element, Tag, BC > &b) noexcept
 
template<typename Tag , typename Element , detail::box_compress BC>
constexpr const Elementranges::get (box< Element, Tag, BC > const &b) noexcept
 
template<typename T >
T && ranges::get (meta::id_t< T > &&value) noexcept
 
template<typename T >
T & ranges::get (meta::id_t< T > &value) noexcept
 
template<typename T >
const T & ranges::get (meta::id_t< T > const &value) noexcept
 
template<std::size_t I, typename TupleLike >
constexpr auto ranges::get (TupleLike &&t) noexcept(noexcept(decltype(detail::adl_get< I >(static_cast< TupleLike && >(t)))(detail::adl_get< I >(static_cast< TupleLike && >(t))))) -> decltype(detail::adl_get< I >(static_cast< TupleLike && >(t)))
 
template<typename I >
auto ranges::iter_ref (I &i) -> iterator_wrapper< I > requires input_or_output_iterator< I >
 
template<typename Val >
raw_buffer< Val > ranges::make_raw_buffer (Val *val)
 
template<typename T >
constexpr decltype(auto) friend ranges::aux::move_fn::operator| (T &&t, move_fn move) noexcept
 

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 >
constexpr friend auto ranges::aux::copy_fn::operator| (T &&t, copy_fn) -> detail::decay_t< T > requires constructible_from< detail::decay_t< T >, T >
 

Typedef Documentation

◆ move_t

template<typename R >
using ranges::aux::move_t = typedef meta::if_c<std::is_reference<R>::value, meta::_t<std::remove_reference<R> > &&, detail::decay_t<R> >

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

See also
move_fn

Function Documentation

◆ operator|()

template<typename T >
constexpr decltype(auto) friend ranges::aux::move_fn::operator| ( T &&  t,
move_fn  move 
)
constexprnoexcept

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

See also
move_fn

References ranges::move().

Variable Documentation

◆ bind_back

constexpr bind_back_fn ranges::bind_back {}
constexpr

◆ copy

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

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

See also
copy_fn

◆ make_common_pair

constexpr make_common_pair_fn ranges::make_common_pair {}
constexpr

◆ make_common_tuple

constexpr make_common_tuple_fn ranges::make_common_tuple {}
constexpr

◆ make_compressed_pair

constexpr make_compressed_pair_fn ranges::make_compressed_pair {}
constexpr

◆ make_compressed_tuple

constexpr make_compressed_tuple_fn ranges::make_compressed_tuple {}
constexpr

◆ make_tuple

constexpr make_tuple_fn ranges::make_tuple {}
constexpr

◆ move

◆ tuple_apply

constexpr tuple_apply_fn ranges::tuple_apply {}
constexpr

◆ tuple_foldl

constexpr tuple_foldl_fn ranges::tuple_foldl {}
constexpr

◆ tuple_for_each

constexpr tuple_for_each_fn ranges::tuple_for_each {}
constexpr

◆ tuple_transform

constexpr tuple_transform_fn ranges::tuple_transform {}
constexpr

◆ value

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

Friends

◆ operator|

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

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

See also
copy_fn