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::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 = 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 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 >
CPP_TEMPLATE_AUX_0 | ranges::i (requires ` input_or_output_iterator< I >) iiiterator_wrapper< I > iter_ref(I &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
| ) |  |

constexpr noexcept

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

See also
  `move_fn`

## Variable Documentation

## bind_back

constexpr bind_back_fn ranges::bind_back {}

constexpr

`#include <range/v3/functional/bind_back.hpp>`

See also
  `bind_back_fn`

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

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

See also
  `make_common_pair_fn`

## make_common_tuple

constexpr make_common_tuple_fn ranges::make_common_tuple {}

constexpr

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

See also
  `make_common_tuple_fn`

## make_compressed_pair

constexpr make_compressed_pair_fn ranges::make_compressed_pair {}

constexpr

`#include <range/v3/utility/compressed_pair.hpp>`

See also
  `make_compressed_pair_fn`

## make_compressed_tuple

constexpr make_compressed_tuple_fn ranges::make_compressed_tuple {}

constexpr

`#include <range/v3/utility/compressed_pair.hpp>`

See also
  `make_compressed_tuple_fn`

## make_tuple

constexpr make_tuple_fn ranges::make_tuple {}

constexpr

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

See also
  `make_tuple_fn`

## move

constexpr move_fn ranges::aux::move {}

related

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

See also
  `move_fn`

Referenced by ranges::view_interface< Derived, Cardinality >::c(), and ranges::view_interface< Derived, Cardinality >::CPP_TEMPLATE_AUX_0().

## tuple_apply

constexpr tuple_apply_fn ranges::tuple_apply {}

constexpr

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

See also
  `tuple_apply_fn`

Referenced by ranges::detail::bind_back_fn_< Fn, Args >::operator()().

## tuple_foldl

constexpr tuple_foldl_fn ranges::tuple_foldl {}

constexpr

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

See also
  `tuple_foldl_fn`

## tuple_for_each

constexpr tuple_for_each_fn ranges::tuple_for_each {}

constexpr

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

See also
  `tuple_for_each_fn`

## tuple_transform

constexpr tuple_transform_fn ranges::tuple_transform {}

constexpr

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

See also
  `tuple_transform_fn`

## value

template<typename T >

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

static constexpr

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`