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 <optional>
#include <type_traits>
#include <string_view>
#include <ostream>
#include <functional>
#include <stdexcept>
 
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
};
 
// 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"},
    };
    for (const auto& [k, v] : kMap) {
        if (k == code) return std::string(v);
    }
    return std::string("Unknown error code");
}
 
class error {
public:
    explicit error(error_code code, std::string message = {})
        : code_(code), message_(std::move(message)) {}
    
    [[nodiscard]] error_code code() const noexcept { return code_; }
    
    [[nodiscard]] const std::string& message() const noexcept { return message_; }
    
    [[nodiscard]] std::string to_string() const {
        if (message_.empty()) {
            return error_code_to_string(code_);
        }
        return error_code_to_string(code_) + ": " + message_;
    }
    
    operator std::string() const {
        return to_string();
    }
    
private:
    error_code code_;
    std::string message_;
};
 
// Forward declaration of result template
template <typename T>
class result;
 
class result_void {
public:
    result_void() = default;
    
    result_void(const error& err) : has_error_(true), error_(err) {}
    
    [[nodiscard]] bool has_error() const noexcept { return has_error_; }
 
    [[nodiscard]] bool has_value() const noexcept { return !has_error_; }
 
    [[nodiscard]] bool is_ok() const noexcept { return !has_error_; }
 
    [[nodiscard]] bool is_error() const noexcept { return has_error_; }
 
    [[nodiscard]] const error& get_error() const { return error_; }
 
    explicit operator bool() const noexcept { return !has_error_; }
    
private:
    bool has_error_ = false;
    error error_{error_code::success, ""};
};
 
template <typename T>
class result {
public:
    using value_type = T;
    using error_type = error;
    
    result(T value) : has_value_(true), value_(std::move(value)), error_(error_code::success, "") {}
    
    result(error err) : has_value_(false), error_(std::move(err)) {}
    
    [[nodiscard]] explicit operator bool() const noexcept {
        return has_value_;
    }
    
    [[nodiscard]] bool has_value() const noexcept {
        return has_value_;
    }
 
    [[nodiscard]] bool is_ok() const noexcept {
        return has_value_;
    }
 
    [[nodiscard]] bool is_error() const noexcept {
        return !has_value_;
    }
 
    [[nodiscard]] T& value() & {
        if (!has_value_) {
            throw std::runtime_error("Cannot access value of an error result");
        }
        return value_;
    }
 
    [[nodiscard]] const T& value() const & {
        if (!has_value_) {
            throw std::runtime_error("Cannot access value of an error result");
        }
        return value_;
    }
    
    [[nodiscard]] T&& value() && {
        if (!has_value_) {
            throw std::runtime_error("Cannot access value of an error result");
        }
        return std::move(value_);
    }
    
    [[nodiscard]] error& get_error() & {
        if (has_value_) {
            throw std::runtime_error("Cannot get error from successful result");
        }
        return error_;
    }
    
    [[nodiscard]] const error& get_error() const & {
        if (has_value_) {
            throw std::runtime_error("Cannot get error from successful result");
        }
        return error_;
    }
    
    [[nodiscard]] error&& get_error() && {
        if (has_value_) {
            throw std::runtime_error("Cannot get error from successful result");
        }
        return std::move(error_);
    }
    
    template <typename U>
    [[nodiscard]] T value_or(U&& default_value) const & {
        if (has_value_) {
            return value_;
        }
        return static_cast<T>(std::forward<U>(default_value));
    }
    
    template <typename U>
    [[nodiscard]] T value_or(U&& default_value) && {
        if (has_value_) {
            return std::move(value_);
        }
        return static_cast<T>(std::forward<U>(default_value));
    }
    
    [[nodiscard]] T value_or_throw() const & {
        if (has_value_) {
            return value_;
        }
        throw std::runtime_error(error_.to_string());
    }
    
    [[nodiscard]] T value_or_throw() && {
        if (has_value_) {
            return std::move(value_);
        }
        throw std::runtime_error(error_.to_string());
    }
    
