event_handler.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_EVENT_HANDLER
#define LIBFILEZILLA_EVENT_HANDLER
 
#include "event_loop.hpp"

namespace fz {

 
enum event_handler_option
{
    child_event_handler
};
 
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(event_handler & h, event_handler_option opt);
 
    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)...), true);
    }
 
    template<typename T>
    void send_event(T* evt) {
        event_loop_.send_event(this, evt, true);
    }
 

    template<typename T>
    void send_persistent_event(T* evt) {
        event_loop_.send_event(this, evt, false);
    }

    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);
 
    void filter_events(std::function<bool(event_base& ev)> const& filter) {
        event_loop_.filter_events([&](event_handler*& h, event_base& ev) {
            if (h != this) {
                return false;
            }
            return filter(ev);
        });
    }
 
    void resend_current_event() {
        event_loop_.resend_current_event();
    }
 
    event_loop & event_loop_;
private:
    friend class event_loop;
    bool removing_{};
 
    void remove_from_parent();
    event_handler* parent_{};
    event_handler* next_{};
    event_handler* child_{};
};

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