event_handler.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_EVENT_HANDLER
#define LIBFILEZILLA_EVENT_HANDLER
 
#include "event_loop.hpp"
 
namespace fz {
 
class FZ_PUBLIC_SYMBOL event_handler
{
public:
    event_handler() = delete;
 
    explicit event_handler(event_loop& loop);
    virtual ~event_handler();
 
    event_handler(event_handler const& h);
    event_handler& operator=(event_handler const&) = delete;
 
    void remove_handler();
 
    virtual void operator()(event_base const&) = 0;
 
    template<typename T, typename... Args>
    void send_event(Args&&... args) {
        event_loop_.send_event(this, new T(std::forward<Args>(args)...));
    }
 
    template<typename T>
    void send_event(T* evt) {
        event_loop_.send_event(this, evt);
    }
 
    timer_id add_timer(monotonic_clock const &deadline, duration const& interval = {});
 
    timer_id add_timer(duration const& interval, bool one_shot);
 
    void stop_timer(timer_id id);
 
    timer_id stop_add_timer(timer_id id, monotonic_clock const& deadline, duration const& interval = {});
 
    timer_id stop_add_timer(timer_id id, duration const& interval, bool one_shot);
 
    event_loop & event_loop_;
private:
    friend class event_loop;
    bool removing_{};
};
 
template<typename T, typename F>
bool dispatch(event_base const& ev, F&& f)
{
    bool const same = same_type<T>(ev);
    if (same) {
        T const* e = static_cast<T const*>(&ev);
        std::apply(std::forward<F>(f), e->v_);
    }
    return same;
}
 
template<typename T, typename H, typename F>
bool dispatch(event_base const& ev, H* h, F&& f)
{
    bool const same = same_type<T>(ev);
    if (same) {
        T const* e = static_cast<T const*>(&ev);
        apply(h, std::forward<F>(f), e->v_);
    }
    return same;
}
 
template<typename T, typename ... Ts, typename H, typename F, typename ... Fs>
bool dispatch(event_base const& ev, H* h, F&& f, Fs&& ... fs)
{
    if (dispatch<T>(ev, h, std::forward<F>(f))) {
        return true;
    }
 
    return dispatch<Ts...>(ev, h, std::forward<Fs>(fs)...);
}
 
}
 
#endif