writer_category.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 <type_traits>
#include <cstdint>
 
namespace kcenon::logger {
 
// Forward declarations
class log_writer_interface;
class base_writer;
 
enum class writer_category : std::uint8_t {
    synchronous,
    asynchronous,
    decorator,
    composite
};
 
struct sync_writer_tag {
    static constexpr writer_category category = writer_category::synchronous;
};
 
struct async_writer_tag {
    static constexpr writer_category category = writer_category::asynchronous;
};
 
struct decorator_writer_tag {
    static constexpr writer_category category = writer_category::decorator;
};
 
struct composite_writer_tag {
    static constexpr writer_category category = writer_category::composite;
};
 
// ============================================================================
// Type Traits
// ============================================================================
 
template<typename T>
struct is_sync_writer : std::is_base_of<sync_writer_tag, T> {};
 
template<typename T>
inline constexpr bool is_sync_writer_v = is_sync_writer<T>::value;
 
template<typename T>
struct is_async_writer : std::is_base_of<async_writer_tag, T> {};
 
template<typename T>
inline constexpr bool is_async_writer_v = is_async_writer<T>::value;
 
template<typename T>
struct is_decorator_writer : std::is_base_of<decorator_writer_tag, T> {};
 
template<typename T>
inline constexpr bool is_decorator_writer_v = is_decorator_writer<T>::value;
 
template<typename T>
struct is_composite_writer : std::is_base_of<composite_writer_tag, T> {};
 
template<typename T>
inline constexpr bool is_composite_writer_v = is_composite_writer<T>::value;
 
// ============================================================================
// C++20 Concepts
// ============================================================================
 
template<typename T>
concept SyncWriter = std::is_base_of_v<log_writer_interface, T> &&
                     std::is_base_of_v<sync_writer_tag, T>;
 
template<typename T>
concept AsyncWriter = std::is_base_of_v<log_writer_interface, T> &&
                      std::is_base_of_v<async_writer_tag, T>;
 
template<typename T>
concept DecoratorWriter = std::is_base_of_v<log_writer_interface, T> &&
                          std::is_base_of_v<decorator_writer_tag, T>;
 
template<typename T>
concept CompositeWriter = std::is_base_of_v<log_writer_interface, T> &&
                          std::is_base_of_v<composite_writer_tag, T>;
 
// ============================================================================
// Runtime Category Query
// ============================================================================
 
template<typename T>
constexpr writer_category get_writer_category() {
    if constexpr (is_composite_writer_v<T>) {
        return writer_category::composite;
    } else if constexpr (is_decorator_writer_v<T>) {
        return writer_category::decorator;
    } else if constexpr (is_async_writer_v<T>) {
        return writer_category::asynchronous;
    } else if constexpr (is_sync_writer_v<T>) {
        return writer_category::synchronous;
    } else {
        // Default for untagged writers
        return writer_category::synchronous;
    }
}
 
constexpr const char* to_string(writer_category cat) noexcept {
    switch (cat) {
        case writer_category::synchronous: return "synchronous";
        case writer_category::asynchronous: return "asynchronous";
        case writer_category::decorator: return "decorator";
        case writer_category::composite: return "composite";
    }
    return "unknown";
}
 
} // namespace kcenon::logger