event_loop.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_EVENT_LOOP_HEADER
#define LIBFILEZILLA_EVENT_LOOP_HEADER

#include "apply.hpp"
#include "event.hpp"
#include "mutex.hpp"
#include "time.hpp"
#include "thread.hpp"

#include <deque>
#include <functional>
#include <memory>
#include <vector>

namespace fz {

class async_task;
class event_handler;
class thread_pool;

class FZ_PUBLIC_SYMBOL event_loop final
{
public:
    event_loop();

    explicit event_loop(thread_pool & pool);

    enum loop_option
    {
        threadless
    };
    explicit event_loop(loop_option);

    ~event_loop();

    event_loop(event_loop const&) = delete;
    event_loop& operator=(event_loop const&) = delete;

    void filter_events(std::function<bool (event_handler*&, event_base&)> const& filter);

    void remove_events(event_source const* const source);

    void stop(bool join = false);

    void run();

    bool running() const;

    void resend_current_event() {
        resend_ = true;
    }

private:
    friend class event_handler;

    void FZ_PRIVATE_SYMBOL remove_handler(event_handler* handler);

    timer_id FZ_PRIVATE_SYMBOL add_timer(event_handler* handler, monotonic_clock const& deadline, duration const& interval);
    void FZ_PRIVATE_SYMBOL stop_timer(timer_id id);
    timer_id FZ_PRIVATE_SYMBOL stop_add_timer(timer_id id, event_handler* handler, monotonic_clock const& deadline, duration const& interval);

    void send_event(event_handler* handler, event_base* evt, bool deletable);

    // Process the next (if any) event. Returns true if an event has been processed
    bool FZ_PRIVATE_SYMBOL process_event(scoped_lock & l);

    // Process timers. Returns true if a timer has been triggered
    bool FZ_PRIVATE_SYMBOL process_timers(scoped_lock & l);

    void FZ_PRIVATE_SYMBOL entry();
    void FZ_PRIVATE_SYMBOL timer_entry();

    struct FZ_PRIVATE_SYMBOL timer_data final
    {
        event_handler* handler_{};
        timer_id id_{};
        monotonic_clock deadline_;
        duration interval_{};
    };

    timer_id FZ_PRIVATE_SYMBOL setup_timer(scoped_lock &lock, timer_data &d, event_handler* handler, monotonic_clock const& deadline, duration const& interval);

    typedef std::vector<timer_data> Timers;

    typedef std::deque<std::tuple<event_handler*, event_base*, bool>> Events;
    Events pending_events_;
    Timers timers_;

    mutable mutex sync_;
    condition cond_;

    condition timer_cond_;
    bool do_timers_{};

    bool active_handler_removed_{};
    event_handler * active_handler_{};

    monotonic_clock deadline_;

    timer_id next_timer_id_{};

    thread::id thread_id_{};

    std::unique_ptr<thread> thread_;
    std::unique_ptr<async_task> task_;

    thread_pool* pool_{};
    std::unique_ptr<thread> timer_thread_;
    std::unique_ptr<async_task> timer_task_;

    bool quit_{};
    bool threadless_{};
    bool resend_{};

    enum class Mode {
        thread,
        tasks,
        threadless
    };
    Mode mode_{};
};

}
#endif