lifecycle_manager.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 <atomic>
#include <future>
#include <optional>
 
namespace kcenon::network::utils
{
 
    class lifecycle_manager
    {
    public:
        lifecycle_manager() = default;
 
        ~lifecycle_manager() = default;
 
        // Non-copyable
        lifecycle_manager(const lifecycle_manager&) = delete;
        lifecycle_manager& operator=(const lifecycle_manager&) = delete;
 
        // Movable
        lifecycle_manager(lifecycle_manager&& other) noexcept
            : is_running_(other.is_running_.load(std::memory_order_acquire))
            , stop_initiated_(other.stop_initiated_.load(std::memory_order_acquire))
            , stop_promise_(std::move(other.stop_promise_))
            , stop_future_(std::move(other.stop_future_))
        {
            other.is_running_.store(false, std::memory_order_release);
            other.stop_initiated_.store(false, std::memory_order_release);
        }
 
        lifecycle_manager& operator=(lifecycle_manager&& other) noexcept
        {
            if (this != &other)
            {
                is_running_.store(other.is_running_.load(std::memory_order_acquire),
                                  std::memory_order_release);
                stop_initiated_.store(other.stop_initiated_.load(std::memory_order_acquire),
                                      std::memory_order_release);
                stop_promise_ = std::move(other.stop_promise_);
                stop_future_ = std::move(other.stop_future_);
 
                other.is_running_.store(false, std::memory_order_release);
                other.stop_initiated_.store(false, std::memory_order_release);
            }
            return *this;
        }
 
        [[nodiscard]] auto is_running() const -> bool
        {
            return is_running_.load(std::memory_order_acquire);
        }
 
        [[nodiscard]] auto try_start() -> bool
        {
            bool expected = false;
            return is_running_.compare_exchange_strong(
                expected, true, std::memory_order_acq_rel);
        }
 
        auto set_running() -> void
        {
            is_running_.store(true, std::memory_order_release);
        }
 
        auto mark_stopped() -> void
        {
            is_running_.store(false, std::memory_order_release);
            if (stop_promise_)
            {
                stop_promise_->set_value();
                stop_promise_.reset();
            }
            stop_initiated_.store(false, std::memory_order_release);
        }
 
        auto wait_for_stop() -> void
        {
            if (stop_future_.valid())
            {
                stop_future_.wait();
            }
        }
 
        [[nodiscard]] auto prepare_stop() -> bool
        {
            // Check if already stopping
            bool expected = false;
            if (!stop_initiated_.compare_exchange_strong(expected, true,
                                                         std::memory_order_acq_rel))
            {
                return false; // Already stopping
            }
 
            // Check if running
            if (!is_running_.load(std::memory_order_acquire))
            {
                stop_initiated_.store(false, std::memory_order_release);
                return false; // Not running
            }
 
            // Create synchronization primitives
            stop_promise_.emplace();
            stop_future_ = stop_promise_->get_future();
            return true;
        }
 
        auto reset() -> void
        {
            is_running_.store(false, std::memory_order_release);
            stop_initiated_.store(false, std::memory_order_release);
            stop_promise_.reset();
            stop_future_ = std::future<void>{};
        }
 
    private:
        std::atomic<bool> is_running_{false};
        std::atomic<bool> stop_initiated_{false};
        std::optional<std::promise<void>> stop_promise_;
        std::future<void> stop_future_;
    };
 
} // namespace kcenon::network::utils