datastructures

#include <hpx/datastructures/any.hpp>

template<>
class basic_any<void, void, void, std::true_type>

Public Functions

constexpr basic_any()
basic_any(basic_any const &x)
basic_any(basic_any &&x)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value>::type>
basic_any(T &&x, typename std::enable_if<std::is_copy_constructible<typename std::decay<T>::type>::value>::type * = nullptr)
~basic_any()
basic_any &operator=(basic_any const &x)
basic_any &operator=(basic_any &&rhs)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type>
basic_any &operator=(T &&rhs)
basic_any &swap(basic_any &x)
std::type_info const &type() const
template<typename T>
T const &cast() const
bool has_value() const
void reset()
bool equal_to(basic_any const &rhs) const

Private Functions

basic_any &assign(basic_any const &x)

Private Members

detail::any::fxn_ptr_table<void, void, void, std::true_type> *table
void *object

Private Static Functions

template<typename T, typename ...Ts>
static void new_object(void *&object, std::true_type, Ts&&... ts)
template<typename T, typename ...Ts>
static void new_object(void *&object, std::false_type, Ts&&... ts)
template<typename Char>
class basic_any<void, void, Char, std::true_type>

Public Functions

constexpr basic_any()
basic_any(basic_any const &x)
basic_any(basic_any &&x)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value>::type>
basic_any(T &&x, typename std::enable_if<std::is_copy_constructible<typename std::decay<T>::type>::value>::type * = nullptr)
~basic_any()
basic_any &operator=(basic_any const &x)
basic_any &operator=(basic_any &&rhs)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type>
basic_any &operator=(T &&rhs)
basic_any &swap(basic_any &x)
std::type_info const &type() const
template<typename T>
T const &cast() const
bool has_value() const
void reset()
bool equal_to(basic_any const &rhs) const

Private Functions

basic_any &assign(basic_any const &x)

Private Members

detail::any::fxn_ptr_table<void, void, Char, std::true_type> *table
void *object

Private Static Functions

template<typename T, typename ...Ts>
static void new_object(void *&object, std::true_type, Ts&&... ts)
template<typename T, typename ...Ts>
static void new_object(void *&object, std::false_type, Ts&&... ts)
template<>
class basic_any<void, void, void, std::false_type>

Public Functions

constexpr basic_any()
basic_any(basic_any &&x)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value>::type>
basic_any(T &&x, typename std::enable_if<std::is_move_constructible<typename std::decay<T>::type>::value>::type * = nullptr)
basic_any(basic_any const &x)
basic_any &operator=(basic_any const &x)
~basic_any()
basic_any &operator=(basic_any &&rhs)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value && std::is_move_constructible<typename std::decay<T>::type>::value>::type>
basic_any &operator=(T &&rhs)
basic_any &swap(basic_any &x)
std::type_info const &type() const
template<typename T>
T const &cast() const
bool has_value() const
void reset()
bool equal_to(basic_any const &rhs) const

Private Members

detail::any::fxn_ptr_table<void, void, void, std::false_type> *table
void *object

Private Static Functions

template<typename T, typename ...Ts>
static void new_object(void *&object, std::true_type, Ts&&... ts)
template<typename T, typename ...Ts>
static void new_object(void *&object, std::false_type, Ts&&... ts)
template<typename Char>
class basic_any<void, void, Char, std::false_type>

Public Functions

constexpr basic_any()
basic_any(basic_any &&x)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value>::type>
basic_any(T &&x, typename std::enable_if<std::is_move_constructible<typename std::decay<T>::type>::value>::type * = nullptr)
basic_any(basic_any const &x)
basic_any &operator=(basic_any const &x)
~basic_any()
basic_any &operator=(basic_any &&rhs)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value && std::is_move_constructible<typename std::decay<T>::type>::value>::type>
basic_any &operator=(T &&rhs)
basic_any &swap(basic_any &x)
std::type_info const &type() const
template<typename T>
T const &cast() const
bool has_value() const
void reset()
bool equal_to(basic_any const &rhs) const

Private Members

