thread_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
 
 // end of core_threading
 
#include <kcenon/thread/utils/formatter.h>
#include <kcenon/thread/utils/convert_string.h>
#include "thread_conditions.h"
#include "error_handling.h"
#include "thread_impl.h"
#include "lifecycle_controller.h"
 
#include <mutex>
#include <memory>
#include <thread>
#include <atomic>
#include <chrono>
#include <iostream>
#include <optional>
#include <condition_variable>
 
#ifdef USE_STD_JTHREAD
#include <stop_token>
#endif
 
namespace kcenon::thread
{
    class thread_base
    {
    public:
        thread_base(const thread_base&) = delete;
        thread_base& operator=(const thread_base&) = delete;
        thread_base(thread_base&&) = delete;
        thread_base& operator=(thread_base&&) = delete;
 
        thread_base(const std::string& thread_title = "thread_base");
 
        virtual ~thread_base(void);
 
        auto set_wake_interval(const std::optional<std::chrono::milliseconds>& wake_interval)
            -> void;
 
        [[nodiscard]] auto get_wake_interval() const 
            -> std::optional<std::chrono::milliseconds>;
 
        auto start(void) -> common::VoidResult;
 
        auto stop(void) -> common::VoidResult;
 
        [[nodiscard]] auto get_thread_title() const -> std::string { return thread_title_; }
 
        [[nodiscard]] auto is_running() const -> bool;
 
        [[nodiscard]] auto get_thread_id() const -> std::thread::id;
 
        [[nodiscard]] virtual auto to_string(void) const -> std::string;
 
    protected:
        [[nodiscard]] virtual auto should_continue_work(void) const -> bool { return false; }
 
        virtual auto before_start(void) -> common::VoidResult { return common::ok(); }
 
        virtual auto do_work(void) -> common::VoidResult { return common::ok(); }
 
        virtual auto after_stop(void) -> common::VoidResult { return common::ok(); }
 
        virtual auto on_stop_requested(void) -> void {}
 
    protected:
        std::optional<std::chrono::milliseconds> wake_interval_;
 
    private:
        std::atomic<int> consecutive_failures_{0};
 
        static constexpr int max_consecutive_failures = 10;
 
        mutable std::mutex wake_interval_mutex_;
 
        lifecycle_controller lifecycle_;
 
#ifdef USE_STD_JTHREAD
        std::unique_ptr<std::jthread> worker_thread_;
#else
        std::unique_ptr<std::thread> worker_thread_;
#endif
 
        std::string thread_title_;
    };
} // namespace kcenon::thread
 
// ----------------------------------------------------------------------------
// Formatter specializations for thread_base
// ----------------------------------------------------------------------------
 
#include <kcenon/thread/utils/formatter_macros.h>
 
// Generate formatter specializations for kcenon::thread::thread_base
DECLARE_FORMATTER(kcenon::thread::thread_base)