macros.hpp

Go to the documentation of this file.

/**
 * @file macros.hpp
 * @brief Zero-overhead logging macros with file/line capture
 *
 * Usage:
 *   // Define your output sink and timestamp provider
 *   struct MyOutput { static void write(const char* s) { ... } };
 *   struct MyTime { static uint32_t now() { return millis(); } };
 *
 *   // Configure before including
 *   #define SBL_LOG_OUTPUT MyOutput
 *   #define SBL_LOG_TIMESTAMP MyTime
 *   #define SBL_LOG_LEVEL sbl::log::Level::Debug
 *   #include <sbl/log/macros.hpp>
 *
 *   // Use
 *   SBL_LOG_INFO("Hello %s", "world");
 *   SBL_LOG_ERROR("Failed with code %d", err);
 *
 * Log levels (set SBL_LOG_LEVEL):
 *   Level::Off   - disable all logging
 *   Level::Error - errors only
 *   Level::Warn  - warnings and above
 *   Level::Info  - info and above (default)
 *   Level::Debug - debug and above
 *   Level::Trace - everything
 */
 
#ifndef SBL_LOG_MACROS_HPP_
#define SBL_LOG_MACROS_HPP_
 
#include <sbl/log/logger.hpp>
 
// Log level as integer for preprocessor (must match Level enum values)
// Level::Off=0, Error=1, Warn=2, Info=3, Debug=4, Trace=5
#ifndef SBL_LOG_LEVEL
    #define SBL_LOG_LEVEL 3  // Info
#endif
 
// Convenience defines for setting log level
#define SBL_LOG_LEVEL_OFF   0
#define SBL_LOG_LEVEL_ERROR 1
#define SBL_LOG_LEVEL_WARN  2
#define SBL_LOG_LEVEL_INFO  3
#define SBL_LOG_LEVEL_DEBUG 4
#define SBL_LOG_LEVEL_TRACE 5
 
// Output sink must be defined by application
#ifndef SBL_LOG_OUTPUT
    #define SBL_LOG_OUTPUT sbl::log::NullOutput
#endif
 
// Timestamp provider (optional, defaults to NullTimestamp)
#ifndef SBL_LOG_TIMESTAMP
    #define SBL_LOG_TIMESTAMP sbl::log::NullTimestamp
#endif
 
// Convert integer level to enum for template
namespace sbl::log::detail {
    constexpr Level level_from_int(int lvl) {
        return static_cast<Level>(lvl);
    }
}
 
// Logger type alias
using SblLogger_ = sbl::log::Logger<
    SBL_LOG_OUTPUT,
    SBL_LOG_TIMESTAMP,
    sbl::log::detail::level_from_int(SBL_LOG_LEVEL)
>;
 
/**
 * @brief Main logging macros with compile-time level filtering
 *
 * These expand to nothing when the level is disabled, achieving
 * zero overhead for disabled log levels.
 */
#if SBL_LOG_LEVEL >= SBL_LOG_LEVEL_ERROR
    #define SBL_LOG_ERROR(...) \
        SblLogger_::log(sbl::log::Level::Error, __FILE__, __LINE__, __VA_ARGS__)
#else
    #define SBL_LOG_ERROR(...) ((void)0)
#endif
 
#if SBL_LOG_LEVEL >= SBL_LOG_LEVEL_WARN
    #define SBL_LOG_WARN(...) \
        SblLogger_::log(sbl::log::Level::Warn, __FILE__, __LINE__, __VA_ARGS__)
#else
    #define SBL_LOG_WARN(...) ((void)0)
#endif
 
#if SBL_LOG_LEVEL >= SBL_LOG_LEVEL_INFO
    #define SBL_LOG_INFO(...) \
        SblLogger_::log(sbl::log::Level::Info, __FILE__, __LINE__, __VA_ARGS__)
#else
    #define SBL_LOG_INFO(...) ((void)0)
#endif
 
#if SBL_LOG_LEVEL >= SBL_LOG_LEVEL_DEBUG
    #define SBL_LOG_DEBUG(...) \
        SblLogger_::log(sbl::log::Level::Debug, __FILE__, __LINE__, __VA_ARGS__)
#else
    #define SBL_LOG_DEBUG(...) ((void)0)
#endif
 
#if SBL_LOG_LEVEL >= SBL_LOG_LEVEL_TRACE
    #define SBL_LOG_TRACE(...) \
        SblLogger_::log(sbl::log::Level::Trace, __FILE__, __LINE__, __VA_ARGS__)
#else
    #define SBL_LOG_TRACE(...) ((void)0)
#endif
 
/**
 * @brief Conditional logging (runtime condition, compile-time level check)
 */
#define SBL_LOG_ERROR_IF(cond, ...) \
    do { if (cond) { SBL_LOG_ERROR(__VA_ARGS__); } } while(0)
 
#define SBL_LOG_WARN_IF(cond, ...) \
    do { if (cond) { SBL_LOG_WARN(__VA_ARGS__); } } while(0)
 
#define SBL_LOG_INFO_IF(cond, ...) \
    do { if (cond) { SBL_LOG_INFO(__VA_ARGS__); } } while(0)
 
/**
 * @brief Log without file/line (smaller output)
 */
#if SBL_LOG_LEVEL > SBL_LOG_LEVEL_OFF
    #define SBL_LOG_SIMPLE(lvl, ...) \
        SblLogger_::log_simple(lvl, __VA_ARGS__)
#else
    #define SBL_LOG_SIMPLE(lvl, ...) ((void)0)
#endif
 
#endif // SBL_LOG_MACROS_HPP_