error_handling.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
 
#include <string>
#include <string_view>
#include <system_error>
 
// Include common_system Result types
#include <kcenon/common/patterns/result.h>
 
namespace kcenon::thread {
 
enum class error_code {
    // General errors (-100 to -109)
    success = 0,
    unknown_error = -101,
    operation_canceled = -102,
    operation_timeout = -103,
    not_implemented = -104,
    invalid_argument = -105,
 
    // Thread errors (-110 to -119)
    thread_already_running = -110,
    thread_not_running = -111,
    thread_start_failure = -112,
    thread_join_failure = -113,
 
    // Queue errors (-120 to -129)
    queue_full = -120,
    queue_empty = -121,
    queue_stopped = -122,
    queue_busy = -123,  // Queue is temporarily busy with concurrent operations
 
    // Job errors (-130 to -139)
    job_creation_failed = -130,
    job_execution_failed = -131,
    job_invalid = -132,
 
    // Resource errors (-140 to -149)
    resource_allocation_failed = -140,
    resource_limit_reached = -141,
 
    // Synchronization errors (-150 to -159)
    mutex_error = -150,
    deadlock_detected = -151,
    condition_variable_error = -152,
 
    // IO errors (-160 to -169)
    io_error = -160,
    file_not_found = -161,
 
    // Circuit breaker errors (-170 to -179)
    circuit_open = -170,           
    circuit_half_open = -171       
};
 
// Compile-time validation for error code range
static_assert(static_cast<int>(error_code::unknown_error) >= -199 &&
              static_cast<int>(error_code::unknown_error) <= -100,
              "error_code values must be in range [-199, -100]");
static_assert(static_cast<int>(error_code::file_not_found) >= -199 &&
              static_cast<int>(error_code::file_not_found) <= -100,
              "error_code values must be in range [-199, -100]");
 
inline std::string error_code_to_string(error_code code) {
    using map_entry = std::pair<error_code, std::string_view>;
    static constexpr map_entry kMap[] = {
        {error_code::success, "Success"},
        {error_code::unknown_error, "Unknown error"},
        {error_code::operation_canceled, "Operation canceled"},
        {error_code::operation_timeout, "Operation timed out"},
        {error_code::not_implemented, "Not implemented"},
        {error_code::invalid_argument, "Invalid argument"},
        {error_code::thread_already_running, "Thread is already running"},
        {error_code::thread_not_running, "Thread is not running"},
        {error_code::thread_start_failure, "Failed to start thread"},
        {error_code::thread_join_failure, "Failed to join thread"},
        {error_code::queue_full, "Queue is full"},
        {error_code::queue_empty, "Queue is empty"},
        {error_code::queue_stopped, "Queue is stopped"},
        {error_code::queue_busy, "Queue is busy"},
        {error_code::job_creation_failed, "Failed to create job"},
        {error_code::job_execution_failed, "Failed to execute job"},
        {error_code::job_invalid, "Invalid job"},
        {error_code::resource_allocation_failed, "Failed to allocate resource"},
        {error_code::resource_limit_reached, "Resource limit reached"},
        {error_code::mutex_error, "Mutex error"},
        {error_code::deadlock_detected, "Deadlock detected"},
        {error_code::condition_variable_error, "Condition variable error"},
        {error_code::io_error, "I/O error"},
        {error_code::file_not_found, "File not found"},
        {error_code::circuit_open, "Circuit breaker is open"},
        {error_code::circuit_half_open, "Circuit breaker is in half-open state"},
    };
    for (const auto& [k, v] : kMap) {
        if (k == code) return std::string(v);
    }
    return std::string("Unknown error code");
}
 
// ============================================================================
// common::Result Integration Utilities
// ============================================================================
 
inline common::error_info to_error_info(error_code code, const std::string& message = "") {
    return common::error_info{
        static_cast<int>(code),
        message.empty() ? error_code_to_string(code) : message,
        "thread_system"
    };
}
 
inline common::VoidResult make_error_result(error_code code, const std::string& message = "") {
    return common::VoidResult(to_error_info(code, message));
}
 
template<typename T>
common::Result<T> make_error_result(error_code code, const std::string& message = "") {
    return common::Result<T>(to_error_info(code, message));
}
 
inline error_code get_error_code(const common::error_info& info) {
    return static_cast<error_code>(info.code);
}
 
// ============================================================================
// std::error_code Integration
// ============================================================================
 
class thread_error_category : public std::error_category {
public:
    [[nodiscard]] const char* name() const noexcept override {
        return "thread_system";
    }
 
    [[nodiscard]] std::string message(int ev) const override {
        return error_code_to_string(static_cast<error_code>(ev));
    }
 
    [[nodiscard]] bool equivalent(int ev, const std::error_condition& condition) const noexcept override {
        switch (static_cast<error_code>(ev)) {
            case error_code::invalid_argument:
                return condition == std::errc::invalid_argument;
            case error_code::resource_allocation_failed:
            case error_code::resource_limit_reached:
                return condition == std::errc::not_enough_memory;
            case error_code::operation_timeout:
                return condition == std::errc::timed_out;
            case error_code::deadlock_detected:
                return condition == std::errc::resource_deadlock_would_occur;
            default:
                return false;
        }
    }
};
 
inline const std::error_category& thread_category() noexcept {
    static thread_error_category instance;
    return instance;
}
 
inline std::error_code make_error_code(error_code e) noexcept {
    return std::error_code(static_cast<int>(e), thread_category());
}
 
inline std::error_condition make_error_condition(error_code e) noexcept {
    return std::error_condition(static_cast<int>(e), thread_category());
}
 
} // namespace kcenon::thread
 
// ============================================================================
// std::error_code specialization (required to be in global namespace)
// ============================================================================
 
namespace std {
template <>
struct is_error_code_enum<kcenon::thread::error_code> : true_type {};
} // namespace std