EventHubComponent.hpp

Go to the documentation of this file.

#pragma once
#ifndef _CONSOLIX_EVENT_HUB_COMPONENT_HPP_INCLUDED
#define _CONSOLIX_EVENT_HUB_COMPONENT_HPP_INCLUDED

 
#if CONSOLIX_USE_EVENT_HUB == 1
 
#include <cstddef>
 
#include <event_hub.hpp>
 
namespace consolix {

    class EventHubComponent :
        public IAppComponent,
        public IShutdownable {
    public:
        static constexpr std::size_t default_max_tasks_per_pass = 128;

        EventHubComponent() = default;

        EventHubComponent(
                event_hub::EventBus* event_bus,
                event_hub::TaskManager* task_manager = nullptr,
                std::size_t max_tasks_per_pass = default_max_tasks_per_pass) :
            m_event_bus(event_bus),
            m_task_manager(task_manager),
            m_max_tasks_per_pass(max_tasks_per_pass) {
        }

        void set_event_bus(event_hub::EventBus* event_bus) {
            m_event_bus = event_bus;
        }

        void set_task_manager(event_hub::TaskManager* task_manager) {
            m_task_manager = task_manager;
        }

        void set_max_tasks_per_pass(std::size_t max_tasks_per_pass) {
            m_max_tasks_per_pass = max_tasks_per_pass;
        }

        std::size_t last_work_count() const {
            return m_last_work_count;
        }
 
    protected:
        bool initialize() override {
            m_is_init = true;
            return true;
        }
 
        bool is_initialized() const override {
            return m_is_init;
        }
 
        void process() override {
            std::size_t work_count = 0;
 
            if (m_event_bus) {
                work_count += m_event_bus->process();
            }
            if (m_task_manager) {
                work_count += m_task_manager->process(m_max_tasks_per_pass);
            }
 
            m_last_work_count = work_count;
        }
 
        void shutdown(int /*signal*/) override {
            if (m_event_bus) {
                m_event_bus->clear_pending();
            }
            if (m_task_manager) {
                m_task_manager->clear_pending();
            }
        }
 
    private:
        event_hub::EventBus*     m_event_bus{nullptr};       
        event_hub::TaskManager*  m_task_manager{nullptr};    
        std::size_t              m_max_tasks_per_pass{default_max_tasks_per_pass};
        std::size_t              m_last_work_count{0};
        bool                     m_is_init{false};
    };
 
} // namespace consolix
 
#endif // CONSOLIX_USE_EVENT_HUB == 1
 
#endif // _CONSOLIX_EVENT_HUB_COMPONENT_HPP_INCLUDED