spdlog::details::registry Class Reference

#include <registry.h>

Public Member Functions
	registry (const registry &)=delete
registry &	operator= (const registry &)=delete
void	register_logger (std::shared_ptr< logger > new_logger)
void	initialize_logger (std::shared_ptr< logger > new_logger)
std::shared_ptr< logger >	get (const std::string &logger_name)
std::shared_ptr< logger >	default_logger ()
logger *	get_default_raw ()
void	set_default_logger (std::shared_ptr< logger > new_default_logger)
void	set_tp (std::shared_ptr< thread_pool > tp)
std::shared_ptr< thread_pool >	get_tp ()
void	set_formatter (std::unique_ptr< formatter > formatter)
void	set_level (level::level_enum log_level)
void	flush_on (level::level_enum log_level)
void	flush_every (std::chrono::seconds interval)
void	set_error_handler (log_err_handler handler)
void	apply_all (const std::function< void(const std::shared_ptr< logger >)> &fun)
void	flush_all ()
void	drop (const std::string &logger_name)
void	drop_all ()
void	shutdown ()
std::recursive_mutex &	tp_mutex ()
void	set_automatic_registration (bool automatic_regsistration)

Static Public Member Functions
static registry &	instance ()

Private Member Functions
	registry ()
	~registry ()=default
void	throw_if_exists_ (const std::string &logger_name)
void	register_logger_ (std::shared_ptr< logger > new_logger)

Private Attributes
std::mutex	logger_map_mutex_
std::mutex	flusher_mutex_
std::recursive_mutex	tp_mutex_
std::unordered_map< std::string, std::shared_ptr< logger > >	loggers_
std::unique_ptr< formatter >	formatter_
level::level_enum	level_ = spdlog::logger::default_level()
level::level_enum	flush_level_ = level::off
log_err_handler	err_handler_
std::shared_ptr< thread_pool >	tp_
std::unique_ptr< periodic_worker >	periodic_flusher_
std::shared_ptr< logger >	default_logger_
bool	automatic_registration_ = true

Detailed Description

Definition at line 36 of file registry.h.

Constructor & Destructor Documentation

spdlog::details::registry::registry ( const registry &  )

delete

spdlog::details::registry::registry ( )

inlineprivate

Definition at line 235 of file registry.h.

        : formatter_(new pattern_formatter())
    {

#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
        // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
#ifdef _WIN32
        auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
#else
        auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
#endif

        const char *default_logger_name = "";
        default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
        loggers_[default_logger_name] = default_logger_;

#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
    }

spdlog::details::registry::~registry ( )

privatedefault

Member Function Documentation

void spdlog::details::registry::apply_all ( const std::function< void(const std::shared_ptr< logger >)> &  fun )

inline

Definition at line 166 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        for (auto &l : loggers_)
        {
            fun(l.second);
        }
    }

std::shared_ptr<logger> spdlog::details::registry::default_logger ( )

inline

Definition at line 74 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        return default_logger_;
    }

void spdlog::details::registry::drop ( const std::string &  logger_name )

inline

Definition at line 184 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        loggers_.erase(logger_name);
        if (default_logger_ && default_logger_->name() == logger_name)
        {
            default_logger_.reset();
        }
    }

void spdlog::details::registry::drop_all ( )

inline

Definition at line 194 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        loggers_.clear();
        default_logger_.reset();
    }

void spdlog::details::registry::flush_all ( )

inline

Definition at line 175 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        for (auto &l : loggers_)
        {
            l.second->flush();
        }
    }

void spdlog::details::registry::flush_every ( std::chrono::seconds  interval )

inline

Definition at line 149 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(flusher_mutex_);
        std::function<void()> clbk = std::bind(&registry::flush_all, this);
        periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
    }

void spdlog::details::registry::flush_on ( level::level_enum  log_level )

inline

Definition at line 139 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        for (auto &l : loggers_)
        {
            l.second->flush_on(log_level);
        }
        flush_level_ = log_level;
    }

std::shared_ptr<logger> spdlog::details::registry::get ( const std::string &  logger_name )

inline

Definition at line 67 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        auto found = loggers_.find(logger_name);
        return found == loggers_.end() ? nullptr : found->second;
    }

logger* spdlog::details::registry::get_default_raw ( )

inline

Definition at line 84 of file registry.h.

    {
        return default_logger_.get();
    }

std::shared_ptr<thread_pool> spdlog::details::registry::get_tp ( )

inline

Definition at line 112 of file registry.h.

    {
        std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
        return tp_;
    }

void spdlog::details::registry::initialize_logger ( std::shared_ptr< logger >  new_logger )

inline

