datastructures

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

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

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

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

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

#include <hpx/datastructures/any.hpp>

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

Public Functions

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>
template<>
class basic_any<void, void, Char, std::true_type>

Public Functions

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 <>
template<>
class basic_any<void, void, void, std::false_type>

Public Functions

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>
template<>
class basic_any<void, void, Char, std::false_type>

Public Functions

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 hpx::util::any_nonser = typedef basic_any<void, void, void, std::true_type>

using hpx::util::streamable_any_nonser = typedef basic_any<void, void, char, std::true_type>

using hpx::util::streamable_wany_nonser = typedef basic_any<void, void, wchar_t, std::true_type>

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

using hpx::util::streamable_unique_any_nonser = typedef basic_any<void, void, char, std::false_type>

using hpx::util::streamable_unique_wany_nonser = typedef basic_any<void, void, wchar_t, std::false_type>

Functions

template <typename IArch, typename OArch, typename Char, typename Copyable, typename Enable = typename std::enable_if<!std::is_void<Char>::value>::type>
std::basic_istream<Char> &operator>>(std::basic_istream<Char> &i, basic_any<IArch, OArch, Char, Copyable> &obj)

template <typename IArch, typename OArch, typename Char, typename Copyable, typename Enable = typename std::enable_if<!std::is_void<Char>::value>::type>
std::basic_ostream<Char> &operator<<(std::basic_ostream<Char> &o, basic_any<IArch, OArch, Char, Copyable> const &obj)

template <typename IArch, typename OArch, typename Char, typename Copyable>
void swap(basic_any<IArch, OArch, Char, Copyable> &lhs, basic_any<IArch, OArch, Char, Copyable> &rhs)

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

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

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

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

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

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

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

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

struct bad_any_cast : public bad_cast

Public Functions

bad_any_cast(std::type_info const &src, std::type_info const &dest)

const char *what() const

Public Members

const char *from

const char *to

template <typename Char>
template<>
class basic_any<void, void, Char, std::false_type>

Public Functions

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>
template<>
class basic_any<void, void, Char, std::true_type>

Public Functions

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 <>
template<>
class basic_any<void, void, void, std::false_type>

Public Functions

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 <>
template<>
class basic_any<void, void, void, std::true_type>

Public Functions

basic_any()

basic_any(basic_any const &x)

basic_any(basic_any &&x)

template <typename T, typename Enable = typename std::enable_if<!std::is_same<basic_any, typename std::decay<T>::type>::value>::type>
basic_any(T &&x, typename std::enable_if<std::is_copy_constructible<typename std::decay<T>::type>::value>::type * = nullptr)

~basic_any()

basic_any &operator=(basic_any const &x)

basic_any &operator=(basic_any &&rhs)

template <typename T, typename Enable = typename std::enable_if< !std::is_same<basic_any, typename std::decay<T>::type>::value && std::is_copy_constructible< typename std::decay<T>::type>::value>::type>
basic_any &operator=(T &&rhs)

basic_any &swap(basic_any &x)

std::type_info const &type() const

template <typename T>
T const &cast() const

bool has_value() const

void reset()

bool equal_to(basic_any const &rhs) const

Private Functions

basic_any &assign(basic_any const &x)

Private Members

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

void *object

Private Static Functions

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

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

#include <hpx/datastructures/optional.hpp>

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

Public Functions

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

namespace hpx

namespace util

Functions

template <typename T>
bool operator==(optional<T> const &lhs, optional<T> const &rhs)

template <typename T>
bool operator!=(optional<T> const &lhs, optional<T> const &rhs)

template <typename T>
bool operator<(optional<T> const &lhs, optional<T> const &rhs)

template <typename T>
bool operator>=(optional<T> const &lhs, optional<T> const &rhs)

template <typename T>
bool operator>(optional<T> const &lhs, optional<T> const &rhs)

template <typename T>
bool operator<=(optional<T> const &lhs, optional<T> const &rhs)

template <typename T>
bool operator==(optional<T> const &opt, nullopt_t)

template <typename T>
bool operator==(nullopt_t, optional<T> const &opt)

template <typename T>
bool operator!=(optional<T> const &opt, nullopt_t)

template <typename T>
bool operator!=(nullopt_t, optional<T> const &opt)

template <typename T>
bool operator<(optional<T> const &opt, nullopt_t)

template <typename T>
bool operator<(nullopt_t, optional<T> const &opt)

template <typename T>
bool operator>=(optional<T> const &opt, nullopt_t)

template <typename T>
bool operator>=(nullopt_t, optional<T> const &opt)

template <typename T>
bool operator>(optional<T> const &opt, nullopt_t)

