error.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <expected>
#include <functional>
#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,    
    no_mem              = 0x101, 
    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) noexcept;
 
template<typename T>
using result = std::expected<T, std::error_code>;
 
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));
}
 
[[nodiscard]] inline std::unexpected<std::error_code> error(esp_err_t e) noexcept {
    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