detail::any::fxn_ptr_table<void, void, Char, std::false_type> *table
void *object

Private Static Functions

template<typename T, typename ...Ts>
static void new_object(void *&object, std::true_type, Ts&&... ts)
template<typename T, typename ...Ts>
static void new_object(void *&object, std::false_type, Ts&&... ts)
namespace hpx
namespace util

Typedefs

using any_nonser = basic_any<void, void, void, std::true_type>
using streamable_any_nonser = basic_any<void, void, char, std::true_type>
using streamable_wany_nonser = basic_any<void, void, wchar_t, std::true_type>
using unique_any_nonser = basic_any<void, void, void, std::false_type>
using streamable_unique_any_nonser = basic_any<void, void, char, std::false_type>
using streamable_unique_wany_nonser = basic_any<void, void, wchar_t, std::false_type>

Functions

template<typename IArch, typename OArch, typename Char, typename Copyable, typename Enable = typename std::enable_if<!std::is_void<Char>::value>::type>
std::basic_istream<Char> &operator>>(std::basic_istream<Char> &i, basic_any<IArch, OArch, Char, Copyable> &obj)
template<typename IArch, typename OArch, typename Char, typename Copyable, typename Enable = typename std::enable_if<!std::is_void<Char>::value>::type>
std::basic_ostream<Char> &operator<<(std::basic_ostream<Char> &o, basic_any<IArch, OArch, Char, Copyable> const &obj)
template<typename IArch, typename OArch, typename Char, typename Copyable>
void swap(basic_any<IArch, OArch, Char, Copyable> &lhs, basic_any<IArch, OArch, Char, Copyable> &rhs)
template<typename T, typename IArch, typename OArch, typename Char, typename Copyable>
T *any_cast(basic_any<IArch, OArch, Char, Copyable> *operand)
template<typename T, typename IArch, typename OArch, typename Char, typename Copyable>
T const *any_cast(basic_any<IArch, OArch, Char, Copyable> const *operand)
template<typename T, typename IArch, typename OArch, typename Char, typename Copyable>
T any_cast(basic_any<IArch, OArch, Char, Copyable> &operand)
template<typename T, typename IArch, typename OArch, typename Char, typename Copyable>
T const &any_cast(basic_any<IArch, OArch, Char, Copyable> const &operand)
template<typename T>
basic_any<void, void, void, std::true_type> make_any_nonser(T &&t)
template<typename T, typename Char>
basic_any<void, void, Char, std::true_type> make_streamable_any_nonser(T &&t)
template<typename T>
basic_any<void, void, void, std::false_type> make_unique_any_nonser(T &&t)
template<typename T, typename Char>
basic_any<void, void, Char, std::false_type> make_streamable_unique_any_nonser(T &&t)
struct bad_any_cast : public bad_cast

Public Functions

bad_any_cast(std::type_info const &src, std::type_info const &dest)
const char *what() const

Public Members

const char *from
const char *to
template<typename Char>
class basic_any<void, void, Char, std::false_type>

Public Functions

constexpr basic_any()
basic_any(basic_any &&x)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value>::type>
basic_any(T &&x, typename std::enable_if<std::is_move_constructible<typename std::decay<T>::type>::value>::type * = nullptr)
basic_any(basic_any const &x)
basic_any &operator=(basic_any const &x)
~basic_any()
basic_any &operator=(basic_any &&rhs)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value && std::is_move_constructible<typename std::decay<T>::type>::value>::type>
basic_any &operator=(T &&rhs)
basic_any &swap(basic_any &x)
std::type_info const &type() const
template<typename T>
T const &cast() const
bool has_value() const
void reset()
bool equal_to(basic_any const &rhs) const

Private Members

detail::any::fxn_ptr_table<void, void, Char, std::false_type> *table
void *object

Private Static Functions

template<typename T, typename ...Ts>
static void new_object(void *&object, std::true_type, Ts&&... ts)
template<typename T, typename ...Ts>
static void new_object(void *&object, std::false_type, Ts&&... ts)
template<typename Char>
class basic_any<void, void, Char, std::true_type>

Public Functions

