logger.hpp

Go to the documentation of this file.

/**
 * @file logger.hpp
 * @brief Logger class with timestamp provider and output sink
 *
 * Output format: I 12345 main.cpp:42| Message
 *
 * The Logger class is templated on:
 * - Output: Sink type with static write(const char*) method
 * - TimestampProvider: Type with static uint32_t now() method
 *
 * Use the macros in macros.hpp for automatic file/line capture.
 */
 
#ifndef SBL_LOG_LOGGER_HPP_
#define SBL_LOG_LOGGER_HPP_
 
#include <cstdint>
#include <cstddef>
#include <sbl/log/format.hpp>
 
namespace sbl::log {
 
/**
 * @brief Log severity levels
 */
enum class Level : uint8_t {
    Off   = 0,   // Disable all logging
    Error = 1,
    Warn  = 2,
    Info  = 3,
    Debug = 4,
    Trace = 5
};
 
/**
 * @brief Convert level to single character
 */
constexpr char level_char(Level level) {
    switch (level) {
        case Level::Error: return 'E';
        case Level::Warn:  return 'W';
        case Level::Info:  return 'I';
        case Level::Debug: return 'D';
        case Level::Trace: return 'T';
        default:           return '?';
    }
}
 
/**
 * @brief Default timestamp provider (returns 0)
 *
 * Replace with a real implementation that calls your timer driver.
 */
struct NullTimestamp {
    static uint32_t now() { return 0; }
};
 
/**
 * @brief Null output sink (discards all output)
 */
struct NullOutput {
    static void write(const char*) {}
};
 
/**
 * @brief Extract filename from path (compile-time safe)
 *
 * Returns pointer to last path component (e.g., "main.cpp" from "/foo/bar/main.cpp")
 */
constexpr const char* basename(const char* path) {
    const char* file = path;
    while (*path) {
        if (*path == '/' || *path == '\\') {
            file = path + 1;
        }
        path++;
    }
    return file;
}
 
/**
 * @brief Logger class with compile-time level filtering
 *
 * @tparam Output Sink type with static write(const char*) method
 * @tparam TimestampProvider Type with static uint32_t now() method
 * @tparam MinLevel Minimum level to compile (lower levels are eliminated)
 */
template<typename Output, typename TimestampProvider = NullTimestamp, Level MinLevel = Level::Info>
class Logger {
public:
    static constexpr size_t BUFFER_SIZE = 256;
 
    /**
     * @brief Log a message with file/line location
     *
     * @param level Log severity level
     * @param file Source file name
     * @param line Source line number
     * @param fmt Printf-style format string
     * @param ... Format arguments
     */
    static void log(Level level, const char* file, int line, const char* fmt, ...) {
        // Runtime level check (compile-time filtering done in macros)
        if (static_cast<int>(level) > static_cast<int>(MinLevel)) {
            return;
        }
 
        char buffer[BUFFER_SIZE];
        size_t pos = 0;
 
        // Format header: I 12345 file.cpp:42|
        uint32_t timestamp = TimestampProvider::now();
        pos += format(buffer, BUFFER_SIZE,
                      "%c %u %s:%d| ",
                      level_char(level),
                      timestamp,
                      basename(file),
                      line);
 
        // Format message
        if (pos < BUFFER_SIZE - 1) {
            va_list args;
            va_start(args, fmt);
            pos += vformat(buffer + pos, BUFFER_SIZE - pos, fmt, args);
            va_end(args);
        }
 
        // Add newline if space
        if (pos < BUFFER_SIZE - 1) {
            buffer[pos++] = '\n';
            buffer[pos] = '\0';
        }
 
        // Output
        Output::write(buffer);
    }
 
    /**
     * @brief Log without location info (simpler format)
     *
     * Format: I 12345| Message
     */
    static void log_simple(Level level, const char* fmt, ...) {
        if (static_cast<int>(level) > static_cast<int>(MinLevel)) {
            return;
        }
 
        char buffer[BUFFER_SIZE];
        size_t pos = 0;
 
        uint32_t timestamp = TimestampProvider::now();
        pos += format(buffer, BUFFER_SIZE,
                      "%c %u| ",
                      level_char(level),
                      timestamp);
 
        if (pos < BUFFER_SIZE - 1) {
            va_list args;
            va_start(args, fmt);
            pos += vformat(buffer + pos, BUFFER_SIZE - pos, fmt, args);
            va_end(args);
        }
 
        if (pos < BUFFER_SIZE - 1) {
            buffer[pos++] = '\n';
            buffer[pos] = '\0';
        }
 
        Output::write(buffer);
    }
};
 
} // namespace sbl::log
 
#endif // SBL_LOG_LOGGER_HPP_