1 files changed, 81 insertions, 81 deletions

diff --git a/source/modules/asura-utils/threading/thread.cpp b/source/modules/asura-utils/threading/thread.cpp
index 0899485..48f287f 100644
--- a/source/modules/asura-utils/threading/thread.cpp
+++ b/source/modules/asura-utils/threading/thread.cpp
@@ -11,217 +11,217 @@ namespace AsuraEngine
 	{
 
 		Thread::Thread(lua_State* luaThread, ThreadType type /*= THREAD_TYPE_DEFERRED*/, uint sleepTime /*= 0*/, const std::string& name /*= ""*/)
-			: mName(name)
-			, mState(THREAD_STATE_IDLE)
-			, mType(type)
-			, mLuaThread(luaThread)
-			, mCallbackThread(nullptr)
-			, mSleepTime(sleepTime)
+			: 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);
-				mCallbackThread = vm->CreateThread();
-				ASSERT(mCallbackThread);
-				SetLuaxMemberRef(state, mCallbackThreadRef, -1);
+			 m_CallbackThread = vm->CreateThread();
+				ASSERT(m_CallbackThread);
+				SetLuaxMemberRef(state, m_CallbackThreadRef, -1);
 				state.Pop(); // callback thread
 			}
 		}
 
 		Thread::~Thread()
 		{
-			if (mImpl)
+			if (m_Impl)
 			{
-				delete mImpl;
-				mImpl = nullptr;
+				delete m_Impl;
+			 m_Impl = nullptr;
 			}
 		}
 
 		bool Thread::AddTask(Task* task)
 		{
-			lock(mTaskQueueMutex)
+			lock(m_TaskQueueMutex)
 			{
 				task->Retain();
-				mTaskQueue.push(task);
+			 m_TaskQueue.push(task);
 			}
 			return true;
 		}
 
 		uint Thread::GetTaskCount()
 		{
-			return mTaskQueue.size();
+			return m_TaskQueue.size();
 		}
 
 		void Thread::Idle()
 		{
-			mState = THREAD_STATE_IDLE;
+		 m_State = THREAD_STATE_IDLE;
 		}
 
 #define try_start_thread(impl)\
-	if (!mImpl) \
+	if (!m_Impl) \
 	{ \
-		mImpl = new impl(); \
-		if (!mImpl->Start(this, stacksize)) \
+	 m_Impl = new impl(); \
+		if (!m_Impl->Start(this, stacksize)) \
 		{ \
-			delete mImpl; \
-			mImpl = nullptr; \
+			delete m_Impl; \
+		 m_Impl = nullptr; \
 		} \
 	}
 
 		bool Thread::Start(bool isDaemon /*= true*/, uint32 stacksize /*= 0*/)
 		{
-			if (mState != THREAD_STATE_IDLE)
+			if (m_State != THREAD_STATE_IDLE)
 				return false;
 
 			// ����Ѿ�����һ��֮ǰ�����ģ��ر�����
-			if (mImpl)
+			if (m_Impl)
 			{
-					delete mImpl;
-					mImpl = nullptr;
+					delete m_Impl;
+				 m_Impl = nullptr;
 			}
 
 #if ASURA_THREAD_WIN32
 			try_start_thread(ThreadImplWin32);
 #endif
 
-			if (!mImpl)
+			if (!m_Impl)
 				return false;
 
-			mIsDaemon = isDaemon;
-			mStateMutex.Lock();
-			mState = THREAD_STATE_RUNNING;
-			mStateMutex.Unlock();
+		 m_IsDaemon = isDaemon;
+		 m_StateMutex.Lock();
+		 m_State = THREAD_STATE_RUNNING;
+		 m_StateMutex.Unlock();
 		}
 
 		void Thread::Pause()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
-			lock(mStateMutex)
+			lock(m_StateMutex)
 			{
-				mState = THREAD_STATE_PAUSED;
+			 m_State = THREAD_STATE_PAUSED;
 			}
 		}
 
 		void Thread::Resume()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
-			lock(mStateMutex)
+			lock(m_StateMutex)
 			{
-				if (mState == THREAD_STATE_PAUSED)
-					mState = THREAD_STATE_RUNNING;
+				if (m_State == THREAD_STATE_PAUSED)
+				 m_State = THREAD_STATE_RUNNING;
 			}
 		}
 
 		void Thread::Stop()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
