Warning fixes, general cleanup (#5053)

common/event/event_loop.cpp

@@ -0,0 +1,57 @@
+/*	EQEmu: EQEmulator
+
+	Copyright (C) 2001-2026 EQEmu Development Team
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common/event/event_loop.h"
+#include "uv.h"
+
+namespace EQ {
+
+EventLoop& EventLoop::Get()
+{
+	thread_local EventLoop inst;
+	return inst;
+}
+
+EventLoop::EventLoop()
+	: m_loop(std::make_unique<uv_loop_t>())
+{
+	memset(m_loop.get(), 0, sizeof(uv_loop_t));
+	uv_loop_init(m_loop.get());
+}
+
+EventLoop::~EventLoop()
+{
+	uv_loop_close(m_loop.get());
+}
+
+void EventLoop::Process()
+{
+	uv_run(m_loop.get(), UV_RUN_NOWAIT);
+}
+
+void EventLoop::Run()
+{
+	uv_run(m_loop.get(), UV_RUN_DEFAULT);
+}
+
+void EventLoop::Shutdown()
+{
+	uv_stop(m_loop.get());
+}
+
+} // namespace EQ

common/event/event_loop.h

@@ -17,48 +17,31 @@
 */
 #pragma once
 
-#include "common/platform/win/include_windows.h" // uv.h is going to include it so let's do it first.
-#include "uv.h"  // FIXME: hide this
+#include <memory>
 
-#include <cstring>
+typedef struct uv_loop_s uv_loop_t;
 
-namespace EQ
+namespace EQ {
+
+class EventLoop
 {
-	class EventLoop
-	{
-	public:
-		static EventLoop &Get() {
-			static thread_local EventLoop inst;
-			return inst;
-		}
+public:
+	static EventLoop& Get();
 
-		~EventLoop() {
-			uv_loop_close(&m_loop);
-		}
+	~EventLoop();
+	EventLoop(const EventLoop&) = delete;
+	EventLoop& operator=(const EventLoop&) = delete;
 
-		void Process() {
-			uv_run(&m_loop, UV_RUN_NOWAIT);
-		}
+	void Process();
+	void Run();
+	void Shutdown();
 
-		void Run() {
-			uv_run(&m_loop, UV_RUN_DEFAULT);
-		}
+	uv_loop_t* Handle() { return m_loop.get(); }
 
-		void Shutdown() {
-			uv_stop(&m_loop);
-		}
+private:
+	EventLoop();
 
-		uv_loop_t* Handle() { return &m_loop; }
+	std::unique_ptr<uv_loop_t> m_loop;
+};
 
-	private:
-		EventLoop() {
-			memset(&m_loop, 0, sizeof(uv_loop_t));
-			uv_loop_init(&m_loop);
-		}
-		
-		EventLoop(const EventLoop&);
-		EventLoop& operator=(const EventLoop&);
-	
-		uv_loop_t m_loop;
-	};
-}
+} // namespace EQ

common/event/task_scheduler.cpp

@@ -0,0 +1,128 @@
+/*	EQEmu: EQEmulator
+
+	Copyright (C) 2001-2026 EQEmu Development Team
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "task_scheduler.h"
+
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <vector>
+
+namespace EQ::Event {
+
+static constexpr int DefaultThreadCount = 4;
+
+struct TaskScheduler::SchedulerData
+{
+	std::atomic_bool running{ false };
+	std::vector<std::thread> threads;
+	std::mutex lock;
+	std::condition_variable cv;
+	std::queue<std::function<void()>> tasks;
+};
+
+TaskScheduler::TaskScheduler()
+	: m_data(std::make_unique<SchedulerData>())
+{
+	Start(DefaultThreadCount);
+}
+
+TaskScheduler::TaskScheduler(size_t threads)
+{
+	Start(threads);
+}
+
+TaskScheduler::~TaskScheduler()
+{
+	Stop();
+}
+
+void TaskScheduler::Start(size_t threads)
+{
+	if (m_data->running.exchange(true))
+		return;
+
+	m_data->threads.reserve(threads);
+
+	for (size_t i = 0; i < threads; ++i)
+	{
+		m_data->threads.emplace_back(
+			[this]{ ProcessWork(); });
+	}
+}
+
+void TaskScheduler::Stop()
+{
+	if (!m_data->running.exchange(false))
+		return;
+
+	m_data->cv.notify_all();
+
+	for (auto& t : m_data->threads)
+	{
+		t.join();
+	}
+
+	m_data->threads.clear();
+}
+
+void TaskScheduler::ProcessWork()
+{
+	for (;;)
+	{
+		std::function<void()> work;
+
+		{
+			std::unique_lock lock(m_data->lock);
+
+			m_data->cv.wait(lock,
+				[this]
+			{
+				return !m_data->running || !m_data->tasks.empty();
+			});
+
+			if (!m_data->running)
+			{
+				return;
+			}
+
+			work = std::move(m_data->tasks.front());
+			m_data->tasks.pop();
+		}
+
+		work();
+	}
+}
+
+void TaskScheduler::AddTask(std::function<void()>&& task)
+{
+	if (!m_data->running)
+	{
+		throw std::runtime_error("Enqueue on stopped scheduler.");
+	}
+
+	{
+		std::scoped_lock lock(m_data->lock);
+		m_data->tasks.push(std::move(task));
+	}
+	m_data->cv.notify_one();
+}
+
+} // namespace EQ::Event

common/event/task_scheduler.h

@@ -17,116 +17,45 @@
 */
 #pragma once
 
