Advanced cancellation token with timeout, deadline, and reason support. More...

#include <enhanced_cancellation_token.h>

Collaboration diagram for kcenon::thread::enhanced_cancellation_token:

Classes
struct	state

Public Types
using	callback_handle = std::size_t
	Callback handle type for registration management.

using	callback_type = std::function<void()>
	Simple callback function type.

using	callback_with_reason_type
	Callback function type with reason parameter.

Public Member Functions
	enhanced_cancellation_token ()
	Default constructor creates a new token.

	enhanced_cancellation_token (const enhanced_cancellation_token &)=default
	Copy constructor (shares state).

	enhanced_cancellation_token (enhanced_cancellation_token &&) noexcept=default
	Move constructor.

auto	operator= (const enhanced_cancellation_token &) -> enhanced_cancellation_token &=default
	Copy assignment (shares state).

auto	operator= (enhanced_cancellation_token &&) noexcept -> enhanced_cancellation_token &=default
	Move assignment.

	~enhanced_cancellation_token ()
	Destructor.

auto	cancel () -> void
	Cancels the token.

auto	cancel (const std::string &message) -> void
	Cancels the token with a message.

auto	cancel (std::exception_ptr ex) -> void
	Cancels the token with an exception.

auto	is_cancelled () const -> bool
	Checks if the token has been cancelled.

auto	is_cancellation_requested () const -> bool
	Checks if cancellation has been requested.

auto	get_reason () const -> std::optional< cancellation_reason >
	Gets the cancellation reason.

auto	check_cancelled () const -> common::VoidResult
	Checks if the token has been cancelled and returns an error result.

auto	has_timeout () const -> bool
	Checks if the token has a timeout or deadline.

auto	remaining_time () const -> std::chrono::milliseconds
	Gets the remaining time before timeout/deadline.

auto	deadline () const -> std::chrono::steady_clock::time_point
	Gets the deadline time point.

auto	extend_timeout (std::chrono::milliseconds additional) -> void
	Extends the timeout by the specified duration.

auto	register_callback (callback_type callback) -> callback_handle
	Registers a callback to be invoked on cancellation.

auto	register_callback (callback_with_reason_type callback) -> callback_handle
	Registers a callback that receives the cancellation reason.

auto	unregister_callback (callback_handle handle) -> void
	Unregisters a previously registered callback.

auto	wait () const -> void
	Waits until the token is cancelled.

auto	wait_for (std::chrono::milliseconds timeout) const -> bool
	Waits for cancellation with a timeout.

auto	wait_until (std::chrono::steady_clock::time_point deadline) const -> bool
	Waits for cancellation until a deadline.

Static Public Member Functions
static auto	create () -> enhanced_cancellation_token
	Creates a new cancellation token.

static auto	create_with_timeout (std::chrono::milliseconds timeout) -> enhanced_cancellation_token
	Creates a token that auto-cancels after the specified timeout.

static auto	create_with_deadline (std::chrono::steady_clock::time_point deadline) -> enhanced_cancellation_token
	Creates a token that auto-cancels at the specified deadline.

static auto	create_linked (std::initializer_list< enhanced_cancellation_token > tokens) -> enhanced_cancellation_token
	Creates a token linked to parent tokens.

static auto	create_linked_with_timeout (const enhanced_cancellation_token &parent, std::chrono::milliseconds timeout) -> enhanced_cancellation_token
	Creates a linked token with additional timeout.

Private Member Functions
	enhanced_cancellation_token (std::shared_ptr< state > state)

auto	do_cancel (cancellation_reason::type reason_type, const std::string &message, std::optional< std::exception_ptr > ex) -> void

Static Private Member Functions
static auto	start_timeout_timer (std::weak_ptr< state > state_weak, std::chrono::steady_clock::time_point deadline) -> void

Private Attributes
std::shared_ptr< state >	state_

Detailed Description

