Exception.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025-2026 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <concepts>
#include <cstring>
#include <format>
#include <functional>
#include <source_location>
#include <stdexcept>
#include <vector>
 
// Project includes
#include "Log.hpp"

 
namespace dfx::Utils
{
class Exception;

using ExceptionStack = std::vector<Exception>;

class Exception : public std::runtime_error
{
public:
    template<typename ... Args>
    Exception(std::source_location location, std::format_string<Args ...> message, Args && ... args)
        : std::runtime_error(std::format(message, std::forward<Args>(args)...))
        , _location { std::move(location) }
    {}

    explicit Exception(std::string const & message) noexcept
        : std::runtime_error(message)
    {}
 
public:
    uint32_t line() const noexcept         { return _location.line(); }
    char const * filename() const noexcept { return _filename(_location.file_name(), _location.file_name() == nullptr ? 0 : std::strlen(_location.file_name())); }
    char const * function() const noexcept { return _location.function_name(); }
 
public:
    template<typename ... Args>
    [[noreturn]] static void throwNested(std::source_location location, std::format_string<Args ...> message, Args && ... args)
    { std::throw_with_nested(Exception(std::move(location), message, std::forward<Args>(args)...)); }

    [[noreturn]] static void throwNestedVector(std::vector<std::string> const & errors);

    static ExceptionStack getExceptionStack(Exception const & e);

    static std::vector<std::string> exceptionStackToString(Exception const & e, std::size_t initialIndentLevel = 0, std::size_t indentSize = 2, bool addSourceLocation = true);

    static void printToLogger(Exception const & e, spdlog::level::level_enum lvl = spdlog::level::err,
                              std::string const & loggerName = "", std::size_t initialIndentLevel = 0,
                              std::string const & logPattern = noFileLogPattern,
                              std::string const & currentLogPattern = defaultLogPattern);

    static void printToLogger(Exception const & e, std::shared_ptr<spdlog::logger> logger,
                              spdlog::level::level_enum lvl = spdlog::level::err,
                              std::size_t initialIndentLevel = 0,
                              std::string const & logPattern = noFileLogPattern,
                              std::string const & currentLogPattern = defaultLogPattern);
 
private:
    static constexpr char const * _filename(char const * const path, std::size_t const length) noexcept
    {
        if (path == nullptr || length == 0 || path[0] == '\0')
            return nullptr;
 
        auto file = path + length;
        while (*file != '/' && file != path)
            --file;
 
        if (*file == '/')
            ++file;
 
        return file;
    }
 
private:
    std::source_location const _location;
};

template<typename T>
constexpr bool __b_assert_expr(T && expr)
{
    static_assert(!(std::is_same_v<std::decay_t<T>, char*> ||
                  std::is_array_v<std::remove_reference_t<T>>),
                  "DFX_ASSERT: First argument appears to be a string literal or array");
 
    static_assert(std::is_convertible_v<T, bool> || std::is_constructible_v<bool, T>,
                  "DFX_ASSERT: First argument must be convertible to bool.");
 
    return static_cast<bool>(std::forward<T>(expr));
}

template<typename F, typename ... Args>
requires std::invocable<F, Args...>
auto safeInvoke(std::shared_ptr<spdlog::logger> logger, F && f, Args && ... args) noexcept
{
    using Result = std::invoke_result_t<F, Args...>;
 
    try
    {
        if constexpr (std::is_void_v<Result>)
            std::invoke(std::forward<F>(f), std::forward<Args>(args)...);
        else
            return std::optional<Result>{ std::invoke(std::forward<F>(f), std::forward<Args>(args)...) };
    }
    catch (Exception const & e)
    { if (logger != nullptr) Exception::printToLogger(e, logger); }
    catch (std::exception const & e)
    { if (logger != nullptr) SPDLOG_LOGGER_ERROR(logger, "An error occured: {}", e.what()); }
    catch (...)
    { if (logger != nullptr) SPDLOG_LOGGER_ERROR(logger, "An unknown error occured"); }
 
    if constexpr (!std::is_void_v<Result>)
        return std::optional<Result>{};
}

template<typename F, typename ... Args>
requires std::invocable<F, Args...>
auto safeInvoke(std::string const & loggerName, F && f, Args && ... args) noexcept
{
    return safeInvoke(spdlog::get(loggerName), std::forward<F>(f), std::forward<Args>(args)...);
}
} // !namespace dfx::Utils

#define DFX_CURRENT_SOURCE_LOCATION std::source_location::current()

#define DFX_THROW(msg, ...) \
    throw ::dfx::Utils::Exception(DFX_CURRENT_SOURCE_LOCATION, msg __VA_OPT__(,) __VA_ARGS__)

#define DFX_THROW_NESTED(msg, ...) \
    ::dfx::Utils::Exception::throwNested(DFX_CURRENT_SOURCE_LOCATION, msg __VA_OPT__(,) __VA_ARGS__)

#define DFX_THROW_VECTOR_NESTED(errors, msg, ...) \
    do { \
        try { ::dfx::Utils::Exception::throwNestedVector(errors); } \
        catch (...) { DFX_THROW_NESTED(msg __VA_OPT__(,) __VA_ARGS__); } \
    } while (false)

#define DFX_ASSERT(expr, msg, ...) \
    do { \
        if (!::dfx::Utils::__b_assert_expr(expr)) \
            DFX_THROW(msg __VA_OPT__(,) __VA_ARGS__); \
    } while (false)