-			lock(mStateMutex)
+			lock(m_StateMutex)
 			{
-				mState = THREAD_STATE_STOPPED;
+			 m_State = THREAD_STATE_STOPPED;
 			}
 		}
 
 		void Thread::PauseSync()
 		{
 			Pause();
-			wait(mSemPause);
+			wait(m_SemPause);
 		}
 
 		void Thread::ResumeSync()
 		{
 			Resume();
-			wait(mSemResume);
+			wait(m_SemResume);
 		}
 
 		void Thread::StopSync()
 		{
 			Stop();
-			wait(mSemStop);
+			wait(m_SemStop);
 		}
 
 		void Thread::Join()
 		{
-			ASSERT(mImpl); 
-			mImpl->Join();
+			ASSERT(m_Impl); 
+		 m_Impl->Join();
 		}
 
 		ThreadState Thread::GetState()
 		{
 			ThreadState state;
-			lock(mStateMutex)
+			lock(m_StateMutex)
 			{
-				state = mState;
+				state = m_State;
 			}
 			return state;
 		}
 
 		bool Thread::IsRunning()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
 			return GetState() == THREAD_STATE_RUNNING;
 		}
 
 		bool Thread::IsPaused()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
 			return GetState() == THREAD_STATE_PAUSED;
 		}
 
 		bool Thread::IsStopped()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
 			return GetState() == THREAD_STATE_STOPPED;
 		}
 
 		bool Thread::IsCurrent()
 		{
-			ASSERT(mImpl);
+			ASSERT(m_Impl);
 
-			return mImpl->IsCurrent(); 
+			return m_Impl->IsCurrent(); 
 		}
 
 		const std::string& Thread::GetName()
 		{
-			return mName;
+			return m_Name;
 		}
 
 		int Thread::Process()
 		{
-			LUAX_STATE(mLuaThread);
+			LUAX_STATE(m_LuaThread);
 
 			do{
 				if (IsRunning())
 				{
-					while (!mTaskQueue.empty())
+					while (!m_TaskQueue.empty())
 					{
-						Task* task = mTaskQueue.front();
+						Task* task = m_TaskQueue.front();
 						if (task && task->Execute())
 						{
-							if (mType == THREAD_TYPE_DEFERRED)
+							if (m_Type == THREAD_TYPE_DEFERRED)
 							{
-								mFinishedMutex.Lock();
+							 m_FinishedMutex.Lock();
 								task->Retain();
-								mFinishedTasks.push(task);
-								mFinishedMutex.Unlock();
+							 m_FinishedTasks.push(task);
+							 m_FinishedMutex.Unlock();
 							}
-							else if (mType == THREAD_TYPE_IMMEDIATE)
+							else if (m_Type == THREAD_TYPE_IMMEDIATE)
 							{
 								// unsafe
-								task->Invoke(mCallbackThread);
+								task->Invoke(m_CallbackThread);
 								this->LuaxRelease<Task>(state, task);
 							}
-							mTaskQueueMutex.Lock();
-							mTaskQueue.pop();
+						 m_TaskQueueMutex.Lock();
+						 m_TaskQueue.pop();
 							task->Release();
-							mTaskQueueMutex.Unlock();
+						 m_TaskQueueMutex.Unlock();
 						}
 					}
 				}
@@ -231,15 +231,15 @@ namespace AsuraEngine
 					break;
 
 				// ����CPUʹ����
-				Sleep(mSleepTime);
+				Sleep(m_SleepTime);
 
-			} while (mIsDaemon);
+			} while (m_IsDaemon);
 
 			// ���ػ��̣߳����е�stop״̬
-			if (!mIsDaemon)
+			if (!m_IsDaemon)
 				Stop();
 
-			signal(mSemStop);
+			signal(m_SemStop);
 
 			// ����״̬ΪIdle
 			Idle();
@@ -252,37 +252,37 @@ namespace AsuraEngine
 		/// 
 		void Thread::Dispatch()
 		{
-			if (mType != THREAD_TYPE_DEFERRED)
+			if (m_Type != THREAD_TYPE_DEFERRED)
 				return;
 
-			LUAX_STATE(mLuaThread);
-			while (!mFinishedTasks.empty())
+			LUAX_STATE(m_LuaThread);
+			while (!m_FinishedTasks.empty())
 			{
-				Task* task = mFinishedTasks.front(); 
+				Task* task = m_FinishedTasks.front(); 
 				if (task)
 				{
-					task->Invoke(mLuaThread);
+					task->Invoke(m_LuaThread);
 					this->LuaxRelease<Task>(state, task);
-					mFinishedMutex.Lock();
-					mFinishedTasks.pop();
+				 m_FinishedMutex.Lock();
+				 m_FinishedTasks.pop();
 					task->Release();
-					mFinishedMutex.Unlock();
+				 m_FinishedMutex.Unlock();
 				}
 			}
 		}
 
 		void Thread::Sleep(uint ms)
 		{
-			ASSERT(mImpl);
-			if (mImpl)
+			ASSERT(m_Impl);
+			if (m_Impl)
 			{
-				mImpl->Sleep(ms);
+			 m_Impl->Sleep(ms);
 			}
 		}
 
 		void Thread::SetSleepTime(uint ms)
 		{
-			mSleepTime = ms;
+		 m_SleepTime = ms;
 		}
 
 	}