Advanced cancellation token with timeout, deadline, and reason support.

Extends the basic cancellation_token with additional features:

Timeout-based automatic cancellation
Deadline-based automatic cancellation
Cancellation reason tracking
Hierarchical token linking
Callback registration with handles
Wait methods with timeout support

Design Principles

Thread Safe: All operations are safe for concurrent access
Efficient: Minimal overhead when not cancelled
Composable: Tokens can be linked to create hierarchies
Observable: Callbacks notify when cancellation occurs

Usage Example

// Create token with 30 second timeout
auto token = enhanced_cancellation_token::create_with_timeout(
    std::chrono::seconds{30});
 
// Use in a worker loop
while (!token.is_cancelled()) {
    do_work_chunk();
}
 
// Check reason if cancelled
if (auto reason = token.get_reason()) {
    std::cout << "Cancelled: " << reason->to_string() << std::endl;
}

See also: cancellation_token For basic Cancellation functionality; cancellation_reason For Cancellation reason details

Definition at line 75 of file enhanced_cancellation_token.h.

Member Typedef Documentation

◆ callback_handle

using kcenon::thread::enhanced_cancellation_token::callback_handle = std::size_t

Callback handle type for registration management.

Definition at line 83 of file enhanced_cancellation_token.h.

◆ callback_type

using kcenon::thread::enhanced_cancellation_token::callback_type = std::function<void()>

Simple callback function type.

Definition at line 86 of file enhanced_cancellation_token.h.

◆ callback_with_reason_type

using kcenon::thread::enhanced_cancellation_token::callback_with_reason_type

Initial value:

std::function<void(const cancellation_reason&)>

Callback function type with reason parameter.

Definition at line 89 of file enhanced_cancellation_token.h.

Constructor & Destructor Documentation

◆ enhanced_cancellation_token() [1/4]

kcenon::thread::enhanced_cancellation_token::enhanced_cancellation_token ( )

Default constructor creates a new token.

Definition at line 40 of file enhanced_cancellation_token.cpp.

        : state_(std::make_shared<state>())
    {
    }

◆ enhanced_cancellation_token() [2/4]

kcenon::thread::enhanced_cancellation_token::enhanced_cancellation_token ( const enhanced_cancellation_token & )

default

Copy constructor (shares state).

◆ enhanced_cancellation_token() [3/4]

kcenon::thread::enhanced_cancellation_token::enhanced_cancellation_token ( enhanced_cancellation_token && )

defaultnoexcept

Move constructor.

◆ ~enhanced_cancellation_token()

kcenon::thread::enhanced_cancellation_token::~enhanced_cancellation_token ( )

Destructor.

Definition at line 51 of file enhanced_cancellation_token.cpp.

    {
        // If this is the last reference and timer is active, signal it to stop
        if (state_ && state_.use_count() == 1)
        {
            state_->timer_should_stop.store(true, std::memory_order_release);
            state_->cv.notify_all();
        }
    }

References state_.

◆ enhanced_cancellation_token() [4/4]

kcenon::thread::enhanced_cancellation_token::enhanced_cancellation_token ( std::shared_ptr< state > state )

explicitprivate

Definition at line 45 of file enhanced_cancellation_token.cpp.

        : state_(std::move(state))
    {
    }

Member Function Documentation

◆ cancel() [1/3]

auto kcenon::thread::enhanced_cancellation_token::cancel ( ) -> void

Cancels the token.

Sets the token to cancelled state with reason_type::user_requested and invokes all registered callbacks.

Definition at line 219 of file enhanced_cancellation_token.cpp.

    {
        do_cancel(cancellation_reason::type::user_requested, "", std::nullopt);
    }

References kcenon::thread::cancellation_reason::user_requested.

◆ cancel() [2/3]

auto kcenon::thread::enhanced_cancellation_token::cancel ( const std::string & message ) -> void

Cancels the token with a message.

Parameters

message Human-readable reason for cancellation.

