logger.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <concepts>
#include <string>
#include <string_view>
#include <type_traits>
 
namespace kcenon::common {
 
// Forward declarations
namespace interfaces {
enum class log_level;
struct log_entry;
}  // namespace interfaces
 
namespace concepts {
 
template <typename T>
concept LogLevelEnumLike = std::is_enum_v<T>;
 
template <typename T>
concept BasicLogger = requires(T t,
                               interfaces::log_level level,
                               const std::string& message) {
    { t.log(level, message) };
};
 
template <typename T>
concept LevelAwareLogger = BasicLogger<T> &&
    requires(T t, const T ct, interfaces::log_level level) {
        { ct.is_enabled(level) } -> std::convertible_to<bool>;
        { t.set_level(level) };
        { ct.get_level() } -> std::convertible_to<interfaces::log_level>;
    };
 
template <typename T>
concept FlushableLogger = BasicLogger<T> && requires(T t) {
    { t.flush() };
};
 
template <typename T>
concept StructuredLogger = BasicLogger<T> &&
    requires(T t, const interfaces::log_entry& entry) {
        { t.log(entry) };
    };
 
template <typename T>
concept LoggerLike = LevelAwareLogger<T> &&
                     FlushableLogger<T> &&
                     StructuredLogger<T>;
 
template <typename T>
concept LoggerProviderLike = requires(T t, const std::string& name) {
    { t.get_logger() };
    { t.create_logger(name) };
};
 
template <typename T>
concept LoggerRegistryLike = requires(T t, const std::string& name) {
    { t.register_logger(name, std::declval<std::shared_ptr<void>>()) };
    { t.get_logger(name) };
    { t.unregister_logger(name) };
    { t.get_default_logger() };
    { t.set_default_logger(std::declval<std::shared_ptr<void>>()) };
};
 
}  // namespace concepts
}  // namespace kcenon::common