error.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <concepts>
#include <expected>
#include <functional>
#include <memory>
#include <new>
#include <string>
#include <system_error>
#include <utility>
 
typedef int esp_err_t;
 
namespace idfxx {
 
enum class errc : esp_err_t {
    // clang-format off
    fail                = -1,    
    invalid_arg         = 0x102, 
    invalid_state       = 0x103, 
    invalid_size        = 0x104, 
    not_found           = 0x105, 
    not_supported       = 0x106, 
    timeout             = 0x107, 
    invalid_response    = 0x108, 
    invalid_crc         = 0x109, 
    invalid_version     = 0x10A, 
    invalid_mac         = 0x10B, 
    not_finished        = 0x10C, 
    not_allowed         = 0x10D, 
    // clang-format on
};
 
class error_category : public std::error_category {
public:
    [[nodiscard]] const char* name() const noexcept override final;
 
    [[nodiscard]] std::string message(int ec) const override final;
};
 
[[nodiscard]] const error_category& default_category() noexcept;
 
[[nodiscard]] inline std::error_code make_error_code(errc e) noexcept {
    return {std::to_underlying(e), default_category()};
}
 
[[nodiscard]] std::error_code make_error_code(esp_err_t e);
 
template<typename T>
using result = std::expected<T, std::error_code>;
 
template<typename T, typename... Args>
concept has_factory = requires {
    { T::make(std::declval<Args>()...) } -> std::same_as<result<T>>;
};
 
template<typename T, typename... Args>
    requires has_factory<T, Args...>
[[nodiscard]] result<std::unique_ptr<T>> make_unique(Args&&... args) {
    auto r = T::make(std::forward<Args>(args)...);
    if (!r) {
        return error(r.error());
    }
    return std::make_unique<T>(std::move(*r));
}
 
template<typename E>
    requires std::is_error_code_enum_v<E>
[[nodiscard]] constexpr std::unexpected<std::error_code> error(E e) noexcept {
    return std::unexpected<std::error_code>(e);
}
 
template<typename E>
    requires std::is_error_condition_enum_v<E>
[[nodiscard]] constexpr std::unexpected<std::error_code> error(E e) noexcept {
    return std::unexpected<std::error_code>(make_error_code(e));
}
 
namespace detail {
constexpr esp_err_t esp_err_no_mem = 0x101;
} // namespace detail
 
[[noreturn]] inline void raise_no_mem() {
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    throw std::bad_alloc();
#else
    abort();
#endif
}
[[nodiscard]] inline std::unexpected<std::error_code> error(esp_err_t e) {
    return std::unexpected<std::error_code>(make_error_code(e));
}
 
[[nodiscard]] inline std::unexpected<std::error_code> error(std::error_code ec) noexcept {
    return std::unexpected<std::error_code>(ec);
}
 
[[nodiscard]] inline result<void> wrap(esp_err_t e) {
    if (e) {
        return error(e);
    }
    return {};
}
 
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
template<typename T>
[[nodiscard]] inline T unwrap(result<T> result) {
    return std::move(result).transform_error([](auto ec) -> std::error_code { throw std::system_error(ec); }).value();
}
 
// Specialization for void
template<>
inline void unwrap(result<void> result) {
    result.transform_error([](auto ec) -> std::error_code { throw std::system_error(ec); });
}
#endif
 
template<typename T, typename Callback>
    requires std::invocable<Callback, std::error_code> &&
    std::same_as<std::invoke_result_t<Callback, std::error_code>, void>
inline void abort_on_error(result<T> result, Callback&& on_error) {
    result.transform_error([&](auto ec) {
        // Check if the callback is valid (for types with operator bool)
        if constexpr (requires { static_cast<bool>(on_error); }) {
            if (!on_error) {
                abort();
                return ec;
            }
        }
        std::forward<Callback>(on_error)(ec);
        abort();
        return ec;
    });
}
 
template<typename T>
inline void abort_on_error(result<T> result) {
    result.transform_error([](auto ec) {
        abort();
        return ec;
    });
}
 
} // namespace idfxx
 
namespace std {
template<>
struct is_error_code_enum<idfxx::errc> : true_type {};
} // namespace std