Definition at line 224 of file enhanced_cancellation_token.cpp.

    {
        do_cancel(cancellation_reason::type::user_requested, message, std::nullopt);
    }

References kcenon::thread::cancellation_reason::user_requested.

◆ cancel() [3/3]

auto kcenon::thread::enhanced_cancellation_token::cancel ( std::exception_ptr ex ) -> void

Cancels the token with an exception.

Parameters

ex	Exception that caused the cancellation.

The cancellation reason_type will be set to error.

Definition at line 229 of file enhanced_cancellation_token.cpp.

    {
        do_cancel(cancellation_reason::type::error, "", ex);
    }

References kcenon::thread::cancellation_reason::error.

◆ check_cancelled()

auto kcenon::thread::enhanced_cancellation_token::check_cancelled ( ) const -> common::VoidResult

nodiscard

Checks if the token has been cancelled and returns an error result.

Returns: common::VoidResult — error with operation_canceled if cancelled, success otherwise

Definition at line 300 of file enhanced_cancellation_token.cpp.

    {
        if (is_cancelled())
        {
            auto reason = get_reason();
            std::string msg = "Operation cancelled";
            if (reason && !reason->message.empty())
            {
                msg += ": " + reason->message;
            }
            return make_error_result(error_code::operation_canceled, msg);
        }
        return common::ok();
    }

References get_reason(), is_cancelled(), kcenon::thread::make_error_result(), and kcenon::thread::operation_canceled.

Referenced by kcenon::thread::cancellation_scope::check_cancelled().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create()

auto kcenon::thread::enhanced_cancellation_token::create ( ) -> enhanced_cancellation_token

staticnodiscard

Creates a new cancellation token.

Returns: A new enhanced_cancellation_token.

Definition at line 61 of file enhanced_cancellation_token.cpp.

    {
        return enhanced_cancellation_token();
    }

Referenced by kcenon::thread::cancellation_context::current().

Here is the caller graph for this function:

◆ create_linked()

auto kcenon::thread::enhanced_cancellation_token::create_linked ( std::initializer_list< enhanced_cancellation_token > tokens ) -> enhanced_cancellation_token

staticnodiscard

Creates a token linked to parent tokens.

Parameters

tokens Parent tokens to link with.

Returns: A new linked token.

The new token will be cancelled when any of the parent tokens are cancelled, with reason_type::parent_cancelled.

Definition at line 88 of file enhanced_cancellation_token.cpp.

    {
        auto new_token = create();
        std::weak_ptr<state> new_state_weak = new_token.state_;
 
        for (const auto& parent : tokens)
        {
            auto parent_copy = parent;
            parent_copy.register_callback(
                [new_state_weak](const cancellation_reason& /*parent_reason*/)
                {
                    if (auto s = new_state_weak.lock())
                    {
                        std::vector<callback_type> simple_to_invoke;
                        std::vector<callback_with_reason_type> reason_to_invoke;
                        cancellation_reason new_reason;
 
                        {
                            std::lock_guard<std::mutex> lock(s->mutex);
                            bool was_cancelled =
                                s->is_cancelled.exchange(true, std::memory_order_release);
                            if (!was_cancelled)
                            {
                                new_reason.reason_type =
                                    cancellation_reason::type::parent_cancelled;
                                new_reason.message = "Parent token was cancelled";
                                new_reason.cancel_time = std::chrono::steady_clock::now();
                                s->reason = new_reason;
 
                                for (auto& [handle, cb] : s->simple_callbacks)
                                {
                                    simple_to_invoke.push_back(std::move(cb));
                                }
                                s->simple_callbacks.clear();
 
                                for (auto& [handle, cb] : s->reason_callbacks)
                                {
                                    reason_to_invoke.push_back(std::move(cb));
                                }
                                s->reason_callbacks.clear();
                            }
                        }
 
                        s->cv.notify_all();
 
                        for (const auto& cb : simple_to_invoke)
                        {
                            cb();
                        }
                        for (const auto& cb : reason_to_invoke)
                        {
                            cb(new_reason);
                        }
                    }
                });
        }
 
        return new_token;
    }

