format

bench/spdlog-async.cpp

@@ -25,7 +25,7 @@ int main(int argc, char *argv[])
         thread_count = std::atoi(argv[1]);
 
     int howmany = 1000000;
-	spdlog::init_thread_pool (howmany, 1);
+    spdlog::init_thread_pool(howmany, 1);
 
     auto logger = spdlog::create_async_logger<spdlog::sinks::simple_file_sink_mt>("file_logger", "logs/spdlog-bench-async.log", false);
     logger->set_pattern("[%Y-%m-%d %T.%F]: %L %t %v");

bench/spdlog-bench-mt.cpp

@@ -10,8 +10,8 @@
 #include <thread>
 #include <vector>
 
-#include "spdlog/spdlog.h"
 #include "spdlog/sinks/simple_file_sink.h"
+#include "spdlog/spdlog.h"
 
 using namespace std;
 

bench/spdlog-bench.cpp

@@ -6,8 +6,8 @@
 #include <chrono>
 #include <iostream>
 
-#include "spdlog/spdlog.h"
 #include "spdlog/sinks/simple_file_sink.h"
+#include "spdlog/spdlog.h"
 
 int main(int, char *[])
 {

example/example.cpp

@@ -82,7 +82,7 @@ int main(int, char *[])
 
         // Asynchronous logging is very fast..
         // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous..
-        //async_example();
+        // async_example();
 
         // Log user-defined types example
         user_defined_example();
@@ -107,7 +107,7 @@ int main(int, char *[])
 #include "spdlog/async.h"
 void async_example()
 {
-    //auto async_file = spd::basic_logger_mt<spdlog::create_async>("async_file_logger", "logs/async_log.txt");
+    // auto async_file = spd::basic_logger_mt<spdlog::create_async>("async_file_logger", "logs/async_log.txt");
 
     for (int j = 0; j < 1; j++)
     {
@@ -119,8 +119,7 @@ void async_example()
         }
         spdlog::drop_all();
     }
-	//std::this_thread::sleep_for(std::chrono::seconds(1));
-		
+    // std::this_thread::sleep_for(std::chrono::seconds(1));
 
     // you can also modify thread pool settings *before* creating the logger:
     // spdlog::init_thread_pool(32768, 4); // queue with max 32k items 4 backing threads.

include/spdlog/common.h

@@ -179,7 +179,13 @@ using filename_t = std::wstring;
 using filename_t = std::string;
 #endif
 
-
-#define SPDLOG_CATCH_AND_HANDLE catch (const std::exception &ex) {_err_handler(ex.what());}\
-								catch (...) {_err_handler("Unknown exeption in logger");}
+#define SPDLOG_CATCH_AND_HANDLE                                                                                                            \
+    catch (const std::exception &ex)                                                                                                       \
+    {                                                                                                                                      \
+        _err_handler(ex.what());                                                                                                           \
+    }                                                                                                                                      \
+    catch (...)                                                                                                                            \
+    {                                                                                                                                      \
+        _err_handler("Unknown exeption in logger");                                                                                        \
+    }
 } // namespace spdlog

include/spdlog/details/thread_pool.h

@@ -10,21 +10,21 @@
 #include <vector>
 
 namespace spdlog {
-	namespace details {
+namespace details {
 
-		using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
+using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
 
-		enum class async_msg_type
-		{
+enum class async_msg_type
+{
     log,
     flush,
     terminate
-		};
+};
 
-		// Async msg to move to/from the queue
-		// Movable only. should never be copied
-		struct async_msg
-		{
+// Async msg to move to/from the queue
+// Movable only. should never be copied
+struct async_msg
+{
     async_msg_type msg_type;
     level::level_enum level;
     log_clock::time_point time;
@@ -78,11 +78,11 @@ namespace spdlog {
         msg.color_range_start = 0;
         msg.color_range_end = 0;
     }
-		};
+};
 
-		class thread_pool
-		{
-		public:
+class thread_pool
+{
+public:
     using item_type = async_msg;
     using q_type = details::mpmc_blocking_queue<item_type>;
     using clock_type = std::chrono::steady_clock;
@@ -139,7 +139,7 @@ namespace spdlog {
         return msg_counter_.load(std::memory_order_relaxed);
     }
 
-		private:
+private:
     std::atomic<size_t> msg_counter_; // total # of messages processed in this pool
     q_type _q;
 
@@ -159,9 +159,7 @@ namespace spdlog {
 
     void worker_loop()
     {
-				while (process_next_msg())
-				{
-				};
+        while (process_next_msg()) {};
     }
 
     // process next message in the queue
@@ -200,7 +198,7 @@ namespace spdlog {
         assert(false);
         return true; // should not be reached
     }
-		};
+};
 
-	} // namespace details
+} // namespace details
 } // namespace spdlog

tests/test_async.cpp

 #include "includes.h"
-#include "test_sink.h"
 #include "spdlog/async.h"
 #include "spdlog/sinks/simple_file_sink.h"
+#include "test_sink.h"
 
-//std::unique_ptr<spdlog::async_logger> create_logger(size_t tp_queue_size, size_t tp_threads)
+// std::unique_ptr<spdlog::async_logger> create_logger(size_t tp_queue_size, size_t tp_threads)
 //{
 //	auto tp = std::make_shared<details::thread_pool>(8192, 1);
 //	auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block_retry);
@@ -87,7 +87,6 @@ TEST_CASE("multi threads", "[async]")
                 {
                     logger->info("Hello message #{}", j);
                 }
-				
             });
         }
 
@@ -96,7 +95,6 @@ TEST_CASE("multi threads", "[async]")
             t.join();
         }
         logger->flush();
-
     }
 
     REQUIRE(test_sink->msg_counter() == messages * n_threads);
@@ -110,7 +108,7 @@ TEST_CASE("to_file", "[async]")
     size_t messages = 512;
     size_t n_threads = 4;
     spdlog::init_thread_pool(queue_size, n_threads);
-	auto logger= spdlog::basic_logger_mt<spdlog::create_async>("as", "logs/async_test.log", true);
+    auto logger = spdlog::basic_logger_mt<spdlog::create_async>("as", "logs/async_test.log", true);
 
     std::vector<std::thread> threads;
     for (size_t i = 0; i < n_threads; i++)