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

Classes | Typedefs | Functions | Variables | Friends
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 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 >
T const & | ranges::get (meta::id_t< T > const &value) noexcept
template<std::size_t I, typename TupleLike >
constexpr auto | ranges::get (TupleLike &&t) noexcept(noexcept(detail::adl_get< I >(static_cast< TupleLike && >(t)))) -> decltype(detail::adl_get< I >(static_cast< TupleLike && >(t)))
template<typename I >
iterator_wrapper< I > | ranges::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 >

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

## ◆ iter_ref()

template<typename I >

iterator_wrapper<I> ranges::iter_ref | ( | I & | i | ) |

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

Precondition
  requires `input_or_output_iterator<I>`

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

Referenced by ranges::rotate_copy().

## ◆ 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::ends_with(), ranges::generate(), ranges::lower_bound(), ranges::views::remove_base_fn::operator()(), ranges::actions::split_fn::operator()(), ranges::views::remove_bind_fn::operator()(), ranges::views::cpp20_counted_fn::operator()(), ranges::views::delimit_base_fn::operator()(), ranges::views::counted_fn::operator()(), ranges::views::drop_while_base_fn::operator()(), ranges::adjacent_difference_fn::operator()(), ranges::views::drop_while_bind_fn::operator()(), ranges::views::trim_bind_fn::operator()(), ranges::views::take_while_base_fn::operator()(), ranges::views::remove_if_base_fn::operator()(), ranges::views::take_while_bind_fn::operator()(), ranges::views::remove_if_bind_fn::operator()(), ranges::views::iter_zip_with_fn::operator()(), ranges::views::zip_with_fn::operator()(), ranges::views::ints_fn::operator()(), ranges::views::join_bind_fn::operator()(), ranges::rotate_copy(), ranges::sample(), ranges::set_intersection(), ranges::const_view< Rng >::size(), ranges::exclusive_scan_view< Rng, T, Fun >::size(), ranges::cache1_view< Rng >::size(), ranges::cartesian_product_view< Views >::size(), ranges::sort(), ranges::subrange< I, S, K >::subrange(), ranges::take_while_view(), and ranges::zip_with_view().

## ◆ tuple_apply

constexpr tuple_apply_fn ranges::tuple_apply {}
| constexpr

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

See also
  `tuple_apply_fn`

## ◆ tuple_foldl

constexpr tuple_foldl_fn ranges::tuple_foldl {}
| constexpr

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

See also
  `tuple_foldl_fn`

Referenced by ranges::concat_view< Rngs >::size().

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

Referenced by ranges::concat_view< Rngs >::size().

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

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

See also
  `copy_fn`