clang format

gabime · Sep 24, 2023 · 1a0bfc7 · 1a0bfc7
1 parent f24f7fa
commit 1a0bfc7
Show file tree

Hide file tree

Showing 92 changed files with 2,368 additions and 3,540 deletions.
diff --git a/include/spdlog/async.h b/include/spdlog/async.h
@@ -18,9 +18,9 @@
 #include <spdlog/details/registry.h>
 #include <spdlog/details/thread_pool.h>
 
+#include <functional>
 #include <memory>
 #include <mutex>
-#include <functional>
 
 namespace spdlog {
 
@@ -31,27 +31,25 @@ static const size_t default_async_q_size = 8192;
 // async logger factory - creates async loggers backed with thread pool.
 // 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
-{
-    template<typename Sink, typename... SinkArgs>
-    static std::shared_ptr<async_logger> create(std::string logger_name, SinkArgs &&...args)
-    {
+template <async_overflow_policy OverflowPolicy = async_overflow_policy::block>
+struct async_factory_impl {
+    template <typename Sink, typename... SinkArgs>
+    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);
         }
 
         auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
-        auto new_logger = std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
+        auto new_logger =
+            std::make_shared<async_logger>(std::move(logger_name), std::move(sink), std::move(tp), OverflowPolicy);
         registry_inst.initialize_logger(new_logger);
         return new_logger;
     }
@@ -60,40 +58,34 @@ struct async_factory_impl
 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)
-{
+template <typename Sink, typename... SinkArgs>
+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)
-{
+template <typename Sink, typename... SinkArgs>
+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)
-{
+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) {
     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()
-{
-    return details::registry::instance().get_tp();
-}
+inline std::shared_ptr<spdlog::details::thread_pool> thread_pool() { return details::registry::instance().get_tp(); }
 } // namespace spdlog
diff --git a/include/spdlog/async_logger-inl.h b/include/spdlog/async_logger-inl.h
@@ -4,96 +4,73 @@
 #pragma once
 
 #ifndef SPDLOG_HEADER_ONLY
-#    include <spdlog/async_logger.h>
+    #include <spdlog/async_logger.h>
 #endif
 
-#include <spdlog/sinks/sink.h>
 #include <spdlog/details/thread_pool.h>
+#include <spdlog/sinks/sink.h>
 
 #include <memory>
 #include <string>
 
-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)
-{}
+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) {}
 
-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)
-{}
+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) {}
 
 // 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
-        {
-            throw_spdlog_ex("async log: thread pool doesn't exist anymore");
-        }
-    }
-    SPDLOG_LOGGER_CATCH(msg.source)
+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 {
+    throw_spdlog_ex("async log: thread pool doesn't exist anymore");
+}
+}
+SPDLOG_LOGGER_CATCH(msg.source)
 }
 
 // send flush request to the thread pool
-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
-        {
-            throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
-        }
-    }
-    SPDLOG_LOGGER_CATCH(source_loc())
+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 {
+    throw_spdlog_ex("async flush: thread pool doesn't exist anymore");
+}
+}
+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
-            {
-                sink->log(msg);
-            }
+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
-        {
-            sink->flush();
-        }
+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/include/spdlog/async_logger.h b/include/spdlog/async_logger.h
@@ -19,8 +19,7 @@
 namespace spdlog {
 
 // Async overflow policy - block by default.
-enum class async_overflow_policy
-{
+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.
@@ -31,24 +30,29 @@ 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)
-    {}
+    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_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_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_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_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);
 
     std::shared_ptr<logger> clone(std::string new_name) override;
 
@@ -65,5 +69,5 @@ class SPDLOG_API async_logger final : public std::enable_shared_from_this<async_
 } // namespace spdlog
 
 #ifdef SPDLOG_HEADER_ONLY
-#    include "async_logger-inl.h"
+    #include "async_logger-inl.h"
 #endif
diff --git a/include/spdlog/cfg/argv.h b/include/spdlog/cfg/argv.h
@@ -21,24 +21,18 @@ 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)
-{
-    load_argv_levels(argc, const_cast<const char **>(argv));
-}
+inline void load_argv_levels(int argc, char **argv) { load_argv_levels(argc, const_cast<const char **>(argv)); }
 
 } // namespace cfg
 } // namespace spdlog
diff --git a/include/spdlog/cfg/env.h b/include/spdlog/cfg/env.h
@@ -3,8 +3,8 @@
 
 #pragma once
 #include <spdlog/cfg/helpers.h>
-#include <spdlog/details/registry.h>
 #include <spdlog/details/os.h>
+#include <spdlog/details/registry.h>
 
 //
 // Init levels and patterns from env variables SPDLOG_LEVEL
@@ -25,11 +25,9 @@
 
 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);
     }
 }