template <typename T>
bool operator>(nullopt_t, optional<T> const &opt)

template <typename T>
bool operator<=(optional<T> const &opt, nullopt_t)

template <typename T>
bool operator<=(nullopt_t, optional<T> const &opt)

template <typename T>
bool operator==(optional<T> const &opt, T const &value)

template <typename T>
bool operator==(T const &value, optional<T> const &opt)

template <typename T>
bool operator!=(optional<T> const &opt, T const &value)

template <typename T>
bool operator!=(T const &value, optional<T> const &opt)

template <typename T>
bool operator<(optional<T> const &opt, T const &value)

template <typename T>
bool operator<(T const &value, optional<T> const &opt)

template <typename T>
bool operator>=(optional<T> const &opt, T const &value)

template <typename T>
bool operator>=(T const &value, optional<T> const &opt)

template <typename T>
bool operator>(optional<T> const &opt, T const &value)

template <typename T>
bool operator>(T const &value, optional<T> const &opt)

template <typename T>
bool operator<=(optional<T> const &opt, T const &value)

template <typename T>
bool operator<=(T const &value, optional<T> const &opt)

template <typename T>
void swap(optional<T> &x, optional<T> &y)

template <typename T>
optional<typename std::decay<T>::type> make_optional(T &&v)

template <typename T, typename... Ts>
optional<T> make_optional(Ts&&... ts)

template <typename T, typename U, typename... Ts>
optional<T> make_optional(std::initializer_list<U> il, Ts&&... ts)

Variables

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

nullopt_t(nullopt_t::init)

template <typename T>
class optional

Public Types

template<>
using value_type = T

Public Functions

optional()

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)

T const *operator->() const

T *operator->()

T const &operator*() const

T &operator*()

operator bool() const

bool has_value() const

T &value()

T const &value() const

template <typename U>

HPX_CXX14_CONSTEXPR T hpx::util::optional::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>
template<>
struct hash<hpx::util::optional<T>>

Public Functions

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

#include <hpx/datastructures/tuple.hpp>

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

Public Types

template<>
using type = T0

Public Static Functions

static HPX_HOST_DEVICE type& hpx::util::tuple_element::get(std::pair< T0, T1 > & tuple)

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

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

Public Types

template<>
using type = T1

Public Static Functions

static HPX_HOST_DEVICE type& hpx::util::tuple_element::get(std::pair< T0, T1 > & tuple)

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

template <std::size_t I, typename Type, std::size_t Size>
template<>
struct tuple_element<I, boost::array<Type, Size>>

Public Types

template<>
using type = Type

Public Static Functions

static HPX_HOST_DEVICE type& hpx::util::tuple_element::get(boost::array< Type, Size > & tuple)

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

template <std::size_t I, typename Type, std::size_t Size>
template<>
struct tuple_element<I, std::array<Type, Size>>

Public Types

template<>
using type = Type

Public Static Functions

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

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

namespace hpx

namespace util

Functions

template <typename… Ts>

HPX_HOST_DEVICE tuple<typename decay_unwrap<Ts>::type...> hpx::util::make_tuple(Ts &&... vs)

template <typename… Ts>

HPX_HOST_DEVICE tuple<Ts&&...> hpx::util::forward_as_tuple(Ts &&... vs)

template <typename… Ts>

HPX_HOST_DEVICE tuple<Ts&...> hpx::util::tie(Ts &... vs)

template <typename… Tuples>

HPX_HOST_DEVICE auto hpx::util::tuple_cat(Tuples &&... tuples)

template <typename… Ts, typename… Us>

HPX_HOST_DEVICE std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type hpx::util::operator==(tuple < Ts... > const & t, tuple < Us... > const & u)

template <typename… Ts, typename… Us>

HPX_HOST_DEVICE std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type hpx::util::operator!=(tuple < Ts... > const & t, tuple < Us... > const & u)

template <typename… Ts, typename… Us>

HPX_HOST_DEVICE std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type hpx::util::operator<(tuple < Ts... > const & t, tuple < Us... > const & u)

template <typename… Ts, typename… Us>

HPX_HOST_DEVICE std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type hpx::util::operator>(tuple < Ts... > const & t, tuple < Us... > const & u)

template <typename… Ts, typename… Us>

HPX_HOST_DEVICE std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type hpx::util::operator<=(tuple < Ts... > const & t, tuple < Us... > const & u)

template <typename… Ts, typename… Us>

HPX_HOST_DEVICE std::enable_if<sizeof...(Ts) == sizeof...(Us), bool>::type hpx::util::operator>=(tuple < Ts... > const & t, tuple < Us... > const & u)

