error_category.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <functional>
#include <string>
#include <string_view>
 
namespace kcenon::common {
 
class error_category {
public:
    virtual ~error_category() = default;
 
    virtual std::string_view name() const noexcept = 0;
 
    virtual std::string message(int code) const = 0;
 
    virtual bool equivalent(int code,
                          const error_category& other_category,
                          int other_code) const noexcept {
        return (this == &other_category) && (code == other_code);
    }
 
    bool operator==(const error_category& other) const noexcept {
        return this == &other;
    }
 
    bool operator!=(const error_category& other) const noexcept {
        return !(*this == other);
    }
 
    bool operator<(const error_category& other) const noexcept {
        return std::less<const error_category*>()(this, &other);
    }
 
protected:
    error_category() = default;
 
    // Non-copyable, non-movable (singleton pattern)
    error_category(const error_category&) = delete;
    error_category& operator=(const error_category&) = delete;
    error_category(error_category&&) = delete;
    error_category& operator=(error_category&&) = delete;
};
 
// Forward declaration
class typed_error_code;
 
class common_error_category : public error_category {
public:
    enum codes : int {
        success = 0,
        unknown_error = -1,
        invalid_argument = -2,
        not_found = -3,
        permission_denied = -4,
        timeout = -5,
        cancelled = -6,
        not_initialized = -7,
        already_exists = -8,
        out_of_memory = -9,
        io_error = -10,
        operation_not_supported = -11,
        internal_error = -99
    };
 
    static const common_error_category& instance() noexcept {
        static common_error_category inst;
        return inst;
    }
 
    std::string_view name() const noexcept override {
        return "common";
    }
 
    std::string message(int code) const override {
        switch (code) {
            case success: return "Success";
            case unknown_error: return "Unknown error";
            case invalid_argument: return "Invalid argument";
            case not_found: return "Not found";
            case permission_denied: return "Permission denied";
            case timeout: return "Operation timed out";
            case cancelled: return "Operation was cancelled";
            case not_initialized: return "Not initialized";
            case already_exists: return "Already exists";
            case out_of_memory: return "Out of memory";
            case io_error: return "I/O error";
            case operation_not_supported: return "Operation not supported";
            case internal_error: return "Internal error";
            default: return "Unknown common error (code: " + std::to_string(code) + ")";
        }
    }
 
private:
    common_error_category() = default;
};
 
class typed_error_code {
public:
    typed_error_code() noexcept
        : code_(0)
        , category_(&common_error_category::instance()) {}
 
    typed_error_code(int code, const error_category& category) noexcept
        : code_(code)
        , category_(&category) {}
 
    typed_error_code(common_error_category::codes code) noexcept
        : code_(static_cast<int>(code))
        , category_(&common_error_category::instance()) {}
 
    int value() const noexcept { return code_; }
 
    const error_category& category() const noexcept { return *category_; }
 
    std::string message() const { return category_->message(code_); }
 
    std::string_view category_name() const noexcept { return category_->name(); }
 
    explicit operator bool() const noexcept { return code_ != 0; }
 
    void clear() noexcept {
        code_ = 0;
        category_ = &common_error_category::instance();
    }
 
    void assign(int code, const error_category& category) noexcept {
        code_ = code;
        category_ = &category;
    }
 
    bool operator==(const typed_error_code& other) const noexcept {
        return code_ == other.code_ && *category_ == *other.category_;
    }
 
    bool operator!=(const typed_error_code& other) const noexcept {
        return !(*this == other);
    }
 
    bool operator<(const typed_error_code& other) const noexcept {
        if (*category_ < *other.category_) return true;
        if (*other.category_ < *category_) return false;
        return code_ < other.code_;
    }
 
private:
    int code_;
    const error_category* category_;
};
 
// ============================================================================
// Helper Functions
// ============================================================================
 
inline typed_error_code make_typed_error_code(common_error_category::codes code) noexcept {
    return typed_error_code(static_cast<int>(code), common_error_category::instance());
}
 
template<typename Category>
typed_error_code make_typed_error_code(int code) noexcept {
    return typed_error_code(code, Category::instance());
}
 
inline bool is_success(const typed_error_code& ec) noexcept {
    return ec.value() == 0;
}
 
inline bool is_error(const typed_error_code& ec) noexcept {
    return ec.value() != 0;
}
 
} // namespace kcenon::common