References kcenon::thread::cancellation_reason::cancel_time, kcenon::thread::cancellation_reason::message, kcenon::thread::cancellation_reason::parent_cancelled, and kcenon::thread::cancellation_reason::reason_type.

◆ create_linked_with_timeout()

auto kcenon::thread::enhanced_cancellation_token::create_linked_with_timeout	(	const enhanced_cancellation_token &	parent,
		std::chrono::milliseconds	timeout ) -> enhanced_cancellation_token

staticnodiscard

Creates a linked token with additional timeout.

Parameters

parent	Parent token to link with.
timeout	Additional timeout duration.

Returns: A new linked token with timeout.

The token cancels when either:

The parent token is cancelled (reason: parent_cancelled)
The timeout expires (reason: timeout)

Definition at line 150 of file enhanced_cancellation_token.cpp.

    {
        auto deadline_point = std::chrono::steady_clock::now() + timeout;
 
        auto token = create();
        token.state_->deadline_point = deadline_point;
        token.state_->has_deadline.store(true, std::memory_order_release);
 
        // Link to parent
        std::weak_ptr<state> token_state_weak = token.state_;
        auto parent_copy = parent;
        parent_copy.register_callback(
            [token_state_weak](const cancellation_reason& /*parent_reason*/)
            {
                if (auto s = token_state_weak.lock())
                {
                    std::vector<callback_type> simple_to_invoke;
                    std::vector<callback_with_reason_type> reason_to_invoke;
                    cancellation_reason new_reason;
 
                    {
                        std::lock_guard<std::mutex> lock(s->mutex);
                        bool was_cancelled =
                            s->is_cancelled.exchange(true, std::memory_order_release);
                        if (!was_cancelled)
                        {
                            new_reason.reason_type =
                                cancellation_reason::type::parent_cancelled;
                            new_reason.message = "Parent token was cancelled";
                            new_reason.cancel_time = std::chrono::steady_clock::now();
                            s->reason = new_reason;
 
                            for (auto& [handle, cb] : s->simple_callbacks)
                            {
                                simple_to_invoke.push_back(std::move(cb));
                            }
                            s->simple_callbacks.clear();
 
                            for (auto& [handle, cb] : s->reason_callbacks)
                            {
                                reason_to_invoke.push_back(std::move(cb));
                            }
                            s->reason_callbacks.clear();
 
                            s->timer_should_stop.store(true, std::memory_order_release);
                        }
                    }
 
                    s->cv.notify_all();
 
                    for (const auto& cb : simple_to_invoke)
                    {
                        cb();
                    }
                    for (const auto& cb : reason_to_invoke)
                    {
                        cb(new_reason);
                    }
                }
            });
 
        // Start timeout timer
        start_timeout_timer(token_state_weak, deadline_point);
 
        return token;
    }

References kcenon::thread::cancellation_reason::cancel_time, kcenon::thread::cancellation_reason::message, kcenon::thread::cancellation_reason::parent_cancelled, and kcenon::thread::cancellation_reason::reason_type.

◆ create_with_deadline()

auto kcenon::thread::enhanced_cancellation_token::create_with_deadline ( std::chrono::steady_clock::time_point deadline ) -> enhanced_cancellation_token

staticnodiscard

Creates a token that auto-cancels at the specified deadline.

Parameters

deadline Time point at which the token auto-cancels.

Returns: A new token with deadline.

The token will automatically cancel with reason_type::deadline when the specified time point is reached.

Definition at line 73 of file enhanced_cancellation_token.cpp.

    {
        auto token = create();
        token.state_->deadline_point = deadline_point;
        token.state_->has_deadline.store(true, std::memory_order_release);
 
        // Start timeout timer in background
        std::weak_ptr<state> state_weak = token.state_;
        start_timeout_timer(state_weak, deadline_point);
 
        return token;
    }

