log.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include "sdkconfig.h"
#ifndef CONFIG_IDFXX_STD_FORMAT
#error "idfxx_log requires CONFIG_IDFXX_STD_FORMAT to be enabled (menuconfig -> IDFXX -> Enable std::format support)"
#endif
 
#include <algorithm>
#include <cstdint>
#include <esp_log.h>
#include <format>
#include <ranges>
#include <span>
#include <string>
#include <string_view>
#include <utility>
 
namespace idfxx::log {
 
enum class level : uint8_t {
    none = ESP_LOG_NONE,       
    error = ESP_LOG_ERROR,     
    warn = ESP_LOG_WARN,       
    info = ESP_LOG_INFO,       
    debug = ESP_LOG_DEBUG,     
    verbose = ESP_LOG_VERBOSE, 
};
 
void log(level lvl, const char* tag, std::string_view msg);
 
template<typename... Args>
void log(level lvl, const char* tag, std::format_string<Args...> fmt, Args&&... args) {
    if (static_cast<int>(lvl) > LOG_LOCAL_LEVEL) {
        return;
    }
    if (esp_log_level_get(tag) < static_cast<esp_log_level_t>(lvl)) {
        return;
    }
    log(lvl, tag, std::format(fmt, std::forward<Args>(args)...));
}
 
template<typename... Args>
void error(const char* tag, std::format_string<Args...> fmt, Args&&... args) {
    log(level::error, tag, fmt, std::forward<Args>(args)...);
}
 
inline void error(const char* tag, std::string_view msg) {
    log(level::error, tag, msg);
}
 
template<typename... Args>
void warn(const char* tag, std::format_string<Args...> fmt, Args&&... args) {
    log(level::warn, tag, fmt, std::forward<Args>(args)...);
}
 
inline void warn(const char* tag, std::string_view msg) {
    log(level::warn, tag, msg);
}
 
template<typename... Args>
void info(const char* tag, std::format_string<Args...> fmt, Args&&... args) {
    log(level::info, tag, fmt, std::forward<Args>(args)...);
}
 
inline void info(const char* tag, std::string_view msg) {
    log(level::info, tag, msg);
}
 
template<typename... Args>
void debug(const char* tag, std::format_string<Args...> fmt, Args&&... args) {
    log(level::debug, tag, fmt, std::forward<Args>(args)...);
}
 
inline void debug(const char* tag, std::string_view msg) {
    log(level::debug, tag, msg);
}
 
template<typename... Args>
void verbose(const char* tag, std::format_string<Args...> fmt, Args&&... args) {
    log(level::verbose, tag, fmt, std::forward<Args>(args)...);
}
 
inline void verbose(const char* tag, std::string_view msg) {
    log(level::verbose, tag, msg);
}
 
void set_level(const char* tag, level lvl);
 
void set_default_level(level lvl);
 
void buffer_hex(level lvl, const char* tag, const void* buffer, uint16_t length);
 
template<std::ranges::contiguous_range R>
    requires(sizeof(std::ranges::range_value_t<R>) == 1)
void buffer_hex(level lvl, const char* tag, const R& data) {
    auto sp = std::span(data);
    buffer_hex(lvl, tag, sp.data(), static_cast<uint16_t>(std::min(sp.size(), static_cast<size_t>(UINT16_MAX))));
}
 
void buffer_char(level lvl, const char* tag, const void* buffer, uint16_t length);
 
template<std::ranges::contiguous_range R>
    requires(sizeof(std::ranges::range_value_t<R>) == 1)
void buffer_char(level lvl, const char* tag, const R& data) {
    auto sp = std::span(data);
    buffer_char(lvl, tag, sp.data(), static_cast<uint16_t>(std::min(sp.size(), static_cast<size_t>(UINT16_MAX))));
}
 
void buffer_hex_dump(level lvl, const char* tag, const void* buffer, uint16_t length);
 
template<std::ranges::contiguous_range R>
    requires(sizeof(std::ranges::range_value_t<R>) == 1)
void buffer_hex_dump(level lvl, const char* tag, const R& data) {
    auto sp = std::span(data);
    buffer_hex_dump(lvl, tag, sp.data(), static_cast<uint16_t>(std::min(sp.size(), static_cast<size_t>(UINT16_MAX))));
}
 
class logger {
public:
    constexpr explicit logger(const char* tag) noexcept
        : _tag(tag) {}
 
    [[nodiscard]] constexpr const char* tag() const noexcept { return _tag; }
 
    template<typename... Args>
    void log(level lvl, std::format_string<Args...> fmt, Args&&... args) const {
        idfxx::log::log(lvl, _tag, fmt, std::forward<Args>(args)...);
    }
 
    void log(level lvl, std::string_view msg) const { idfxx::log::log(lvl, _tag, msg); }
 
    template<typename... Args>
    void error(std::format_string<Args...> fmt, Args&&... args) const {
        idfxx::log::error(_tag, fmt, std::forward<Args>(args)...);
    }
 
    void error(std::string_view msg) const { idfxx::log::error(_tag, msg); }
 
    template<typename... Args>
    void warn(std::format_string<Args...> fmt, Args&&... args) const {
        idfxx::log::warn(_tag, fmt, std::forward<Args>(args)...);
    }
 
