cpplogging/include/cpplogging/manager/logger_impl.h

#pragma once

#include <set>
#include <mutex>

#include "rule.h"
#include "../interface/logger.h"

namespace cpplogging
{

    struct logger_impl
        : public logger
    {
    private:
        mutable std::mutex  _mutex;                             //!< mutex to protect the object
        std::set<rule*>     _rules;                             //!< rules assigned to this logger
        log_level           _min_level { log_level::unknown };  //!< min log level over all rules
        log_level           _max_level { log_level::unknown };  //!< max log level over all rules

    public:
        using logger::logger;

        /**
         * @brief Add a rule to this logger.
         *
         * @param[in] rule  Rule to add.
         */
        void add_rule(rule& rule);

        /**
         * @brief Remove a rule to this logger.
         *
         * @param[in] rule  Rule to remove.
         */
        void remove_rule(rule& rule);

        /**
         * @brief Check if the passed log level is enabled.
         *
         * @param[in] level     Level to check.
         *
         * @retval true         The passed log level is enabled.
         * @retval false        The passed log level is disabled.
         */
        bool is_enabled(log_level level) const override;

    protected:
        /**
         * @brief Write a log entry.
         *
         * @param[in] entry Log entry to write.
         */
        void write_entry(const log_entry_ptr_s& entry) const override;

        /**
         * @brief Update the log levels cached in the logger.
         */
        void update_log_level();
    };

}