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.

Header hpx/type_support/always_void.hpp

namespace hpx

namespace util

template<typename ...T>
struct always_void

#include <always_void.hpp>

Public Types

typedef void type

Header hpx/type_support/decay.hpp

Header hpx/type_support/detected.hpp

namespace hpx

namespace util

Typedefs

using is_detected = typename detail::detector<nonesuch, void, Op, Args...>::value_t

using detected_t = typename detail::detector<nonesuch, void, Op, Args...>::type

using detected_or = detail::detector<Default, void, Op, Args...>

using detected_or_t = typename detected_or<Default, Op, Args...>::type

using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>

using is_detected_convertible = std::is_convertible<detected_t<Op, Args...>, To>

struct nonesuch

#include <detected.hpp>

Public Functions

nonesuch()

~nonesuch()

nonesuch(nonesuch const&)

void operator=(nonesuch const&)

Header hpx/type_support/equality.hpp

Header hpx/type_support/identity.hpp

namespace hpx

namespace util

template<typename T>
struct identity

#include <identity.hpp>

Public Types

typedef T type

Header hpx/type_support/lazy_conditional.hpp

Header hpx/type_support/lazy_enable_if.hpp

namespace hpx

namespace util

template<typename T>
struct lazy_enable_if<true, T>

#include <lazy_enable_if.hpp>

Public Types

typedef T::type type

Header hpx/type_support/pack.hpp

namespace hpx

namespace util

Typedefs

using index_pack = pack_c<std::size_t, Is...>

template<typename ...Ts>
struct pack

#include <pack.hpp>

Public Types

typedef pack type

Public Static Attributes

const std::size_t size = sizeof...(Ts)

template<typename T, T... Vs>
struct pack_c

#include <pack.hpp>

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

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

Header hpx/type_support/static.hpp

Defines

HPX_EXPORT_STATIC_

namespace hpx

namespace util

template<typename T, typename Tag = T>
struct static_

#include <static.hpp>

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()

Header hpx/type_support/unused.hpp

Defines

HPX_UNUSED(x)

HPX_MAYBE_UNUSED

namespace hpx

namespace util

Variables

constexpr unused_type unused = unused_type()

struct unused_type

#include <unused.hpp>

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&&)

Header hpx/type_support/unwrap_ref.hpp

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

#include <unwrap_ref.hpp>

Public Types

typedef T type

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

#include <unwrap_ref.hpp>

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

#include <unwrap_ref.hpp>

Public Types

typedef T type

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

#include <unwrap_ref.hpp>

Public Types

typedef T type

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

#include <unwrap_ref.hpp>

Public Types

typedef T type

Header hpx/type_support/void_guard.hpp

namespace hpx

namespace util

template<>
struct void_guard<void>

#include <void_guard.hpp>

Public Functions

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