◆ create_with_timeout()

auto kcenon::thread::enhanced_cancellation_token::create_with_timeout ( std::chrono::milliseconds timeout ) -> enhanced_cancellation_token

staticnodiscard

Creates a token that auto-cancels after the specified timeout.

Parameters

timeout Duration after which the token auto-cancels.

Returns: A new token with timeout.

The token will automatically cancel with reason_type::timeout when the specified duration elapses from the creation time.

Definition at line 66 of file enhanced_cancellation_token.cpp.

    {
        auto deadline_point = std::chrono::steady_clock::now() + timeout;
        return create_with_deadline(deadline_point);
    }

◆ deadline()

auto kcenon::thread::enhanced_cancellation_token::deadline ( ) const -> std::chrono::steady_clock::time_point

nodiscard

Gets the deadline time point.

Returns: The deadline if set, or time_point::max() if none.

Definition at line 340 of file enhanced_cancellation_token.cpp.

    {
        return state_->deadline_point;
    }

References state_.

◆ do_cancel()

auto kcenon::thread::enhanced_cancellation_token::do_cancel	(	cancellation_reason::type	reason_type,
		const std::string &	message,
		std::optional< std::exception_ptr >	ex ) -> void

private

Definition at line 234 of file enhanced_cancellation_token.cpp.

    {
        std::vector<callback_type> simple_to_invoke;
        std::vector<callback_with_reason_type> reason_to_invoke;
        cancellation_reason new_reason;
 
        {
            std::lock_guard<std::mutex> lock(state_->mutex);
            bool was_cancelled =
                state_->is_cancelled.exchange(true, std::memory_order_release);
            if (!was_cancelled)
            {
                new_reason.reason_type = reason_type;
                new_reason.message = message;
                new_reason.cancel_time = std::chrono::steady_clock::now();
                new_reason.exception = ex;
                state_->reason = new_reason;
 
                for (auto& [handle, cb] : state_->simple_callbacks)
                {
                    simple_to_invoke.push_back(std::move(cb));
                }
                state_->simple_callbacks.clear();
 
                for (auto& [handle, cb] : state_->reason_callbacks)
                {
                    reason_to_invoke.push_back(std::move(cb));
                }
                state_->reason_callbacks.clear();
 
                state_->timer_should_stop.store(true, std::memory_order_release);
            }
        }
 
        state_->cv.notify_all();
 
        for (const auto& cb : simple_to_invoke)
        {
            cb();
        }
        for (const auto& cb : reason_to_invoke)
        {
            cb(new_reason);
        }
    }

References kcenon::thread::cancellation_reason::cancel_time, kcenon::thread::cancellation_reason::exception, kcenon::thread::cancellation_reason::message, and kcenon::thread::cancellation_reason::reason_type.

◆ extend_timeout()

auto kcenon::thread::enhanced_cancellation_token::extend_timeout ( std::chrono::milliseconds additional ) -> void

Extends the timeout by the specified duration.

Parameters

additional Additional time to add to the deadline.

Definition at line 346 of file enhanced_cancellation_token.cpp.

    {
        std::lock_guard<std::mutex> lock(state_->mutex);
        if (state_->has_deadline.load(std::memory_order_acquire))
        {
            state_->deadline_point += additional;
        }
    }

◆ get_reason()

auto kcenon::thread::enhanced_cancellation_token::get_reason ( ) const -> std::optional<cancellation_reason>

nodiscard

Gets the cancellation reason.

Returns: The cancellation reason if cancelled, std::nullopt otherwise.

Definition at line 293 of file enhanced_cancellation_token.cpp.

    {
        std::lock_guard<std::mutex> lock(state_->mutex);
        return state_->reason;
    }

References state_.

