.rst .pdf

repository open issue

functional

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

namespace hpx

Functions

template<typename F, typename ...Ts, typename Enable = std::enable_if_t<!traits::is_action_v<std::decay_t<F>>>>
constexpr detail::bound<std::decay_t<F>, util::make_index_pack_t<sizeof...(Ts)>, util::decay_unwrap_t<Ts>...> bind(F &&f, Ts&&... vs)

namespace placeholders

Variables

constexpr detail::placeholder<1> _1 = {}

constexpr detail::placeholder<2> _2 = {}

constexpr detail::placeholder<3> _3 = {}

constexpr detail::placeholder<4> _4 = {}

constexpr detail::placeholder<5> _5 = {}

constexpr detail::placeholder<6> _6 = {}

constexpr detail::placeholder<7> _7 = {}

constexpr detail::placeholder<8> _8 = {}

constexpr detail::placeholder<9> _9 = {}

namespace serialization

Functions

template<typename Archive, typename F, typename ...Ts>
void serialize(Archive &ar, ::hpx::detail::bound<F, Ts...> &bound, unsigned int const version = 0)

template<typename Archive, std::size_t I>
constexpr void serialize(Archive&, ::hpx::detail::placeholder<I>&, unsigned int const = 0)

namespace util

Functions

template<typename F, typename... Ts>hpx::util::HPX_DEPRECATED_V(1, 8, "hpx::util::bind is deprecated, use hpx::bind  instead ") const&&

Variables

