lifecycle_controller.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "thread_conditions.h"
 
#include <mutex>
#include <atomic>
#include <chrono>
#include <optional>
#include <condition_variable>
 
#ifdef USE_STD_JTHREAD
#include <stop_token>
#endif
 
namespace kcenon::thread
{
    class lifecycle_controller
    {
    public:
        lifecycle_controller(const lifecycle_controller&) = delete;
        lifecycle_controller& operator=(const lifecycle_controller&) = delete;
        lifecycle_controller(lifecycle_controller&&) = delete;
        lifecycle_controller& operator=(lifecycle_controller&&) = delete;
 
        lifecycle_controller();
 
        ~lifecycle_controller() = default;
 
        // =========================================================================
        // State Management
        // =========================================================================
 
        [[nodiscard]] auto get_state() const noexcept -> thread_conditions;
 
        auto set_state(thread_conditions state) noexcept -> void;
 
        [[nodiscard]] auto is_running() const noexcept -> bool;
 
        auto set_stopped() noexcept -> void;
 
        // =========================================================================
        // Stop Request Management
        // =========================================================================
 
        auto initialize_for_start() -> void;
 
        auto request_stop() noexcept -> void;
 
        [[nodiscard]] auto is_stop_requested() const noexcept -> bool;
 
        [[nodiscard]] auto has_active_source() const noexcept -> bool;
 
        auto reset_stop_source() noexcept -> void;
 
        // =========================================================================
        // Condition Variable Operations
        // =========================================================================
 
        [[nodiscard]] auto acquire_lock() -> std::unique_lock<std::mutex>;
 
        template<typename Predicate>
        auto wait(std::unique_lock<std::mutex>& lock, Predicate pred) -> void
        {
#ifdef USE_STD_JTHREAD
            if (stop_source_.has_value())
            {
                auto stop_token = stop_source_.value().get_token();
                condition_.wait(lock, [this, &stop_token, &pred]() {
                    return stop_token.stop_requested() || pred();
                });
            }
            else
            {
                condition_.wait(lock, pred);
            }
#else
            condition_.wait(lock, [this, &pred]() {
                return stop_requested_.load(std::memory_order_acquire) || pred();
            });
#endif
        }
 
        template<typename Rep, typename Period, typename Predicate>
        auto wait_for(std::unique_lock<std::mutex>& lock,
                      const std::chrono::duration<Rep, Period>& timeout,
                      Predicate pred) -> bool
        {
#ifdef USE_STD_JTHREAD
            if (stop_source_.has_value())
            {
                auto stop_token = stop_source_.value().get_token();
                return condition_.wait_for(lock, timeout, [this, &stop_token, &pred]() {
                    return stop_token.stop_requested() || pred();
                });
            }
            else
            {
                return condition_.wait_for(lock, timeout, pred);
            }
#else
            return condition_.wait_for(lock, timeout, [this, &pred]() {
                return stop_requested_.load(std::memory_order_acquire) || pred();
            });
#endif
        }
 
        auto notify_one() -> void;
 
        auto notify_all() -> void;
 
    private:
        std::mutex cv_mutex_;
 
        std::condition_variable condition_;
 
        std::atomic<thread_conditions> state_{thread_conditions::Created};
 
#ifdef USE_STD_JTHREAD
        std::optional<std::stop_source> stop_source_;
#else
        std::atomic<bool> stop_requested_{false};
#endif
    };
 
} // namespace kcenon::thread