Descent3/win32/wintask.cpp

/*
 * $Logfile: /DescentIII/Main/win32/wintask.cpp $
 * $Revision: 5 $
 * $Date: 9/14/98 4:02p $
 * $Author: Samir $
 *
 * Task manager
 *
 * $Log: /DescentIII/Main/win32/wintask.cpp $
 * 
 * 5     9/14/98 4:02p Samir
 * allow variable lengths of blocking for tasks.
 * 
 * 4     8/10/98 5:54p Samir
 * added mutexes.
 * 
 * 3     10/22/97 10:57a Samir
 * Made highest priority time critical again.
 * 
 * 2     10/17/97 11:37a Samir
 * Changed highest task priority from TIME_CRITICAL to HIGHEST.
 * 
 * 2     6/09/97 4:17p Samir
 * RCS check in.
 *
 * $NoKeywords: $
 */



//	Allow Full DD system access.
#include "DDAccess.h"

//	Library includes
#include "TaskSystem.h"
#include "pserror.h"

//	Standard includes
#include <windows.h>


//	---------------------------------------------------------------------------
//	osTask implementation
//	---------------------------------------------------------------------------


osTask::osTask(unsigned (*func)(void *), tTaskPriority priority, void *parm)
{
	int pri;

	task_os_handle = 0;
	task_os_id = 0;

 	task_os_handle = (unsigned)CreateThread(NULL, 0,
								(LPTHREAD_START_ROUTINE)func, 
								(LPVOID)parm, 0, 
								(LPDWORD)&task_os_id);
	if (task_os_handle == 0) {
		Int3();									// Get Samir.
	}
 
	if (priority == TASKPRIORITY_HIGHEST)
		pri = THREAD_PRIORITY_TIME_CRITICAL;
	else if (priority == TASKPRIORITY_NORMAL)
		pri = THREAD_PRIORITY_NORMAL;
	else if (priority == TASKPRIORITY_LOWEST)
		pri = THREAD_PRIORITY_LOWEST;

	SetThreadPriority((HANDLE)task_os_handle, pri);
}


osTask::~osTask()
{
	if (task_os_handle) {
		CloseHandle((HANDLE)task_os_handle);
	}
}


bool osTask::error() const
{
	if (!task_os_handle) return 1;
	else return 0;
}


void osTask::suspend()							// suspends task
{
	if (task_os_handle) {
		SuspendThread((HANDLE)task_os_handle);
	}
}


void osTask::resume()							// resumes task
{
	if (task_os_handle) {
		ResumeThread((HANDLE)task_os_handle);
	}
}


//	---------------------------------------------------------------------------
//	osEvent implementation
//	---------------------------------------------------------------------------
osEvent::osEvent(char *name)
{
	event_os_handle = (unsigned)CreateEvent(NULL, TRUE, FALSE, name);	
}


osEvent::~osEvent()
{
	if (event_os_handle)
		CloseHandle((HANDLE)event_os_handle);
}

// signal the event so blocking can stop
void osEvent::signal()
{
	if (event_os_handle) 
		SetEvent((HANDLE)event_os_handle);
}


// clear the event so blocking can continue
void osEvent::clear()
{
	if (event_os_handle)
		ResetEvent((HANDLE)event_os_handle);
}


// block until signaled
bool osEvent::block(int timeout)
{
	DWORD res;

	if (event_os_handle) {
		res = WaitForSingleObject((HANDLE)event_os_handle, (timeout==-1) ? INFINITE : timeout);
		if (res == WAIT_OBJECT_0) return 1;
		else if (res == WAIT_ABANDONED) return 0;
	}

	return 0;
}


bool osEvent::error() const
{
	if (!event_os_handle) return 1;
	else return 0;
}



//	This establishes a mutual exclusion object.  once one thread locks the object, 
//	any code in another thread that contains a mutex check will block or skip that code until
//	the locking thread unlocks it.
osMutex::osMutex()
{
	mutex_os_handle = 0;
}


osMutex::~osMutex()
{
	Destroy();
}

bool osMutex::Create()								// creates a mutex object.
{
	if (!mutex_os_handle) {
		mutex_os_handle = (unsigned)CreateMutex(NULL, FALSE, NULL);
		return mutex_os_handle ? true : false;
	}

	return false;
}

void osMutex::Destroy()								// destroys a mutex object
{
	if (mutex_os_handle) {
		CloseHandle((HANDLE)mutex_os_handle);
		mutex_os_handle = 0;
	}
}

	
// calling thread will attempt to acquire mutex (wait until timeout) if timeout == -1, wait forever...
bool osMutex::Acquire(int timeout)
{
	DWORD res;

	if (!mutex_os_handle) 
		return true;							// we should return true because the caller will skip code if false is returned.

	if (timeout == -1) 
		timeout = INFINITE;

	res = WaitForSingleObject((HANDLE)mutex_os_handle, timeout);
	if (res == WAIT_OBJECT_0 || res == WAIT_ABANDONED) 
		return true;
	else 
		return false;
}


// calling thread releases control of mutex.
void osMutex::Release()
{
	if (mutex_os_handle) {
		ReleaseMutex((HANDLE)mutex_os_handle);
	}
}