-#include <condition_variable>
 #include <functional>
 #include <future>
-#include <mutex>
-#include <queue>
-#include <thread>
-#include <vector>
+#include <memory>
 
-namespace EQ
+namespace EQ::Event {
+
+class TaskScheduler
 {
-	namespace Event
+public:
+	TaskScheduler();
+	TaskScheduler(size_t threads);
+			
+	~TaskScheduler();
+
+	void Start(size_t threads);
+	void Stop();
+
+	template <typename Fn, typename... Args>
+	auto Enqueue(Fn&& fn, Args&&... args) -> std::future<typename std::invoke_result<Fn, Args...>::type>
 	{
-		class TaskScheduler
-		{
-		public:
-			static const int DefaultThreadCount = 4;
-		
-			TaskScheduler() : _running(false)
+		using return_type = typename std::invoke_result<Fn, Args...>::type;
+
+		auto task = std::make_shared<std::packaged_task<return_type()>>(
+			[fn = std::forward<Fn>(fn), ...args = std::forward<Args>(args)]() mutable
 			{
-				Start(DefaultThreadCount);
-			}
-
-			TaskScheduler(size_t threads) : _running(false)
-			{
-				Start(threads);
+				return fn(std::forward<Args>(args)...);
 			}
+		);
 			
-			~TaskScheduler() {
-				Stop();
-			}
-
-			void Start(size_t threads) {
-				if (true == _running) {
-					return;
-				}
-
-				_running = true;
-
-				for (size_t i = 0; i < threads; ++i) {
-					_threads.emplace_back(std::thread(std::bind(&TaskScheduler::ProcessWork, this)));
-				}
-			}
-			
-			void Stop() {
-				if (false == _running) {
-					return;
-				}
-
-				{
-					std::unique_lock<std::mutex> lock(_lock);
-					_running = false;
-				}
-
-				_cv.notify_all();
-
-				for (auto &t : _threads) {
-					t.join();
-				}
-			}
-			
-			template<typename Fn, typename... Args>
-			auto Enqueue(Fn&& fn, Args&&... args) -> std::future<typename std::invoke_result<Fn, Args...>::type> {
-				using return_type = typename std::invoke_result<Fn, Args...>::type;
-			
-				auto task = std::make_shared<std::packaged_task<return_type()>>(
-					std::bind(std::forward<Fn>(fn), std::forward<Args>(args)...)
-					);
-			
-				std::future<return_type> res = task->get_future();
-				{
-					std::unique_lock<std::mutex> lock(_lock);
-			
-					if (false == _running) {
-						throw std::runtime_error("Enqueue on stopped scheduler.");
-					}
-			
-					_tasks.emplace([task]() { (*task)(); });
-				}
-			
-				_cv.notify_one();
-				return res;
-			}
-			
-			private:
-			void ProcessWork() {
-				for (;;) {
-					std::function<void()> work;
-
-					{
-						std::unique_lock<std::mutex> lock(_lock);
-						_cv.wait(lock, [this] { return !_running || !_tasks.empty(); });
-
-						if (false == _running) {
-							return;
-						}
-
-						work = std::move(_tasks.front());
-						_tasks.pop();
-					}
-
-					work();
-				}
-				
-			}
-
-			bool _running = true;
-			std::vector<std::thread> _threads;
-			std::mutex _lock;
-			std::condition_variable _cv;
-			std::queue<std::function<void()>> _tasks;
-		};
+		AddTask([task] { (*task)(); });
+		return task->get_future();
 	}
-}
+
+private:
+	void AddTask(std::function<void()>&& task);
+	void ProcessWork();
+
+	struct SchedulerData;
+	std::unique_ptr<SchedulerData> m_data;
+};
+
+} // namespace EQ::Event

