kcenon::logger::composite_strategy Class Reference

Combines multiple configuration strategies. More...

#include <composite_strategy.h>

Inheritance diagram for kcenon::logger::composite_strategy:

Collaboration diagram for kcenon::logger::composite_strategy:

Public Member Functions
std::string	get_name () const override
	Get the strategy name.
void	apply (logger_config &config) const override
	Apply this strategy to a logger configuration.
bool	is_applicable () const override
	Check if this strategy is applicable in the current context.
composite_strategy &	add (std::unique_ptr< config_strategy_interface > strategy)
	Add a strategy to the composite.
template<typename Strategy , typename... Args>
composite_strategy &	add (Args &&... args)
	Add a strategy by constructing it in-place.
composite_strategy &	clear ()
	Clear all strategies.
std::size_t	size () const
	Get the number of strategies.
bool	empty () const
	Check if composite is empty.
Public Member Functions inherited from kcenon::logger::config_strategy_interface
virtual	~config_strategy_interface ()=default
virtual int	priority () const
	Get the strategy priority.

Private Attributes
std::vector< std::unique_ptr< config_strategy_interface > >	strategies_

Detailed Description

Combines multiple configuration strategies.

Stores multiple strategies and applies them in priority order. Strategies with higher priority values are applied first.

Since

2.0.0

Definition at line 32 of file composite_strategy.h.

Member Function Documentation

add() [1/2]

template<typename Strategy , typename... Args>

composite_strategy & kcenon::logger::composite_strategy::add ( Args &&... args )

inline

Add a strategy by constructing it in-place.

Template Parameters

Strategy	The strategy type to construct
Args	Constructor argument types

Parameters

args	Constructor arguments

Returns

Reference to this for chaining

Definition at line 86 of file composite_strategy.h.

                                            {
        strategies_.push_back(
            std::make_unique<Strategy>(std::forward<Args>(args)...)
        );
        return *this;
    }

References strategies_.

add() [2/2]

composite_strategy & kcenon::logger::composite_strategy::add ( std::unique_ptr< config_strategy_interface > strategy )

inline

Add a strategy to the composite.

Parameters

strategy

The strategy to add

Returns

Reference to this for chaining

Definition at line 71 of file composite_strategy.h.

                                                                               {
        if (strategy) {
            strategies_.push_back(std::move(strategy));
        }
        return *this;
    }

References strategies_.

apply()

void kcenon::logger::composite_strategy::apply ( logger_config & config ) const

inlineoverridevirtual

Apply this strategy to a logger configuration.

Parameters

config

The configuration to modify

Modifies the provided configuration according to the strategy's rules. Changes are applied in-place.

Implements kcenon::logger::config_strategy_interface.

Definition at line 38 of file composite_strategy.h.

                                                     {
        // Create sorted copy of strategies by priority (descending)
        std::vector<const config_strategy_interface*> sorted;
        sorted.reserve(strategies_.size());
        for (const auto& strategy : strategies_) {
            sorted.push_back(strategy.get());
        }
        std::sort(sorted.begin(), sorted.end(),
            [](const auto* a, const auto* b) {
                return a->priority() > b->priority();
            });
 
        // Apply each applicable strategy in order
        for (const auto* strategy : sorted) {
            if (strategy->is_applicable()) {
                strategy->apply(config);
            }
        }
    }

References strategies_.

clear()

composite_strategy & kcenon::logger::composite_strategy::clear ( )

inline

Clear all strategies.

Returns

Reference to this for chaining

Definition at line 97 of file composite_strategy.h.

                                {
        strategies_.clear();
        return *this;
    }

References clear(), and strategies_.

Referenced by clear().

Here is the call graph for this function:

Here is the caller graph for this function:

empty()

bool kcenon::logger::composite_strategy::empty ( ) const

inline

Check if composite is empty.

Returns

true if no strategies are contained

Definition at line 114 of file composite_strategy.h.

                       {
        return strategies_.empty();
    }

References strategies_.

get_name()

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

inlineoverridevirtual

Get the strategy name.

Returns

Human-readable strategy name

Implements kcenon::logger::config_strategy_interface.

Definition at line 34 of file composite_strategy.h.

                                        {
        return "composite";
    }

is_applicable()

bool kcenon::logger::composite_strategy::is_applicable ( ) const

inlineoverridevirtual

Check if this strategy is applicable in the current context.

Returns

true if the strategy should be applied

Override to implement conditional strategy application (e.g., only apply in certain environments).

Reimplemented from kcenon::logger::config_strategy_interface.

Definition at line 58 of file composite_strategy.h.

                                        {
        // Applicable if any contained strategy is applicable
        return std::any_of(strategies_.begin(), strategies_.end(),
            [](const auto& strategy) {
                return strategy->is_applicable();
            });
    }

References strategies_.

size()

std::size_t kcenon::logger::composite_strategy::size ( ) const

inline

Get the number of strategies.

Returns

Number of contained strategies

Definition at line 106 of file composite_strategy.h.

                           {
        return strategies_.size();
    }

References strategies_.

Member Data Documentation

strategies_

std::vector<std::unique_ptr<config_strategy_interface> > kcenon::logger::composite_strategy::strategies_

private

Definition at line 119 of file composite_strategy.h.

Referenced by add(), add(), apply(), clear(), empty(), is_applicable(), and size().

---

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

• include/kcenon/logger/core/strategies/composite_strategy.h