type_support

The contents of this module can be included with the header hpx/modules/type_support.hpp. These headers may be used by user-code but are not guaranteed stable (neither header location nor contents). You are using these at your own risk. If you wish to use non-public functionality from a module we strongly suggest only including the module header hpx/modules/type_support.hpp, not the particular header in which the functionality you would like to use is defined. See Public API for a list of names that are part of the public HPX API.

namespace hpx
namespace util

Typedefs

template<typename ...T>
using always_void_t = typename always_void<T...>::type
template<typename ...T>
struct always_void

Public Types

template<>
using type = void
namespace hpx
namespace util

Typedefs

template<typename T>
using decay_unwrap_t = typename decay_unwrap<T>::type
namespace hpx
namespace util

Typedefs

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

Public Functions

nonesuch()
~nonesuch()
nonesuch(nonesuch const&)
void operator=(nonesuch const&)
namespace hpx
namespace util
template<typename T>
struct identity

Public Types

template<>
using type = T
namespace hpx
namespace util

Typedefs

template<bool Enable, typename C1, typename C2>
using lazy_conditional_t = typename lazy_conditional<Enable, C1, C2>::type
namespace hpx
namespace util
template<typename T>
struct lazy_enable_if<true, T>

Public Types

template<>
using type = typename T::type
namespace hpx
namespace util

Typedefs

template<std::size_t... Is>
using index_pack = pack_c<std::size_t, Is...>
template<std::size_t N>
using make_index_pack_t = typename make_index_pack<N>::type
template<std::size_t I, typename ...Ts>
using at_index_t = typename at_index<I, Ts...>::type

Variables

template<typename ...Ts>
constexpr bool all_of_v = all_of<Ts...>::value
template<typename ...Ts>
constexpr bool any_of_v = any_of<Ts...>::value
template<typename ...Ts>
constexpr bool none_of_v = none_of<Ts...>::value
template<typename ...Ts>
struct pack

Public Types

typedef pack type

Public Static Attributes

constexpr std::size_t size = sizeof...(Ts)
template<typename T, T... Vs>
struct pack_c

Subclassed by hpx::util::detail::make_index_pack_join< index_pack< Left… >, index_pack< Right… > >, hpx::util::make_index_pack< 1 >

Public Types

typedef pack_c type

Public Static Attributes

constexpr std::size_t size = sizeof...(Vs)

Defines

HPX_EXPORT_STATIC_
namespace hpx
namespace util
template<typename T, typename Tag = T>
struct static_

Public Types

typedef T value_type
typedef T &reference
typedef T const &const_reference

Public Functions

HPX_NON_COPYABLE(static_)
static_()
operator reference()
operator const_reference() const
reference get()
const_reference get() const

Private Types

typedef std::add_pointer<value_type>::type pointer
typedef std::aligned_storage<sizeof(value_type), std::alignment_of<value_type>::value>::type storage_type

Private Static Functions

static pointer get_address()

Private Static Attributes

static_<T, Tag>::storage_type data_
std::once_flag constructed_
struct default_constructor

Public Static Functions

template<>
static void construct()
struct destructor

Public Functions

template<>
~destructor()

Defines

HPX_UNUSED(x)
HPX_MAYBE_UNUSED
namespace hpx
namespace util

Variables

constexpr unused_type unused = unused_type()
struct unused_type

Public Functions

constexpr unused_type()
constexpr unused_type(unused_type const&)
constexpr unused_type(unused_type&&)
template<typename T>
constexpr unused_type(T const&)
template<typename T>
constexpr unused_type const &operator=(T const&) const
template<typename T>
unused_type &operator=(T const&)
constexpr unused_type const &operator=(unused_type const&) const
unused_type &operator=(unused_type const&)
constexpr unused_type const &operator=(unused_type&&) const
unused_type &operator=(unused_type&&)
template<typename T>
struct unwrap_reference<std::reference_wrapper<T>>

Public Types

typedef T type
template<typename T>
struct unwrap_reference<std::reference_wrapper<T> const>

Public Types

typedef T type
namespace hpx
namespace util

Functions

template<typename T>
unwrap_reference<T>::type &unwrap_ref(T &t)
template<typename T>
struct unwrap_reference

Public Types

typedef T type
template<typename T>
struct unwrap_reference<std::reference_wrapper<T>>

Public Types

typedef T type
template<typename T>
struct unwrap_reference<std::reference_wrapper<T> const>

Public Types

typedef T type
namespace hpx
namespace util
template<>
struct void_guard<void>

Public Functions

template<typename T>
void operator,(T const&) const