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&) = delete;
    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(duration const& interval, bool one_shot);

    void stop_timer(timer_id id);

    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