Ts && hpx::util::ts{        return hpx::bind(HPX_FORWARD(F, f), HPX_FORWARD(Ts, ts)...)

namespace placeholders

Functions

hpx::util::placeholders::HPX_DEPRECATED_V(1, 8, "hpx::placeholders::_1 is deprecated, use " "hpx::placeholders::_1  instead ") const

hpx::util::placeholders::HPX_DEPRECATED_V(1, 8, "hpx::placeholders::_2 is deprecated, use " "hpx::placeholders::_2  instead ") const

hpx::util::placeholders::HPX_DEPRECATED_V(1, 8, "hpx::placeholders::_3 is deprecated, use " "hpx::placeholders::_3  instead ") const

hpx::util::placeholders::HPX_DEPRECATED_V(1, 8, "hpx::placeholders::_4 is deprecated, use " "hpx::placeholders::_4  instead ") const

hpx::util::placeholders::HPX_DEPRECATED_V(1, 8, "hpx::placeholders::_5 is deprecated, use " "hpx::placeholders::_5  instead ") const

hpx::util::placeholders::HPX_DEPRECATED_V(1, 8, "hpx::placeholders::_6 is deprecated, use " "hpx::placeholders::_6  instead ") const

hpx::util::placeholders::HPX_DEPRECATED_V(1, 8, "hpx::placeholders::_7 is deprecated, use " "hpx::placeholders::_7  instead ") const

hpx::util::placeholders::HPX_DEPRECATED_V(1, 8, "hpx::placeholders::_8 is deprecated, use " "hpx::placeholders::_8  instead ") const

hpx::util::placeholders::HPX_DEPRECATED_V(1, 8, "hpx::placeholders::_9 is deprecated, use " "hpx::placeholders::_9  instead ") const

namespace hpx

Functions

template<typename F, typename ...Ts>
constexpr hpx::detail::bound_back<std::decay_t<F>, util::make_index_pack_t<sizeof...(Ts)>, util::decay_unwrap_t<Ts>...> bind_back(F &&f, Ts&&... vs)

template<typename F>
constexpr std::decay_t<F> bind_back(F &&f)

namespace serialization

Functions

template<typename Archive, typename F, typename ...Ts>
void serialize(Archive &ar, ::hpx::detail::bound_back<F, Ts...> &bound, unsigned int const version = 0)

namespace util

Functions

template<typename F, typename... Ts>hpx::util::HPX_DEPRECATED_V(1, 8, "hpx::util::bind_back is deprecated, use hpx::bind_back  instead ") const&&

namespace hpx

Functions

template<typename F, typename ...Ts>
constexpr detail::bound_front<std::decay_t<F>, util::make_index_pack_t<sizeof...(Ts)>, util::decay_unwrap_t<Ts>...> bind_front(F &&f, Ts&&... vs)

template<typename F>
constexpr std::decay_t<F> bind_front(F &&f)

namespace serialization

Functions

template<typename Archive, typename F, typename ...Ts>
void serialize(Archive &ar, ::hpx::detail::bound_front<F, Ts...> &bound, unsigned int const version = 0)

namespace util

Functions

template<typename F, typename... Ts>hpx::util::HPX_DEPRECATED_V(1, 8, "hpx::util::bind_front is deprecated, use hpx::bind_front  instead ") const&&

namespace hpx

namespace serialization

Functions

template<typename Archive, typename F, typename ...Ts>
void serialize(Archive &ar, ::hpx::util::detail::deferred<F, Ts...> &d, unsigned int const version = 0)

namespace util

Functions

template<typename F, typename ...Ts>
detail::deferred<std::decay_t<F>, util::make_index_pack_t<sizeof...(Ts)>, util::decay_unwrap_t<Ts>...> deferred_call(F &&f, Ts&&... vs)

template<typename F>
std::decay_t<F> deferred_call(F &&f)

Defines

HPX_UTIL_REGISTER_FUNCTION_DECLARATION(Sig, F, Name)

HPX_UTIL_REGISTER_FUNCTION(Sig, F, Name)

namespace hpx

template<typename R, typename ...Ts, bool Serializable>
class function<R(Ts...), Serializable> : public util::detail::basic_function<R(Ts...), true, Serializable>

Public Types

template<>
using result_type = R

Public Functions

constexpr function(std::nullptr_t = nullptr)

function(function const&)

function(function&&)

function &operator=(function const&)

function &operator=(function&&)

template<typename F, typename FD = std::decay_t<F>, typename Enable1 = std::enable_if_t<!std::is_same_v<FD, function>>, typename Enable2 = std::enable_if_t<is_invocable_r_v<R, FD&, Ts...>>>
function(F &&f)

template<typename F, typename FD = std::decay_t<F>, typename Enable1 = std::enable_if_t<!std::is_same_v<FD, function>>, typename Enable2 = std::enable_if_t<is_invocable_r_v<R, FD&, Ts...>>>
function &operator=(F &&f)

Private Types

template<>
using base_type = util::detail::basic_function<R(Ts...), true, Serializable>

namespace distributed

Typedefs

template<typename Sig>
using function = hpx::function<Sig, true>

namespace util

Typedefs

typedef hpx::move_only_function<Sig> instead

namespace hpx

template<typename R, typename ...Ts>
class function_ref<R(Ts...)>

Public Functions

template<typename F, typename FD = std::decay_t<F>, typename Enable = std::enable_if_t<!std::is_same_v<FD, function_ref> && is_invocable_r_v<R, F&, Ts...>>>
function_ref(F &&f)

function_ref(function_ref const &other)

template<typename F, typename FD = std::decay_t<F>, typename Enable = std::enable_if_t<!std::is_same_v<FD, function_ref> && is_invocable_r_v<R, F&, Ts...>>>
function_ref &operator=(F &&f)

function_ref &operator=(function_ref const &other)

template<typename F, typename T = std::remove_reference_t<F>, typename Enable = std::enable_if_t<!std::is_pointer_v<T>>>
void assign(F &&f)

template<typename T>
void assign(std::reference_wrapper<T> f_ref)

template<typename T>
void assign(T *f_ptr)

void swap(function_ref &f)

R operator()(Ts... vs) const

std::size_t get_function_address() const

char const *get_function_annotation() const

util::itt::string_handle get_function_annotation_itt() const

Protected Attributes

template<>
R (*vptr)(void*, Ts&&...)

void *object

Private Types

template<>
using VTable = util::detail::function_ref_vtable<R(Ts...)>

Private Static Functions

template<typename T>
static VTable const *get_vtable()

Defines

HPX_INVOKE_R(R, F, ...)

namespace hpx

namespace util

Functions

template<typename F, typename ...Ts>
constexpr util::invoke_result<F, Ts...>::type invoke(F &&f, Ts&&... vs)

Invokes the given callable object f with the content of the argument pack vs

Return

The result of the callable object when it’s called with the given argument types.

Note

This function is similar to std::invoke (C++17)

Parameters

• f: Requires to be a callable object. If f is a member function pointer, the first argument in the pack will be treated as the callee (this object).

• vs: An arbitrary pack of arguments

Exceptions

• std::exception: like objects thrown by call to object f with the argument types vs.

template<typename R, typename F, typename ...Ts>
constexpr R invoke_r(F &&f, Ts&&... vs)

Template Parameters

• R: The result type of the function when it’s called with the content of the given argument types vs.

namespace functional

struct invoke

Public Functions

template<typename F, typename ...Ts>
constexpr util::invoke_result<F, Ts...>::type operator()(F &&f, Ts&&... vs) const

template<typename R>
struct invoke_r

Public Functions

template<typename F, typename ...Ts>
constexpr R operator()(F &&f, Ts&&... vs) const

namespace hpx

namespace util

Functions

template<typename F, typename Tuple>
constexpr detail::invoke_fused_result<F, Tuple>::type invoke_fused(F &&f, Tuple &&t)

Invokes the given callable object f with the content of the sequenced type t (tuples, pairs)

Return

The result of the callable object when it’s called with the content of the given sequenced type.

Note

This function is similar to std::apply (C++17)

Parameters

• f: Must be a callable object. If f is a member function pointer, the first argument in the sequenced type will be treated as the callee (this object).

• t: A type whose contents are accessible through a call to hpx::get.

Exceptions

• std::exception: like objects thrown by call to object f with the arguments contained in the sequenceable type t.

template<typename R, typename F, typename Tuple>
constexpr R invoke_fused_r(F &&f, Tuple &&t)

Template Parameters

• R: The result type of the function when it’s called with the content of the given sequenced type.

namespace hpx

namespace util

Functions

template<typename M, typename C>
constexpr detail::mem_fn<M C::*> mem_fn(M C::* pm)

template<typename R, typename C, typename ...Ps>
constexpr detail::mem_fn<R (C::*)(Ps...)> mem_fn(R (C::* pm)(Ps...))

template<typename R, typename C, typename ...Ps>
constexpr detail::mem_fn<R (C::*)(Ps...) const> mem_fn(R (C::* pm)(Ps...) const)

Defines

HPX_UTIL_REGISTER_UNIQUE_FUNCTION_DECLARATION(Sig, F, Name)

HPX_UTIL_REGISTER_UNIQUE_FUNCTION(Sig, F, Name)

namespace hpx

template<typename R, typename ...Ts, bool Serializable>
class move_only_function<R(Ts...), Serializable> : public util::detail::basic_function<R(Ts...), false, Serializable>

Public Types

template<>
using result_type = R

Public Functions

constexpr move_only_function(std::nullptr_t = nullptr)

move_only_function(move_only_function const&)

move_only_function(move_only_function&&)

move_only_function &operator=(move_only_function const&)

move_only_function &operator=(move_only_function&&)

template<typename F, typename FD = std::decay_t<F>, typename Enable1 = std::enable_if_t<!std::is_same_v<FD, move_only_function>>, typename Enable2 = std::enable_if_t<is_invocable_r_v<R, FD&, Ts...>>>
move_only_function(F &&f)

template<typename F, typename FD = std::decay_t<F>, typename Enable1 = std::enable_if_t<!std::is_same_v<FD, move_only_function>>, typename Enable2 = std::enable_if_t<is_invocable_r_v<R, FD&, Ts...>>>
move_only_function &operator=(F &&f)

Private Types

template<>
using base_type = util::detail::basic_function<R(Ts...), false, Serializable>

namespace distributed

Typedefs

template<typename Sig>
using move_only_function = hpx::move_only_function<Sig, true>

namespace hpx

namespace serialization

Functions

template<typename Archive, typename F>
void serialize(Archive &ar, ::hpx::util::detail::one_shot_wrapper<F> &one_shot_wrapper, unsigned int const version = 0)

namespace util

Functions

template<typename F>
constexpr detail::one_shot_wrapper<typename std::decay<F>::type> one_shot(F &&f)

namespace hpx

namespace util

Functions

template<typename T>
std::enable_if_t<hpx::is_bind_expression_v<std::decay_t<T>>, detail::protected_bind<std::decay_t<T>>> protect(T &&f)

template<typename T>
std::enable_if_t<!hpx::is_bind_expression_v<std::decay_t<T>>, T> protect(T &&v)

template<typename R, typename Obj, typename ...Ts>
struct get_function_address<R (Obj::*)(Ts...)>

Public Static Functions

static std::size_t call(R (Obj::* f)(Ts...))

template<typename R, typename Obj, typename ...Ts>
struct get_function_address<R (Obj::*)(Ts...) const>

Public Static Functions

static std::size_t call(R (Obj::* f)(Ts...) const)

namespace hpx

namespace traits

template<typename F, typename Enable = void>
struct get_function_address

Public Static Functions

static constexpr std::size_t call(F const &f)

template<typename R, typename ...Ts>
struct get_function_address<R (*)(Ts...)>

Public Static Functions

static constexpr std::size_t call(R (*f)(Ts...))

template<typename R, typename Obj, typename ...Ts>
struct get_function_address<R (Obj::*)(Ts...) const>

Public Static Functions

static std::size_t call(R (Obj::* f)(Ts...) const)

template<typename R, typename Obj, typename ...Ts>
struct get_function_address<R (Obj::*)(Ts...)>

Public Static Functions

static std::size_t call(R (Obj::* f)(Ts...))

namespace hpx

namespace traits

template<typename F, typename Enable = void>
struct get_function_annotation

Public Static Functions

static constexpr char const *call(F const&)

namespace hpx

Variables

template<typename T>
constexpr bool is_bound_action_v = is_bound_action<T>::value

namespace traits

Typedefs

typedef hpx::is_placeholder<T> instead

Functions

template<typename Action>hpx::traits::HPX_DEPRECATED_V(1, 8, "hpx::traits::is_bound_action_v is deprecated, use " "hpx::is_bound_action_v  instead ") const

Variables

template<typename T>
constexpr bool is_action_v = is_action<T>::value

namespace hpx

Variables

template<typename T>
constexpr bool is_bind_expression_v = is_bind_expression<T>::value

template<typename T>
struct is_bind_expression : public std::is_bind_expression<T>

Subclassed by hpx::is_bind_expression< T const >

namespace traits

Functions

template<typename T>hpx::traits::HPX_DEPRECATED_V(1, 8, "hpx::traits::is_bind_expression_v is deprecated, use " "hpx::is_bind_expression_v  instead ") const

namespace hpx

template<typename T>
struct is_placeholder

#include <is_placeholder.hpp>

If T is a standard, Boost, or HPX placeholder (_1, _2, _3, …) then this template is derived from std::integral_constant<int, 1>, std::integral_constant<int, 2>, std::integral_constant<int, 3>, respectively. Otherwise it is derived from , std::integral_constant<int, 0>.

namespace traits

Functions

template<typename T>hpx::traits::HPX_DEPRECATED_V(1, 8, "hpx::traits::is_placeholder_v is deprecated, use " "hpx::is_placeholder_v  instead ") const

previous

format

next

futures