Assert.hpp

#pragma once
 
#include <boost/log/core/core.hpp>
#include <fmt/base.h>
 
#include <functional>
#include <string_view>
#ifndef CLIO_WITHOUT_STACKTRACE
#include <boost/stacktrace.hpp>
#include <boost/stacktrace/stacktrace.hpp>
#endif  // CLIO_WITHOUT_STACKTRACE
#include <fmt/format.h>
 
#include <cstdlib>
 
namespace util::impl {
 
class OnAssert {
public:
    using ActionType = std::function<void(std::string_view)>;
 
private:
    static ActionType action;
 
public:
    static void
    call(std::string_view message);
 
    static void
    setAction(ActionType newAction);
 
    static void
    resetAction();
 
private:
    static void
    defaultAction(std::string_view message);
};

template <typename... Args>
constexpr void
assertImpl(
    std::source_location const location,
    char const* expression,
    bool const condition,
    fmt::format_string<Args...> format,
    Args&&... args
)
{
    if (!condition) {
#ifndef CLIO_WITHOUT_STACKTRACE
        auto const resultMessage = fmt::format(
            "Assertion '{}' failed at {}:{}:\n{}\nStacktrace:\n{}",
            expression,
            location.file_name(),
            location.line(),
            fmt::format(format, std::forward<Args>(args)...),
            boost::stacktrace::to_string(boost::stacktrace::stacktrace())
        );
#else
        auto const resultMessage = fmt::format(
            "Assertion '{}' failed at {}:{}:\n{}",
            expression,
            location.file_name(),
            location.line(),
            fmt::format(format, std::forward<Args>(args)...)
        );
#endif
 
        OnAssert::call(resultMessage);
    }
}
 
}  // namespace util::impl
 
#define ASSERT(condition, ...)                                                                 \
    util::impl::assertImpl(                                                                    \
        std::source_location::current(), #condition, static_cast<bool>(condition), __VA_ARGS__ \
    )