Decorator that applies a filter to a wrapped writer. More...

#include <filtered_writer.h>

Inheritance diagram for kcenon::logger::filtered_writer:

Collaboration diagram for kcenon::logger::filtered_writer:

Public Member Functions
	filtered_writer (std::unique_ptr< log_writer_interface > wrapped, std::unique_ptr< log_filter_interface > filter)
	Construct a filtered writer.

	~filtered_writer () override=default
	Destructor.

	filtered_writer (const filtered_writer &)=delete

filtered_writer &	operator= (const filtered_writer &)=delete

	filtered_writer (filtered_writer &&) noexcept=default

filtered_writer &	operator= (filtered_writer &&) noexcept=default

common::VoidResult	write (const log_entry &entry) override
	Write a log entry if it passes the filter.

std::string	get_name () const override
	Get the name of this writer.

const log_filter_interface *	get_filter () const
	Get the current filter.

Public Member Functions inherited from kcenon::logger::decorator_writer_base
	decorator_writer_base (std::unique_ptr< log_writer_interface > wrapped, std::string_view decorator_name)
	Construct a decorator writer base.

	~decorator_writer_base () override=default
	Virtual destructor for proper cleanup.

	decorator_writer_base (const decorator_writer_base &)=delete

decorator_writer_base &	operator= (const decorator_writer_base &)=delete

	decorator_writer_base (decorator_writer_base &&) noexcept=default

decorator_writer_base &	operator= (decorator_writer_base &&) noexcept=default

common::VoidResult	flush () override
	Flush the wrapped writer.

bool	is_healthy () const override
	Check if the writer is healthy.

const log_writer_interface *	get_wrapped_writer () const noexcept
	Get the wrapped writer (const version)

Public Member Functions inherited from kcenon::logger::log_writer_interface
virtual	~log_writer_interface ()=default

virtual common::VoidResult	close ()
	Close the writer and release resources.

virtual auto	is_open () const -> bool
	Check if writer is open and ready.

Private Attributes
std::unique_ptr< log_filter_interface >	filter_

Additional Inherited Members
Static Public Attributes inherited from kcenon::logger::decorator_writer_tag
static constexpr writer_category	category = writer_category::decorator

Protected Member Functions inherited from kcenon::logger::decorator_writer_base
log_writer_interface &	wrapped () noexcept
	Access the wrapped writer (non-const)

const log_writer_interface &	wrapped () const noexcept
	Access the wrapped writer (const)

const std::string &	decorator_name () const noexcept
	Get the decorator name.

Detailed Description

Decorator that applies a filter to a wrapped writer.

This class implements the Decorator pattern for log writers. It wraps any log_writer_interface implementation and applies filtering logic before delegating write operations. Log entries that do not pass the filter are silently dropped (returning success).

Key features:

Composable with any log_writer_interface implementation
Works with all filter types from log_filter.h
Can be nested with other decorators (async_writer, batch_writer, etc.)
Thread-safe if the wrapped writer and filter are thread-safe

Category: Synchronous (delegates to wrapped writer), Decorator

Note: The filter is evaluated before each write operation.; Filtered entries return success (not an error).

Since: 4.0.0; 4.1.0 Migrated to use decorator_writer_base for code reuse

Examples: decorator_usage.cpp.

Definition at line 70 of file filtered_writer.h.

Constructor & Destructor Documentation

◆ filtered_writer() [1/3]

kcenon::logger::filtered_writer::filtered_writer	(	std::unique_ptr< log_writer_interface >	wrapped,
		std::unique_ptr< log_filter_interface >	filter )

explicit

Construct a filtered writer.

Parameters

wrapped	The writer to wrap with filtering
filter	The filter to apply before writing

Exceptions

std::invalid_argument if wrapped is nullptr

Note: filter can be nullptr, in which case all entries pass through

Since: 4.0.0

Definition at line 13 of file filtered_writer.cpp.

    : decorator_writer_base(std::move(wrapped), "filtered"), filter_(std::move(filter)) {
    // Base class constructor handles nullptr check for wrapped writer
}

◆ ~filtered_writer()

kcenon::logger::filtered_writer::~filtered_writer ( )

overridedefault

Destructor.

◆ filtered_writer() [2/3]

kcenon::logger::filtered_writer::filtered_writer ( const filtered_writer & )

delete

◆ filtered_writer() [3/3]

kcenon::logger::filtered_writer::filtered_writer ( filtered_writer && )

defaultnoexcept

Member Function Documentation

◆ get_filter()

const log_filter_interface * kcenon::logger::filtered_writer::get_filter ( ) const

Get the current filter.

Returns: Pointer to the filter (may be nullptr)

Since: 4.0.0

Definition at line 42 of file filtered_writer.cpp.

                                                              {
    return filter_.get();
}

References filter_.

◆ get_name()

std::string kcenon::logger::filtered_writer::get_name ( ) const

overridevirtual

Get the name of this writer.

Returns: String in format "filtered_<wrapped_name>" or "filtered(<filter_name>)_<wrapped_name>" if filter has a name

Overrides base class to include filter name when available.

Since: 4.0.0

Reimplemented from kcenon::logger::decorator_writer_base.

Examples: decorator_usage.cpp.

Definition at line 34 of file filtered_writer.cpp.

                                          {
    if (filter_) {
        return "filtered(" + filter_->get_name() + ")_" + wrapped().get_name();
    }
    // Use base class default format when no filter
    return decorator_writer_base::get_name();
}

References filter_, kcenon::logger::decorator_writer_base::get_name(), kcenon::logger::log_writer_interface::get_name(), and kcenon::logger::decorator_writer_base::wrapped().

Referenced by example_single_decorators().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=() [1/2]

filtered_writer & kcenon::logger::filtered_writer::operator= ( const filtered_writer & )

delete

◆ operator=() [2/2]

filtered_writer & kcenon::logger::filtered_writer::operator= ( filtered_writer && )

defaultnoexcept

◆ write()

common::VoidResult kcenon::logger::filtered_writer::write ( const log_entry & entry )

overridevirtual

Write a log entry if it passes the filter.

Parameters

entry The log entry to write

Returns: common::VoidResult Success if filtered out or written successfully, error if write operation fails

If the filter is nullptr or the entry passes the filter, the entry is delegated to the wrapped writer. If the entry does not pass the filter, this method returns success without writing.

Since: 4.0.0

Implements kcenon::logger::decorator_writer_base.

Definition at line 19 of file filtered_writer.cpp.

                                                              {
    // If no filter, pass through all entries
    if (!filter_) {
        return wrapped().write(entry);
    }
 
    // Check if entry passes the filter
    if (filter_->should_log(entry)) {
        return wrapped().write(entry);
    }
 
    // Entry filtered out - return success (not an error)
    return common::ok();
}

References filter_, kcenon::common::ok(), kcenon::logger::decorator_writer_base::wrapped(), and kcenon::logger::log_writer_interface::write().

Here is the call graph for this function:

Member Data Documentation

◆ filter_

std::unique_ptr<log_filter_interface> kcenon::logger::filtered_writer::filter_

private

Definition at line 137 of file filtered_writer.h.

Referenced by get_filter(), get_name(), and write().

The documentation for this class was generated from the following files:

include/kcenon/logger/writers/filtered_writer.h
src/impl/writers/filtered_writer.cpp

Public Member Functions

Private Attributes

Additional Inherited Members