debug_log.hpp

Go to the documentation of this file.

#pragma once
 
#ifdef BBERG_DEBUG_LOG
 
#include <iostream>
#include <sstream>
#include <string>
namespace barretenberg {
void _debug_log_impl(const std::string& log_str);
 
template <class T>
concept Printable = requires(T a) { std::cout << a; };
template <class T>
concept ContainerLike = requires(T a) {
    a.begin();
    a.size();
};
 
template <typename T> const char* _summarize(const T* /*unused*/)
{
    return "(?)";
}
 
template <Printable T> const T& _summarize(const T* x)
{
    return *x;
}
 
// fallback for non-printable containers
template <ContainerLike T>
std::string _summarize(const T* x)
    requires(!Printable<T>)
{
    std::ostringstream ss;
    if (x->size() == 0) {
        ss << "[]";
    } else {
        ss << "[" << _summarize(&*x->begin()) << "...]";
    }
    return ss.str();
}
 
template <typename... FuncArgs> void _debug_log(const char* func_name, const char* arg_string, const FuncArgs&... args)
{
    // shut off recursive DEBUG_LOG
    static size_t debug_log_calls = 0;
    if (debug_log_calls > 0) {
        return;
    }
    debug_log_calls++;
    std::ostringstream ss;
    ss << func_name << " " << arg_string << " = ";
    // Using fold expression to append args to stringstream
    ((ss << _summarize(&args) << " "), ...);
    std::string log_str = ss.str();
    // Want to be able to catch offending statements in a debugger, this throws if we match an env variable pattern
    _debug_log_impl(log_str);
    debug_log_calls--;
}
} // namespace barretenberg
#define DEBUG_LOG(...)                                                                                                 \
    if (!std::is_constant_evaluated()) { /*we are not in a compile-time constexpr*/                                    \
        barretenberg::_debug_log(__FUNCTION__, #__VA_ARGS__, __VA_ARGS__);                                             \
    }
 
#define DEBUG_LOG_ALL(container)                                                                                       \
    for (auto& x : (container)) {                                                                                      \
        barretenberg::_debug_log(__FUNCTION__, #container, x);                                                         \
    }
 
#else // If BBERG_DEBUG_LOG is not defined
 
// Define empty macros and functions
#define DEBUG_LOG(...)
#define DEBUG_LOG_ALL(container)
 
#endif // BBERG_DEBUG_LOG