revert src/spdlog

fixstars · Sep 4, 2024 · 6848bc7 · 6848bc7
1 parent 9949d45
commit 6848bc7
Show file tree

Hide file tree

Showing 100 changed files with 14,175 additions and 15,223 deletions.
diff --git a/src/spdlog/async.h b/src/spdlog/async.h
@@ -32,17 +32,20 @@ static const size_t default_async_q_size = 8192;
 // if a global thread pool doesn't already exist, create it with default queue
 // size of 8192 items and single thread.
 template<async_overflow_policy OverflowPolicy = async_overflow_policy::block>
-struct async_factory_impl {
+struct async_factory_impl
+{
     template<typename Sink, typename... SinkArgs>
-    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args) {
+    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args)
+    {
         auto &registry_inst = details::registry::instance();
 
         // create global thread pool if not already exists..
 
         auto &mutex = registry_inst.tp_mutex();
         std::lock_guard<std::recursive_mutex> tp_lock(mutex);
         auto tp = registry_inst.get_tp();
-        if (tp == nullptr) {
+        if (tp == nullptr)
+        {
             tp = std::make_shared<details::thread_pool>(details::default_async_q_size, 1U);
             registry_inst.set_tp(tp);
         }
@@ -58,33 +61,39 @@ using async_factory = async_factory_impl<async_overflow_policy::block>;
 using async_factory_nonblock = async_factory_impl<async_overflow_policy::overrun_oldest>;
 
 template<typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&...sink_args) {
+inline std::shared_ptr<spdlog::logger> create_async(std::string logger_name, SinkArgs &&...sink_args)
+{
     return async_factory::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
 }
 
 template<typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&...sink_args) {
+inline std::shared_ptr<spdlog::logger> create_async_nb(std::string logger_name, SinkArgs &&...sink_args)
+{
     return async_factory_nonblock::create<Sink>(std::move(logger_name), std::forward<SinkArgs>(sink_args)...);
 }
 
 // set global thread pool.
 inline void init_thread_pool(
-    size_t q_size, size_t thread_count, std::function<void()> on_thread_start, std::function<void()> on_thread_stop) {
+    size_t q_size, size_t thread_count, std::function<void()> on_thread_start, std::function<void()> on_thread_stop)
+{
     auto tp = std::make_shared<details::thread_pool>(q_size, thread_count, on_thread_start, on_thread_stop);
     details::registry::instance().set_tp(std::move(tp));
 }
 
-inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start) {
+inline void init_thread_pool(size_t q_size, size_t thread_count, std::function<void()> on_thread_start)
+{
     init_thread_pool(q_size, thread_count, on_thread_start, [] {});
 }
 
-inline void init_thread_pool(size_t q_size, size_t thread_count) {
+inline void init_thread_pool(size_t q_size, size_t thread_count)
+{
     init_thread_pool(
         q_size, thread_count, [] {}, [] {});
 }
 
 // get the global thread pool.
-inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() {
+inline std::shared_ptr<spdlog::details::thread_pool> thread_pool()
+{
     return details::registry::instance().get_tp();
 }
-}  // namespace spdlog
+} // namespace spdlog
diff --git a/src/spdlog/async_logger-inl.h b/src/spdlog/async_logger-inl.h
@@ -4,7 +4,7 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/async_logger.h>
+#    include <spdlog/async_logger.h>
 #endif
 
 #include <spdlog/sinks/sink.h>
@@ -15,19 +15,20 @@
 
 SPDLOG_INLINE spdlog::async_logger::async_logger(
     std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
-    : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy) {
-}
+    : async_logger(std::move(logger_name), sinks_list.begin(), sinks_list.end(), std::move(tp), overflow_policy)
+{}
 
 SPDLOG_INLINE spdlog::async_logger::async_logger(
     std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp, async_overflow_policy overflow_policy)
-    : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy) {
-}
+    : async_logger(std::move(logger_name), {std::move(single_sink)}, std::move(tp), overflow_policy)
+{}
 
 // send the log message to the thread pool
 SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg){
     SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
 }
-else {
+else
+{
     throw_spdlog_ex("async log: thread pool doesn't exist anymore");
 }
 }
@@ -38,7 +39,8 @@ SPDLOG_LOGGER_CATCH(msg.source)
 SPDLOG_INLINE void spdlog::async_logger::flush_(){
     SPDLOG_TRY{if (auto pool_ptr = thread_pool_.lock()){pool_ptr->post_flush(shared_from_this(), overflow_policy_);
 }
-else {
+else
+{
     throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
 }
 }
@@ -48,31 +50,40 @@ SPDLOG_LOGGER_CATCH(source_loc())
 //
 // backend functions - called from the thread pool to do the actual job
 //
-SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg) {
-    for (auto &sink : sinks_) {
-        if (sink->should_log(msg.level)) {
-            SPDLOG_TRY {
+SPDLOG_INLINE void spdlog::async_logger::backend_sink_it_(const details::log_msg &msg)
+{
+    for (auto &sink : sinks_)
+    {
+        if (sink->should_log(msg.level))
+        {
+            SPDLOG_TRY
+            {
                 sink->log(msg);
             }
             SPDLOG_LOGGER_CATCH(msg.source)
         }
     }
 
-    if (should_flush_(msg)) {
+    if (should_flush_(msg))
+    {
         backend_flush_();
     }
 }
 
-SPDLOG_INLINE void spdlog::async_logger::backend_flush_() {
-    for (auto &sink : sinks_) {
-        SPDLOG_TRY {
+SPDLOG_INLINE void spdlog::async_logger::backend_flush_()
+{
+    for (auto &sink : sinks_)
+    {
+        SPDLOG_TRY
+        {
             sink->flush();
         }
         SPDLOG_LOGGER_CATCH(source_loc())
     }
 }
 
-SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name) {
+SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name)
+{
     auto cloned = std::make_shared<spdlog::async_logger>(*this);
     cloned->name_ = std::move(new_name);
     return cloned;

diff --git a/src/spdlog/async_logger.h b/src/spdlog/async_logger.h
@@ -19,31 +19,35 @@
 namespace spdlog {
 
 // Async overflow policy - block by default.
-enum class async_overflow_policy {
-    block,          // Block until message can be enqueued
-    overrun_oldest  // Discard oldest message in the queue if full when trying to
-                    // add new item.
+enum class async_overflow_policy
+{
+    block,         // Block until message can be enqueued
+    overrun_oldest // Discard oldest message in the queue if full when trying to
+                   // add new item.
 };
 
 namespace details {
 class thread_pool;
 }
 
-class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>, public logger {
+class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_logger>, public logger
+{
     friend class details::thread_pool;
 
 public:
     template<typename It>
     async_logger(std::string logger_name, It begin, It end, std::weak_ptr<details::thread_pool> tp,
-                 async_overflow_policy overflow_policy = async_overflow_policy::block)
-        : logger(std::move(logger_name), begin, end), thread_pool_(std::move(tp)), overflow_policy_(overflow_policy) {
-    }
+        async_overflow_policy overflow_policy = async_overflow_policy::block)
+        : logger(std::move(logger_name), begin, end)
+        , thread_pool_(std::move(tp))
+        , overflow_policy_(overflow_policy)
+    {}
 
     async_logger(std::string logger_name, sinks_init_list sinks_list, std::weak_ptr<details::thread_pool> tp,
-                 async_overflow_policy overflow_policy = async_overflow_policy::block);
+        async_overflow_policy overflow_policy = async_overflow_policy::block);
 
     async_logger(std::string logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp,
-                 async_overflow_policy overflow_policy = async_overflow_policy::block);
+        async_overflow_policy overflow_policy = async_overflow_policy::block);
 
     std::shared_ptr<logger> clone(std::string new_name) override;
 
@@ -57,8 +61,8 @@ class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_
     std::weak_ptr<details::thread_pool> thread_pool_;
     async_overflow_policy overflow_policy_;
 };
-}  // namespace spdlog
+} // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#include "async_logger-inl.h"
+#    include "async_logger-inl.h"
 #endif
diff --git a/src/spdlog/cfg/argv.h b/src/spdlog/cfg/argv.h
@@ -21,20 +21,24 @@ namespace spdlog {
 namespace cfg {
 
 // search for SPDLOG_LEVEL= in the args and use it to init the levels
-inline void load_argv_levels(int argc, const char **argv) {
+inline void load_argv_levels(int argc, const char **argv)
+{
     const std::string spdlog_level_prefix = "SPDLOG_LEVEL=";
-    for (int i = 1; i < argc; i++) {
+    for (int i = 1; i < argc; i++)
+    {
         std::string arg = argv[i];
-        if (arg.find(spdlog_level_prefix) == 0) {
+        if (arg.find(spdlog_level_prefix) == 0)
+        {
             auto levels_string = arg.substr(spdlog_level_prefix.size());
             helpers::load_levels(levels_string);
         }
     }
 }
 
-inline void load_argv_levels(int argc, char **argv) {
+inline void load_argv_levels(int argc, char **argv)
+{
     load_argv_levels(argc, const_cast<const char **>(argv));
 }
 
-}  // namespace cfg
-}  // namespace spdlog
+} // namespace cfg
+} // namespace spdlog
diff --git a/src/spdlog/cfg/env.h b/src/spdlog/cfg/env.h
@@ -25,12 +25,14 @@
 
 namespace spdlog {
 namespace cfg {
-inline void load_env_levels() {
+inline void load_env_levels()
+{
     auto env_val = details::os::getenv("SPDLOG_LEVEL");
-    if (!env_val.empty()) {
+    if (!env_val.empty())
+    {
         helpers::load_levels(env_val);
     }
 }
 
-}  // namespace cfg
-}  // namespace spdlog
+} // namespace cfg
+} // namespace spdlog
diff --git a/src/spdlog/cfg/helpers-inl.h b/src/spdlog/cfg/helpers-inl.h
@@ -4,7 +4,7 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#include <spdlog/cfg/helpers.h>
+#    include <spdlog/cfg/helpers.h>
 #endif
 
 #include <spdlog/spdlog.h>
@@ -21,14 +21,16 @@ namespace cfg {
 namespace helpers {
 
 // inplace convert to lowercase
-inline std::string &to_lower_(std::string &str) {
+inline std::string &to_lower_(std::string &str)
+{
     std::transform(
         str.begin(), str.end(), str.begin(), [](char ch) { return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch); });
     return str;
 }
 
 // inplace trim spaces
-inline std::string &trim_(std::string &str) {
+inline std::string &trim_(std::string &str)
+{
     const char *spaces = " \n\r\t";
     str.erase(str.find_last_not_of(spaces) + 1);
     str.erase(0, str.find_first_not_of(spaces));
@@ -42,12 +44,16 @@ inline std::string &trim_(std::string &str) {
 // "key=" => ("key", "")
 // "val" => ("", "val")
 
-inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str) {
+inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str)
+{
     auto n = str.find(sep);
     std::string k, v;
-    if (n == std::string::npos) {
+    if (n == std::string::npos)
+    {
         v = str;
-    } else {
+    }
+    else
+    {
         k = str.substr(0, n);
         v = str.substr(n + 1);
     }
@@ -56,12 +62,15 @@ inline std::pair<std::string, std::string> extract_kv_(char sep, const std::stri
 
 // return vector of key/value pairs from sequence of "K1=V1,K2=V2,.."
 // "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...}
-inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str) {
+inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str)
+{
     std::string token;
     std::istringstream token_stream(str);
     std::unordered_map<std::string, std::string> rv{};
-    while (std::getline(token_stream, token, ',')) {
-        if (token.empty()) {
+    while (std::getline(token_stream, token, ','))
+    {
+        if (token.empty())
+        {
             continue;
         }
         auto kv = extract_kv_('=', token);
@@ -70,8 +79,10 @@ inline std::unordered_map<std::string, std::string> extract_key_vals_(const std:
     return rv;
 }
 
-SPDLOG_INLINE void load_levels(const std::string &input) {
-    if (input.empty() || input.size() > 512) {
+SPDLOG_INLINE void load_levels(const std::string &input)
+{
+    if (input.empty() || input.size() > 512)
+    {
         return;
     }
 
@@ -80,26 +91,30 @@ SPDLOG_INLINE void load_levels(const std::string &input) {
     level::level_enum global_level = level::info;
     bool global_level_found = false;
 
-    for (auto &name_level : key_vals) {
+    for (auto &name_level : key_vals)
+    {
         auto &logger_name = name_level.first;
         auto level_name = to_lower_(name_level.second);
         auto level = level::from_str(level_name);
         // ignore unrecognized level names
-        if (level == level::off && level_name != "off") {
+        if (level == level::off && level_name != "off")
+        {
             continue;
         }
-        if (logger_name.empty())  // no logger name indicate global level
+        if (logger_name.empty()) // no logger name indicate global level
         {
             global_level_found = true;
             global_level = level;
-        } else {
+        }
+        else
+        {
             levels[logger_name] = level;
         }
     }
 
     details::registry::instance().set_levels(std::move(levels), global_level_found ? &global_level : nullptr);
 }
 
-}  // namespace helpers
-}  // namespace cfg
-}  // namespace spdlog
+} // namespace helpers
+} // namespace cfg
+} // namespace spdlog