constexpr basic_any()
basic_any(basic_any const &x)
basic_any(basic_any &&x)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value>::type>
basic_any(T &&x, typename std::enable_if<std::is_copy_constructible<typename std::decay<T>::type>::value>::type * = nullptr)
~basic_any()
basic_any &operator=(basic_any const &x)
basic_any &operator=(basic_any &&rhs)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type>
basic_any &operator=(T &&rhs)
basic_any &swap(basic_any &x)
std::type_info const &type() const
template<typename T>
T const &cast() const
bool has_value() const
void reset()
bool equal_to(basic_any const &rhs) const

Private Functions

basic_any &assign(basic_any const &x)

Private Members

detail::any::fxn_ptr_table<void, void, Char, std::true_type> *table
void *object

Private Static Functions

template<typename T, typename ...Ts>
static void new_object(void *&object, std::true_type, Ts&&... ts)
template<typename T, typename ...Ts>
static void new_object(void *&object, std::false_type, Ts&&... ts)
template<>
class basic_any<void, void, void, std::false_type>

Public Functions

constexpr basic_any()
basic_any(basic_any &&x)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value>::type>
basic_any(T &&x, typename std::enable_if<std::is_move_constructible<typename std::decay<T>::type>::value>::type * = nullptr)
basic_any(basic_any const &x)
basic_any &operator=(basic_any const &x)
~basic_any()
basic_any &operator=(basic_any &&rhs)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value && std::is_move_constructible<typename std::decay<T>::type>::value>::type>
basic_any &operator=(T &&rhs)
basic_any &swap(basic_any &x)
std::type_info const &type() const
template<typename T>
T const &cast() const
bool has_value() const
void reset()
bool equal_to(basic_any const &rhs) const

Private Members

detail::any::fxn_ptr_table<void, void, void, std::false_type> *table
void *object

Private Static Functions

template<typename T, typename ...Ts>
static void new_object(void *&object, std::true_type, Ts&&... ts)
template<typename T, typename ...Ts>
static void new_object(void *&object, std::false_type, Ts&&... ts)
template<>
class basic_any<void, void, void, std::true_type>

Public Functions

constexpr basic_any()
basic_any(basic_any const &x)
basic_any(basic_any &&x)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value>::type>
basic_any(T &&x, typename std::enable_if<std::is_copy_constructible<typename std::decay<T>::type>::value>::type * = nullptr)
~basic_any()
basic_any &operator=(basic_any const &x)
basic_any &operator=(basic_any &&rhs)
template<typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type>
basic_any &operator=(T &&rhs)
basic_any &swap(basic_any &x)
std::type_info const &type() const
template<typename T>
T const &cast() const
bool has_value() const
void reset()
bool equal_to(basic_any const &rhs) const

Private Functions

basic_any &assign(basic_any const &x)

Private Members

detail::any::fxn_ptr_table<void, void, void, std::true_type> *table
void *object

Private Static Functions

template<typename T, typename ...Ts>
static void new_object(void *&object, std::true_type, Ts&&... ts)
template<typename T, typename ...Ts>
static void new_object(void *&object, std::false_type, Ts&&... ts)

#include <hpx/datastructures/optional.hpp>

template<typename T>
struct hash<hpx::util::optional<T>>

Public Functions

constexpr std::size_t operator()(hpx::util::optional<T> const &arg) const
namespace hpx
namespace util

Functions