Definition at line 48 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        new_logger->set_formatter(formatter_->clone());

        if (err_handler_)
        {
            new_logger->set_error_handler(err_handler_);
        }

        new_logger->set_level(level_);
        new_logger->flush_on(flush_level_);

        if (automatic_registration_)
        {
            register_logger_(std::move(new_logger));
        }
    }

static registry& spdlog::details::registry::instance ( )

inlinestatic

Definition at line 228 of file registry.h.

    {
        static registry s_instance;
        return s_instance;
    }

registry& spdlog::details::registry::operator= ( const registry &  )

delete

void spdlog::details::registry::register_logger ( std::shared_ptr< logger >  new_logger )

inline

Definition at line 42 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        register_logger_(std::move(new_logger));
    }

void spdlog::details::registry::register_logger_ ( std::shared_ptr< logger >  new_logger )

inlineprivate

Definition at line 264 of file registry.h.

    {
        auto logger_name = new_logger->name();
        throw_if_exists_(logger_name);
        loggers_[logger_name] = std::move(new_logger);
    }

void spdlog::details::registry::set_automatic_registration ( bool  automatic_regsistration )

inline

Definition at line 222 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        automatic_registration_ = automatic_regsistration;
    }

void spdlog::details::registry::set_default_logger ( std::shared_ptr< logger >  new_default_logger )

inline

Definition at line 91 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        // remove previous default logger from the map
        if (default_logger_ != nullptr)
        {
            loggers_.erase(default_logger_->name());
        }
        if (new_default_logger != nullptr)
        {
            loggers_[new_default_logger->name()] = new_default_logger;
        }
        default_logger_ = std::move(new_default_logger);
    }

void spdlog::details::registry::set_error_handler ( log_err_handler  handler )

inline

Definition at line 156 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        for (auto &l : loggers_)
        {
            l.second->set_error_handler(handler);
        }
        err_handler_ = handler;
    }

void spdlog::details::registry::set_formatter ( std::unique_ptr< formatter >  formatter )

inline

Definition at line 119 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        formatter_ = std::move(formatter);
        for (auto &l : loggers_)
        {
            l.second->set_formatter(formatter_->clone());
        }
    }

void spdlog::details::registry::set_level ( level::level_enum  log_level )

inline

Definition at line 129 of file registry.h.

    {
        std::lock_guard<std::mutex> lock(logger_map_mutex_);
        for (auto &l : loggers_)
        {
            l.second->set_level(log_level);
        }
        level_ = log_level;
    }

void spdlog::details::registry::set_tp ( std::shared_ptr< thread_pool >  tp )

inline

Definition at line 106 of file registry.h.

    {
        std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
        tp_ = std::move(tp);
    }

void spdlog::details::registry::shutdown ( )

inline

Definition at line 202 of file registry.h.

    {
        {
            std::lock_guard<std::mutex> lock(flusher_mutex_);
            periodic_flusher_.reset();
        }

        drop_all();

        {
            std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
            tp_.reset();
        }
    }

void spdlog::details::registry::throw_if_exists_ ( const std::string &  logger_name )

inlineprivate

Definition at line 256 of file registry.h.

    {
        if (loggers_.find(logger_name) != loggers_.end())
        {
            throw spdlog_ex("logger with name '" + logger_name + "' already exists");
        }
    }

std::recursive_mutex& spdlog::details::registry::tp_mutex ( )

inline

Definition at line 217 of file registry.h.

    {
        return tp_mutex_;
    }

Member Data Documentation

bool spdlog::details::registry::automatic_registration_ = true

private

Definition at line 281 of file registry.h.

std::shared_ptr<logger> spdlog::details::registry::default_logger_

private

Definition at line 280 of file registry.h.

log_err_handler spdlog::details::registry::err_handler_

private

Definition at line 277 of file registry.h.

level::level_enum spdlog::details::registry::flush_level_ = level::off

private

Definition at line 276 of file registry.h.

std::mutex spdlog::details::registry::flusher_mutex_

private

Definition at line 271 of file registry.h.

std::unique_ptr<formatter> spdlog::details::registry::formatter_

private

Definition at line 274 of file registry.h.

level::level_enum spdlog::details::registry::level_ = spdlog::logger::default_level()

private

Definition at line 275 of file registry.h.

std::mutex spdlog::details::registry::logger_map_mutex_

private

Definition at line 271 of file registry.h.

std::unordered_map<std::string, std::shared_ptr<logger> > spdlog::details::registry::loggers_

private

Definition at line 273 of file registry.h.

std::unique_ptr<periodic_worker> spdlog::details::registry::periodic_flusher_

private

Definition at line 279 of file registry.h.

std::shared_ptr<thread_pool> spdlog::details::registry::tp_

private

Definition at line 278 of file registry.h.

std::recursive_mutex spdlog::details::registry::tp_mutex_

private

Definition at line 272 of file registry.h.

---

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

• wire-cell-build/util/inc/spdlog/details/registry.h