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.

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

typedef hpx::tuple_element<I, T> instead
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... Ts>hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::make_any_nonser is deprecated. Please use " "hpx::make_any_nonser instead.")
std::true_type make_any_nonser(Ts&&... ts)
template<typename T, typename U, typename... Ts>hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::make_any_nonser is deprecated. Please use " "hpx::make_any_nonser instead.")
std::true_type make_any_nonser(std::initializer_list<U> il, Ts&&... ts)
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<U> il, Ts&&... ts)
template<typename T, typename... Ts>hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::make_unique_any_nonser is deprecated. Please use " "hpx::make_unique_any_nonser instead.")
std::false_type make_unique_any_nonser(Ts&&... ts)
template<typename T, typename U, typename... Ts>hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::make_unique_any_nonser is deprecated. Please use " "hpx::make_unique_any_nonser instead.")
std::false_type make_unique_any_nonser(std::initializer_list<U> 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<U> il, Ts&&... ts)
template<typename T>hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::make_any_nonser is deprecated. Please use " "hpx::make_any_nonser instead.")
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>hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::make_unique_any_nonser is deprecated. Please use " "hpx::make_unique_any_nonser instead.")
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)

Variables

hpx::util::void
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<U> 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<U> 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<U> 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<U> 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<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>
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 &&
template<typename T>
struct hash<hpx::optional<T>>

Public Functions

constexpr std::size_t operator()(::hpx::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&, nullopt_t)
template<typename T>
constexpr bool operator<(nullopt_t, optional<T> const &opt)
template<typename T>
constexpr bool operator>=(optional<T> const&, 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&)
template<typename T>
constexpr bool operator<=(optional<T> const &opt, nullopt_t)
template<typename T>
constexpr bool operator<=(nullopt_t, optional<T> const&)
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)
template<typename F, typename ...Ts>
void emplace_f(F &&f, 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::optional<T>>

Public Functions

constexpr std::size_t operator()(::hpx::optional<T> const &arg) 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<typename util::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)
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<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

const hpx::detail::ignore_type 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 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<hpx::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<hpx::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<>

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

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

Functions

hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::ignore is deprecated. Use hpx::ignore instead.")
template<typename... Ts>hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::make_tuple is deprecated. Use hpx::make_tuple instead.") const&&
template<typename... Ts>hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::tie is deprecated. Use hpx::tie instead.") const&&
template<typename... Ts>hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::forward_as_tuple is deprecated. Use hpx::forward_as_tuple " "instead.") const&&
template<typename... Ts>hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::tuple_cat is deprecated. Use hpx::tuple_cat " "instead.") const&&
template<std::size_t I, typename Tuple>hpx::util::HPX_DEPRECATED_V(1, 6, "hpx::util::get is deprecated. Use hpx::get " "instead.") const&&
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.