datastructures

The contents of this module can be included with the header hpx/modules/datastructures.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/datastructures.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/datastructures/any.hpp

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

#include <any.hpp>

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>

#include <any.hpp>

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>

#include <any.hpp>

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>

#include <any.hpp>

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

#include <any.hpp>

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>

#include <any.hpp>

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>

#include <any.hpp>

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>

#include <any.hpp>

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>

#include <any.hpp>

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)

Header 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>

#include <member_pack.hpp>

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>

#include <member_pack.hpp>

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

Header hpx/datastructures/optional.hpp

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

#include <optional.hpp>

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

#include <optional.hpp>

Public Functions

bad_optional_access(std::string const &what_arg)

bad_optional_access(char const *what_arg)

struct nullopt_t

#include <optional.hpp>

Public Functions

constexpr nullopt_t(nullopt_t::init)

template<typename T>
class optional

#include <optional.hpp>

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

#include <optional.hpp>

Public Functions

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

Header hpx/datastructures/tagged.hpp

Defines

HPX_DEFINE_TAG_SPECIFIER(NAME)

namespace hpx

namespace util

template<typename Base, typename ...Tags>
struct tagged : public Base, public detail::getters::collect<tagged<Base, Tags...>, Tags...>

#include <tagged.hpp>

Public Functions

template<typename ...Ts>
tagged(Ts&&... ts)

template<typename Other>
tagged(tagged<Other, Tags...> &&rhs)

template<typename Other>
tagged(tagged<Other, Tags...> const &rhs)

template<typename Other>
tagged &operator=(tagged<Other, Tags...> &&rhs)

template<typename Other>
tagged &operator=(tagged<Other, Tags...> const &rhs)

template<typename U>
tagged &operator=(U &&u)

void swap(tagged &other)

Friends

void swap(tagged &x, tagged &y)

Header hpx/datastructures/tagged_pair.hpp

namespace hpx

namespace util

Functions

template<typename Tag1, typename Tag2, typename T1, typename T2>
constexpr tagged_pair<Tag1(typename decay<T1>::type), Tag2(typename decay<T2>::type)> make_tagged_pair(std::pair<T1, T2> &&p)

template<typename Tag1, typename Tag2, typename T1, typename T2>
constexpr tagged_pair<Tag1(typename decay<T1>::type), Tag2(typename decay<T2>::type)> make_tagged_pair(std::pair<T1, T2> const &p)

template<typename Tag1, typename Tag2, typename ...Ts>
constexpr tagged_pair<Tag1(typename tuple_element<0, tuple<Ts...>>::type), Tag2(typename tuple_element<1, tuple<Ts...>>::type)> make_tagged_pair(tuple<Ts...> &&p)

template<typename Tag1, typename Tag2, typename ...Ts>
constexpr tagged_pair<Tag1(typename tuple_element<0, tuple<Ts...>>::type), Tag2(typename tuple_element<1, tuple<Ts...>>::type)> make_tagged_pair(tuple<Ts...> const &p)

template<typename Tag1, typename Tag2, typename T1, typename T2>
constexpr tagged_pair<Tag1(typename decay<T1>::type), Tag2(typename decay<T2>::type)> make_tagged_pair(T1 &&t1, T2 &&t2)

template<typename F, typename S>
struct tagged_pair : public hpx::util::tagged<std::pair<detail::tag_elem<F>::type, detail::tag_elem<S>::type>, detail::tag_spec<F>::type, detail::tag_spec<S>::type>

#include <tagged_pair.hpp>

Public Types

typedef tagged<std::pair<typename detail::tag_elem<F>::type, typename detail::tag_elem<S>::type>, typename detail::tag_spec<F>::type, typename detail::tag_spec<S>::type> base_type

Public Functions

template<typename ...Ts>
tagged_pair(Ts&&... ts)

Header hpx/datastructures/tagged_tuple.hpp

namespace hpx

namespace util

Functions

template<typename ...Tags, typename ...Ts>
constexpr tagged_tuple<typename detail::tagged_type<Tags, Ts>::type...> make_tagged_tuple(Ts&&... ts)

template<typename ...Tags, typename ...Ts>
constexpr tagged_tuple<typename detail::tagged_type<Tags, Ts>::type...> make_tagged_tuple(tuple<Ts...> &&t)

template<typename ...Ts>
struct tagged_tuple : public hpx::util::tagged<tuple<detail::tag_elem<Ts>::type...>, detail::tag_spec<Ts>::type...>

#include <tagged_tuple.hpp>

Public Types

typedef tagged<tuple<typename detail::tag_elem<Ts>::type...>, typename detail::tag_spec<Ts>::type...> base_type

Public Functions

template<typename ...Ts_>
tagged_tuple(Ts_&&... ts)

Header 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.

Header hpx/datastructures/traits/supports_streaming_with_any.hpp

Header hpx/datastructures/tuple.hpp

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

#include <tuple.hpp>

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

#include <tuple.hpp>

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

#include <tuple.hpp>

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

namespace util

Functions

template<typename ...Ts>
constexpr tuple<typename decay_unwrap<Ts>::type...> make_tuple(Ts&&... vs)

template<typename ...Ts>
tuple<Ts&&...> forward_as_tuple(Ts&&... vs)

template<typename ...Ts>
tuple<Ts&...> tie(Ts&... vs)

template<typename ...Tuples>
constexpr auto tuple_cat(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<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<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>
void swap(tuple<Ts...> &x, tuple<Ts...> &y)

Variables

detail::ignore_type const ignore = {}

template<typename ...Ts>
class tuple

#include <tuple.hpp>

Public Functions

template<typename Dependent = void, typename Enable = typename std::enable_if<util::all_of<std::is_constructible<Ts>...>::value, Dependent>::type>
constexpr tuple()

constexpr 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 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 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 = typename util::make_index_pack<sizeof...(Ts)>::type

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

#include <tuple.hpp>

Public Functions

constexpr tuple()

constexpr tuple(tuple const&)

constexpr tuple(tuple&&)

tuple &operator=(tuple const&)

tuple &operator=(tuple&&)

void swap(tuple&)

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

#include <tuple.hpp>

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

#include <tuple.hpp>

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

#include <tuple.hpp>

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...>>

#include <tuple.hpp>

Public Types

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

Public Static Functions

static constexpr type &get(tuple<Ts...> &tuple)

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

template<class T>
struct tuple_size

#include <tuple.hpp>

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, typename Enable = typename util::always_void<typename util::tuple_element<I, Tuple>::type>::type>
constexpr util::tuple_element<I, Tuple>::type &get(Tuple &t)

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

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

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

namespace std_adl_barrier

Functions

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

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

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

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

Header hpx/datastructures/variant_helper.hpp