    template <typename Fn>
    [[nodiscard]] auto map(Fn&& fn) const -> result<std::invoke_result_t<Fn, const T&>> {
        using ResultType = result<std::invoke_result_t<Fn, const T&>>;
        
        if (has_value_) {
            return ResultType(std::invoke(std::forward<Fn>(fn), value_));
        }
        return ResultType(error_);
    }
    
    template <typename Fn>
    [[nodiscard]] auto and_then(Fn&& fn) const -> std::invoke_result_t<Fn, const T&> {
        using ResultType = std::invoke_result_t<Fn, const T&>;
        static_assert(std::is_same_v<typename ResultType::error_type, error>, "Function must return a result with the same error type");
        
        if (has_value_) {
            return std::invoke(std::forward<Fn>(fn), value_);
        }
        return ResultType(error_);
    }
    
private:
    bool has_value_ = false;
    T value_{};
    error error_{error_code::success, ""};
};
 
template <>
class result<void> {
public:
    using value_type = void;
    using error_type = error;
    
    result() : success_(true) {}
    
    result(const result_void& r) : success_(!r.has_error()), error_(r.has_error() ? r.get_error() : error{error_code::success, ""}) {}
    
    result(error err) : success_(false), error_(std::move(err)) {}
    
    [[nodiscard]] explicit operator bool() const noexcept {
        return success_;
    }
    
    [[nodiscard]] bool has_value() const noexcept {
        return success_;
    }
 
    [[nodiscard]] bool is_ok() const noexcept {
        return success_;
    }
 
    [[nodiscard]] bool is_error() const noexcept {
        return !success_;
    }
 
    [[nodiscard]] error& get_error() & {
        if (success_) {
            throw std::runtime_error("Cannot get error from successful result");
        }
        return error_;
    }
    
    [[nodiscard]] const error& get_error() const & {
        if (success_) {
            throw std::runtime_error("Cannot get error from successful result");
        }
        return error_;
    }
    
    [[nodiscard]] error&& get_error() && {
        if (success_) {
            throw std::runtime_error("Cannot get error from successful result");
        }
        return std::move(error_);
    }
    
    void value_or_throw() const {
        if (!success_) {
            throw std::runtime_error(error_.to_string());
        }
    }
    
    template <typename Fn>
    [[nodiscard]] auto map(Fn&& fn) const -> result<std::invoke_result_t<Fn>> {
        using ResultType = result<std::invoke_result_t<Fn>>;
        
        if (success_) {
            return ResultType(std::invoke(std::forward<Fn>(fn)));
        }
        return ResultType(error_);
    }
    
    template <typename Fn>
    [[nodiscard]] auto and_then(Fn&& fn) const -> std::invoke_result_t<Fn> {
        using ResultType = std::invoke_result_t<Fn>;
        static_assert(std::is_same_v<typename ResultType::error_type, error>, "Function must return a result with the same error type");
        
        if (success_) {
            return std::invoke(std::forward<Fn>(fn));
        }
        return ResultType(error_);
    }
    
private:
    bool success_ = false;
    error error_{error_code::success, ""};
};
 
// Type aliases for common result types
template <typename T>
using result_t = result<T>;
 
// Helper to convert std::optional<std::string> to result<T>
template <typename T>
result<T> optional_error_to_result(const std::optional<std::string>& error, T&& value) {
    if (error) {
        return result<T>(kcenon::thread::error{error_code::unknown_error, *error});
    }
    return result<T>(std::forward<T>(value));
}
 
// Helper to convert std::optional<std::string> to result<void>
inline result<void> optional_error_to_result(const std::optional<std::string>& error) {
    if (error) {
        return result<void>(kcenon::thread::error{error_code::unknown_error, *error});
    }
    return result<void>();
}
 
// Compatibility layer for existing code
inline std::optional<std::string> result_to_optional_error(const result<void>& res) {
    if (res) {
        return std::nullopt;
    }
    return res.get_error().to_string();
}
 
template <typename T>
std::pair<std::optional<T>, std::optional<std::string>> result_to_pair(const result<T>& res) {
    if (res) {
        return {res.value(), std::nullopt};
    }
    return {std::nullopt, res.get_error().to_string()};
}
 
} // namespace kcenon::thread