Modify the async_logger_ptr parameter type to backend_worker_ptr

include/spdlog/details/thread_pool-inl.h

@@ -55,14 +55,14 @@ SPDLOG_INLINE thread_pool::~thread_pool() {
     SPDLOG_CATCH_STD
 }
 
-void SPDLOG_INLINE thread_pool::post_log(async_logger_ptr &&worker_ptr,
+void SPDLOG_INLINE thread_pool::post_log(backend_worker_ptr &&worker_ptr,
                                          const details::log_msg &msg,
                                          async_overflow_policy overflow_policy) {
     async_msg async_m(std::move(worker_ptr), async_msg_type::log, msg);
     post_async_msg_(std::move(async_m), overflow_policy);
 }
 
-void SPDLOG_INLINE thread_pool::post_flush(async_logger_ptr &&worker_ptr,
+void SPDLOG_INLINE thread_pool::post_flush(backend_worker_ptr &&worker_ptr,
                                            async_overflow_policy overflow_policy) {
     post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
 }

include/spdlog/details/thread_pool.h

@@ -14,11 +14,12 @@
 #include <vector>
 
 namespace spdlog {
-class async_logger;
 
 namespace details {
 
-using async_logger_ptr = std::shared_ptr<spdlog::async_logger>;
+class backend_worker;
+
+using backend_worker_ptr = std::shared_ptr<backend_worker>;
 
 enum class async_msg_type { log, flush, terminate };
 
@@ -26,7 +27,7 @@ enum class async_msg_type { log, flush, terminate };
 // Movable only. should never be copied
 struct async_msg : log_msg_buffer {
     async_msg_type msg_type{async_msg_type::log};
-    async_logger_ptr worker_ptr;
+    backend_worker_ptr worker_ptr;
 
     async_msg() = default;
     ~async_msg() = default;
@@ -53,12 +54,12 @@ struct async_msg : log_msg_buffer {
 #endif
 
     // construct from log_msg with given type
-    async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m)
+    async_msg(backend_worker_ptr &&worker, async_msg_type the_type, const details::log_msg &m)
         : log_msg_buffer{m},
           msg_type{the_type},
           worker_ptr{std::move(worker)} {}
 
-    async_msg(async_logger_ptr &&worker, async_msg_type the_type)
+    async_msg(backend_worker_ptr &&worker, async_msg_type the_type)
         : log_msg_buffer{},
           msg_type{the_type},
           worker_ptr{std::move(worker)} {}
@@ -85,10 +86,10 @@ public:
     thread_pool(const thread_pool &) = delete;
     thread_pool &operator=(thread_pool &&) = delete;
 
-    void post_log(async_logger_ptr &&worker_ptr,
+    void post_log(backend_worker_ptr &&worker_ptr,
                   const details::log_msg &msg,
                   async_overflow_policy overflow_policy);
-    void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
+    void post_flush(backend_worker_ptr &&worker_ptr, async_overflow_policy overflow_policy);
     size_t overrun_counter();
     void reset_overrun_counter();
     size_t discard_counter();