Referenced by check_cancelled().

Here is the caller graph for this function:

◆ has_timeout()

auto kcenon::thread::enhanced_cancellation_token::has_timeout ( ) const -> bool

nodiscard

Checks if the token has a timeout or deadline.

Returns: true if the token has a timeout/deadline, false otherwise.

Definition at line 315 of file enhanced_cancellation_token.cpp.

    {
        return state_->has_deadline.load(std::memory_order_acquire);
    }

References state_.

Referenced by remaining_time().

Here is the caller graph for this function:

◆ is_cancellation_requested()

auto kcenon::thread::enhanced_cancellation_token::is_cancellation_requested ( ) const -> bool

nodiscard

Checks if cancellation has been requested.

Returns: true if cancellation is requested, false otherwise.

This is functionally equivalent to is_cancelled() for this implementation.

Definition at line 288 of file enhanced_cancellation_token.cpp.

    {
        return is_cancelled();
    }

References is_cancelled().

Here is the call graph for this function:

◆ is_cancelled()

auto kcenon::thread::enhanced_cancellation_token::is_cancelled ( ) const -> bool

nodiscard

Checks if the token has been cancelled.

Returns: true if cancelled, false otherwise.

Definition at line 283 of file enhanced_cancellation_token.cpp.

    {
        return state_->is_cancelled.load(std::memory_order_acquire);
    }

References is_cancelled(), and state_.

Referenced by check_cancelled(), is_cancellation_requested(), kcenon::thread::cancellation_scope::is_cancelled(), and is_cancelled().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=() [1/2]

auto kcenon::thread::enhanced_cancellation_token::operator= ( const enhanced_cancellation_token & ) -> enhanced_cancellation_token &=default

default

Copy assignment (shares state).

◆ operator=() [2/2]

auto kcenon::thread::enhanced_cancellation_token::operator= ( enhanced_cancellation_token && ) -> enhanced_cancellation_token &=default

defaultnoexcept

Move assignment.

◆ register_callback() [1/2]

auto kcenon::thread::enhanced_cancellation_token::register_callback ( callback_type callback ) -> callback_handle

nodiscard

Registers a callback to be invoked on cancellation.

Parameters

callback Function to call when cancelled.

Returns: Handle for unregistering the callback.

If already cancelled, the callback is invoked immediately.

Definition at line 356 of file enhanced_cancellation_token.cpp.

    {
        std::unique_lock<std::mutex> lock(state_->mutex);
 
        if (state_->is_cancelled.load(std::memory_order_acquire))
        {
            lock.unlock();
            callback();
            return 0;
        }
 
        callback_handle handle =
            state_->next_handle.fetch_add(1, std::memory_order_relaxed);
        state_->simple_callbacks[handle] = std::move(callback);
        return handle;
    }

References kcenon::thread::callback.

◆ register_callback() [2/2]

auto kcenon::thread::enhanced_cancellation_token::register_callback ( callback_with_reason_type callback ) -> callback_handle

nodiscard

Registers a callback that receives the cancellation reason.

Parameters

callback Function to call with reason when cancelled.

Returns: Handle for unregistering the callback.

If already cancelled, the callback is invoked immediately.

Definition at line 374 of file enhanced_cancellation_token.cpp.

    {
        std::unique_lock<std::mutex> lock(state_->mutex);
 
        if (state_->is_cancelled.load(std::memory_order_acquire))
        {
            auto reason = state_->reason;
            lock.unlock();
            if (reason)
            {
                callback(*reason);
            }
            else
            {
                callback(cancellation_reason{cancellation_reason::type::user_requested,
                                             "Operation cancelled",
                                             std::chrono::steady_clock::now(),
                                             std::nullopt});
            }
            return 0;
        }
 
        callback_handle handle =
            state_->next_handle.fetch_add(1, std::memory_order_relaxed);
        state_->reason_callbacks[handle] = std::move(callback);
        return handle;
    }

