LoopComponent.hpp

Go to the documentation of this file.

#pragma once
#ifndef _CONSOLIX_LOOP_COMPONENT_HPP_INCLUDED
#define _CONSOLIX_LOOP_COMPONENT_HPP_INCLUDED

 
#include <thread>
#include <atomic>
#include <chrono>
#include <functional>
 
namespace consolix {

    class LoopComponent :
        public IAppComponent,
        public IShutdownable  {
    public:

        LoopComponent() = default;

        LoopComponent(
                std::function<bool()>    on_initialize,
                std::function<void()>    on_execute,
                std::function<void(int)> on_shutdown) :
            m_on_initialize(std::move(on_initialize)),
            m_on_execute(std::move(on_execute)),
            m_on_shutdown(std::move(on_shutdown)) {
        }

        virtual ~LoopComponent() override = default;

        std::function<bool()>& on_initialize() {
            return m_on_initialize;
        }

        std::function<void()>& on_execute() {
            return m_on_execute;
        }

        std::function<void(int)>& on_shutdown() {
            return m_on_shutdown;
        }
 
    protected:

        bool initialize() override {
            try {
                if (m_on_initialize) {
                    m_is_init = m_on_initialize();
                } else m_is_init = true;
                return m_is_init;
            } catch (const std::exception& e) {
#               if CONSOLIX_USE_LOGIT == 1
                LOGIT_PRINT_ERROR("Unhandled exception during initialization: ", e.what());
#               else
                CONSOLIX_STREAM() << "Unhandled exception during initialization: " << e.what() << std::endl;
#               endif
                throw;
            }
        }

        bool is_initialized() const override {
            return m_is_init;
        }

        void process() override {
            try {
                if (m_on_execute) m_on_execute();
                else std::this_thread::sleep_for(std::chrono::milliseconds(1));
            } catch (const std::exception& e) {
#               if CONSOLIX_USE_LOGIT == 1
                LOGIT_PRINT_ERROR("Unhandled exception during execution: ", e.what());
#               else
                CONSOLIX_STREAM() << "Unhandled exception during execution: " << e.what() << std::endl;
#               endif
                throw;
            }
        }

        void shutdown(int signal) override {
            try {
                if (m_on_shutdown) m_on_shutdown(signal);
            } catch (const std::exception& e) {
#               if CONSOLIX_USE_LOGIT == 1
                LOGIT_PRINT_ERROR("Unhandled exception during shutdown: ", e.what());
#               else
                CONSOLIX_STREAM() << "Unhandled exception during shutdown: " << e.what() << std::endl;
#               endif
                throw;
            }
        }
 
    private:
        std::function<bool()> m_on_initialize;   
        std::function<void()> m_on_execute;      
        std::function<void(int)> m_on_shutdown;  
        std::atomic<bool> m_is_init{false};      
    }; // LoopComponent
 
}; // namespace consolix
 
#endif // _CONSOLIX_LOOP_COMPONENT_HPP_INCLUDED