1 files changed, 227 insertions, 229 deletions

diff --git a/source/modules/asura-utils/threading/thread.cpp b/source/modules/asura-utils/threading/thread.cpp
index 48f287f..cb71d32 100644
--- a/source/modules/asura-utils/threading/thread.cpp
+++ b/source/modules/asura-utils/threading/thread.cpp
@@ -5,285 +5,283 @@
 #include "thread_impl_sdl.h"
 #include "thread_impl_std.h"
 
-namespace AsuraEngine
+namespace_begin(AsuraEngine)
+namespace_begin(Threading)
+
+Thread::Thread(lua_State* luaThread, ThreadType type /*= THREAD_TYPE_DEFERRED*/, uint sleepTime /*= 0*/, const std::string& name /*= ""*/)
+	: m_Name(name)
+	, m_State(THREAD_STATE_IDLE)
+	, m_Type(type)
+	, m_LuaThread(luaThread)
+	, m_CallbackThread(nullptr)
+	, m_SleepTime(sleepTime)
 {
-	namespace Threading
+	LUAX_STATE(luaThread);
+	if (type == THREAD_TYPE_IMMEDIATE)
 	{
+		Luax::LuaxVM* vm = state.GetVM();
+		ASSERT(vm);
+		m_CallbackThread = vm->CreateThread();
+		ASSERT(m_CallbackThread);
+		SetLuaxMemberRef(state, m_CallbackThreadRef, -1);
+		state.Pop(); // callback thread
+	}
+}
 
-		Thread::Thread(lua_State* luaThread, ThreadType type /*= THREAD_TYPE_DEFERRED*/, uint sleepTime /*= 0*/, const std::string& name /*= ""*/)
-			: m_Name(name)
-			, m_State(THREAD_STATE_IDLE)
-			, m_Type(type)
-			, m_LuaThread(luaThread)
-			, m_CallbackThread(nullptr)
-			, m_SleepTime(sleepTime)
-		{
-			LUAX_STATE(luaThread);
-			if (type == THREAD_TYPE_IMMEDIATE)
-			{
-				Luax::LuaxVM* vm = state.GetVM();
-				ASSERT(vm);
-			 m_CallbackThread = vm->CreateThread();
-				ASSERT(m_CallbackThread);
-				SetLuaxMemberRef(state, m_CallbackThreadRef, -1);
-				state.Pop(); // callback thread
-			}
-		}
-
-		Thread::~Thread()
-		{
-			if (m_Impl)
-			{
-				delete m_Impl;
-			 m_Impl = nullptr;
-			}
-		}
+Thread::~Thread()
+{
+	if (m_Impl)
+	{
+		delete m_Impl;
+		m_Impl = nullptr;
+	}
+}
 
-		bool Thread::AddTask(Task* task)
-		{
-			lock(m_TaskQueueMutex)
-			{
-				task->Retain();
-			 m_TaskQueue.push(task);
-			}
-			return true;
-		}
+bool Thread::AddTask(Task* task)
+{
+	lock(m_TaskQueueMutex)
+	{
+		task->Retain();
+		m_TaskQueue.push(task);
+	}
+	return true;
+}
 
-		uint Thread::GetTaskCount()
-		{
-			return m_TaskQueue.size();
-		}
+uint Thread::GetTaskCount()
+{
+	return m_TaskQueue.size();
+}
 
-		void Thread::Idle()
-		{
-		 m_State = THREAD_STATE_IDLE;
-		}
+void Thread::Idle()
+{
+	m_State = THREAD_STATE_IDLE;
+}
 
 #define try_start_thread(impl)\
-	if (!m_Impl) \
-	{ \
-	 m_Impl = new impl(); \
-		if (!m_Impl->Start(this, stacksize)) \
-		{ \
-			delete m_Impl; \
-		 m_Impl = nullptr; \
-		} \
-	}
-
-		bool Thread::Start(bool isDaemon /*= true*/, uint32 stacksize /*= 0*/)
-		{
-			if (m_State != THREAD_STATE_IDLE)
-				return false;
+if (!m_Impl) \
+{ \
+m_Impl = new impl(); \
+if (!m_Impl->Start(this, stacksize)) \
+{ \
+	delete m_Impl; \
+	m_Impl = nullptr; \
+} \
+}
+
+bool Thread::Start(bool isDaemon /*= true*/, uint32 stacksize /*= 0*/)
+{
+	if (m_State != THREAD_STATE_IDLE)
+		return false;
 
-			// ����Ѿ�����һ��֮ǰ�����ģ��ر�����
-			if (m_Impl)
-			{
-					delete m_Impl;
-				 m_Impl = nullptr;
-			}
+	// ����Ѿ�����һ��֮ǰ�����ģ��ر�����
+	if (m_Impl)
+	{
+			delete m_Impl;
+			m_Impl = nullptr;
+	}
 
 #if ASURA_THREAD_WIN32
-			try_start_thread(ThreadImplWin32);
+	try_start_thread(ThreadImplWin32);
 #endif
 
-			if (!m_Impl)
-				return false;
+	if (!m_Impl)
+		return false;
 
-		 m_IsDaemon = isDaemon;
-		 m_StateMutex.Lock();
-		 m_State = THREAD_STATE_RUNNING;
-		 m_StateMutex.Unlock();
-		}
+	m_IsDaemon = isDaemon;
+	m_StateMutex.Lock();
+	m_State = THREAD_STATE_RUNNING;
+	m_StateMutex.Unlock();
+}
 