template<typename T>
constexpr bool operator==(optional<T> const &lhs, optional<T> const &rhs)
template<typename T>
constexpr bool operator!=(optional<T> const &lhs, optional<T> const &rhs)
template<typename T>
constexpr bool operator<(optional<T> const &lhs, optional<T> const &rhs)
template<typename T>
constexpr bool operator>=(optional<T> const &lhs, optional<T> const &rhs)
template<typename T>
constexpr bool operator>(optional<T> const &lhs, optional<T> const &rhs)
template<typename T>
constexpr bool operator<=(optional<T> const &lhs, optional<T> const &rhs)
template<typename T>
constexpr bool operator==(optional<T> const &opt, nullopt_t)
template<typename T>
constexpr bool operator==(nullopt_t, optional<T> const &opt)
template<typename T>
constexpr bool operator!=(optional<T> const &opt, nullopt_t)
template<typename T>
constexpr bool operator!=(nullopt_t, optional<T> const &opt)
template<typename T>
constexpr bool operator<(optional<T> const &opt, nullopt_t)
template<typename T>
constexpr bool operator<(nullopt_t, optional<T> const &opt)
template<typename T>
constexpr bool operator>=(optional<T> const &opt, nullopt_t)
template<typename T>
constexpr bool operator>=(nullopt_t, optional<T> const &opt)
template<typename T>
constexpr bool operator>(optional<T> const &opt, nullopt_t)
template<typename T>
constexpr bool operator>(nullopt_t, optional<T> const &opt)
template<typename T>
constexpr bool operator<=(optional<T> const &opt, nullopt_t)
template<typename T>
constexpr bool operator<=(nullopt_t, optional<T> const &opt)
template<typename T>
constexpr bool operator==(optional<T> const &opt, T const &value)
template<typename T>
constexpr bool operator==(T const &value, optional<T> const &opt)
template<typename T>
constexpr bool operator!=(optional<T> const &opt, T const &value)
template<typename T>
constexpr bool operator!=(T const &value, optional<T> const &opt)
template<typename T>
constexpr bool operator<(optional<T> const &opt, T const &value)
template<typename T>
constexpr bool operator<(T const &value, optional<T> const &opt)
template<typename T>
constexpr bool operator>=(optional<T> const &opt, T const &value)
template<typename T>
constexpr bool operator>=(T const &value, optional<T> const &opt)
template<typename T>
constexpr bool operator>(optional<T> const &opt, T const &value)
template<typename T>
constexpr bool operator>(T const &value, optional<T> const &opt)
template<typename T>
constexpr bool operator<=(optional<T> const &opt, T const &value)
template<typename T>
constexpr bool operator<=(T const &value, optional<T> const &opt)
template<typename T>
void swap(optional<T> &x, optional<T> &y)
template<typename T>
constexpr optional<typename std::decay<T>::type> make_optional(T &&v)
template<typename T, typename ...Ts>
constexpr optional<T> make_optional(Ts&&... ts)
template<typename T, typename U, typename ...Ts>
constexpr optional<T> make_optional(std::initializer_list<U> il, Ts&&... ts)

Variables

constexpr nullopt_t nullopt = {nullopt_t::init()}
class bad_optional_access : public logic_error

Public Functions

bad_optional_access(std::string const &what_arg)
bad_optional_access(char const *what_arg)
struct nullopt_t

Public Functions

constexpr nullopt_t(nullopt_t::init)
template<typename T>
class optional

Public Types

template<>
using value_type = T

Public Functions

constexpr optional()
constexpr optional(nullopt_t)
optional(optional const &other)
optional(optional &&other)
optional(T const &val)
optional(T &&val)
template<typename ...Ts>
optional(in_place_t, Ts&&... ts)
template<typename U, typename ...Ts>
optional(in_place_t, std::initializer_list<U> il, Ts&&... ts)
~optional()
optional &operator=(optional const &other)
optional &operator=(optional &&other)
optional &operator=(T const &other)
optional &operator=(T &&other)
optional &operator=(nullopt_t)
constexpr T const *operator->() const
T *operator->()
constexpr T const &operator*() const
T &operator*()
constexpr operator bool() const
constexpr bool has_value() const
T &value()
T const &value() const
template<typename U>
constexpr T value_or(U &&value) const
template<typename ...Ts>
void emplace(Ts&&... ts)
void swap(optional &other)
void reset()

Private Members

std::aligned_storage<sizeof(T), alignof(T)>::type storage_
bool empty_
namespace _optional_swap

Functions

template<typename T>
void check_swap()
namespace std
template<typename T>
struct hash<hpx::util::optional<T>>

Public Functions

constexpr std::size_t operator()(hpx::util::optional<T> const &arg) const

#include <hpx/datastructures/tuple.hpp>

