Logger.h

#pragma once
#include <UnCompute/Base/CompilerTraits.h>
#include <UnCompute/Base/ResultCode.h>
 
#if UN_DEBUG
#    define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
 
#    define UN_Fail()                                                                                                            \
        do                                                                                                                       \
        {                                                                                                                        \
            UN_DebugBreak();                                                                                                     \
        }                                                                                                                        \
        while (false)
#else
#    define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_INFO
 
#    define UN_Fail()                                                                                                            \
        do                                                                                                                       \
        {                                                                                                                        \
            assert(false && "Fatal error");                                                                                      \
        }                                                                                                                        \
        while (false)
#endif
 
#include <spdlog/spdlog.h>
#include <string_view>
 
template<>
struct fmt::formatter<UN::ResultCode> : fmt::formatter<std::string_view>
{
    template<typename FormatContext>
    auto format(const UN::ResultCode& result, FormatContext& ctx) const -> decltype(ctx.out())
    {
        return fmt::format_to(ctx.out(), "{}", UN::ResultToString(result));
    }
};
 
#define UNLOG_Debug(...) SPDLOG_DEBUG(__VA_ARGS__)
#define UNLOG_Info(...) SPDLOG_INFO(__VA_ARGS__)
#define UNLOG_Warning(...) SPDLOG_WARN(__VA_ARGS__)
#define UNLOG_Error(...) SPDLOG_ERROR(__VA_ARGS__)
 
#define UN_Verify(expr, ...)                                                                                                     \
    do                                                                                                                           \
    {                                                                                                                            \
        if (!(expr))                                                                                                             \
        {                                                                                                                        \
            UNLOG_Error(__VA_ARGS__);                                                                                            \
            UN_Fail();                                                                                                           \
        }                                                                                                                        \
    }                                                                                                                            \
    while (false)
 
#define UN_VerifyResultFatal(expr, ...)                                                                                        \
    do                                                                                                                           \
    {                                                                                                                            \
        if (auto resultCode = (expr); !::UN::Succeeded(resultCode))                                                              \
        {                                                                                                                        \
            UN_Verify(false, "[Result was {}]: {}", resultCode, ::fmt::format(__VA_ARGS__));                                     \
        }                                                                                                                        \
    }                                                                                                                            \
    while (false)
 
#define UN_VerifyWarning(expr, ...)                                                                                              \
    do                                                                                                                           \
    {                                                                                                                            \
        if (!(expr))                                                                                                             \
        {                                                                                                                        \
            UNLOG_Warning(__VA_ARGS__);                                                                                          \
        }                                                                                                                        \
    }                                                                                                                            \
    while (false)
 
#define UN_VerifyError(expr, ...)                                                                                                \
    do                                                                                                                           \
    {                                                                                                                            \
        if (!(expr))                                                                                                             \
        {                                                                                                                        \
            UNLOG_Error(__VA_ARGS__);                                                                                            \
        }                                                                                                                        \
    }                                                                                                                            \
    while (false)
 
#define UN_VerifyResult(expr, ...)                                                                                               \
    do                                                                                                                           \
    {                                                                                                                            \
        if (auto resultCode = (expr); !::UN::Succeeded(resultCode))                                                              \
        {                                                                                                                        \
            UN_VerifyError(false, "[Result was {}]: {}", resultCode, ::fmt::format(__VA_ARGS__));                                \
        }                                                                                                                        \
    }                                                                                                                            \
    while (false)
 
#if UN_DEBUG || defined DOXYGEN
#    define UN_Assert(expr, ...) UN_Verify(expr, __VA_ARGS__)
#    define UN_Warning(expr, ...) UN_VerifyWarning(expr, __VA_ARGS__)
#    define UN_Error(expr, ...) UN_VerifyError(expr, __VA_ARGS__)
#else
#    define UN_Assert(expr, ...) UN_UNUSED(expr)
#    define UN_Warning(expr, ...) UN_UNUSED(expr)
#    define UN_Error(expr, ...) UN_UNUSED(expr)
#endif
 
namespace UN
{
    inline void InitializeLogger()
    {
        spdlog::set_level(spdlog::level::debug);
    }
} // namespace UN