Cleanup

src/core/thread/atomic_int.h

@@ -14,8 +14,17 @@
 
 namespace crown
 {
+/// Atomic integer.
+///
+/// @ingroup Thread
 struct AtomicInt
 {
+#if CROWN_PLATFORM_POSIX && CROWN_COMPILER_GCC
+	mutable int _val;
+#elif CROWN_PLATFORM_WINDOWS
+	mutable LONG _val;
+#endif
+
 	AtomicInt(int val)
 	{
 		store(val);
@@ -40,14 +49,6 @@ struct AtomicInt
 		InterlockedExchange(&_val, val);
 #endif
 	}
-
-private:
-
-#if CROWN_PLATFORM_POSIX && CROWN_COMPILER_GCC
-	mutable int _val;
-#elif CROWN_PLATFORM_WINDOWS
-	mutable LONG _val;
-#endif
 };
 
 } // namespace crown

src/core/thread/mutex.h

@@ -5,10 +5,10 @@
 
 #pragma once
 
-#include "platform.h"
-#include "types.h"
 #include "error.h"
 #include "macros.h"
+#include "platform.h"
+#include "types.h"
 
 #if CROWN_PLATFORM_POSIX
 	#include <pthread.h>
@@ -18,18 +18,30 @@
 
 namespace crown
 {
+/// Mutex.
+///
+/// @ingroup Thread
 struct Mutex
 {
+#if CROWN_PLATFORM_POSIX
+	pthread_mutex_t _mutex;
+#elif CROWN_PLATFORM_WINDOWS
+	CRITICAL_SECTION _cs;
+#endif
+
 	Mutex()
 	{
 #if CROWN_PLATFORM_POSIX
-		int result = pthread_mutexattr_init(&_attr);
-		CE_ASSERT(result == 0, "pthread_mutexattr_init: errno = %d", result);
-		result = pthread_mutexattr_settype(&_attr, PTHREAD_MUTEX_ERRORCHECK);
-		CE_ASSERT(result == 0, "pthread_mutexattr_settype: errno = %d", result);
-		result = pthread_mutex_init(&_mutex, &_attr);
-		CE_ASSERT(result == 0, "pthread_mutex_init: errno = %d", result);
-		CE_UNUSED(result);
+		pthread_mutexattr_t attr;
+		int err = pthread_mutexattr_init(&attr);
+		CE_ASSERT(err == 0, "pthread_mutexattr_init: errno = %d", err);
+		err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
+		CE_ASSERT(err == 0, "pthread_mutexattr_settype: errno = %d", err);
+		err = pthread_mutex_init(&_mutex, &attr);
+		CE_ASSERT(err == 0, "pthread_mutex_init: errno = %d", err);
+		err = pthread_mutexattr_destroy(&attr);
+		CE_ASSERT(err == 0, "pthread_mutexattr_destroy: errno = %d", err);
+		CE_UNUSED(err);
 #elif CROWN_PLATFORM_WINDOWS
 		InitializeCriticalSection(&_cs);
 #endif
@@ -38,48 +50,38 @@ struct Mutex
 	~Mutex()
 	{
 #if CROWN_PLATFORM_POSIX
-		int result = pthread_mutex_destroy(&_mutex);
-		CE_ASSERT(result == 0, "pthread_mutex_destroy: errno = %d", result);
-		result = pthread_mutexattr_destroy(&_attr);
-		CE_ASSERT(result == 0, "pthread_mutexattr_destroy: errno = %d", result);
-		CE_UNUSED(result);
+		int err = pthread_mutex_destroy(&_mutex);
+		CE_ASSERT(err == 0, "pthread_mutex_destroy: errno = %d", err);
+		CE_UNUSED(err);
 #elif CROWN_PLATFORM_WINDOWS
 		DeleteCriticalSection(&_cs);
 #endif
-
 	}
 
+	/// Locks the mutex.
 	void lock()
 	{
 #if CROWN_PLATFORM_POSIX
-		int result = pthread_mutex_lock(&_mutex);
-		CE_ASSERT(result == 0, "pthread_mutex_lock: errno = %d", result);
-		CE_UNUSED(result);
+		int err = pthread_mutex_lock(&_mutex);
+		CE_ASSERT(err == 0, "pthread_mutex_lock: errno = %d", err);
+		CE_UNUSED(err);
 #elif CROWN_PLATFORM_WINDOWS
 		EnterCriticalSection(&_cs);
 #endif
 	}
 
+	/// Unlocks the mutex.
 	void unlock()
 	{
 #if CROWN_PLATFORM_POSIX
-		int result = pthread_mutex_unlock(&_mutex);
-		CE_ASSERT(result == 0, "pthread_mutex_unlock: errno = %d", result);
-		CE_UNUSED(result);
+		int err = pthread_mutex_unlock(&_mutex);
+		CE_ASSERT(err == 0, "pthread_mutex_unlock: errno = %d", err);
+		CE_UNUSED(err);
 #elif CROWN_PLATFORM_WINDOWS
 		LeaveCriticalSection(&_cs);
 #endif
 	}
 
-public:
-
-#if CROWN_PLATFORM_POSIX
-	pthread_mutex_t _mutex;
-	pthread_mutexattr_t _attr;
-#elif CROWN_PLATFORM_WINDOWS
-	CRITICAL_SECTION _cs;
-#endif
-
 private:
 
 	// Disable copying.
@@ -88,9 +90,13 @@ private:
 };
 
 /// Automatically locks a mutex when created and unlocks when destroyed.
+///
+/// @ingroup Thread
 struct ScopedMutex
 {
-	/// Locks the given @a m mutex.
+	Mutex& _mutex;
+
+	/// Locks the mutex @a m.
 	ScopedMutex(Mutex& m)
 		: _mutex(m)
 	{
@@ -103,10 +109,6 @@ struct ScopedMutex
 		_mutex.unlock();
 	}
 
-private:
-
-	Mutex& _mutex;
-
 private:
 
 	// Disable copying

src/core/thread/semaphore.h

@@ -5,9 +5,9 @@
 
 #pragma once
 
-#include "platform.h"
 #include "error.h"
 #include "mutex.h"
+#include "platform.h"
 
 #if CROWN_PLATFORM_POSIX
 	#include <pthread.h>
@@ -18,8 +18,19 @@
 
 namespace crown
 {
+/// Semaphore.
+///
+/// @ingroup Thread.
 struct Semaphore
 {
+#if CROWN_PLATFORM_POSIX
+	Mutex _mutex;
+	pthread_cond_t _cond;
+	s32 _count;
+#elif CROWN_PLATFORM_WINDOWS
+	HANDLE _handle;
+#endif
+
 	Semaphore()
 #if CROWN_PLATFORM_POSIX
 		: _count(0)
@@ -91,16 +102,6 @@ struct Semaphore
 #endif
 	}
 
-private:
-
-#if CROWN_PLATFORM_POSIX
-	Mutex _mutex;
-	pthread_cond_t _cond;
-	s32 _count;
-#elif CROWN_PLATFORM_WINDOWS
-	HANDLE _handle;
-#endif
-
 private:
 
 	// Disable copying

src/core/thread/thread.h

@@ -5,10 +5,10 @@
 
 #pragma once
 
-#include "platform.h"
 #include "error.h"
-#include "types.h"
+#include "platform.h"
 #include "semaphore.h"
+#include "types.h"
 
 #if CROWN_PLATFORM_POSIX
 	#include <pthread.h>
@@ -17,22 +17,37 @@
 	#include <process.h>
 #endif
 
+/// @defgroup Thread Thread
 namespace crown
 {
-typedef s32 (*ThreadFunction)(void*);
-
+/// Thread.
+///
+/// @ingroup Thread.
 struct Thread
 {
-	Thread()
+	typedef s32 (*ThreadFunction)(void* data);
+
+	ThreadFunction _function;
+	void* _user_data;
+	Semaphore _sem;
+	u32 _stack_size;
+	bool _is_running;
 #if CROWN_PLATFORM_POSIX
-		: _handle(0)
+	pthread_t _handle;
 #elif CROWN_PLATFORM_WINDOWS
-		: _handle(INVALID_HANDLE_VALUE)
+	HANDLE _handle;
 #endif
-		, _function(NULL)
-		, _data(NULL)
+
+	Thread()
+		: _function(NULL)
+		, _user_data(NULL)
 		, _stack_size(0)
 		, _is_running(false)
+#if CROWN_PLATFORM_POSIX
+		, _handle(0)
+#elif CROWN_PLATFORM_WINDOWS
+		, _handle(INVALID_HANDLE_VALUE)
+#endif
 	{
 	}
 
@@ -42,33 +57,32 @@ struct Thread
 			stop();
 	}
 
-	void start(ThreadFunction func, void* data = NULL, u32 stack_size = 0)
+	void start(ThreadFunction func, void* user_data = NULL, u32 stack_size = 0)
 	{
 		CE_ASSERT(!_is_running, "Thread is already running");
 		CE_ASSERT(func != NULL, "Function must be != NULL");
 		_function = func;
-		_data = data;
+		_user_data = user_data;
 		_stack_size = stack_size;
 
 #if CROWN_PLATFORM_POSIX
 		pthread_attr_t attr;
-		int result = pthread_attr_init(&attr);
+		int err = pthread_attr_init(&attr);
 		pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
-		CE_ASSERT(result == 0, "pthread_attr_init: errno = %d", result);
+		CE_ASSERT(err == 0, "pthread_attr_init: errno = %d", err);
 
 		if (_stack_size != 0)
 		{
-			result = pthread_attr_setstacksize(&attr, _stack_size);
-			CE_ASSERT(result == 0, "pthread_attr_setstacksize: errno = %d", result);
+			err = pthread_attr_setstacksize(&attr, _stack_size);
+			CE_ASSERT(err == 0, "pthread_attr_setstacksize: errno = %d", err);
 		}
 
-		result = pthread_create(&_handle, &attr, thread_proc, this);
-		CE_ASSERT(result == 0, "pthread_create: errno = %d", result);
+		err = pthread_create(&_handle, &attr, thread_proc, this);
+		CE_ASSERT(err == 0, "pthread_create: errno = %d", err);
 
-		// Free attr memory
-		result = pthread_attr_destroy(&attr);
-		CE_ASSERT(result == 0, "pthread_attr_destroy: errno = %d", result);
-		CE_UNUSED(result);
+		err = pthread_attr_destroy(&attr);
+		CE_ASSERT(err == 0, "pthread_attr_destroy: errno = %d", err);
+		CE_UNUSED(err);
 #elif CROWN_PLATFORM_WINDOWS
 		_handle = CreateThread(NULL, stack_size, Thread::thread_proc, this, 0, NULL);
 		CE_ASSERT(_handle != NULL, "CreateThread: GetLastError = %d", GetLastError());
@@ -83,9 +97,9 @@ struct Thread
 		CE_ASSERT(_is_running, "Thread is not running");
 
 #if CROWN_PLATFORM_POSIX
-		int result = pthread_join(_handle, NULL);
-		CE_ASSERT(result == 0, "pthread_join: errno = %d", result);
-		CE_UNUSED(result);
+		int err = pthread_join(_handle, NULL);
+		CE_ASSERT(err == 0, "pthread_join: errno = %d", err);
+		CE_UNUSED(err);
 		_handle = 0;
 #elif CROWN_PLATFORM_WINDOWS
 		WaitForSingleObject(_handle, INFINITE);
@@ -107,7 +121,7 @@ private:
 	s32 run()
 	{
 		_sem.post();
-		return _function(_data);
+		return _function(_user_data);
 	}
 
 #if CROWN_PLATFORM_POSIX
@@ -120,26 +134,12 @@ private:
 #elif CROWN_PLATFORM_WINDOWS
 	static DWORD WINAPI thread_proc(void* arg)
 	{
-		Thread* thread = (Thread*) arg;
+		Thread* thread = (Thread*)arg;
 		s32 result = thread->run();
 		return result;
 	}
 #endif
 
-private:
-
-#if CROWN_PLATFORM_POSIX
-	pthread_t _handle;
-#elif CROWN_PLATFORM_WINDOWS
-	HANDLE _handle;
-#endif
-
-	ThreadFunction _function;
-	void* _data;
-	Semaphore _sem;
-	u32 _stack_size;
-	bool _is_running;
-
 private:
 
 	// Disable copying