wip static-lib

include/spdlog/details/thread_pool.h

@@ -123,118 +123,36 @@ public:
     using item_type = async_msg;
     using q_type = details::mpmc_blocking_queue<item_type>;
 
-    thread_pool(size_t q_max_items, size_t threads_n)
-        : q_(q_max_items)
-    {
-        // std::cout << "thread_pool()  q_size_bytes: " << q_size_bytes <<
-        // "\tthreads_n: " << threads_n << std::endl;
-        if (threads_n == 0 || threads_n > 1000)
-        {
-            throw spdlog_ex("spdlog::thread_pool(): invalid threads_n param (valid "
-                            "range is 1-1000)");
-        }
-        for (size_t i = 0; i < threads_n; i++)
-        {
-            threads_.emplace_back(&thread_pool::worker_loop_, this);
-        }
-    }
-
+    thread_pool(size_t q_max_items, size_t threads_n);
     // message all threads to terminate gracefully join them
-    ~thread_pool()
-    {
-        try
-        {
-            for (size_t i = 0; i < threads_.size(); i++)
-            {
-                post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
-            }
+    ~thread_pool();
 
-            for (auto &t : threads_)
-            {
-                t.join();
-            }
-        }
-        catch (...)
-        {
-        }
-    }
 
     thread_pool(const thread_pool &) = delete;
     thread_pool &operator=(thread_pool &&) = delete;
 
-    void post_log(async_logger_ptr &&worker_ptr, 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 post_log(async_logger_ptr &&worker_ptr, details::log_msg &msg, async_overflow_policy overflow_policy);
+    void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
+    size_t overrun_counter();
 
-    void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
-    {
-        post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
-    }
-
-    size_t overrun_counter()
-    {
-        return q_.overrun_counter();
-    }
 
 private:
     q_type q_;
 
     std::vector<std::thread> threads_;
 
-    void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
-    {
-        if (overflow_policy == async_overflow_policy::block)
-        {
-            q_.enqueue(std::move(new_msg));
-        }
-        else
-        {
-            q_.enqueue_nowait(std::move(new_msg));
-        }
-    }
-
-    void worker_loop_()
-    {
-        while (process_next_msg_()) {};
-    }
+    void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy);
+    void worker_loop_();
 
     // process next message in the queue
     // return true if this thread should still be active (while no terminate msg
     // was received)
-    bool process_next_msg_()
-    {
-        async_msg incoming_async_msg;
-        bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
-        if (!dequeued)
-        {
-            return true;
-        }
-
-        switch (incoming_async_msg.msg_type)
-        {
-        case async_msg_type::log:
-        {
-            auto msg = incoming_async_msg.to_log_msg();
-            incoming_async_msg.worker_ptr->backend_log_(msg);
-            return true;
-        }
-        case async_msg_type::flush:
-        {
-            incoming_async_msg.worker_ptr->backend_flush_();
-            return true;
-        }
-
-        case async_msg_type::terminate:
-        {
-            return false;
-        }
-        }
-        assert(false && "Unexpected async_msg_type");
-        return true;
-    }
+    bool process_next_msg_();
 };
 
 } // namespace details
 } // namespace spdlog
+
+#ifndef SPDLOG_STATIC_LIB
+#include "spdlog/impl/thread_pool.cpp"
+#endif