Utility

Utility classes. More...

Namespaces
namespace	ranges::cpp20

Classes
struct	concepts::is_swappable_with< T, U >
struct	concepts::is_nothrow_swappable_with< T, U >
struct	concepts::is_swappable< T >
struct	concepts::is_nothrow_swappable< T >
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::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	ranges::variant< Ts >
struct	ranges::variant_unique< variant< Ts... > >
class	ranges::box< Element, Tag, box_compress >
class	ranges::box< Element, Tag, detail::box_compress::ebo >
class	ranges::box< Element, Tag, detail::box_compress::coalesce >
struct	ranges::common_pair< F, S >
struct	ranges::compressed_pair< First, Second >
struct	ranges::in_place_t
struct	ranges::raw_storage_iterator< O, Val >
struct	ranges::iterator_wrapper< I >
struct	ranges::indirectly_readable_traits< iterator_wrapper< I > >
struct	ranges::raw_buffer< Val >
struct	ranges::aux::move_fn
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_transform_fn
struct	ranges::tuple_foldl_fn
struct	ranges::tuple_for_each_fn
struct	ranges::make_tuple_fn

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

Functions
	ranges::template (typename... Ts, typename... Us)() bool operator
template<typename... Ts>
variant_unique_t< variant< Ts... > >	ranges::unique_variant (variant< Ts... > const &var)
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 Tag, typename Element, detail::box_compress BC>
constexpr Element &&	ranges::get (box< Element, Tag, 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<std::size_t I, typename Element, detail::box_compress BC>
constexpr Element &&	ranges::get (box< Element, meta::size_t< I >, BC > &&b) noexcept
	ranges::template (typename I)() iterator_wrapper< I > iter_ref(I &i)
template<typename Val>
raw_buffer< Val >	ranges::make_raw_buffer (Val *val)
	RANGES_DEPRECATED_HEADER ("This header is deprecated and will be removed from a future version of range-v3.") namespace ranges

Variables
template<typename Element, typename Tag>
Element	ranges::box< Element, Tag, detail::box_compress::coalesce >::value {}
template<typename T>
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) -> CPP_broken_friend_ret(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

Initial value:

 
            meta::if_c<std::is_reference<R>::value, meta::_t<std::remove_reference<R>> &&,
                       detail::decay_t<R>>

See also

move_fn

move_fn

semiregular_box_ref_or_val_t

template<typename T, bool IsConst = false>

using ranges::semiregular_box_ref_or_val_t

Initial value:

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

tuple_indices_t

template<typename Tup>

using ranges::tuple_indices_t

Initial value:

 meta::make_index_sequence<
        std::tuple_size<typename std::remove_reference<Tup>::type>::value>

Function Documentation

RANGES_DEPRECATED_HEADER()

RANGES_DEPRECATED_HEADER

(

"This header is deprecated and will be removed from a future version of range-v3."

)

Variable Documentation

static_const< T >::value

template<typename T>

T ranges::static_const< T >::value

constexpr

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  )->CPP_broken_friend_ret(detail::decay_t< T >)(

friend

See also

copy_fn

operator| [2/2]

template<typename T>

decltype(auto) operator| ( T && t, move_fn move )

friend

See also

move_fn