clang-format

include/spdlog/async_logger-inl.h

@@ -17,38 +17,49 @@
 #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) {}
+    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) {}
+    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) {
-    if (auto pool_ptr = thread_pool_.lock()) {
+SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg)
+{
+    if (auto pool_ptr = thread_pool_.lock())
+    {
         pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
-    } else {
+    }
+    else
+    {
         SPDLOG_THROW(spdlog_ex("async log: thread pool doesn't exist anymore"));
     }
 }
 
 // send flush request to the thread pool
-SPDLOG_INLINE void spdlog::async_logger::flush_() {
-    if (auto pool_ptr = thread_pool_.lock()) {
+SPDLOG_INLINE void spdlog::async_logger::flush_()
+{
+    if (auto pool_ptr = thread_pool_.lock())
+    {
         pool_ptr->post_flush(shared_from_this(), overflow_policy_);
-    } else {
+    }
+    else
+    {
         SPDLOG_THROW(spdlog_ex("async flush: thread pool doesn't exist anymore"));
     }
 }
 
 SPDLOG_INLINE void spdlog::async_logger::dump_backtrace_()
 {
-    if (auto pool_ptr = thread_pool_.lock()) {
+    if (auto pool_ptr = thread_pool_.lock())
+    {
         pool_ptr->post_dump_backtrace(shared_from_this(), overflow_policy_);
-    } else {
+    }
+    else
+    {
         SPDLOG_THROW(spdlog_ex("async dump_backtrace: thread pool doesn't exist anymore"));
     }
 }
@@ -83,13 +94,12 @@ SPDLOG_INLINE void spdlog::async_logger::backend_flush_()
 
 SPDLOG_INLINE void spdlog::async_logger::backend_dump_backtrace_()
 {
-  spdlog::logger::dump_backtrace_();
+    spdlog::logger::dump_backtrace_();
 }
 
-
-SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name) {
-    auto cloned = std::make_shared<spdlog::async_logger>(std::move(new_name), sinks_.begin(), sinks_.end(),
-                                                         thread_pool_, overflow_policy_);
+SPDLOG_INLINE std::shared_ptr<spdlog::logger> spdlog::async_logger::clone(std::string new_name)
+{
+    auto cloned = std::make_shared<spdlog::async_logger>(std::move(new_name), sinks_.begin(), sinks_.end(), thread_pool_, overflow_policy_);
 
     cloned->set_level(this->level());
     cloned->flush_on(this->flush_level());

include/spdlog/async_logger.h

@@ -51,11 +51,10 @@ public:
 
     std::shared_ptr<logger> clone(std::string new_name) override;
 
-
 protected:
     void sink_it_(const details::log_msg &msg) override;
     void flush_() override;
-    void dump_backtrace_() override ;
+    void dump_backtrace_() override;
     void backend_sink_it_(const details::log_msg &incoming_log_msg);
     void backend_flush_();
     void backend_dump_backtrace_();

include/spdlog/logger-inl.h

@@ -161,7 +161,6 @@ SPDLOG_INLINE void logger::dump_backtrace()
     dump_backtrace_();
 }
 
-
 // flush functions
 SPDLOG_INLINE void logger::flush()
 {