core_error.h

Go to the documentation of this file.

 
#pragma once
 
#include <string_view>
#include <cstdint>
#include <format>
#include <fmt/core.h>
 
namespace CaptureMoment::Core {
 
namespace ErrorHandling {
 
enum class CoreError : uint8_t {
    // ==========================================
    // Success State
    // ==========================================
 
    Success = 0,
 
    // ==========================================
    // Image Processing Errors
    // ==========================================
 
    InvalidImageRegion = 1,
 
    AllocationFailed = 2,
 
    InvalidHalideBuffer = 3,
 
    InvalidWorkingImage = 4,
 
    // ==========================================
    // I/O Errors
    // ==========================================
 
    IOError = 5,
 
    FileNotFound = 6,
 
    UnsupportedFormat = 7,
 
    DecodingError = 8,
 
    SourceNotLoaded = 9,
 
    // ==========================================
    // System Errors
    // ==========================================
 
    Unexpected = 99
};
 
enum class CoreErrorCategory : uint8_t {
    System = 0,
 
    ImageProcessing = 1,
 
    Serialization = 2,
 
    Common = 3,
 
    Source = 4
};
 
 
// ============================================================
// Helpers (Conversion functions)
// ============================================================
 
[[nodiscard]] constexpr CoreErrorCategory get_error_category(CoreError code)
{
    switch (code)
    {
    case CoreError::InvalidImageRegion:
        return CoreErrorCategory::Common;
 
    case CoreError::AllocationFailed:
    case CoreError::InvalidHalideBuffer:
    case CoreError::InvalidWorkingImage:
        return CoreErrorCategory::ImageProcessing;
 
    case CoreError::IOError:
    case CoreError::FileNotFound:
    case CoreError::UnsupportedFormat:
    case CoreError::SourceNotLoaded:
        return CoreErrorCategory::Source;
 
    case CoreError::DecodingError:
        return CoreErrorCategory::Serialization;
 
    case CoreError::Success:
    case CoreError::Unexpected:
    default:
        return CoreErrorCategory::System;
    }
}
 
[[nodiscard]] constexpr std::string_view to_string(CoreError code)
{
    switch (code)
    {
    case CoreError::Success: return "Success";
    case CoreError::InvalidImageRegion: return "InvalidImageRegion";
    case CoreError::AllocationFailed: return "AllocationFailed";
    case CoreError::InvalidHalideBuffer: return "InvalidHalideBuffer";
    case CoreError::InvalidWorkingImage: return "InvalidWorkingImage";
    case CoreError::IOError: return "IOError";
    case CoreError::Unexpected: return "Unexpected";
    case CoreError::FileNotFound:  return "FileNotFound";
    case CoreError::UnsupportedFormat: return "UnsupportedFormat";
    case CoreError::SourceNotLoaded: return "SourceNotLoaded";
    case CoreError::DecodingError: return "DecodingError";
    default: return "Unknown";
    }
}
 
[[nodiscard]] constexpr std::string_view to_string(CoreErrorCategory category)
{
    switch (category)
    {
    case CoreErrorCategory::System: return "System";
    case CoreErrorCategory::ImageProcessing: return "ImageProcessing";
    case CoreErrorCategory::Serialization: return "Serialization";
    case CoreErrorCategory::Common: return "Common";
    case CoreErrorCategory::Source: return "Source";
 
    default: return "Unknown";
    }
}
 
} // namespace ErrorHandling
 
} // namespace CaptureMoment::Core
 
template <>
struct std::formatter<CaptureMoment::Core::ErrorHandling::CoreError> : std::formatter<std::string_view>
{
    template <typename FormatContext>
    auto format(const CaptureMoment::Core::ErrorHandling::CoreError code, FormatContext& ctx) const
    {
        return std::formatter<std::string_view>::format(
            CaptureMoment::Core::ErrorHandling::to_string(code), ctx);
    }
};
template <>
struct fmt::formatter<CaptureMoment::Core::ErrorHandling::CoreError>
{
    template <typename ParseContext>
    constexpr auto parse(ParseContext& ctx) {
        return ctx.begin();
    }
 
    template <typename FormatContext>
    auto format(const CaptureMoment::Core::ErrorHandling::CoreError& code, FormatContext& ctx) const {
        const auto sv { CaptureMoment::Core::ErrorHandling::to_string(code) };
        auto out = ctx.out();
        for (const char c : sv) {
            *out++ = c;
        }
        return out;
    }
};