www.pudn.com > zfxcengine-0.1.0.zip > ceThreading.cpp

#include "Core/ceExceptions.h" 
#include "Core/ceThreading.h" 
#include "SDL.h" 
#include "SDL_thread.h" 
#include "SDL_mutex.h" 
 
using namespace ZFXCE; 
using namespace ZFXCE::Threading; 
 
void Sleep(UINT milisec) 
{ 
	SDL_Delay(milisec); 
} 
 
ceThread::ceThread() 
: m_Data(0) 
{ 
} 
 
ceThread::ceThread(int (*func) (void*), void* data) 
{ 
	if(!(m_Data = SDL_CreateThread(func, data))) 
		CE_EXCEPTION("ceThread::ctor: Create thread failed.", 2); 
} 
 
ceThread::ceThread(const ceThread& t) 
: m_Data(t.m_Data) 
{ 
} 
 
void ceThread::Kill() 
{ 
	if(m_Data) 
		SDL_KillThread((SDL_Thread*)m_Data); 
} 
 
INT ceThread::WaitForExit() 
{ 
	INT ret = 0; 
	if(m_Data) 
		SDL_WaitThread((SDL_Thread*)m_Data, &ret); 
	return ret; 
} 
 
ceMutex::ceMutex() 
{ 
	if(!(m_Data = SDL_CreateMutex())) 
		CE_EXCEPTION("ceMutex::ctor: Create mutex failed.", 2); 
} 
 
ceMutex::~ceMutex() 
{ 
	SDL_DestroyMutex((SDL_mutex*)m_Data); 
} 
 
void ceMutex::Lock() 
{ 
	if(SDL_mutexP((SDL_mutex*)m_Data)==-1) 
		CE_EXCEPTION("ceMutex::Lock: Lock mutex failed.", 2); 
} 
 
void ceMutex::Unlock() 
{ 
	if(SDL_mutexV((SDL_mutex*)m_Data)==-1) 
		CE_EXCEPTION("ceMutex::Lock: Lock mutex failed.", 2); 
} 
 
ceSemaphore::ceSemaphore(UINT initVal) 
{ 
	if(!(m_Data = SDL_CreateSemaphore(initVal))) 
		CE_EXCEPTION("ceSemaphore::ctor: Create semaphore failed.", 2); 
} 
 
ceSemaphore::~ceSemaphore() 
{ 
	SDL_DestroySemaphore((SDL_sem*)m_Data); 
} 
 
void ceSemaphore::Wait() 
{ 
	if(SDL_SemWait((SDL_sem*)m_Data)==-1) 
		CE_EXCEPTION("ceSemaphore::Wait: Wait for semaphore failed.", 2); 
} 
 
BOOL ceSemaphore::TryWait() 
{ 
	INT ret = SDL_SemTryWait((SDL_sem*)m_Data); 
	if(ret==-1) 
		CE_EXCEPTION("ceSemaphore::TryWait: Wait for semaphore failed.", 2); 
	return(ret!=SDL_MUTEX_TIMEDOUT); 
} 
 
BOOL ceSemaphore::WaitTimeout(UINT milisec) 
{ 
	INT ret = SDL_SemWaitTimeout((SDL_sem*)m_Data, milisec); 
	if(ret==-1) 
		CE_EXCEPTION("ceSemaphore::WaitTimeout: Wait for semaphore failed.", 2); 
	 
	return(ret!=SDL_MUTEX_TIMEDOUT); 
} 
 
void ceSemaphore::Unlock() 
{ 
	if(SDL_SemPost((SDL_sem*)m_Data)==-1) 
		CE_EXCEPTION("ceSemaphore::Unlock: Unlock semaphore failed.", 2); 
} 
 
UINT ceSemaphore::GetValue() 
{ 
	return SDL_SemValue((SDL_sem*)m_Data); 
} 
 
ceCondition::ceCondition() 
{ 
	if(!(m_Data = SDL_CreateCond())) 
		CE_EXCEPTION("ceCondition::ctor: Create condition failed.", 2); 
} 
 
ceCondition::~ceCondition() 
{ 
	SDL_DestroyCond((SDL_cond*)m_Data); 
} 
 
void ceCondition::Signal() 
{ 
	if(SDL_CondSignal((SDL_cond*)m_Data)==-1) 
		CE_EXCEPTION("ceCondition::Signal: Signal condition failed.", 2); 
} 
 
void ceCondition::Broadcast() 
{ 
	if(SDL_CondBroadcast((SDL_cond*)m_Data)==-1) 
		CE_EXCEPTION("ceCondition::Broadcast: Broadcast condition failed.", 2); 
} 
 
void ceCondition::Wait(const ceMutex* mutex) 
{ 
	if(SDL_CondWait((SDL_cond*)m_Data, (SDL_mutex*)mutex->m_Data)==-1) 
		CE_EXCEPTION("ceCondition::Wait: Wait for condition failed.", 2); 
} 
 
BOOL ceCondition::WaitTimeout(const ceMutex* mutex, UINT milisec) 
{ 
	INT ret = SDL_CondWaitTimeout((SDL_cond*)m_Data, (SDL_mutex*)mutex->m_Data,milisec); 
	if(ret==-1) 
		CE_EXCEPTION("ceCondition::WaitTimeout: Wait for condition failed.", 2); 
 
	return(ret!=SDL_MUTEX_TIMEDOUT); 
}