    void warn(std::string_view msg) const { idfxx::log::warn(_tag, msg); }
 
    template<typename... Args>
    void info(std::format_string<Args...> fmt, Args&&... args) const {
        idfxx::log::info(_tag, fmt, std::forward<Args>(args)...);
    }
 
    void info(std::string_view msg) const { idfxx::log::info(_tag, msg); }
 
    template<typename... Args>
    void debug(std::format_string<Args...> fmt, Args&&... args) const {
        idfxx::log::debug(_tag, fmt, std::forward<Args>(args)...);
    }
 
    void debug(std::string_view msg) const { idfxx::log::debug(_tag, msg); }
 
    template<typename... Args>
    void verbose(std::format_string<Args...> fmt, Args&&... args) const {
        idfxx::log::verbose(_tag, fmt, std::forward<Args>(args)...);
    }
 
    void verbose(std::string_view msg) const { idfxx::log::verbose(_tag, msg); }
 
    void set_level(level lvl) const;
 
    void buffer_hex(level lvl, const void* buffer, uint16_t length) const {
        idfxx::log::buffer_hex(lvl, _tag, buffer, length);
    }
 
    template<std::ranges::contiguous_range R>
        requires(sizeof(std::ranges::range_value_t<R>) == 1)
    void buffer_hex(level lvl, const R& data) const {
        idfxx::log::buffer_hex(lvl, _tag, data);
    }
 
    void buffer_char(level lvl, const void* buffer, uint16_t length) const {
        idfxx::log::buffer_char(lvl, _tag, buffer, length);
    }
 
    template<std::ranges::contiguous_range R>
        requires(sizeof(std::ranges::range_value_t<R>) == 1)
    void buffer_char(level lvl, const R& data) const {
        idfxx::log::buffer_char(lvl, _tag, data);
    }
 
    void buffer_hex_dump(level lvl, const void* buffer, uint16_t length) const {
        idfxx::log::buffer_hex_dump(lvl, _tag, buffer, length);
    }
 
    template<std::ranges::contiguous_range R>
        requires(sizeof(std::ranges::range_value_t<R>) == 1)
    void buffer_hex_dump(level lvl, const R& data) const {
        idfxx::log::buffer_hex_dump(lvl, _tag, data);
    }
 
private:
    const char* _tag;
};
 
} // namespace idfxx::log
 
namespace idfxx {
 
[[nodiscard]] inline std::string to_string(log::level lvl) {
    switch (lvl) {
    case log::level::none:
        return "NONE";
    case log::level::error:
        return "ERROR";
    case log::level::warn:
        return "WARN";
    case log::level::info:
        return "INFO";
    case log::level::debug:
        return "DEBUG";
    case log::level::verbose:
        return "VERBOSE";
    default:
        return "unknown(" + std::to_string(static_cast<unsigned int>(lvl)) + ")";
    }
}
 
} // namespace idfxx
 
namespace std {
template<>
struct formatter<idfxx::log::level> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template<typename FormatContext>
    auto format(idfxx::log::level lvl, FormatContext& ctx) const {
        auto s = idfxx::to_string(lvl);
        return std::copy(s.begin(), s.end(), ctx.out());
    }
};
} // namespace std
// NOLINTBEGIN(cppcoreguidelines-macro-usage)
 
#define IDFXX_LOGE(tag, fmt, ...)                                                                                      \
    do {                                                                                                               \
        if (LOG_LOCAL_LEVEL >= ESP_LOG_ERROR) {                                                                        \
            idfxx::log::error(tag, fmt __VA_OPT__(, ) __VA_ARGS__);                                                    \
        }                                                                                                              \
    } while (0)
 
#define IDFXX_LOGW(tag, fmt, ...)                                                                                      \
    do {                                                                                                               \
        if (LOG_LOCAL_LEVEL >= ESP_LOG_WARN) {                                                                         \
            idfxx::log::warn(tag, fmt __VA_OPT__(, ) __VA_ARGS__);                                                     \
        }                                                                                                              \
    } while (0)
 
#define IDFXX_LOGI(tag, fmt, ...)                                                                                      \
    do {                                                                                                               \
        if (LOG_LOCAL_LEVEL >= ESP_LOG_INFO) {                                                                         \
            idfxx::log::info(tag, fmt __VA_OPT__(, ) __VA_ARGS__);                                                     \
        }                                                                                                              \
    } while (0)
 
#define IDFXX_LOGD(tag, fmt, ...)                                                                                      \
    do {                                                                                                               \
        if (LOG_LOCAL_LEVEL >= ESP_LOG_DEBUG) {                                                                        \
            idfxx::log::debug(tag, fmt __VA_OPT__(, ) __VA_ARGS__);                                                    \
        }                                                                                                              \
    } while (0)
 
#define IDFXX_LOGV(tag, fmt, ...)                                                                                      \
    do {                                                                                                               \
        if (LOG_LOCAL_LEVEL >= ESP_LOG_VERBOSE) {                                                                      \
            idfxx::log::verbose(tag, fmt __VA_OPT__(, ) __VA_ARGS__);                                                  \
        }                                                                                                              \
    } while (0)
 
// NOLINTEND(cppcoreguidelines-macro-usage)