composite_strategy.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 "config_strategy_interface.h"
#include "../logger_config.h"
#include <vector>
#include <algorithm>
 
namespace kcenon::logger {
 
class composite_strategy : public config_strategy_interface {
public:
    std::string get_name() const override {
        return "composite";
    }
 
    void apply(logger_config& config) const override {
        // 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);
            }
        }
    }
 
    bool is_applicable() const override {
        // Applicable if any contained strategy is applicable
        return std::any_of(strategies_.begin(), strategies_.end(),
            [](const auto& strategy) {
                return strategy->is_applicable();
            });
    }
 
    composite_strategy& add(std::unique_ptr<config_strategy_interface> strategy) {
        if (strategy) {
            strategies_.push_back(std::move(strategy));
        }
        return *this;
    }
 
    template<typename Strategy, typename... Args>
    composite_strategy& add(Args&&... args) {
        strategies_.push_back(
            std::make_unique<Strategy>(std::forward<Args>(args)...)
        );
        return *this;
    }
 
    composite_strategy& clear() {
        strategies_.clear();
        return *this;
    }
 
    std::size_t size() const {
        return strategies_.size();
    }
 
    bool empty() const {
        return strategies_.empty();
    }
 
private:
    std::vector<std::unique_ptr<config_strategy_interface>> strategies_;
};
 
} // namespace kcenon::logger