type_traits.hpp File Reference
Include dependency graph for type_traits.hpp:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  aligned_union< Len, Types >
 
struct  aligned_union< Len, Types >
 
struct  common_type< Ts >
 
struct  common_type< T >
 
struct  common_type< T, U >
 
struct  common_type< T, U, Ts... >
 
struct  conjunction<... >
 
struct  conjunction< T, Ts... >
 
struct  conjunction<>
 
struct  disjunction<... >
 
struct  disjunction< T, Ts... >
 
struct  disjunction<>
 
union  discriminate< Ts >
 
union  discriminate< T, Ts... >
 
union  discriminate<>
 
struct  invokable< Args >
 
struct  invokable< Args >
 
struct  invoke_of< Args >
 
struct  invoke_of< Args >
 
struct  is_null_pointer< T >
 
struct  is_null_pointer< add_cv_t<::std::nullptr_t > >
 
struct  is_null_pointer<::std::nullptr_t >
 
struct  is_null_pointer<::std::nullptr_t const >
 
struct  is_null_pointer<::std::nullptr_t volatile >
 
struct  negation<... >
 
struct  negation< T, Ts... >
 
struct  negation<>
 
struct  nonesuch
 
struct  result_of< T >
 
struct  result_of< F(Args...)>
 
struct  transmit_const< T, U >
 
struct  transmit_cv< T, U >
 
struct  transmit_volatile< T, U >
 

Namespaces

 core
 
Copyright © 2013 - 2015 MNMLSTC.
 
 core::v2
 
 core::v2::impl
 

Typedefs

template
<
class
T
>
using add_const_t = typename ::std::add_const< T >::type
 
template
<
class
T
>
using add_cv_t = typename ::std::add_cv< T >::type
 
template
<
class
T
>
using add_lvalue_reference_t = typename ::std::add_lvalue_reference< T >::type
 
template
<
class
T
>
using add_pointer_t = typename ::std::add_pointer< T >::type
 
template
<
class
T
>
using add_rvalue_reference_t = typename ::std::add_rvalue_reference< T >::type
 
template
<
class
T
>
using add_volatile_t = typename ::std::add_volatile< T >::type
 
template<::std::size_t Len, ::std::size_t Align = alignof(typename ::std::aligned_storage<Len>::type)>
using aligned_storage_t = typename ::std::aligned_storage< Len, Align >::type
 
template<::std::size_t Len, class... Types>
using aligned_union_t = typename aligned_union< Len, Types... >::type
 
template<bool B>
using bool_constant = ::std::integral_constant< bool, B >
 
template
<
class
T
>
using class_of = impl::class_of< T >
 
template
<
class
T
>
using class_of_t = impl::class_of_t< T >
 
template<class... T>
using common_type_t = typename common_type< T... >::type
 
template<bool B, class T , class F >
using conditional_t = typename ::std::conditional< B, T, F >::type
 
template
<
class
T
>
using decay_t = impl::decay_t< T >
 
template<class T , template< class... > class U, class... Args>
using detected_or = impl::make_detect< T, void, U, Args... >
 
template<class T , template< class... > class U, class... Args>
using detected_or_t = typename detected_or< T, U, Args... >::type
 
template<template< class... > class T, class... Args>
using detected_t = typename detected_or< nonesuch, T, Args... >::type
 
template<bool B, class T = void>
using enable_if_t = typename ::std::enable_if< B, T >::type
 
template
<
class
T
>
using identity = meta::identity< T >
 
template
<
class
T
>
using identity_t = typename meta::identity< T >::type
 
template<class... Args>
using invoke_of_t = typename invoke_of< Args... >::type
 
template<template< class... > class T, class... Args>
using is_detected = typename detected_or< nonesuch, T, Args... >::value_t
 
template<class To , template< class... > class T, class... Args>
using is_detected_convertible = ::std::is_convertible< detected_t< T, Args... >, To >
 
template<class T , template< class... > class U, class... Args>
using is_detected_same = ::std::is_same< T, detected_t< U, Args... > >
 
template
<
class
T
,
class
U
=
T
>
using is_nothrow_swappable = impl::is_nothrow_swappable< T, U >
 
template
<
class
T
>
using make_signed_t = typename ::std::make_signed< T >::type
 
template
<
class
T
>
using make_unsigned_t = typename ::std::make_unsigned< T >::type
 
template
<
class
T
>
using remove_all_extents_t = typename ::std::remove_all_extents< T >::type
 
template
<
class
T
>
using remove_const_t = typename ::std::remove_const< T >::type
 
template
<
class
T
>
using remove_cv_t = typename ::std::remove_cv< T >::type
 
template
<
class
T
>
using remove_extent_t = typename ::std::remove_extent< T >::type
 
template
<
class
T
>
using remove_pointer_t = typename ::std::remove_pointer< T >::type
 
template
<
class
T
>
using remove_reference_t = typename ::std::remove_reference< T >::type
 
template
<
class
T
>
using remove_volatile_t = typename ::std::remove_volatile< T >::type
 
template
<
class
T
>
using result_of_t = typename result_of< T >::type
 
template
<
class
T
,
class
U
>
using transmit_const_t = typename transmit_const< T, U >::type
 
template
<
class
T
,
class
U
>
using transmit_cv_t = typename transmit_cv< T, U >::type
 
template
<
class
T
,
class
U
>
using transmit_volatile_t = typename transmit_volatile< T, U >::type
 
template<::std::size_t I, class T >
using tuple_element_t = typename ::std::tuple_element< I, T >::type
 
template
<
class
T
>
using tuple_size_t = typename ::std::tuple_size< T >::type
 
template
<
class
T
>
using underlying_type_t = typename ::std::underlying_type< T >::type
 
template<class... Ts>
using void_t = meta::deduce< Ts... >