Event loop basics + libuv

common/event/background_task.h

@@ -0,0 +1,39 @@
+#pragma once
+#include <functional>
+#include "event_loop.h"
+
+namespace EQ {
+	class BackgroundTask
+	{
+	public:
+		typedef std::function<void(void)> BackgroundTaskFunction;
+		struct BackgroundTaskBaton
+		{
+			BackgroundTaskFunction fn;
+			BackgroundTaskFunction on_finish;
+		};
+
+		BackgroundTask(BackgroundTaskFunction fn, BackgroundTaskFunction on_finish) {
+			uv_work_t *m_work = new uv_work_t;
+			memset(m_work, 0, sizeof(uv_work_t));
+			BackgroundTaskBaton *baton = new BackgroundTaskBaton();
+			baton->fn = fn;
+			baton->on_finish = on_finish;
+		
+			m_work->data = baton;
+			uv_queue_work(EventLoop::Get().Handle(), m_work, [](uv_work_t* req) {
+				BackgroundTaskBaton *baton = (BackgroundTaskBaton*)req->data;
+				baton->fn();
+			}, [](uv_work_t* req, int status) {
+				BackgroundTaskBaton *baton = (BackgroundTaskBaton*)req->data;
+				baton->on_finish();
+				delete baton;
+				delete req;
+			});
+		}
+
+		~BackgroundTask() {
+
+		}
+	};
+}

common/event/event_loop.h

@@ -0,0 +1,36 @@
+#pragma once
+#include <functional>
+#include <uv.h>
+
+namespace EQ
+{
+	class EventLoop
+	{
+	public:
+		static EventLoop &Get() {
+			static EventLoop inst;
+			return inst;
+		}
+
+		~EventLoop() {
+			uv_loop_close(&m_loop);
+		}
+
+		void Process() {
+			uv_run(&m_loop, UV_RUN_NOWAIT);
+		}
+
+		uv_loop_t* Handle() { return &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;
+	};
+}

common/event/timer.h

@@ -0,0 +1,63 @@
+#pragma once
+#include <functional>
+#include "event_loop.h"
+
+namespace EQ {
+	class Timer
+	{
+	public:
+		Timer(uint64_t duration_ms, bool repeats, std::function<void(void)> cb)
+		{
+			memset(&m_timer, 0, sizeof(uv_timer_t));
+			m_cb = cb;
+			m_duration_ms = duration_ms;
+			m_repeats = repeats;
+			m_attached = nullptr;
+			Attach(EventLoop::Get().Handle());
+		}
+
+		~Timer()
+		{
+			Detach();
+		}
+	private:
+		void Execute() {
+			m_cb();
+		}
+
+		virtual void Attach(uv_loop_t *loop) {
+			if (!m_attached) {
+				uv_timer_init(loop, &m_timer);
+				m_timer.data = this;
+
+				if (m_repeats) {
+					uv_timer_start(&m_timer, [](uv_timer_t *handle) {
+						Timer *t = (Timer*)handle->data;
+						t->Execute();
+					}, m_duration_ms, m_duration_ms);
+				}
+				else {
+					uv_timer_start(&m_timer, [](uv_timer_t *handle) {
+						Timer *t = (Timer*)handle->data;
+						t->Execute();
+					}, m_duration_ms, 0);
+				}
+
+				m_attached = loop;
+			}
+		}
+
+		virtual void Detach() {
+			if (m_attached) {
+				uv_timer_stop(&m_timer);
+				m_attached = nullptr;
+			}
+		}
+
+		uv_timer_t m_timer;
+		std::function<void(void)> m_cb;
+		uint64_t m_duration_ms;
+		bool m_repeats;
+		uv_loop_t *m_attached;
+	};
+}