any.hpp¶

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)