datastructures¶

See Public API for a list of names and headers that are part of the public HPX API.

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

template<typename T, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, Ts&&... ts)¶

template<typename T, typename U, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, std::initializer_list il, Ts&&... ts)¶

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

template<typename T, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, Ts&&... ts)

template<typename T, typename U, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, std::initializer_list il, Ts&&... ts)

~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)¶

template<typename T, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, Ts&&... ts)

template<typename T, typename U, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, std::initializer_list il, Ts&&... ts)

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)

template<typename T, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, Ts&&... ts)

template<typename T, typename U, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, std::initializer_list il, Ts&&... ts)

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

Typedefs

using any_nonser = util::basic_any<void, void, void, std::true_type>¶

using unique_any_nonser = util::basic_any<void, void, void, std::false_type>¶

Functions

template<typename T, typename ...Ts> util::basic_any<void, void, void, std::true_type> make_any_nonser(Ts&&... ts)¶

template<typename T, typename U, typename ...Ts> util::basic_any<void, void, void, std::true_type> make_any_nonser(std::initializer_list il, Ts&&... ts)¶

template<typename T, typename ...Ts> util::basic_any<void, void, void, std::false_type> make_unique_any_nonser(Ts&&... ts)¶

template<typename T, typename U, typename ...Ts> util::basic_any<void, void, void, std::false_type> make_unique_any_nonser(std::initializer_list il, Ts&&... ts)¶

template<typename T> util::basic_any<void, void, void, std::true_type> make_any_nonser(T &&t)¶

template<typename T> util::basic_any<void, void, void, std::false_type> make_unique_any_nonser(T &&t)¶

template<typename T, typename IArch, typename OArch, typename Char, typename Copyable> T *any_cast(util::basic_any<IArch, OArch, Char, Copyable> *operand)¶

template<typename T, typename IArch, typename OArch, typename Char, typename Copyable> T const *any_cast(util::basic_any<IArch, OArch, Char, Copyable> const *operand)¶

template<typename T, typename IArch, typename OArch, typename Char, typename Copyable> T any_cast(util::basic_any<IArch, OArch, Char, Copyable> &operand)¶

template<typename T, typename IArch, typename OArch, typename Char, typename Copyable> T const &any_cast(util::basic_any<IArch, OArch, Char, Copyable> const &operand)¶

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¶

namespace util

Typedefs

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 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 Char, typename ...Ts> basic_any<void, void, Char, std::true_type> make_streamable_any_nonser(Ts&&... ts)¶

template<typename T, typename Char, typename U, typename ...Ts> basic_any<void, void, Char, std::true_type> make_streamable_any_nonser(std::initializer_list il, Ts&&... ts)¶

template<typename T, typename Char, typename ...Ts> basic_any<void, void, Char, std::false_type> make_streamable_unique_any_nonser(Ts&&... ts)¶

template<typename T, typename Char, typename U, typename ...Ts> basic_any<void, void, Char, std::false_type> make_streamable_unique_any_nonser(std::initializer_list il, Ts&&... ts)¶

template<typename T, typename Char> basic_any<void, void, Char, std::true_type> make_streamable_any_nonser(T &&t)¶

template<typename T, typename Char> basic_any<void, void, Char, std::false_type> make_streamable_unique_any_nonser(T &&t)¶

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)

template<typename T, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, Ts&&... ts)

template<typename T, typename U, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, std::initializer_list il, Ts&&... ts)

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)

template<typename T, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, Ts&&... ts)

template<typename T, typename U, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, std::initializer_list il, Ts&&... ts)

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

template<typename T, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, Ts&&... ts)

template<typename T, typename U, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, std::initializer_list il, Ts&&... ts)

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)

template<typename T, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, Ts&&... ts)

template<typename T, typename U, typename ...Ts, typename Enable = typename std::enable_if<std::is_constructible<typename std::decay<T>::type, Ts...>::value && std::is_copy_constructible<typename std::decay<T>::type>::value>::type> basic_any(std::in_place_type_t<T>, std::initializer_list il, Ts&&... ts)

~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<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> constexpr decltype(auto) get() &¶

template<std::size_t I> constexpr decltype(auto) get() const &¶

template<std::size_t I> constexpr decltype(auto) get() &&¶

template<std::size_t I> constexpr decltype(auto) 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

template<typename ...Ts> using member_pack_for = member_pack<util::make_index_pack_t<sizeof...(Ts)>, 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> constexpr decltype(auto) get() &

template<std::size_t I> constexpr decltype(auto) get() const &

template<std::size_t I> constexpr decltype(auto) get() &&

template<std::size_t I> constexpr decltype(auto) get() const &&

namespace hpx

