type_support

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

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

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

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

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

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

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

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

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

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

#include <hpx/type_support/unwrap_ref.hpp>

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

Public Types

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

Public Types

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

Public Types

typedef T type
template <typename T>
template<>
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>
template<>
struct unwrap_reference<boost::reference_wrapper<T>>

Public Types

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

Public Types

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

Public Types

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

Public Types

typedef T type

#include <hpx/type_support/lazy_conditional.hpp>

#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/unused.hpp>

Defines

HPX_UNUSED(x)
namespace hpx
namespace util

Variables

HPX_CONSTEXPR_OR_CONST unused_type hpx::util::unused = unused_type()
struct unused_type

Public Functions

HPX_HOST_DEVICE unused_type()
HPX_HOST_DEVICE unused_type(unused_type const&)
HPX_HOST_DEVICE unused_type(unused_type&&)
template <typename T>
HPX_HOST_DEVICE unused_type(T const&)
template <typename T>
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 &)
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 &)
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/decay.hpp>

#include <hpx/type_support/identity.hpp>

namespace hpx
namespace util
template <typename T>
struct identity

Public Types

typedef T type

#include <hpx/type_support/detected.hpp>

namespace hpx
namespace util

Typedefs

using hpx::util::is_detected = typedef typename detail::detector<nonesuch, void, Op, Args...>::value_t
using hpx::util::detected_t = typedef typename detail::detector<nonesuch, void, Op, Args...>::type
using hpx::util::detected_or = typedef detail::detector<Default, void, Op, Args...>
using hpx::util::detected_or_t = typedef typename detected_or<Default, Op, Args...>::type
using hpx::util::is_detected_exact = typedef std::is_same<Expected, detected_t<Op, Args...> >
using hpx::util::is_detected_convertible = typedef 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/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/void_guard.hpp>

namespace hpx
namespace util
template <>
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/lazy_enable_if.hpp>

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

Public Types

typedef T::type type