-		void Thread::Pause()
-		{
-			ASSERT(m_Impl);
+void Thread::Pause()
+{
+	ASSERT(m_Impl);
 
-			lock(m_StateMutex)
-			{
-			 m_State = THREAD_STATE_PAUSED;
-			}
-		}
+	lock(m_StateMutex)
+	{
+		m_State = THREAD_STATE_PAUSED;
+	}
+}
 
-		void Thread::Resume()
-		{
-			ASSERT(m_Impl);
+void Thread::Resume()
+{
+	ASSERT(m_Impl);
 
-			lock(m_StateMutex)
-			{
-				if (m_State == THREAD_STATE_PAUSED)
-				 m_State = THREAD_STATE_RUNNING;
-			}
-		}
+	lock(m_StateMutex)
+	{
+		if (m_State == THREAD_STATE_PAUSED)
+			m_State = THREAD_STATE_RUNNING;
+	}
+}
 
-		void Thread::Stop()
-		{
-			ASSERT(m_Impl);
+void Thread::Stop()
+{
+	ASSERT(m_Impl);
 
-			lock(m_StateMutex)
-			{
-			 m_State = THREAD_STATE_STOPPED;
-			}
-		}
+	lock(m_StateMutex)
+	{
+		m_State = THREAD_STATE_STOPPED;
+	}
+}
 
-		void Thread::PauseSync()
-		{
-			Pause();
-			wait(m_SemPause);
-		}
+void Thread::PauseSync()
+{
+	Pause();
+	wait(m_SemPause);
+}
 
-		void Thread::ResumeSync()
-		{
-			Resume();
-			wait(m_SemResume);
-		}
+void Thread::ResumeSync()
+{
+	Resume();
+	wait(m_SemResume);
+}
 
-		void Thread::StopSync()
-		{
-			Stop();
-			wait(m_SemStop);
-		}
+void Thread::StopSync()
+{
+	Stop();
+	wait(m_SemStop);
+}
 
-		void Thread::Join()
-		{
-			ASSERT(m_Impl); 
-		 m_Impl->Join();
-		}
+void Thread::Join()
+{
+	ASSERT(m_Impl); 
+	m_Impl->Join();
+}
 
-		ThreadState Thread::GetState()
-		{
-			ThreadState state;
-			lock(m_StateMutex)
-			{
-				state = m_State;
-			}
-			return state;
-		}
+ThreadState Thread::GetState()
+{
+	ThreadState state;
+	lock(m_StateMutex)
+	{
+		state = m_State;
+	}
+	return state;
+}
 
-		bool Thread::IsRunning()
-		{
-			ASSERT(m_Impl);
+bool Thread::IsRunning()
+{
+	ASSERT(m_Impl);
 
-			return GetState() == THREAD_STATE_RUNNING;
-		}
+	return GetState() == THREAD_STATE_RUNNING;
+}
 
-		bool Thread::IsPaused()
-		{
-			ASSERT(m_Impl);
+bool Thread::IsPaused()
+{
+	ASSERT(m_Impl);
 
-			return GetState() == THREAD_STATE_PAUSED;
-		}
+	return GetState() == THREAD_STATE_PAUSED;
+}
 
-		bool Thread::IsStopped()
-		{
-			ASSERT(m_Impl);
+bool Thread::IsStopped()
+{
+	ASSERT(m_Impl);
 
-			return GetState() == THREAD_STATE_STOPPED;
-		}
+	return GetState() == THREAD_STATE_STOPPED;
+}
 
-		bool Thread::IsCurrent()
-		{
-			ASSERT(m_Impl);
+bool Thread::IsCurrent()
+{
+	ASSERT(m_Impl);
 
-			return m_Impl->IsCurrent(); 
-		}
+	return m_Impl->IsCurrent(); 
+}
 
-		const std::string& Thread::GetName()
-		{
-			return m_Name;
-		}
+const std::string& Thread::GetName()
+{
+	return m_Name;
+}
 
