type_traits.h File Reference

#include <stddef.h>
#include <functional>
#include <type_traits>
#include "absl/base/config.h"

Include dependency graph for type_traits.h:

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

Go to the source code of this file.

Classes
struct	absl::type_traits_internal::AssertHashEnabledHelper
struct	absl::conjunction< Ts >
struct	absl::conjunction< T >
struct	absl::conjunction< T, Ts... >
struct	absl::conjunction<>
struct	absl::type_traits_internal::default_alignment_of_aligned_storage< Len, T >
struct	absl::type_traits_internal::default_alignment_of_aligned_storage< Len, std::aligned_storage< Len, Align > >
struct	absl::disjunction< Ts >
struct	absl::disjunction< T >
struct	absl::disjunction< T, Ts... >
struct	absl::disjunction<>
struct	absl::is_copy_assignable< T >
struct	absl::type_traits_internal::is_detected< Op, Args >
struct	absl::type_traits_internal::is_detected_convertible< To, Op, Args >
struct	absl::type_traits_internal::is_detected_convertible_impl< Enabler, To, Op, Args >
struct	absl::type_traits_internal::is_detected_convertible_impl< typename std::enable_if< std::is_convertible< Op< Args... >, To >::value >::type, To, Op, Args... >
struct	absl::type_traits_internal::is_detected_impl< Enabler, Op, Args >
struct	absl::type_traits_internal::is_detected_impl< typename VoidTImpl< Op< Args... > >::type, Op, Args... >
struct	absl::is_move_assignable< T >
struct	absl::is_trivially_copy_assignable< T >
struct	absl::is_trivially_copy_constructible< T >
struct	absl::type_traits_internal::is_trivially_copyable< T >
class	absl::type_traits_internal::is_trivially_copyable_impl< T >
struct	absl::is_trivially_default_constructible< T >
struct	absl::is_trivially_destructible< T >
struct	absl::is_trivially_move_assignable< T >
struct	absl::is_trivially_move_assignable< T >
struct	absl::is_trivially_move_constructible< T >
struct	absl::type_traits_internal::IsHashable< Key, typename >
struct	absl::swap_internal::IsNothrowSwappable< T >
struct	absl::swap_internal::IsSwappable< T >
struct	absl::type_traits_internal::IsTriviallyMoveAssignableReference< T >
struct	absl::type_traits_internal::IsTriviallyMoveAssignableReference< T & >
struct	absl::type_traits_internal::IsTriviallyMoveAssignableReference< T && >
struct	absl::type_traits_internal::AssertHashEnabledHelper::NAT
struct	absl::negation< T >
union	absl::type_traits_internal::SingleMemberUnion< T >
struct	absl::type_traits_internal::VoidTImpl< Ts >

Namespaces
	absl
	absl::swap_internal
	absl::type_traits_internal

Macros
#define	ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_   1

Typedefs
template<typename T >
using	absl::add_const_t = typename std::add_const< T >::type
template<typename T >
using	absl::add_cv_t = typename std::add_cv< T >::type
template<typename T >
using	absl::add_lvalue_reference_t = typename std::add_lvalue_reference< T >::type
template<typename T >
using	absl::add_pointer_t = typename std::add_pointer< T >::type
template<typename T >
using	absl::add_rvalue_reference_t = typename std::add_rvalue_reference< T >::type
template<typename T >
using	absl::add_volatile_t = typename std::add_volatile< T >::type
template<size_t Len, size_t Align = type_traits_internal:: default_alignment_of_aligned_storage<Len>::value>
using	absl::aligned_storage_t = typename std::aligned_storage< Len, Align >::type
template<typename... T>
using	absl::common_type_t = typename std::common_type< T... >::type
template<bool B, typename T , typename F >
using	absl::conditional_t = typename std::conditional< B, T, F >::type
template<typename T >
using	absl::decay_t = typename std::decay< T >::type
template<bool B, typename T = void>
using	absl::enable_if_t = typename std::enable_if< B, T >::type
template<typename T >
using	absl::type_traits_internal::IsCopyAssignableImpl = decltype(std::declval< T & >()=std::declval< const T & >())
template<typename T >
using	absl::type_traits_internal::IsMoveAssignableImpl = decltype(std::declval< T & >()=std::declval< T && >())
template<class T , class IsNoexcept = std::integral_constant< bool, noexcept(swap(std::declval<T&>(), std::declval<T&>()))>>
using	absl::swap_internal::IsNothrowSwappableImpl = typename std::enable_if< IsNoexcept::value >::type
template<class T >
using	absl::swap_internal::IsSwappableImpl = decltype(swap(std::declval< T & >(), std::declval< T & >()))
template<typename T >
using	absl::make_signed_t = typename std::make_signed< T >::type
template<typename T >
using	absl::make_unsigned_t = typename std::make_unsigned< T >::type
template<typename T >
using	absl::remove_all_extents_t = typename std::remove_all_extents< T >::type
template<typename T >
using	absl::remove_const_t = typename std::remove_const< T >::type
template<typename T >
using	absl::remove_cv_t = typename std::remove_cv< T >::type
template<typename T >
using	absl::remove_extent_t = typename std::remove_extent< T >::type
template<typename T >
using	absl::remove_pointer_t = typename std::remove_pointer< T >::type
template<typename T >
using	absl::remove_reference_t = typename std::remove_reference< T >::type
template<typename T >
using	absl::remove_volatile_t = typename std::remove_volatile< T >::type
template<typename T >
using	absl::result_of_t = typename std::result_of< T >::type
using	absl::swap_internal::StdSwapIsUnconstrained = IsSwappable< void()>
template<typename T >
using	absl::underlying_type_t = typename std::underlying_type< T >::type
template<typename... Ts>
using	absl::void_t = typename type_traits_internal::VoidTImpl< Ts... >::type

Functions
template<class... Ts>
void	absl::type_traits_internal::AssertHashEnabled ()
void	absl::swap_internal::swap ()
template<class T , absl::enable_if_t< IsSwappable< T >::value, int > = 0>
void	absl::swap_internal::Swap (T &lhs, T &rhs) noexcept(IsNothrowSwappable< T >::value)

Macro Definition Documentation

#define ABSL_META_INTERNAL_STD_HASH_SFINAE_FRIENDLY_   1

Definition at line 570 of file type_traits.h.