MADNESS  0.10.1
Namespaces | Classes | Typedefs | Variables
madness::meta Namespace Reference

Namespaces

 detail
 

Classes

struct  conjunction
 
struct  conjunction< B1 >
 
struct  conjunction< B1, Bn... >
 
struct  disjunction
 
struct  disjunction< B1 >
 
struct  disjunction< B1, Bn... >
 
struct  drop_last_arg_and_apply
 
struct  drop_last_arg_and_apply_callable
 
struct  drop_last_arg_and_apply_callable_impl
 
struct  drop_last_arg_and_apply_callable_impl< MetaFn, Callable, typelist< UpToLast... >, Last >
 
struct  drop_last_arg_and_apply_callable_impl< MetaFn, Callable, typelist< UpToT... >, T, Rest... >
 
struct  drop_last_arg_and_apply_impl
 
struct  drop_last_arg_and_apply_impl< MetaFn, typelist< UpToLast... >, Last >
 
struct  drop_last_arg_and_apply_impl< MetaFn, typelist< UpToT... >, T, Rest... >
 
struct  last_type
 
struct  last_type< T0 >
 
struct  last_type< T0, T1, Ts... >
 
struct  make_void
 
struct  nonesuch
 
struct  taskattr_is_last_arg
 
struct  taskattr_is_last_arg<>
 
struct  typelist
 

Typedefs

template<class Default , template< class... > class Op, class... Args>
using detected_or = detail::detector< Default, void, Op, Args... >
 
template<class Default , template< class... > class Op, class... Args>
using detected_or_t = typename detected_or< Default, Op, Args... >::type
 
template<template< class... > class Op, class... Args>
using detected_t = typename detail::detector< nonesuch, void, Op, Args... >::type
 
template<template< class... > class Op, class... Args>
using is_detected = typename detail::detector< nonesuch, void, Op, Args... >::value_t
 
template<class To , template< class... > class Op, class... Args>
using is_detected_convertible = std::is_convertible< detected_t< Op, Args... >, To >
 
template<class Expected , template< class... > class Op, class... Args>
using is_detected_exact = std::is_same< Expected, detected_t< Op, Args... > >
 
template<typename... Ts>
using void_t = typename make_void< Ts... >::type
 

Variables

template<class... B>
constexpr bool conjunction_v = conjunction<B...>::value
 
template<class... B>
constexpr bool disjunction_v = disjunction<B...>::value
 
template<class To , template< class... > class Op, class... Args>
constexpr bool is_detected_convertible_v = is_detected_convertible<To, Op, Args...>::value
 
template<class Expected , template< class... > class Op, class... Args>
constexpr bool is_detected_exact_v = is_detected_exact<Expected, Op, Args...>::value
 
template<template< class... > class Op, class... Args>
constexpr bool is_detected_v = is_detected<Op, Args...>::value
 
template<class T >
constexpr bool is_function_v = std::is_function<T>::value
 
template<class T >
constexpr bool is_member_function_pointer_v = std::is_member_function_pointer<T>::value
 

Typedef Documentation

◆ detected_or

template<class Default , template< class... > class Op, class... Args>
using madness::meta::detected_or = typedef detail::detector<Default, void, Op, Args...>

◆ detected_or_t

template<class Default , template< class... > class Op, class... Args>
using madness::meta::detected_or_t = typedef typename detected_or<Default, Op, Args...>::type

◆ detected_t

template<template< class... > class Op, class... Args>
using madness::meta::detected_t = typedef typename detail::detector<nonesuch, void, Op, Args...>::type

◆ is_detected

template<template< class... > class Op, class... Args>
using madness::meta::is_detected = typedef typename detail::detector<nonesuch, void, Op, Args...>::value_t

◆ is_detected_convertible

template<class To , template< class... > class Op, class... Args>
using madness::meta::is_detected_convertible = typedef std::is_convertible<detected_t<Op, Args...>, To>

◆ is_detected_exact

template<class Expected , template< class... > class Op, class... Args>
using madness::meta::is_detected_exact = typedef std::is_same<Expected, detected_t<Op, Args...> >

◆ void_t

template<typename... Ts>
using madness::meta::void_t = typedef typename make_void<Ts...>::type

Variable Documentation

◆ conjunction_v

template<class... B>
constexpr bool madness::meta::conjunction_v = conjunction<B...>::value
inlineconstexpr

◆ disjunction_v

template<class... B>
constexpr bool madness::meta::disjunction_v = disjunction<B...>::value
inlineconstexpr

◆ is_detected_convertible_v

template<class To , template< class... > class Op, class... Args>
constexpr bool madness::meta::is_detected_convertible_v = is_detected_convertible<To, Op, Args...>::value
constexpr

◆ is_detected_exact_v

template<class Expected , template< class... > class Op, class... Args>
constexpr bool madness::meta::is_detected_exact_v = is_detected_exact<Expected, Op, Args...>::value
constexpr

◆ is_detected_v

template<template< class... > class Op, class... Args>
constexpr bool madness::meta::is_detected_v = is_detected<Op, Args...>::value
constexpr

◆ is_function_v

template<class T >
constexpr bool madness::meta::is_function_v = std::is_function<T>::value
inlineconstexpr

◆ is_member_function_pointer_v

template<class T >
constexpr bool madness::meta::is_member_function_pointer_v = std::is_member_function_pointer<T>::value
inlineconstexpr