hpx/lcos_local/trigger.hpp

Defined in header hpx/lcos_local/trigger.hpp.

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

namespace hpx

namespace lcos

namespace local

template<typename Mutex = hpx::spinlock>
struct base_trigger

Public Functions

inline base_trigger() noexcept

inline base_trigger(base_trigger &&rhs) noexcept

inline base_trigger &operator=(base_trigger &&rhs) noexcept

inline hpx::future<void> get_future(std::size_t *generation_value = nullptr, error_code &ec = hpx::throws)

get a future allowing to wait for the trigger to fire

inline bool set(error_code &ec = throws)

Trigger this object.

inline void synchronize(std::size_t generation_value, char const *function_name = "trigger::synchronize", error_code &ec = throws)

Wait for the generational counter to reach the requested stage.

inline std::size_t next_generation()

inline std::size_t generation() const

Protected Types

using mutex_type = Mutex

Protected Functions

inline bool trigger_conditions(error_code &ec = throws)

template<typename Lock>
inline void synchronize(std::size_t generation_value, Lock &l, char const *function_name = "trigger::synchronize", error_code &ec = throws)

Private Types

using condition_list_type = hpx::detail::intrusive_list<condition_list_entry>

Private Functions

inline bool test_condition(std::size_t generation_value) noexcept

Private Members

mutable mutex_type mtx_

hpx::promise<void> promise_

std::size_t generation_

condition_list_type conditions_

struct condition_list_entry : public conditional_trigger

Public Functions

condition_list_entry() = default

Public Members

condition_list_entry *prev = nullptr

condition_list_entry *next = nullptr

struct manage_condition

Public Functions

inline manage_condition(base_trigger &gate, condition_list_entry &cond) noexcept

inline ~manage_condition()

template<typename Condition>
inline hpx::future<void> get_future(Condition &&func, error_code &ec = hpx::throws)

Public Members

base_trigger &this_

condition_list_entry &e_

struct trigger : public hpx::lcos::local::base_trigger<hpx::no_mutex>

Public Functions

trigger() = default

inline trigger(trigger &&rhs) noexcept

inline trigger &operator=(trigger &&rhs) noexcept

template<typename Lock>
inline void synchronize(std::size_t generation_value, Lock &l, char const *function_name = "trigger::synchronize", error_code &ec = throws)

Private Types

using base_type = base_trigger<hpx::no_mutex>