namespace util

Typedefs

typedef hpx::bad_optional_access instead¶

Functions

template<typename T>hpx::util::HPX_DEPRECATED_V(1, 8, "hpx::util::make_optional is deprecated. Please use hpx::optional " "instead.") const&&

template<typename T, typename... Ts>hpx::util::HPX_DEPRECATED_V(1, 8, "hpx::util::make_optional is deprecated. Please use hpx::optional " "instead.") const&&

template<typename T, typename U, typename... Ts>hpx::util::HPX_DEPRECATED_V(1, 8, "hpx::util::make_optional is deprecated. Please use hpx::optional " "instead.") const

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

Public Types

template<> using type = T0¶

Public Static Functions

static constexpr type &get(std::pair<T0, T1> &tuple)¶

static constexpr type const &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 type &get(std::pair<T0, T1> &tuple)

static constexpr type const &get(std::pair<T0, T1> 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 type &get(std::array<Type, Size> &tuple)¶

static constexpr type const &get(std::array<Type, Size> const &tuple)¶

namespace hpx

Functions

template<typename ...Ts> constexpr tuple<util::decay_unwrap_t<Ts>...> make_tuple(Ts&&... ts)¶

template<typename ...Ts> constexpr tuple<Ts&&...> forward_as_tuple(Ts&&... ts)¶

template<typename ...Ts> constexpr tuple<Ts&...> tie(Ts&... ts)¶

template<typename ...Tuples> constexpr auto tuple_cat(Tuples&&... tuples)¶

HPX_FORWARD(Tuples, tuples)¶

template<typename ...Ts, typename ...Us> constexpr std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type operator==(tuple<Ts...> const &t, tuple<Us...> const &u)¶

template<typename ...Ts, typename ...Us> constexpr std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type operator!=(tuple<Ts...> const &t, tuple<Us...> const &u)¶

template<typename ...Ts, typename ...Us> constexpr std::enable_if_t<sizeof...(Ts) == sizeof...(Us), bool> operator<(tuple<Ts...> const &t, tuple<Us...> const &u)¶

template<typename ...Ts, typename ...Us> constexpr std::enable_if_t<sizeof...(Ts) == sizeof...(Us), bool> operator>(tuple<Ts...> const &t, tuple<Us...> const &u)¶

template<typename ...Ts, typename ...Us> constexpr std::enable_if_t<sizeof...(Ts) == sizeof...(Us), bool> operator<=(tuple<Ts...> const &t, tuple<Us...> const &u)¶

template<typename ...Ts, typename ...Us> constexpr std::enable_if_t<sizeof...(Ts) == sizeof...(Us), bool> operator>=(tuple<Ts...> const &t, tuple<Us...> const &u)¶

template<typename ...Ts> void swap(tuple<Ts...> &x, tuple<Ts...> &y)¶

Variables

constexpr hpx::detail::ignore_type ignore = {}¶

template<typename ...Ts> class tuple¶

Public Functions

template<typename Dependent = void, typename Enable = std::enable_if_t<util::all_of_v<std::is_constructible<Ts>...>, Dependent>> constexpr tuple()¶

constexpr tuple(Ts const&... vs)¶

template<typename U, typename ...Us, typename Enable = std::enable_if_t<!std::is_same_v<tuple, std::decay_t> || util::pack<Us...>::size != 0>, typename EnableCompatible = std::enable_if_t<hpx::detail::are_tuples_compatible<tuple, tuple<U, Us...>>::value>> constexpr tuple(U &&v, Us&&... vs)¶

tuple(tuple const&)¶

tuple(tuple&&)¶

template<typename UTuple, typename Enable = std::enable_if_t<!std::is_same<tuple, std::decay_t<UTuple>>::value>, typename EnableCompatible = std::enable_if_t<hpx::detail::are_tuples_compatible<tuple, UTuple>::value>> constexpr tuple(UTuple &&other)¶

tuple &operator=(tuple const &other)¶

tuple &operator=(tuple &&other)¶

template<typename UTuple> tuple &operator=(UTuple &&other)¶

void swap(tuple &other)¶

template<std::size_t I> util::at_index<I, Ts...>::type &get()¶

template<std::size_t I> util::at_index<I, Ts...>::type const &get() const¶

Private Types

template<> using index_pack = util::make_index_pack_t<sizeof...(Ts)>¶

Private Functions

template<std::size_t... Is, typename UTuple> constexpr tuple(util::index_pack<Is...>, UTuple &&other)¶

template<std::size_t... Is> void assign_(util::index_pack<Is...>, tuple const &other)¶

template<std::size_t... Is> void assign_(util::index_pack<Is...>, tuple &&other)¶

template<std::size_t... Is, typename UTuple> void assign_(util::index_pack<Is...>, UTuple &&other)¶

template<std::size_t... Is> void swap_(util::index_pack<Is...>, tuple &other)¶

Private Members

util::member_pack_for<Ts...> _members¶

template<> class tuple<>¶

Public Functions

constexpr tuple()¶

constexpr tuple(tuple const&)

constexpr tuple(tuple&&)

tuple &operator=(tuple const&)

tuple &operator=(tuple&&)

constexpr void 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 type &get(std::pair<T0, T1> &tuple)

static constexpr type const &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 type &get(std::pair<T0, T1> &tuple)

static constexpr type const &get(std::pair<T0, T1> 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 type &get(std::array<Type, Size> &tuple)

static constexpr type const &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 type &get(hpx::tuple<Ts...> &tuple)¶

static constexpr type const &get(hpx::tuple<Ts...> const &tuple)¶

template<class T> struct tuple_size¶: Subclassed by hpx::tuple_size< const T >, hpx::tuple_size< const volatile T >, hpx::tuple_size< volatile T >

namespace adl_barrier¶

Functions

template<std::size_t I, typename Tuple, typename Enable = std::void_t<typename hpx::tuple_element<I, Tuple>::type>> constexpr hpx::tuple_element<I, Tuple>::type &get(Tuple &t)¶

template<std::size_t I, typename Tuple, typename Enable = std::void_t<typename hpx::tuple_element<I, Tuple>::type>> constexpr hpx::tuple_element<I, Tuple>::type const &get(Tuple const &t)¶

template<std::size_t I, typename Tuple, typename Enable = std::void_t<typename hpx::tuple_element<I, typename std::decay<Tuple>::type>::type>> constexpr hpx::tuple_element<I, Tuple>::type &&get(Tuple &&t)¶

template<std::size_t I, typename Tuple, typename Enable = std::void_t<typename hpx::tuple_element<I, Tuple>::type>> constexpr hpx::tuple_element<I, Tuple>::type const &&get(Tuple const &&t)¶

template<std::size_t I, typename Tuple, typename Enable> constexpr tuple_element<I, Tuple>::type &get(Tuple &t)¶

template<std::size_t I, typename Tuple, typename Enable> constexpr tuple_element<I, Tuple>::type const &get(Tuple const &t)¶

template<std::size_t I, typename Tuple, typename Enable> constexpr tuple_element<I, Tuple>::type &&get(Tuple &&t)¶

template<std::size_t I, typename Tuple, typename Enable> constexpr tuple_element<I, Tuple>::type const &&get(Tuple const &&t)¶

namespace std_adl_barrier¶

Functions

template<std::size_t I, typename ...Ts> constexpr hpx::tuple_element<I, hpx::tuple<Ts...>>::type &get(hpx::tuple<Ts...> &t)¶

template<std::size_t I, typename ...Ts> constexpr hpx::tuple_element<I, hpx::tuple<Ts...>>::type const &get(hpx::tuple<Ts...> const &t)¶

template<std::size_t I, typename ...Ts> constexpr hpx::tuple_element<I, hpx::tuple<Ts...>>::type &&get(hpx::tuple<Ts...> &&t)¶

template<std::size_t I, typename ...Ts> constexpr hpx::tuple_element<I, hpx::tuple<Ts...>>::type const &&get(hpx::tuple<Ts...> const &&t)¶

template<std::size_t I, typename ...Ts> constexpr tuple_element<I, tuple<Ts...>>::type &get(tuple<Ts...> &t)¶

template<std::size_t I, typename ...Ts> constexpr tuple_element<I, tuple<Ts...>>::type const &get(tuple<Ts...> const &t)¶

template<std::size_t I, typename ...Ts> constexpr tuple_element<I, tuple<Ts...>>::type &&get(tuple<Ts...> &&t)¶

template<std::size_t I, typename ...Ts> constexpr tuple_element<I, tuple<Ts...>>::type const &&get(tuple<Ts...> const &&t)¶

namespace hpx

namespace adl_barrier

Functions

template<std::size_t I, typename ...Ts> constexpr util::at_index<I, Ts...>::type &get(std::variant<Ts...> &var)¶

template<std::size_t I, typename ...Ts> constexpr util::at_index<I, Ts...>::type const &get(std::variant<Ts...> const &var)¶

template<std::size_t I, typename ...Ts> constexpr util::at_index<I, Ts...>::type &&get(std::variant<Ts...> &&var)¶

template<std::size_t I, typename ...Ts> constexpr util::at_index<I, Ts...>::type const &&get(std::variant<Ts...> const &&var)¶

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.