-		int Thread::Process()
-		{
-			LUAX_STATE(m_LuaThread);
+int Thread::Process()
+{
+	LUAX_STATE(m_LuaThread);
 
-			do{
-				if (IsRunning())
+	do{
+		if (IsRunning())
+		{
+			while (!m_TaskQueue.empty())
+			{
+				Task* task = m_TaskQueue.front();
+				if (task && task->Execute())
 				{
-					while (!m_TaskQueue.empty())
+					if (m_Type == THREAD_TYPE_DEFERRED)
+					{
+						m_FinishedMutex.Lock();
+						task->Retain();
+						m_FinishedTasks.push(task);
+						m_FinishedMutex.Unlock();
+					}
+					else if (m_Type == THREAD_TYPE_IMMEDIATE)
 					{
-						Task* task = m_TaskQueue.front();
-						if (task && task->Execute())
-						{
-							if (m_Type == THREAD_TYPE_DEFERRED)
-							{
-							 m_FinishedMutex.Lock();
-								task->Retain();
-							 m_FinishedTasks.push(task);
-							 m_FinishedMutex.Unlock();
-							}
-							else if (m_Type == THREAD_TYPE_IMMEDIATE)
-							{
-								// unsafe
-								task->Invoke(m_CallbackThread);
-								this->LuaxRelease<Task>(state, task);
-							}
-						 m_TaskQueueMutex.Lock();
-						 m_TaskQueue.pop();
-							task->Release();
-						 m_TaskQueueMutex.Unlock();
-						}
+						// unsafe
+						task->Invoke(m_CallbackThread);
+						this->LuaxRelease<Task>(state, task);
 					}
+					m_TaskQueueMutex.Lock();
+					m_TaskQueue.pop();
+					task->Release();
+					m_TaskQueueMutex.Unlock();
 				}
+			}
+		}
 
-				// �˳�ѭ��
-				if (IsStopped())
-					break;
-
-				// ����CPUʹ����
-				Sleep(m_SleepTime);
-
-			} while (m_IsDaemon);
+		// �˳�ѭ��
+		if (IsStopped())
+			break;
 
-			// ���ػ��̣߳����е�stop״̬
-			if (!m_IsDaemon)
-				Stop();
+		// ����CPUʹ����
+		Sleep(m_SleepTime);
 
-			signal(m_SemStop);
+	} while (m_IsDaemon);
 
-			// ����״̬ΪIdle
-			Idle();
+	// ���ػ��̣߳����е�stop״̬
+	if (!m_IsDaemon)
+		Stop();
 
-			return 0;
-		}
+	signal(m_SemStop);
 
-		///
-		/// �ӳ�ģʽ���������ص���
-		/// 
-		void Thread::Dispatch()
-		{
-			if (m_Type != THREAD_TYPE_DEFERRED)
-				return;
+	// ����״̬ΪIdle
+	Idle();
 
-			LUAX_STATE(m_LuaThread);
-			while (!m_FinishedTasks.empty())
-			{
-				Task* task = m_FinishedTasks.front(); 
-				if (task)
-				{
-					task->Invoke(m_LuaThread);
-					this->LuaxRelease<Task>(state, task);
-				 m_FinishedMutex.Lock();
-				 m_FinishedTasks.pop();
-					task->Release();
-				 m_FinishedMutex.Unlock();
-				}
-			}
-		}
+	return 0;
+}
 
-		void Thread::Sleep(uint ms)
-		{
-			ASSERT(m_Impl);
-			if (m_Impl)
-			{
-			 m_Impl->Sleep(ms);
-			}
-		}
+///
+/// �ӳ�ģʽ���������ص���
+/// 
+void Thread::Dispatch()
+{
+	if (m_Type != THREAD_TYPE_DEFERRED)
+		return;
 
-		void Thread::SetSleepTime(uint ms)
+	LUAX_STATE(m_LuaThread);
+	while (!m_FinishedTasks.empty())
+	{
+		Task* task = m_FinishedTasks.front(); 
+		if (task)
 		{
-		 m_SleepTime = ms;
+			task->Invoke(m_LuaThread);
+			this->LuaxRelease<Task>(state, task);
+			m_FinishedMutex.Lock();
+			m_FinishedTasks.pop();
+			task->Release();
+			m_FinishedMutex.Unlock();
 		}
+	}
+}
 
+void Thread::Sleep(uint ms)
+{
+	ASSERT(m_Impl);
+	if (m_Impl)
+	{
+		m_Impl->Sleep(ms);
 	}
-}
\ No newline at end of file
+}
+
+void Thread::SetSleepTime(uint ms)
+{
+	m_SleepTime = ms;
+}
+
+namespace_end
+namespace_end
\ No newline at end of file