Wrapper for std::jthread or std::thread with manual stop mechanism. More...

#include <jthread_compat.h>

Collaboration diagram for kcenon::logger::async::compat_jthread:

Public Member Functions
	compat_jthread () noexcept=default
	Default constructor - no thread.

template<typename F >
	compat_jthread (F &&func)
	Construct and start thread with stop token support.

	~compat_jthread ()
	Destructor - requests stop and joins.

	compat_jthread (const compat_jthread &)=delete

compat_jthread &	operator= (const compat_jthread &)=delete

	compat_jthread (compat_jthread &&other) noexcept

compat_jthread &	operator= (compat_jthread &&other) noexcept

bool	joinable () const noexcept
	Check if thread is joinable.

void	request_stop ()
	Request the thread to stop.

void	join ()
	Wait for thread to complete.

std::shared_ptr< simple_stop_source >	get_stop_source () const noexcept
	Get the stop source (fallback mode only)

Private Attributes
std::shared_ptr< simple_stop_source >	stop_source_

std::thread	thread_

Detailed Description

Wrapper for std::jthread or std::thread with manual stop mechanism.

When KCENON_HAS_JTHREAD is true, this is a thin wrapper around std::jthread. When KCENON_HAS_JTHREAD is false, this provides equivalent functionality using std::thread with a simple_stop_source.

Definition at line 84 of file jthread_compat.h.

Constructor & Destructor Documentation

◆ compat_jthread() [1/4]

kcenon::logger::async::compat_jthread::compat_jthread ( )

defaultnoexcept

Default constructor - no thread.

◆ compat_jthread() [2/4]

template<typename F >

kcenon::logger::async::compat_jthread::compat_jthread ( F && func )

inlineexplicit

Construct and start thread with stop token support.

Template Parameters

F	Callable type

Parameters

func	Function to run in thread

The function signature should be:

For jthread: void(std::stop_token)
For fallback: void(simple_stop_source&)

Definition at line 106 of file jthread_compat.h.

        : stop_source_(std::make_shared<simple_stop_source>())
        , thread_([func = std::forward<F>(func), stop = stop_source_]() {
            func(*stop);
        }) {}

◆ ~compat_jthread()

kcenon::logger::async::compat_jthread::~compat_jthread ( )

inline

Destructor - requests stop and joins.

Definition at line 116 of file jthread_compat.h.

                      {
        if (joinable()) {
            request_stop();
            join();
        }
    }

References join(), joinable(), and request_stop().

Here is the call graph for this function:

◆ compat_jthread() [3/4]

kcenon::logger::async::compat_jthread::compat_jthread ( const compat_jthread & )

delete

◆ compat_jthread() [4/4]

kcenon::logger::async::compat_jthread::compat_jthread ( compat_jthread && other )

inlinenoexcept

Definition at line 128 of file jthread_compat.h.

        : thread_(std::move(other.thread_)) {}
#else
        : stop_source_(std::move(other.stop_source_))
        , thread_(std::move(other.thread_)) {}

Member Function Documentation

◆ get_stop_source()

std::shared_ptr< simple_stop_source > kcenon::logger::async::compat_jthread::get_stop_source ( ) const

inlinenodiscardnoexcept

Get the stop source (fallback mode only)

Returns: Shared pointer to the stop source

This is used by async_worker to pass the stop source to the worker loop, ensuring the same stop source is used for both request_stop() and stop_requested() checks.

Definition at line 200 of file jthread_compat.h.

                                                                                     {
        return stop_source_;
    }

References stop_source_.

◆ join()

void kcenon::logger::async::compat_jthread::join ( )

inline

Wait for thread to complete.

Definition at line 179 of file jthread_compat.h.

                {
#if KCENON_HAS_JTHREAD
        if (thread_.joinable()) {
            thread_.join();
        }
#else
        if (thread_.joinable()) {
            thread_.join();
        }
#endif
    }

References thread_.

Referenced by operator=(), kcenon::logger::async::async_worker::stop(), kcenon::logger::async::batch_processing_jthread_worker::stop(), kcenon::logger::log_collector_jthread_worker::stop(), kcenon::logger::network_reconnect_jthread_worker::stop(), kcenon::logger::network_send_jthread_worker::stop(), and ~compat_jthread().

Here is the caller graph for this function:

◆ joinable()

bool kcenon::logger::async::compat_jthread::joinable ( ) const

inlinenodiscardnoexcept

Check if thread is joinable.

Definition at line 155 of file jthread_compat.h.

                                                 {
#if KCENON_HAS_JTHREAD
        return thread_.joinable();
#else
        return thread_.joinable();
#endif
    }

References thread_.

Referenced by operator=(), and ~compat_jthread().

Here is the caller graph for this function:

◆ operator=() [1/2]

compat_jthread & kcenon::logger::async::compat_jthread::operator= ( compat_jthread && other )

inlinenoexcept

Definition at line 136 of file jthread_compat.h.

                                                               {
        if (this != &other) {
            if (joinable()) {
                request_stop();
                join();
            }
#if KCENON_HAS_JTHREAD
            thread_ = std::move(other.thread_);
#else
            stop_source_ = std::move(other.stop_source_);
            thread_ = std::move(other.thread_);
#endif
        }
        return *this;
    }

References join(), joinable(), request_stop(), stop_source_, and thread_.

Here is the call graph for this function:

◆ operator=() [2/2]

compat_jthread & kcenon::logger::async::compat_jthread::operator= ( const compat_jthread & )

delete

◆ request_stop()

void kcenon::logger::async::compat_jthread::request_stop ( )

inline

Request the thread to stop.

Definition at line 166 of file jthread_compat.h.

                        {
#if KCENON_HAS_JTHREAD
        thread_.request_stop();
#else
        if (stop_source_) {
            stop_source_->request_stop();
        }
#endif
    }