References kcenon::thread::callback, and kcenon::thread::cancellation_reason::user_requested.

◆ remaining_time()

auto kcenon::thread::enhanced_cancellation_token::remaining_time ( ) const -> std::chrono::milliseconds

nodiscard

Gets the remaining time before timeout/deadline.

Returns: Remaining duration, or zero if expired or no timeout.

Definition at line 320 of file enhanced_cancellation_token.cpp.

    {
        if (!has_timeout())
        {
            return std::chrono::milliseconds::max();
        }
 
        auto now = std::chrono::steady_clock::now();
        auto deadline_point = state_->deadline_point;
 
        if (now >= deadline_point)
        {
            return std::chrono::milliseconds::zero();
        }
 
        return std::chrono::duration_cast<std::chrono::milliseconds>(deadline_point -
                                                                     now);
    }

References has_timeout(), and state_.

Here is the call graph for this function:

◆ start_timeout_timer()

auto kcenon::thread::enhanced_cancellation_token::start_timeout_timer	(	std::weak_ptr< state >	state_weak,
		std::chrono::steady_clock::time_point	deadline ) -> void

staticprivate

Definition at line 444 of file enhanced_cancellation_token.cpp.

    {
        std::thread timer_thread(
            [state_weak, deadline_point]() mutable
            {
                auto s = state_weak.lock();
                // Release the weak_ptr immediately after locking, regardless of
                // lock success. This ensures ~weak_ptr() runs while the strong
                // reference (s) is still alive, preventing a data race on the
                // shared control block between this thread's operator delete
                // (via __on_zero_shared_weak) and the token destructor's
                // __release_shared read (ThreadSanitizer: data race).
                state_weak.reset();
                if (!s)
                {
                    return;
                }
 
                s->timer_active.store(true, std::memory_order_release);
 
                std::unique_lock<std::mutex> lock(s->mutex);
 
                // Wait until deadline or cancellation
                auto result = s->cv.wait_until(
                    lock, deadline_point,
                    [&s]
                    {
                        return s->is_cancelled.load(std::memory_order_acquire) ||
                               s->timer_should_stop.load(std::memory_order_acquire);
                    });
 
                // If not cancelled and deadline reached, cancel with timeout reason
                if (!result && !s->is_cancelled.load(std::memory_order_acquire))
                {
                    std::vector<callback_type> simple_to_invoke;
                    std::vector<callback_with_reason_type> reason_to_invoke;
                    cancellation_reason new_reason;
 
                    bool was_cancelled =
                        s->is_cancelled.exchange(true, std::memory_order_release);
                    if (!was_cancelled)
                    {
                        new_reason.reason_type = cancellation_reason::type::timeout;
                        new_reason.message = "Timeout expired";
                        new_reason.cancel_time = std::chrono::steady_clock::now();
                        s->reason = new_reason;
 
                        for (auto& [handle, cb] : s->simple_callbacks)
                        {
                            simple_to_invoke.push_back(std::move(cb));
                        }
                        s->simple_callbacks.clear();
 
                        for (auto& [handle, cb] : s->reason_callbacks)
                        {
                            reason_to_invoke.push_back(std::move(cb));
                        }
                        s->reason_callbacks.clear();
                    }
 
                    lock.unlock();
                    s->cv.notify_all();
 
                    for (const auto& cb : simple_to_invoke)
                    {
                        cb();
                    }
                    for (const auto& cb : reason_to_invoke)
                    {
                        cb(new_reason);
                    }
                }
                else
                {
                    lock.unlock();
                }
 
                s->timer_active.store(false, std::memory_order_release);
            });
 
        timer_thread.detach();
    }

References kcenon::thread::cancellation_reason::cancel_time, kcenon::thread::cancellation_reason::message, kcenon::thread::cancellation_reason::reason_type, and kcenon::thread::cancellation_reason::timeout.