template<typename T0, typename T1>
struct tuple_element<0, std::pair<T0, T1>>

Public Types

template<>
using type = T0

Public Static Functions

static constexpr HPX_HOST_DEVICE type& hpx::util::tuple_element::get(std::pair< T0, T1 > & tuple)
static constexpr HPX_HOST_DEVICE type const& hpx::util::tuple_element::get(std::pair< T0, T1 > const & tuple)
template<typename T0, typename T1>
struct tuple_element<1, std::pair<T0, T1>>

Public Types

template<>
using type = T1

Public Static Functions

static constexpr HPX_HOST_DEVICE type& hpx::util::tuple_element::get(std::pair< T0, T1 > & tuple)
static constexpr HPX_HOST_DEVICE type const& hpx::util::tuple_element::get(std::pair< T0, T1 > const & tuple)
template<std::size_t I, typename Type, std::size_t Size>
struct tuple_element<I, boost::array<Type, Size>>

Public Types

template<>
using type = Type

Public Static Functions

static constexpr HPX_HOST_DEVICE type& hpx::util::tuple_element::get(boost::array< Type, Size > & tuple)
static constexpr HPX_HOST_DEVICE type const& hpx::util::tuple_element::get(boost::array< Type, Size > const & tuple)
template<std::size_t I, typename Type, std::size_t Size>
struct tuple_element<I, std::array<Type, Size>>

Public Types

template<>
using type = Type

Public Static Functions

static constexpr HPX_HOST_DEVICE type& hpx::util::tuple_element::get(std::array< Type, Size > & tuple)
static constexpr HPX_HOST_DEVICE type const& hpx::util::tuple_element::get(std::array< Type, Size > const & tuple)
namespace hpx
namespace util

Functions

template<typename... Ts>constexpr HPX_HOST_DEVICE tuple<typename decay_unwrap<Ts>::type...> hpx::util::make_tuple(Ts &&... vs)
template<typename... Ts>HPX_HOST_DEVICE tuple<Ts&&...> hpx::util::forward_as_tuple(Ts &&... vs)
template<typename... Ts>HPX_HOST_DEVICE tuple<Ts&...> hpx::util::tie(Ts &... vs)
template<typename... Tuples>constexpr HPX_HOST_DEVICE auto hpx::util::tuple_cat(Tuples &&... tuples)
template<typename... Ts, typename... Us>constexpr HPX_HOST_DEVICE std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type hpx::util::operator==(tuple < Ts... > const & t, tuple < Us... > const & u)
template<typename... Ts, typename... Us>constexpr HPX_HOST_DEVICE std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type hpx::util::operator!=(tuple < Ts... > const & t, tuple < Us... > const & u)
template<typename... Ts, typename... Us>constexpr HPX_HOST_DEVICE std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type hpx::util::operator<(tuple < Ts... > const & t, tuple < Us... > const & u)
template<typename... Ts, typename... Us>constexpr HPX_HOST_DEVICE std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type hpx::util::operator>(tuple < Ts... > const & t, tuple < Us... > const & u)
template<typename... Ts, typename... Us>constexpr HPX_HOST_DEVICE std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type hpx::util::operator<=(tuple < Ts... > const & t, tuple < Us... > const & u)
template<typename... Ts, typename... Us>constexpr HPX_HOST_DEVICE std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type hpx::util::operator>=(tuple < Ts... > const & t, tuple < Us... > const & u)
template<typename... Ts>HPX_HOST_DEVICE void hpx::util::swap(tuple < Ts... > & x, tuple < Ts... > & y)

Variables

detail::ignore_type const ignore = {}
template<typename ...Ts>
class tuple

Public Functions

