error.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2026 Kamil Lulko <kamil.lulko@gmail.com>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * This file is part of oveRTOS.
 */
 
#pragma once
 
#include <ove/ove.h>
 
#include <expected>
#include <string>
#include <system_error>
#include <type_traits>
#include <utility>
 
namespace ove
{
 
enum class Error : int {
    Ok = OVE_OK,
    NotRegistered = OVE_ERR_NOT_REGISTERED,
    InvalidParam = OVE_ERR_INVALID_PARAM,
    NoMemory = OVE_ERR_NO_MEMORY,
    Timeout = OVE_ERR_TIMEOUT,
    NotSupported = OVE_ERR_NOT_SUPPORTED,
    QueueFull = OVE_ERR_QUEUE_FULL,
    MlFailed = OVE_ERR_ML_FAILED,
    NetRefused = OVE_ERR_NET_REFUSED,
    NetUnreachable = OVE_ERR_NET_UNREACHABLE,
    NetAddrInUse = OVE_ERR_NET_ADDR_IN_USE,
    NetReset = OVE_ERR_NET_RESET,
    NetDnsFail = OVE_ERR_NET_DNS_FAIL,
    NetClosed = OVE_ERR_NET_CLOSED,
    BusNack = OVE_ERR_BUS_NACK,
    BusBusy = OVE_ERR_BUS_BUSY,
    BusError = OVE_ERR_BUS_ERROR,
    QueueEmpty = OVE_ERR_QUEUE_EMPTY,
    WouldBlock = OVE_ERR_WOULD_BLOCK,
    Eof = OVE_ERR_EOF,
    Inval = OVE_ERR_INVAL,
    NotFound = OVE_ERR_NOT_FOUND,
};
 
/*
 * Drift pin.  `<ove/types.h>` already pins every `OVE_ERR_*` to a
 * literal integer with `OVE_STATIC_ASSERT`; this second pass pins
 * `Error::*` to those same substrate values.  A future variant must
 * either land here too or have its substrate constant renumbered —
 * the silent-drift surface is closed at both ends.
 */
static_assert(static_cast<int>(Error::Ok) == OVE_OK, "Error::Ok drifted");
static_assert(static_cast<int>(Error::NotRegistered) == OVE_ERR_NOT_REGISTERED,
          "Error::NotRegistered drifted");
static_assert(static_cast<int>(Error::InvalidParam) == OVE_ERR_INVALID_PARAM,
          "Error::InvalidParam drifted");
static_assert(static_cast<int>(Error::NoMemory) == OVE_ERR_NO_MEMORY, "Error::NoMemory drifted");
static_assert(static_cast<int>(Error::Timeout) == OVE_ERR_TIMEOUT, "Error::Timeout drifted");
static_assert(static_cast<int>(Error::NotSupported) == OVE_ERR_NOT_SUPPORTED,
          "Error::NotSupported drifted");
static_assert(static_cast<int>(Error::QueueFull) == OVE_ERR_QUEUE_FULL, "Error::QueueFull drifted");
static_assert(static_cast<int>(Error::MlFailed) == OVE_ERR_ML_FAILED, "Error::MlFailed drifted");
static_assert(static_cast<int>(Error::NetRefused) == OVE_ERR_NET_REFUSED,
          "Error::NetRefused drifted");
static_assert(static_cast<int>(Error::NetUnreachable) == OVE_ERR_NET_UNREACHABLE,
          "Error::NetUnreachable drifted");
static_assert(static_cast<int>(Error::NetAddrInUse) == OVE_ERR_NET_ADDR_IN_USE,
          "Error::NetAddrInUse drifted");
static_assert(static_cast<int>(Error::NetReset) == OVE_ERR_NET_RESET, "Error::NetReset drifted");
static_assert(static_cast<int>(Error::NetDnsFail) == OVE_ERR_NET_DNS_FAIL,
          "Error::NetDnsFail drifted");
static_assert(static_cast<int>(Error::NetClosed) == OVE_ERR_NET_CLOSED, "Error::NetClosed drifted");
static_assert(static_cast<int>(Error::BusNack) == OVE_ERR_BUS_NACK, "Error::BusNack drifted");
static_assert(static_cast<int>(Error::BusBusy) == OVE_ERR_BUS_BUSY, "Error::BusBusy drifted");
static_assert(static_cast<int>(Error::BusError) == OVE_ERR_BUS_ERROR, "Error::BusError drifted");
static_assert(static_cast<int>(Error::QueueEmpty) == OVE_ERR_QUEUE_EMPTY,
          "Error::QueueEmpty drifted");
static_assert(static_cast<int>(Error::WouldBlock) == OVE_ERR_WOULD_BLOCK,
          "Error::WouldBlock drifted");
static_assert(static_cast<int>(Error::Eof) == OVE_ERR_EOF, "Error::Eof drifted");
static_assert(static_cast<int>(Error::Inval) == OVE_ERR_INVAL, "Error::Inval drifted");
static_assert(static_cast<int>(Error::NotFound) == OVE_ERR_NOT_FOUND, "Error::NotFound drifted");
 
template <class T = void> using Result = std::expected<T, Error>;
 
namespace detail
{
 
class error_category_impl : public std::error_category
{
      public:
    const char *name() const noexcept override
    {
        return "ove";
    }
 
