aboutsummaryrefslogtreecommitdiff
path: root/thirdparty/spdlog/details/registry-inl.h
diff options
context:
space:
mode:
Diffstat (limited to 'thirdparty/spdlog/details/registry-inl.h')
-rw-r--r--thirdparty/spdlog/details/registry-inl.h313
1 files changed, 313 insertions, 0 deletions
diff --git a/thirdparty/spdlog/details/registry-inl.h b/thirdparty/spdlog/details/registry-inl.h
new file mode 100644
index 00000000..a60faabc
--- /dev/null
+++ b/thirdparty/spdlog/details/registry-inl.h
@@ -0,0 +1,313 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+#include <spdlog/details/registry.h>
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/details/periodic_worker.h>
+#include <spdlog/logger.h>
+#include <spdlog/pattern_formatter.h>
+
+#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
+// support for the default stdout color logger
+#ifdef _WIN32
+#include <spdlog/sinks/wincolor_sink.h>
+#else
+#include <spdlog/sinks/ansicolor_sink.h>
+#endif
+#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace spdlog {
+namespace details {
+
+SPDLOG_INLINE registry::registry()
+ : 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_INLINE registry::~registry() = default;
+
+SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger)
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ register_logger_(std::move(new_logger));
+}
+
+SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger)
+{
+ 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_);
+ }
+
+ // set new level according to previously configured level or default level
+ auto it = log_levels_.find(new_logger->name());
+ auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
+ new_logger->set_level(new_level);
+
+ new_logger->flush_on(flush_level_);
+
+ if (backtrace_n_messages_ > 0)
+ {
+ new_logger->enable_backtrace(backtrace_n_messages_);
+ }
+
+ if (automatic_registration_)
+ {
+ register_logger_(std::move(new_logger));
+ }
+}
+
+SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string &logger_name)
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ auto found = loggers_.find(logger_name);
+ return found == loggers_.end() ? nullptr : found->second;
+}
+
+SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ return default_logger_;
+}
+
+// Return raw ptr to the default logger.
+// To be used directly by the spdlog default api (e.g. spdlog::info)
+// This make the default API faster, but cannot be used concurrently with set_default_logger().
+// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
+SPDLOG_INLINE logger *registry::get_default_raw()
+{
+ return default_logger_.get();
+}
+
+// set default logger.
+// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
+SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
+{
+ 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);
+}
+
+SPDLOG_INLINE void registry::set_tp(std::shared_ptr<thread_pool> tp)
+{
+ std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+ tp_ = std::move(tp);
+}
+
+SPDLOG_INLINE std::shared_ptr<thread_pool> registry::get_tp()
+{
+ std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+ return tp_;
+}
+
+// Set global formatter. Each sink in each logger will get a clone of this object
+SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ formatter_ = std::move(formatter);
+ for (auto &l : loggers_)
+ {
+ l.second->set_formatter(formatter_->clone());
+ }
+}
+
+SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages)
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ backtrace_n_messages_ = n_messages;
+
+ for (auto &l : loggers_)
+ {
+ l.second->enable_backtrace(n_messages);
+ }
+}
+
+SPDLOG_INLINE void registry::disable_backtrace()
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ backtrace_n_messages_ = 0;
+ for (auto &l : loggers_)
+ {
+ l.second->disable_backtrace();
+ }
+}
+
+SPDLOG_INLINE void registry::set_level(level::level_enum log_level)
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ for (auto &l : loggers_)
+ {
+ l.second->set_level(log_level);
+ }
+ global_log_level_ = log_level;
+}
+
+SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ for (auto &l : loggers_)
+ {
+ l.second->flush_on(log_level);
+ }
+ flush_level_ = log_level;
+}
+
+SPDLOG_INLINE void registry::flush_every(std::chrono::seconds interval)
+{
+ std::lock_guard<std::mutex> lock(flusher_mutex_);
+ auto clbk = [this]() { this->flush_all(); };
+ periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
+}
+
+SPDLOG_INLINE void registry::set_error_handler(void (*handler)(const std::string &msg))
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ for (auto &l : loggers_)
+ {
+ l.second->set_error_handler(handler);
+ }
+ err_handler_ = handler;
+}
+
+SPDLOG_INLINE void registry::apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ for (auto &l : loggers_)
+ {
+ fun(l.second);
+ }
+}
+
+SPDLOG_INLINE void registry::flush_all()
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ for (auto &l : loggers_)
+ {
+ l.second->flush();
+ }
+}
+
+SPDLOG_INLINE void registry::drop(const std::string &logger_name)
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ loggers_.erase(logger_name);
+ if (default_logger_ && default_logger_->name() == logger_name)
+ {
+ default_logger_.reset();
+ }
+}
+
+SPDLOG_INLINE void registry::drop_all()
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ loggers_.clear();
+ default_logger_.reset();
+}
+
+// clean all resources and threads started by the registry
+SPDLOG_INLINE void registry::shutdown()
+{
+ {
+ std::lock_guard<std::mutex> lock(flusher_mutex_);
+ periodic_flusher_.reset();
+ }
+
+ drop_all();
+
+ {
+ std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
+ tp_.reset();
+ }
+}
+
+SPDLOG_INLINE std::recursive_mutex &registry::tp_mutex()
+{
+ return tp_mutex_;
+}
+
+SPDLOG_INLINE void registry::set_automatic_registration(bool automatic_registration)
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ automatic_registration_ = automatic_registration;
+}
+
+SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum *global_level)
+{
+ std::lock_guard<std::mutex> lock(logger_map_mutex_);
+ log_levels_ = std::move(levels);
+ auto global_level_requested = global_level != nullptr;
+ global_log_level_ = global_level_requested ? *global_level : global_log_level_;
+
+ for (auto &logger : loggers_)
+ {
+ auto logger_entry = log_levels_.find(logger.first);
+ if (logger_entry != log_levels_.end())
+ {
+ logger.second->set_level(logger_entry->second);
+ }
+ else if (global_level_requested)
+ {
+ logger.second->set_level(*global_level);
+ }
+ }
+}
+
+SPDLOG_INLINE registry &registry::instance()
+{
+ static registry s_instance;
+ return s_instance;
+}
+
+SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)
+{
+ if (loggers_.find(logger_name) != loggers_.end())
+ {
+ throw_spdlog_ex("logger with name '" + logger_name + "' already exists");
+ }
+}
+
+SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger)
+{
+ auto logger_name = new_logger->name();
+ throw_if_exists_(logger_name);
+ loggers_[logger_name] = std::move(new_logger);
+}
+
+} // namespace details
+} // namespace spdlog