formatter_factory.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 <memory>
#include <string>
#include <unordered_map>
#include <functional>
 
#include "../interfaces/log_formatter_interface.h"
#include "../formatters/json_formatter.h"
#include "../formatters/logfmt_formatter.h"
#include "../formatters/template_formatter.h"
#include "../formatters/timestamp_formatter.h"
 
namespace kcenon::logger {
 
enum class format_type {
    plain,      
    json,       
    logfmt,     
    templated,  
    compact     
};
 
class formatter_factory {
public:
    using creator_fn = std::function<std::unique_ptr<log_formatter_interface>()>;
 
    //========================================================================
    // Static Factory Methods
    //========================================================================
 
    static std::unique_ptr<log_formatter_interface> create_plain(
        const format_options& opts = format_options{}
    ) {
        return std::make_unique<timestamp_formatter>(opts);
    }
 
    static std::unique_ptr<log_formatter_interface> create_json(
        const format_options& opts = format_options{}
    ) {
        return std::make_unique<json_formatter>(opts);
    }
 
    static std::unique_ptr<log_formatter_interface> create_logfmt(
        const format_options& opts = format_options{}
    ) {
        return std::make_unique<logfmt_formatter>(opts);
    }
 
    static std::unique_ptr<log_formatter_interface> create_template(
        const std::string& template_pattern = template_formatter::DEFAULT_TEMPLATE,
        const format_options& opts = format_options{}
    ) {
        return std::make_unique<template_formatter>(template_pattern, opts);
    }
 
    static std::unique_ptr<log_formatter_interface> create_compact() {
        format_options opts;
        opts.include_timestamp = true;
        opts.include_thread_id = false;
        opts.include_source_location = false;
        opts.include_level = true;
        opts.use_colors = false;
        return std::make_unique<timestamp_formatter>(opts);
    }
 
    static std::unique_ptr<log_formatter_interface> create(
        format_type type,
        const format_options& opts = format_options{}
    ) {
        switch (type) {
        case format_type::json:
            return create_json(opts);
        case format_type::logfmt:
            return create_logfmt(opts);
        case format_type::templated:
            return create_template(template_formatter::DEFAULT_TEMPLATE, opts);
        case format_type::compact:
            return create_compact();
        case format_type::plain:
        default:
            return create_plain(opts);
        }
    }
 
    //========================================================================
    // Preset Factory Methods
    //========================================================================
 
    static std::unique_ptr<log_formatter_interface> create_development() {
        format_options opts;
        opts.include_timestamp = true;
        opts.include_thread_id = true;
        opts.include_source_location = true;
        opts.include_level = true;
        opts.use_colors = true;
        return create_plain(opts);
    }
 
    static std::unique_ptr<log_formatter_interface> create_production() {
        format_options opts;
        opts.include_timestamp = true;
        opts.include_thread_id = true;
        opts.include_source_location = false;
        opts.include_level = true;
        opts.use_colors = false;
        return create_json(opts);
    }
 
    static std::unique_ptr<log_formatter_interface> create_minimal() {
        format_options opts;
        opts.include_timestamp = false;
        opts.include_thread_id = false;
        opts.include_source_location = false;
        opts.include_level = true;
        opts.use_colors = false;
        return create_plain(opts);
    }
 
    //========================================================================
    // Registry Pattern
    //========================================================================
 
    static void register_type(const std::string& name, creator_fn creator) {
        registry()[name] = std::move(creator);
    }
 
    static std::unique_ptr<log_formatter_interface> create(const std::string& name) {
        auto it = registry().find(name);
        if (it == registry().end()) {
            return nullptr;
        }
        return it->second();
    }
 
    static bool has_type(const std::string& name) {
        return registry().find(name) != registry().end();
    }
 
private:
    static std::unordered_map<std::string, creator_fn>& registry() {
        static std::unordered_map<std::string, creator_fn> instance;
        return instance;
    }
};
 
} // namespace kcenon::logger