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 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_{};
 
    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