common/event/timer.cpp

@@ -0,0 +1,90 @@
+/*	EQEmu: EQEmulator
+
+	Copyright (C) 2001-2026 EQEmu Development Team
+
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "common/event/timer.h"
+#include "uv.h"
+
+namespace EQ {
+
+Timer::Timer(callback_t cb)
+	: m_cb(std::move(cb))
+{
+}
+
+Timer::Timer(uint64_t duration_ms, bool repeats, callback_t cb)
+	: m_cb(std::move(cb))
+{
+	Start(duration_ms, repeats);
+}
+
+Timer::~Timer()
+{
+	Stop();
+}
+
+void Timer::Start(uint64_t duration_ms, bool repeats)
+{
+	if (!m_timer)
+	{
+		uv_loop_t* loop = EventLoop::Get().Handle();
+
+		m_timer = std::make_unique<uv_timer_t>();
+		memset(m_timer.get(), 0, sizeof(uv_timer_t));
+
+		uv_timer_init(loop, m_timer.get());
+		m_timer->data = this;
+
+		if (repeats)
+		{
+			uv_timer_start(m_timer.get(), [](uv_timer_t* handle)
+			{
+				Timer* t = static_cast<Timer*>(handle->data);
+				t->Execute();
+			}, duration_ms, duration_ms);
+		}
+		else
+		{
+			uv_timer_start(m_timer.get(),
+				[](uv_timer_t* handle)
+			{
+				Timer* t = static_cast<Timer*>(handle->data);
+				t->Stop();
+				t->Execute();
+			}, duration_ms, 0);
+		}
+	}
+}
+
+void Timer::Stop()
+{
+	if (m_timer)
+	{
+		uv_close(reinterpret_cast<uv_handle_t*>(m_timer.release()),
+			[](uv_handle_t* handle)
+		{
+			delete reinterpret_cast<uv_timer_t*>(handle);
+		});
+	}
+}
+
+void Timer::Execute()
+{
+	m_cb(this);
+}
+
+} // namespace EQ

common/event/timer.h

@@ -19,69 +19,31 @@
 
 #include "event_loop.h"
 
-#include <cstring>
 #include <functional>
+#include <memory>
+
+typedef struct uv_timer_s uv_timer_t;
 
 namespace EQ {
-	class Timer
-	{
-	public:
-		Timer(std::function<void(Timer *)> cb)
-		{
-			m_timer = nullptr;
-			m_cb = cb;
-		}
 
-		Timer(uint64_t duration_ms, bool repeats, std::function<void(Timer *)> cb)
-		{
-			m_timer = nullptr;
-			m_cb = cb;
-			Start(duration_ms, repeats);
-		}
+class Timer
+{
+public:
+	using callback_t = std::function<void(Timer*)>;
+
+	Timer(callback_t cb);
+	Timer(uint64_t duration_ms, bool repeats, callback_t cb);
 	
-		~Timer()
-		{
-			Stop();
-		}
+	~Timer();
 
-		void Start(uint64_t duration_ms, bool repeats) {
-			auto loop = EventLoop::Get().Handle();
-			if (!m_timer) {
-				m_timer = new uv_timer_t;
-				memset(m_timer, 0, sizeof(uv_timer_t));
-				uv_timer_init(loop, m_timer);
-				m_timer->data = this;
+	void Start(uint64_t duration_ms, bool repeats);
+	void Stop();
 
-				if (repeats) {
-					uv_timer_start(m_timer, [](uv_timer_t *handle) {
-						Timer *t = (Timer*)handle->data;
-						t->Execute();
-					}, duration_ms, duration_ms);
-				}
-				else {
-					uv_timer_start(m_timer, [](uv_timer_t *handle) {
-						Timer *t = (Timer*)handle->data;
-						t->Stop();
-						t->Execute();
-					}, duration_ms, 0);
-				}
-			}
-		}
-
-		void Stop() {
-			if (m_timer) {
-				uv_close((uv_handle_t*)m_timer, [](uv_handle_t* handle) {
-					delete (uv_timer_t *)handle;
-				});
-				m_timer = nullptr;
-			}
-		}
-	private:
-		void Execute() {
-			m_cb(this);
-		}
+private:
+	void Execute();
 	
-		uv_timer_t *m_timer;
-		std::function<void(Timer*)> m_cb;
-	};
-}
+	std::unique_ptr<uv_timer_t> m_timer;
+	callback_t m_cb;
+};
+
+} // namespace EQ