utility.h File Reference

#include <cstddef>
#include <cstdlib>
#include <tuple>
#include <utility>
#include "absl/base/config.h"
#include "absl/base/internal/inline_variable.h"
#include "absl/base/internal/invoke.h"
#include "absl/meta/type_traits.h"

Include dependency graph for utility.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	absl::utility_internal::Extend< Seq, SeqSize, Rem >
struct	absl::utility_internal::Extend< integer_sequence< T, Ints... >, SeqSize, 0 >
struct	absl::utility_internal::Extend< integer_sequence< T, Ints... >, SeqSize, 1 >
struct	absl::utility_internal::Gen< T, N >
struct	absl::utility_internal::Gen< T, 0 >
struct	absl::in_place_t
struct	absl::utility_internal::InPlaceIndexTag< I >
struct	absl::utility_internal::InPlaceTypeTag< T >
struct	absl::integer_sequence< T, Ints >

Namespaces
	absl
	absl::utility_internal

Typedefs
template<size_t I>
using	absl::in_place_index_t = void(*)(utility_internal::InPlaceIndexTag< I >)
template<typename T >
using	absl::in_place_type_t = void(*)(utility_internal::InPlaceTypeTag< T >)
template<size_t... Ints>
using	absl::index_sequence = integer_sequence< size_t, Ints... >
template<typename... Ts>
using	absl::index_sequence_for = make_index_sequence< sizeof...(Ts)>
template<size_t N>
using	absl::make_index_sequence = make_integer_sequence< size_t, N >
template<typename T , T N>
using	absl::make_integer_sequence = typename utility_internal::Gen< T, N >::type

Functions
	absl::ABSL_INTERNAL_INLINE_CONSTEXPR (in_place_t, in_place,{})
template<typename Functor , typename Tuple >
auto	absl::apply (Functor &&functor, Tuple &&t) -> decltype(utility_internal::apply_helper(absl::forward< Functor >(functor), absl::forward< Tuple >(t), absl::make_index_sequence< std::tuple_size< typename std::remove_reference< Tuple >::type >::value >
template<typename Functor , typename Tuple , std::size_t... Indexes>
auto	absl::utility_internal::apply_helper (Functor &&functor, Tuple &&t, index_sequence< Indexes... >) -> decltype(absl::base_internal::Invoke(absl::forward< Functor >(functor), std::get< Indexes >(absl::forward< Tuple >(t))...))
template<typename T , typename U = T>
T	absl::exchange (T &obj, U &&new_value)
template<typename T >
constexpr T &&	absl::forward (absl::remove_reference_t< T > &t) noexcept
template<size_t I>
void	absl::in_place_index (utility_internal::InPlaceIndexTag< I >)
template<typename T >
void	absl::in_place_type (utility_internal::InPlaceTypeTag< T >)
template<typename T >
constexpr absl::remove_reference_t< T > &&	absl::move (T &&t) noexcept