cancellation_reason.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 cancellation
 
#include <chrono>
#include <exception>
#include <optional>
#include <string>
 
namespace kcenon::thread
{
    struct cancellation_reason
    {
        enum class type
        {
            none,              
            user_requested,    
            timeout,           
            deadline,          
            parent_cancelled,  
            pool_shutdown,     
            error              
        };
 
        type reason_type = type::none;
 
        std::string message;
 
        std::chrono::steady_clock::time_point cancel_time;
 
        std::optional<std::exception_ptr> exception;
 
        [[nodiscard]] auto to_string() const -> std::string
        {
            std::string type_str;
            switch (reason_type)
            {
                case type::none:
                    type_str = "none";
                    break;
                case type::user_requested:
                    type_str = "user_requested";
                    break;
                case type::timeout:
                    type_str = "timeout";
                    break;
                case type::deadline:
                    type_str = "deadline";
                    break;
                case type::parent_cancelled:
                    type_str = "parent_cancelled";
                    break;
                case type::pool_shutdown:
                    type_str = "pool_shutdown";
                    break;
                case type::error:
                    type_str = "error";
                    break;
            }
 
            std::string result = "cancellation_reason{type=" + type_str;
            if (!message.empty())
            {
                result += ", message=\"" + message + "\"";
            }
            result += "}";
            return result;
        }
 
        [[nodiscard]] static auto type_to_string(type t) -> std::string
        {
            switch (t)
            {
                case type::none:
                    return "none";
                case type::user_requested:
                    return "user_requested";
                case type::timeout:
                    return "timeout";
                case type::deadline:
                    return "deadline";
                case type::parent_cancelled:
                    return "parent_cancelled";
                case type::pool_shutdown:
                    return "pool_shutdown";
                case type::error:
                    return "error";
            }
            return "unknown";
        }
    };
 
} // namespace kcenon::thread