    std::string message(int ev) const override
    {
        switch (static_cast<Error>(ev)) {
        case Error::Ok:
            return "success";
        case Error::NotRegistered:
            return "backend or feature not registered";
        case Error::InvalidParam:
            return "invalid parameter";
        case Error::NoMemory:
            return "out of memory";
        case Error::Timeout:
            return "operation timed out";
        case Error::NotSupported:
            return "operation not supported";
        case Error::QueueFull:
            return "queue full";
        case Error::MlFailed:
            return "ML inference failed";
        case Error::NetRefused:
            return "connection refused";
        case Error::NetUnreachable:
            return "network unreachable";
        case Error::NetAddrInUse:
            return "address in use";
        case Error::NetReset:
            return "connection reset by peer";
        case Error::NetDnsFail:
            return "DNS resolution failed";
        case Error::NetClosed:
            return "connection closed";
        case Error::BusNack:
            return "bus NACK";
        case Error::BusBusy:
            return "bus busy";
        case Error::BusError:
            return "bus framing/parity error";
        case Error::QueueEmpty:
            return "queue empty";
        case Error::WouldBlock:
            return "operation would block";
        case Error::Eof:
            return "end of file";
        case Error::Inval:
            return "argument or state invalid";
        case Error::NotFound:
            return "resource not found";
        }
        return "unknown ove error";
    }
};
 
} /* namespace detail */
 
inline const std::error_category &error_category() noexcept
{
    static const detail::error_category_impl instance;
    return instance;
}
 
inline std::error_code make_error_code(Error e) noexcept
{
    return {static_cast<int>(e), error_category()};
}
 
[[nodiscard]] inline Result<void> from_rc(int rc) noexcept
{
    if (rc == OVE_OK)
        return {};
    return std::unexpected{static_cast<Error>(rc)};
}
 
template <class T> [[nodiscard]] inline Result<std::decay_t<T>> from_rc(int rc, T &&value)
{
    using V = std::decay_t<T>;
    if (rc == OVE_OK)
        return Result<V>{std::forward<T>(value)};
    return std::unexpected{static_cast<Error>(rc)};
}
 
} /* namespace ove */
 
/*
 * Enable `std::error_code ec = ove::Error::X;` — the standard lookup
 * rule is: if `is_error_code_enum<E>` is true, error_code's
 * converting constructor calls `make_error_code(E)` via ADL.
 */
namespace std
{
template <> struct is_error_code_enum<ove::Error> : true_type {
};
} /* namespace std */