template<typename Dependent = void, typename Enable = typename std::enable_if<util::all_of<std::is_constructible<Ts>...>::value, Dependent>::type>
constexpr HPX_HOST_DEVICE tuple()
constexpr HPX_HOST_DEVICE tuple(Ts const&... vs)
template<typename U, typename ...Us, typename Enable = typename std::enable_if<!std::is_same<tuple, typename std::decay<U>::type>::value || util::pack<Us...>::size != 0>::type, typename EnableCompatible = typename std::enable_if<detail::are_tuples_compatible<tuple, tuple<U, Us...>>::value>::type>
constexpr HPX_HOST_DEVICE tuple(U &&v, Us&&... vs)
tuple(tuple const&)
tuple(tuple&&)
template<typename UTuple, typename Enable = typename std::enable_if<!std::is_same<tuple, typename std::decay<UTuple>::type>::value>::type, typename EnableCompatible = typename std::enable_if<detail::are_tuples_compatible<tuple, UTuple>::value>::type>
constexpr HPX_HOST_DEVICE tuple(UTuple &&other)
HPX_HOST_DEVICE tuple& hpx::util::tuple::operator=(tuple const & other)
HPX_HOST_DEVICE tuple& hpx::util::tuple::operator=(tuple && other)
template<typename UTuple>HPX_HOST_DEVICE tuple& hpx::util::tuple::operator=(UTuple && other)
HPX_HOST_DEVICE void hpx::util::tuple::swap(tuple & other)
template<std::size_t I>HPX_HOST_DEVICE util::at_index<I, Ts...>::type& hpx::util::tuple::get()
template<std::size_t I>HPX_HOST_DEVICE util::at_index<I, Ts...>::type const& hpx::util::tuple::get() const

Private Types

template<>
using index_pack = typename util::make_index_pack<sizeof...(Ts)>::type

Private Functions

template<std::size_t... Is, typename UTuple>
constexpr HPX_HOST_DEVICE tuple(util::index_pack<Is...>, UTuple &&other)
template<std::size_t... Is>HPX_HOST_DEVICE void hpx::util::tuple::assign_(util::index_pack< Is... >, tuple const & other)
template<std::size_t... Is>HPX_HOST_DEVICE void hpx::util::tuple::assign_(util::index_pack< Is... >, tuple && other)
template<std::size_t... Is, typename UTuple>HPX_HOST_DEVICE void hpx::util::tuple::assign_(util::index_pack< Is... >, UTuple && other)
template<std::size_t... Is>HPX_HOST_DEVICE void hpx::util::tuple::swap_(util::index_pack< Is... >, tuple & other)

Private Members

util::member_pack_for<Ts...> _members
template<>
class tuple<>

Public Functions

constexpr HPX_HOST_DEVICE tuple()
constexpr HPX_HOST_DEVICE tuple(tuple const&)
constexpr HPX_HOST_DEVICE tuple(tuple&&)
HPX_HOST_DEVICE tuple& hpx::util::tuple::operator=(tuple const &)
HPX_HOST_DEVICE tuple& hpx::util::tuple::operator=(tuple &&)
HPX_HOST_DEVICE void hpx::util::tuple::swap(tuple &)
template<typename T0, typename T1>
struct tuple_element<0, std::pair<T0, T1>>

Public Types

template<>
using type = T0

Public Static Functions

static constexpr HPX_HOST_DEVICE type& hpx::util::tuple_element::get(std::pair< T0, T1 > & tuple)
static constexpr HPX_HOST_DEVICE type const& hpx::util::tuple_element::get(std::pair< T0, T1 > const & tuple)
template<typename T0, typename T1>
struct tuple_element<1, std::pair<T0, T1>>

Public Types

template<>
using type = T1

Public Static Functions

static constexpr HPX_HOST_DEVICE type& hpx::util::tuple_element::get(std::pair< T0, T1 > & tuple)
static constexpr HPX_HOST_DEVICE type const& hpx::util::tuple_element::get(std::pair< T0, T1 > const & tuple)
template<std::size_t I, typename Type, std::size_t Size>
struct tuple_element<I, boost::array<Type, Size>>

Public Types

template<>
using type = Type

Public Static Functions

static constexpr HPX_HOST_DEVICE type& hpx::util::tuple_element::get(boost::array< Type, Size > & tuple)
static constexpr HPX_HOST_DEVICE type const& hpx::util::tuple_element::get(boost::array< Type, Size > const & tuple)
template<std::size_t I, typename Type, std::size_t Size>
struct tuple_element<I, std::array<Type, Size>>

