composite_writer.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 "../interfaces/log_writer_interface.h"
#include "../interfaces/log_formatter_interface.h"
#include "../interfaces/output_sink_interface.h"
#include "../interfaces/writer_category.h"
 
namespace kcenon::logger {
 
class composite_writer : public log_writer_interface, public composite_writer_tag {
public:
    composite_writer(std::unique_ptr<log_formatter_interface> formatter,
                    std::unique_ptr<output_sink_interface> sink)
        : formatter_(std::move(formatter))
        , sink_(std::move(sink))
    {
        if (!formatter_) {
            throw std::invalid_argument("Formatter cannot be null");
        }
        if (!sink_) {
            throw std::invalid_argument("Sink cannot be null");
        }
    }
 
    ~composite_writer() override {
        flush(); // Ensure all data is written
    }
 
    common::VoidResult write(const log_entry& entry) override {
        // Stage 1: Format the log entry
        std::string formatted = formatter_->format(entry);
 
        // Stage 2: Write to sink
        return sink_->write_raw(formatted);
    }
 
    common::VoidResult flush() override {
        return sink_->flush();
    }
 
    std::string get_name() const override {
        return formatter_->get_name() + "+" + sink_->get_name();
    }
 
    bool is_healthy() const override {
        return sink_->is_healthy();
    }
 
    log_formatter_interface* get_formatter() const {
        return formatter_.get();
    }
 
    output_sink_interface* get_sink() const {
        return sink_.get();
    }
 
private:
    std::unique_ptr<log_formatter_interface> formatter_; 
    std::unique_ptr<output_sink_interface> sink_;       
};
 
inline std::unique_ptr<composite_writer> make_composite_writer(
    std::unique_ptr<log_formatter_interface> formatter,
    std::unique_ptr<output_sink_interface> sink)
{
    return std::make_unique<composite_writer>(
        std::move(formatter),
        std::move(sink)
    );
}
 
} // namespace kcenon::logger