template <typename… Ts>

HPX_HOST_DEVICE void hpx::util::swap(tuple < Ts... > & x, tuple < Ts... > & y)

Variables

detail::ignore_type const ignore = {}

template <typename... Ts>
class tuple

Public Functions

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

HPX_HOST_DEVICE tuple(Ts const&... vs)

template <typename U, typename... Us, typename Enable = typename std::enable_if< detail::pack<U, Us...>::size == detail::pack<Ts...>::size && std::conditional<detail::pack<Us...>::size == 0, typename std::enable_if< !std::is_same<tuple, typename std::decay<U>::type>::value && !detail::are_tuples_compatible_not_same<tuple, U&&>::value, detail::are_tuples_compatible<tuple, tuple<U>&&>>::type, detail::are_tuples_compatible<tuple, tuple<U, Us...>&&>>::type::value>::type>
HPX_HOST_DEVICE tuple(U &&v, Us&&... vs)

tuple(tuple const&)

tuple(tuple&&)

template <typename UTuple, typename Enable = typename std::enable_if<detail::are_tuples_compatible_not_same< tuple, UTuple&&>::value>::type>
HPX_HOST_DEVICE tuple(UTuple &&other)

HPX_HOST_DEVICE tuple& hpx::util::tuple::operator=(tuple const & other)

HPX_HOST_DEVICE tuple& hpx::util::tuple::operator=(tuple && other)

template <typename UTuple>

HPX_HOST_DEVICE std::enable_if< tuple_size<typename std::decay<UTuple>::type>::value == detail::pack<Ts...>::size, tuple&>::type hpx::util::tuple::operator=(UTuple && other)

HPX_HOST_DEVICE void hpx::util::tuple::swap(tuple & other)

Public Members

detail::tuple_impl<typename detail::make_index_pack<sizeof...(Ts)>::type, Ts...> _impl

template <>
template<>
class tuple<>

Public Functions

HPX_HOST_DEVICE tuple()

HPX_HOST_DEVICE tuple(tuple const&)

HPX_HOST_DEVICE tuple(tuple&&)

HPX_HOST_DEVICE tuple& hpx::util::tuple::operator=(tuple const &)

HPX_HOST_DEVICE tuple& hpx::util::tuple::operator=(tuple &&)

HPX_HOST_DEVICE void hpx::util::tuple::swap(tuple &)

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

Public Types

template<>
using type = T0

Public Static Functions

static HPX_HOST_DEVICE type& hpx::util::tuple_element::get(std::pair< T0, T1 > & tuple)

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

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

Public Types

template<>
using type = T1

Public Static Functions

static HPX_HOST_DEVICE type& hpx::util::tuple_element::get(std::pair< T0, T1 > & tuple)

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

template <std::size_t I, typename Type, std::size_t Size>
template<>
struct tuple_element<I, boost::array<Type, Size>>

Public Types

template<>
using type = Type

Public Static Functions

static HPX_HOST_DEVICE type& hpx::util::tuple_element::get(boost::array< Type, Size > & tuple)

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

template <std::size_t I, typename Type, std::size_t Size>
template<>
struct tuple_element<I, std::array<Type, Size>>

Public Types

template<>
using type = Type

Public Static Functions

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

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

template <std::size_t I, typename... Ts>
template<>
struct tuple_element<I, tuple<Ts...>>

Public Types

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

Public Static Functions

static HPX_HOST_DEVICE type& hpx::util::tuple_element::get(tuple < Ts... > & tuple)

static HPX_HOST_DEVICE type const& hpx::util::tuple_element::get(tuple < Ts... > const & tuple)

template <class T>
struct tuple_size

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

namespace adl_barrier

Functions

template <std::size_t I, typename Tuple>

HPX_HOST_DEVICE tuple_element< I, Tuple >::type & hpx::util::adl_barrier::get(Tuple & t)

template <std::size_t I, typename Tuple>

HPX_HOST_DEVICE tuple_element< I, Tuple >::type const & hpx::util::adl_barrier::get(Tuple const & t)

template <std::size_t I, typename Tuple>

HPX_HOST_DEVICE tuple_element< I, Tuple >::type && hpx::util::adl_barrier::get(Tuple && t)

template <std::size_t I, typename Tuple>

HPX_HOST_DEVICE tuple_element< I, Tuple >::type const && hpx::util::adl_barrier::get(Tuple const && t)

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

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

namespace hpx

namespace traits

template <typename T>
struct is_tuple_like : public hpx::traits::detail::is_tuple_like_impl<std::remove_cv<T>::type>

#include <is_tuple_like.hpp>

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