Public Types

template<>
using type = Type

Public Static Functions

static constexpr HPX_HOST_DEVICE type& hpx::util::tuple_element::get(std::array< Type, Size > & tuple)
static constexpr HPX_HOST_DEVICE type const& hpx::util::tuple_element::get(std::array< Type, Size > const & tuple)
template<std::size_t I, typename ...Ts>
struct tuple_element<I, tuple<Ts...>>

Public Types

template<>
using type = typename util::at_index::type

Public Static Functions

static constexpr HPX_HOST_DEVICE type& hpx::util::tuple_element::get(tuple < Ts... > & tuple)
static constexpr HPX_HOST_DEVICE type const& hpx::util::tuple_element::get(tuple < Ts... > const & tuple)
template<class T>
struct tuple_size

Subclassed by hpx::util::tuple_size< const T >, hpx::util::tuple_size< const volatile T >, hpx::util::tuple_size< volatile T >

namespace adl_barrier

Functions

template<std::size_t I, typename Tuple>constexpr HPX_HOST_DEVICE tuple_element< I, Tuple >::type & hpx::util::adl_barrier::get(Tuple & t)
template<std::size_t I, typename Tuple>constexpr HPX_HOST_DEVICE tuple_element< I, Tuple >::type const & hpx::util::adl_barrier::get(Tuple const & t)
template<std::size_t I, typename Tuple>constexpr HPX_HOST_DEVICE tuple_element< I, Tuple >::type && hpx::util::adl_barrier::get(Tuple && t)
template<std::size_t I, typename Tuple>constexpr HPX_HOST_DEVICE tuple_element< I, Tuple >::type const && hpx::util::adl_barrier::get(Tuple const && t)

#include <hpx/datastructures/member_pack.hpp>

template<std::size_t... Is, typename ...Ts>
struct member_pack<util::index_pack<Is...>, Ts...> : public hpx::util::detail::member_leaf<Is, Ts>

Public Functions

member_pack()
template<typename ...Us>
constexpr member_pack(std::piecewise_construct_t, Us&&... us)
template<std::size_t I>
decltype(auto) constexpr get() &
template<std::size_t I>
decltype(auto) constexpr get() const &
template<std::size_t I>
decltype(auto) constexpr get() &&
template<std::size_t I>
decltype(auto) constexpr get() const &&
namespace hpx
namespace serialization

Functions

template<typename Archive, std::size_t... Is, typename ...Ts>
void serialize(Archive &ar, hpx::util::member_pack<util::index_pack<Is...>, Ts...> &mp, unsigned int const = 0)
namespace util

Typedefs

using member_pack_for = member_pack<typename util::make_index_pack<sizeof...(Ts)>::type, Ts...>

Variables

template<typename Is, typename ...Ts>
struct HPX_EMPTY_BASES member_pack
template<std::size_t... Is, typename ...Ts>
struct member_pack<util::index_pack<Is...>, Ts...> : public hpx::util::detail::member_leaf<Is, Ts>

Public Functions

member_pack()
template<typename ...Us>
constexpr member_pack(std::piecewise_construct_t, Us&&... us)
template<std::size_t I>
decltype(auto) constexpr get() &
template<std::size_t I>
decltype(auto) constexpr get() const &
template<std::size_t I>
decltype(auto) constexpr get() &&
template<std::size_t I>
decltype(auto) constexpr get() const &&

#include <hpx/datastructures/traits/is_tuple_like.hpp>

namespace hpx
namespace traits
template<typename T>
struct is_tuple_like : public hpx::traits::detail::is_tuple_like_impl<std::remove_cv<T>::type>
#include <is_tuple_like.hpp>

Deduces to a true type if the given parameter T has a specific tuple like size.

#include <hpx/datastructures/traits/supports_streaming_with_any.hpp>

#include <compatibility/hpx/traits/is_tuple_like.hpp>

#include <compatibility/hpx/traits/supports_streaming_with_any.hpp>

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

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

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