startable_base.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 <string>
#include <string_view>
#include <type_traits>
#include <utility>
 
#include "kcenon/network/detail/utils/lifecycle_manager.h"
#include "kcenon/network/detail/utils/result_types.h"
 
namespace kcenon::network::utils
{
 
    template<typename Derived>
    class startable_base
    {
    public:
        [[nodiscard]] auto is_running() const noexcept -> bool
        {
            return lifecycle_.is_running();
        }
 
        auto wait_for_stop() -> void
        {
            lifecycle_.wait_for_stop();
        }
 
    protected:
        startable_base() = default;
 
        ~startable_base() = default;
 
        // Non-copyable
        startable_base(const startable_base&) = delete;
        startable_base& operator=(const startable_base&) = delete;
 
        // Movable
        startable_base(startable_base&&) noexcept = default;
        startable_base& operator=(startable_base&&) noexcept = default;
 
        template<typename... Args>
        [[nodiscard]] auto do_start(Args&&... args) -> VoidResult
        {
            if (!lifecycle_.try_start())
            {
                return error_void(
                    error_codes::common_errors::already_exists,
                    std::string(derived().component_name()) + " is already running",
                    "startable_base::do_start",
                    std::string(derived().component_name()));
            }
 
            reset_connection_state();
 
            auto result = derived().do_start_impl(std::forward<Args>(args)...);
 
            if (result.is_err())
            {
                lifecycle_.mark_stopped();
            }
 
            return result;
        }
 
        [[nodiscard]] auto do_stop() -> VoidResult
        {
            if (!lifecycle_.is_running())
            {
                return ok();
            }
 
            // Prevent multiple stop calls
            bool expected = false;
            if (!stop_initiated_.compare_exchange_strong(expected, true,
                                                          std::memory_order_acq_rel))
            {
                return ok();
            }
 
            auto result = derived().do_stop_impl();
            lifecycle_.mark_stopped();
 
            // Call derived class's on_stopped hook for callbacks
            derived().on_stopped();
 
            return result;
        }
 
        [[nodiscard]] auto is_stop_initiated() const noexcept -> bool
        {
            return stop_initiated_.load(std::memory_order_acquire);
        }
 
        [[nodiscard]] auto get_lifecycle() -> lifecycle_manager&
        {
            return lifecycle_;
        }
 
        [[nodiscard]] auto get_lifecycle() const -> const lifecycle_manager&
        {
            return lifecycle_;
        }
 
    private:
        auto reset_connection_state() -> void
        {
            stop_initiated_.store(false, std::memory_order_release);
        }
 
        [[nodiscard]] auto derived() -> Derived&
        {
            return static_cast<Derived&>(*this);
        }
 
        [[nodiscard]] auto derived() const -> const Derived&
        {
            return static_cast<const Derived&>(*this);
        }
 
        lifecycle_manager lifecycle_;                   
        std::atomic<bool> stop_initiated_{false};       
    };
 
} // namespace kcenon::network::utils