kcenon::logger::network_reconnect_jthread_worker Class Reference

Worker thread for reconnection attempts with jthread compatibility. More...

Collaboration diagram for kcenon::logger::network_reconnect_jthread_worker:

Public Types
using	reconnect_callback = std::function<void()>

Public Member Functions
	network_reconnect_jthread_worker (reconnect_callback callback, std::chrono::seconds interval)
	~network_reconnect_jthread_worker ()
void	start ()
void	stop ()

Private Attributes
reconnect_callback	callback_
std::chrono::seconds	reconnect_interval_
compat_jthread	thread_
std::atomic< bool >	running_ {false}

Detailed Description

Worker thread for reconnection attempts with jthread compatibility.

Uses std::jthread with std::stop_token for cooperative cancellation where available, falls back to std::thread with manual stop mechanism.

Definition at line 122 of file network_writer.cpp.

Member Typedef Documentation

reconnect_callback

using kcenon::logger::network_reconnect_jthread_worker::reconnect_callback = std::function<void()>

Definition at line 124 of file network_writer.cpp.

Constructor & Destructor Documentation

network_reconnect_jthread_worker()

kcenon::logger::network_reconnect_jthread_worker::network_reconnect_jthread_worker ( reconnect_callback callback, std::chrono::seconds interval )

inlineexplicit

Definition at line 126 of file network_writer.cpp.

        : callback_(std::move(callback))
        , reconnect_interval_(interval)
    {}

~network_reconnect_jthread_worker()

kcenon::logger::network_reconnect_jthread_worker::~network_reconnect_jthread_worker ( )

inline

Definition at line 132 of file network_writer.cpp.

                                        {
        stop();
    }

References stop().

Here is the call graph for this function:

Member Function Documentation

start()

void kcenon::logger::network_reconnect_jthread_worker::start ( )

inline

Definition at line 136 of file network_writer.cpp.

                 {
        if (running_.exchange(true, std::memory_order_acq_rel)) {
            return;  // Already started
        }
 
#if LOGGER_HAS_JTHREAD
        auto callback = callback_;
        auto interval = reconnect_interval_;
        thread_ = compat_jthread([callback, interval](std::stop_token stop_token) {
            while (!stop_token.stop_requested()) {
                if (callback) {
                    callback();
                }
                // Sleep with stop checking
                for (auto elapsed = std::chrono::milliseconds{0};
                     elapsed < std::chrono::duration_cast<std::chrono::milliseconds>(interval)
                        && !stop_token.stop_requested();
                     elapsed += std::chrono::milliseconds(100)) {
                    std::this_thread::sleep_for(std::chrono::milliseconds(100));
                }
            }
        });
#else
        // Create worker thread with manual stop source
        // Note: We use the stop_source created by compat_jthread to ensure
        // request_stop() correctly signals the worker loop
        auto callback = callback_;
        auto interval = reconnect_interval_;
        thread_ = compat_jthread([callback, interval](simple_stop_source& stop) {
            while (!stop.stop_requested()) {
                if (callback) {
                    callback();
                }
                // Sleep with stop checking
                for (auto elapsed = std::chrono::milliseconds{0};
                     elapsed < std::chrono::duration_cast<std::chrono::milliseconds>(interval)
                        && !stop.stop_requested();
                     elapsed += std::chrono::milliseconds(100)) {
                    std::this_thread::sleep_for(std::chrono::milliseconds(100));
                }
            }
        });
#endif
    }

References callback_, reconnect_interval_, running_, stop(), and thread_.

Here is the call graph for this function:

stop()

void kcenon::logger::network_reconnect_jthread_worker::stop ( )

inline

Definition at line 181 of file network_writer.cpp.

                {
        if (!running_.exchange(false, std::memory_order_acq_rel)) {
            return;  // Already stopped
        }
 
        // Request stop and join thread
        thread_.request_stop();
        thread_.join();
    }

References kcenon::logger::async::compat_jthread::join(), kcenon::logger::async::compat_jthread::request_stop(), running_, and thread_.

Referenced by start(), and ~network_reconnect_jthread_worker().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

callback_

reconnect_callback kcenon::logger::network_reconnect_jthread_worker::callback_

private

Definition at line 192 of file network_writer.cpp.

Referenced by start().

reconnect_interval_

std::chrono::seconds kcenon::logger::network_reconnect_jthread_worker::reconnect_interval_

private

Definition at line 193 of file network_writer.cpp.

Referenced by start().

running_

std::atomic<bool> kcenon::logger::network_reconnect_jthread_worker::running_ {false}

private

Definition at line 195 of file network_writer.cpp.

{false};

Referenced by start(), and stop().

thread_

compat_jthread kcenon::logger::network_reconnect_jthread_worker::thread_

private

Definition at line 194 of file network_writer.cpp.

Referenced by start(), and stop().

---

The documentation for this class was generated from the following file:

• src/impl/writers/network_writer.cpp