AppComponentManager.hpp

Go to the documentation of this file.

#pragma once
#ifndef _CONSOLIX_APP_COMPONENT_MANAGER_HPP_INCLUDED
#define _CONSOLIX_APP_COMPONENT_MANAGER_HPP_INCLUDED

 
#include <vector>
 
namespace consolix {

    class AppComponentManager {
    public:

        AppComponentManager() = default;

        ~AppComponentManager() {
            m_components.clear(); // Ensures the container is empty.
        }

        template <typename Component, typename... Args>
        std::shared_ptr<Component> add(Args&&... args) {
            auto ptr = std::make_shared<Component>(std::forward<Args>(args)...);
            m_components.push_back(ptr);
            return ptr;
        }

        void add(std::shared_ptr<IAppComponent> component) {
            m_components.push_back(std::move(component));
        }

        bool initialize() {
            try {
                for (const auto& component : m_components) {
                    if (component->is_initialized()) continue;
                    component->initialize();
                }
                return is_initialized();
            } catch (const std::exception& e) {
#               if CONSOLIX_USE_LOGIT == 1
                LOGIT_PRINT_FATAL("Initialization error: ", e.what());
#               endif
                throw;
            }
        }

        bool is_initialized() const {
            for (const auto& component : m_components) {
                if (!component->is_initialized()) return false;
            }
            return true;
        }

        void process() {
            try {
                for (const auto& component : m_components) {
                    component->process();
                }
            } catch (const std::exception& e) {
#               if CONSOLIX_USE_LOGIT == 1
                LOGIT_PRINT_FATAL("Processing error: ", e.what());
#               endif
                throw;
            }
        }

        void shutdown(int signal) {
#           if CONSOLIX_USE_LOGIT == 1
            LOGIT_PRINT_INFO("Starting shutdown with signal: ", signal);
#           endif
            std::vector<std::string> errors; // Собираем ошибки
            for (size_t remaining = m_components.size(); remaining > 0; --remaining) {
                const size_t index = remaining - 1;
                const auto& component = m_components[index];
                try {
                    if (auto shutdownable = std::dynamic_pointer_cast<IShutdownable>(component)) {
                        shutdownable->shutdown(signal);
                    }
                } catch (const std::exception& e) {
#                   if CONSOLIX_USE_LOGIT == 1
                    LOGIT_PRINT_FATAL("Component [", index, "] shutdown error: ", e.what());
#                   endif
                    errors.push_back("Component [" + std::to_string(index) + "] error: " + e.what());
                } catch (...) {
#                   if CONSOLIX_USE_LOGIT == 1
                    LOGIT_PRINT_FATAL("Component [", index, "] shutdown error: Unknown error");
#                   endif
                    errors.push_back("Component [" + std::to_string(index) + "] error: Unknown error");
                }
            }
 
            if (!errors.empty()) {
                // Обрабатываем собранные ошибки
#               if CONSOLIX_USE_LOGIT == 1
                std::string summary = std::accumulate(
                    errors.begin(), errors.end(), std::string(),
                    [](const std::string& acc, const std::string& error) {
                        return acc.empty() ? error : acc + "; " + error;
                    }
                );
                LOGIT_PRINT_FATAL("Shutdown completed with errors. Summary: ", summary);
#               endif
                //throw std::runtime_error("Shutdown completed with errors. See logs for details.");
            }
        }
 
    private:
        std::vector<std::shared_ptr<IAppComponent>> m_components;
    }; // AppComponentManager
 
}; // namespace consolix
 
#endif // _CONSOLIX_APP_COMPONENT_MANAGER_HPP_INCLUDED