1 #ifndef LIBFILEZILLA_EVENT_HANDLER
2 #define LIBFILEZILLA_EVENT_HANDLER
71 void remove_handler();
79 virtual void operator()(
event_base const&) = 0;
87 template<
typename T,
typename... Args>
89 event_loop_.send_event(
this,
new T(std::forward<Args>(args)...),
true);
93 void send_event(T* evt) {
94 event_loop_.send_event(
this, evt,
true);
101 event_loop_.send_event(
this, evt,
false);
139 timer_id add_timer(duration
const& interval,
bool one_shot);
145 void stop_timer(timer_id
id);
154 timer_id stop_add_timer(timer_id
id, monotonic_clock
const& deadline, duration
const& interval = {});
163 timer_id stop_add_timer(timer_id
id, duration
const& interval,
bool one_shot);
165 void filter_events(std::function<
bool(event_base& ev)>
const& filter) {
166 event_loop_.filter_events([&](event_handler*& h, event_base& ev) {
174 void resend_current_event() {
175 event_loop_.resend_current_event();
178 event_loop & event_loop_;
180 friend class event_loop;
198 template<
typename T,
typename F>
201 bool const same = same_type<T>(ev);
203 T
const* e =
static_cast<T const*
>(&ev);
224 template<
typename T,
typename H,
typename F>
227 bool const same = same_type<T>(ev);
229 T
const* e =
static_cast<T const*
>(&ev);
230 apply(h, std::forward<F>(f), e->v_);
253 template<
typename T,
typename ... Ts,
typename H,
typename F,
typename ... Fs>
256 if (dispatch<T>(ev, h, std::forward<F>(f))) {
260 return dispatch<Ts...>(ev, h, std::forward<Fs>(fs)...);
auto apply(Obj &&obj, F &&f, Tuple &&args) -> decltype(apply_(std::forward< Obj >(obj), std::forward< F >(f), std::forward< Tuple >(args), Seq()))
Apply tuple to pointer to member.
Definition: apply.hpp:48
Simple handler for asynchronous event processing.
Definition: event_handler.hpp:54
bool dispatch(event_base const &ev, F &&f)
Dispatch for simple_event<> based events to simple functors.
Definition: event_handler.hpp:199
void send_persistent_event(T *evt)
Be careful with lifetime.
Definition: event_handler.hpp:100
A simple threaded event loop for the typesafe event system.
A threaded event loop that supports sending events and timers.
Definition: event_loop.hpp:33
A monotonic clock (aka steady clock) is independent from walltime.
Definition: time.hpp:402
The namespace used by libfilezilla.
Definition: apply.hpp:17
The duration class represents a time interval in milliseconds.
Definition: time.hpp:290
Common base class for all events.
Definition: event.hpp:22
void send_event(Args &&...args)
Sends the passed event asynchronously to the handler.
Definition: event_handler.hpp:88