supervisor_ev.h

#pragma once
 
//
// Copyright (c) 2019-2022 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
//
// Distributed under the MIT Software License
//
 
#include "rotor/supervisor.h"
#include "rotor/ev/export.h"
#include "rotor/ev/supervisor_config_ev.h"
#include "rotor/ev/system_context_ev.h"
#include "rotor/system_context.h"
#include <ev.h>
#include <memory>
#include <unordered_map>
 
namespace rotor {
namespace ev {
 
struct ROTOR_EV_API supervisor_ev_t : public supervisor_t {
    using config_t = supervisor_config_ev_t;
 
    template <typename Supervisor> using config_builder_t = supervisor_config_ev_builder_t<Supervisor>;
 
    struct timer_t : public ev_timer {
 
        using supervisor_ptr_t = intrusive_ptr_t<supervisor_ev_t>;
 
        timer_handler_base_t *handler;
 
        supervisor_ptr_t sup;
    };
 
    using timer_ptr_t = std::unique_ptr<timer_t>;
 
    supervisor_ev_t(supervisor_config_ev_t &config);
    virtual void do_initialize(system_context_t *ctx) noexcept override;
    ~supervisor_ev_t();
 
    void start() noexcept override;
    void shutdown() noexcept override;
    void enqueue(message_ptr_t message) noexcept override;
    void shutdown_finish() noexcept override;
 
    inline struct ev_loop *get_loop() noexcept { return loop; }
 
    template <typename T> auto &access() noexcept;
 
  protected:
    using timers_map_t = std::unordered_map<request_id_t, timer_ptr_t>;
 
    static void async_cb(EV_P_ ev_async *w, int revents) noexcept;
 
    void do_start_timer(const pt::time_duration &interval, timer_handler_base_t &handler) noexcept override;
    void do_cancel_timer(request_id_t timer_id) noexcept override;
 
    virtual void on_async() noexcept;
 
    struct ev_loop *loop;
 
    bool loop_ownership;
 
    ev_async async_watcher;
 
    ev_tstamp poll_duration;
 
    timers_map_t timers_map;
 
    friend struct supervisor_ev_shutdown_t;
 
  private:
    void move_inbound_queue() noexcept;
};
 
} // namespace ev
} // namespace rotor