type_support

#include <hpx/type_support/static.hpp>

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

#include <hpx/type_support/unwrap_ref.hpp>

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

Public Types

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

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

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<boost::reference_wrapper<T>>

Public Types

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

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

#include <hpx/type_support/always_void.hpp>

namespace hpx
namespace util
template<typename ...T>
struct always_void

Public Types

typedef void type

#include <hpx/type_support/void_guard.hpp>

namespace hpx
namespace util
template<>
struct void_guard<void>

Public Functions

template<typename T>HPX_HOST_DEVICE void hpx::util::void_guard::operator,(T const &) const

#include <hpx/type_support/decay.hpp>

#include <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

Public Functions

nonesuch()
~nonesuch()
nonesuch(nonesuch const&)
void operator=(nonesuch const&)

#include <hpx/type_support/lazy_conditional.hpp>

#include <hpx/type_support/pack.hpp>

namespace hpx
namespace util

Typedefs

using index_pack = pack_c<std::size_t, Is...>
template<typename ...Ts>
struct pack

Public Types

typedef pack type

Public Static Attributes

const 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

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

#include <hpx/type_support/identity.hpp>

namespace hpx
namespace util
template<typename T>
struct identity

Public Types

typedef T type

#include <hpx/type_support/unused.hpp>

Defines

HPX_UNUSED(x)
namespace hpx
namespace util

Variables

constexpr unused_type unused = unused_type()
struct unused_type

Public Functions

constexpr HPX_HOST_DEVICE unused_type()
constexpr HPX_HOST_DEVICE unused_type(unused_type const&)
constexpr HPX_HOST_DEVICE unused_type(unused_type&&)
template<typename T>
constexpr HPX_HOST_DEVICE unused_type(T const&)
template<typename T>constexpr HPX_HOST_DEVICE unused_type const& hpx::util::unused_type::operator=(T const &) const
template<typename T>HPX_HOST_DEVICE unused_type& hpx::util::unused_type::operator=(T const &)
constexpr HPX_HOST_DEVICE unused_type const& hpx::util::unused_type::operator=(unused_type const &) const
HPX_HOST_DEVICE unused_type& hpx::util::unused_type::operator=(unused_type const &)
constexpr HPX_HOST_DEVICE unused_type const& hpx::util::unused_type::operator=(unused_type &&) const
HPX_HOST_DEVICE unused_type& hpx::util::unused_type::operator=(unused_type &&)

#include <hpx/type_support/lazy_enable_if.hpp>

namespace hpx
namespace util
template<typename T>
struct lazy_enable_if<true, T>

Public Types

typedef T::type type

#include <compatibility/hpx/util/static.hpp>

#include <compatibility/hpx/util/unwrap_ref.hpp>

#include <compatibility/hpx/util/always_void.hpp>

#include <compatibility/hpx/util/void_guard.hpp>

#include <compatibility/hpx/util/decay.hpp>

#include <compatibility/hpx/util/detected.hpp>

#include <compatibility/hpx/util/lazy_conditional.hpp>

#include <compatibility/hpx/util/identity.hpp>

#include <compatibility/hpx/util/unused.hpp>

#include <compatibility/hpx/util/lazy_enable_if.hpp>