◆ unregister_callback()

auto kcenon::thread::enhanced_cancellation_token::unregister_callback ( callback_handle handle ) -> void

Unregisters a previously registered callback.

Parameters

handle The handle returned from register_callback.

Definition at line 403 of file enhanced_cancellation_token.cpp.

    {
        if (handle == 0)
        {
            return;
        }
 
        std::lock_guard<std::mutex> lock(state_->mutex);
        state_->simple_callbacks.erase(handle);
        state_->reason_callbacks.erase(handle);
    }

Referenced by kcenon::thread::cancellation_callback_guard::~cancellation_callback_guard().

Here is the caller graph for this function:

◆ wait()

auto kcenon::thread::enhanced_cancellation_token::wait ( ) const -> void

Waits until the token is cancelled.

Blocks the calling thread until the token is cancelled.

Definition at line 416 of file enhanced_cancellation_token.cpp.

    {
        std::unique_lock<std::mutex> lock(state_->mutex);
        state_->cv.wait(
            lock, [this]
            { return state_->is_cancelled.load(std::memory_order_acquire); });
    }

References state_.

◆ wait_for()

auto kcenon::thread::enhanced_cancellation_token::wait_for ( std::chrono::milliseconds timeout ) const -> bool

nodiscard

Waits for cancellation with a timeout.

Parameters

timeout Maximum time to wait.

Returns: true if cancelled, false if timeout expired.

Definition at line 424 of file enhanced_cancellation_token.cpp.

    {
        std::unique_lock<std::mutex> lock(state_->mutex);
        return state_->cv.wait_for(
            lock, timeout,
            [this]
            { return state_->is_cancelled.load(std::memory_order_acquire); });
    }

◆ wait_until()

auto kcenon::thread::enhanced_cancellation_token::wait_until ( std::chrono::steady_clock::time_point deadline ) const -> bool

nodiscard

Waits for cancellation until a deadline.

Parameters

deadline Maximum time point to wait until.

Returns: true if cancelled, false if deadline reached.

Definition at line 434 of file enhanced_cancellation_token.cpp.

    {
        std::unique_lock<std::mutex> lock(state_->mutex);
        return state_->cv.wait_until(
            lock, deadline_point,
            [this]
            { return state_->is_cancelled.load(std::memory_order_acquire); });
    }

Member Data Documentation

◆ state_

std::shared_ptr<state> kcenon::thread::enhanced_cancellation_token::state_

private

Definition at line 325 of file enhanced_cancellation_token.h.

Referenced by deadline(), get_reason(), has_timeout(), is_cancelled(), remaining_time(), wait(), and ~enhanced_cancellation_token().

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

include/kcenon/thread/core/enhanced_cancellation_token.h
src/core/enhanced_cancellation_token.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Design Principles

Usage Example

Member Typedef Documentation

◆ callback_handle

◆ callback_type

◆ callback_with_reason_type

Constructor & Destructor Documentation

◆ enhanced_cancellation_token() [1/4]

◆ enhanced_cancellation_token() [2/4]

◆ enhanced_cancellation_token() [3/4]

◆ ~enhanced_cancellation_token()

◆ enhanced_cancellation_token() [4/4]

Member Function Documentation

◆ cancel() [1/3]

◆ cancel() [2/3]

◆ cancel() [3/3]

◆ check_cancelled()

◆ create()

◆ create_linked()

◆ create_linked_with_timeout()

◆ create_with_deadline()

◆ create_with_timeout()

◆ deadline()

◆ do_cancel()

◆ extend_timeout()

◆ get_reason()

◆ has_timeout()

◆ is_cancellation_requested()

◆ is_cancelled()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ register_callback() [1/2]

◆ register_callback() [2/2]

◆ remaining_time()

◆ start_timeout_timer()

◆ unregister_callback()

◆ wait()

◆ wait_for()

◆ wait_until()

Member Data Documentation

◆ state_