253 lines
6.6 KiB
C++
253 lines
6.6 KiB
C++
#ifndef VXTHREAD_H
|
|
#define VXTHREAD_H
|
|
|
|
|
|
#include "VxMutex.h"
|
|
|
|
|
|
|
|
#define VXTERROR_TIMEOUT 9 // The timeout of an operation was reached.
|
|
|
|
#define VXTERROR_NULLTHREAD 50 // The thread object is null.
|
|
|
|
#define VXTERROR_WAIT 51 // An error occured while you try to join (wait for) a thread.
|
|
|
|
#define VXTERROR_EXITCODE 52 // An error while you try to get the exit code of a tread.
|
|
|
|
#define VXT_OK 53
|
|
|
|
|
|
/*************************************************
|
|
Summary: VxThread state
|
|
|
|
See also: VxThread, VxThread::Join.
|
|
*************************************************/
|
|
typedef enum VXTHREAD_STATE
|
|
{
|
|
VXTS_INITIALE = 0x00000000L, // Initiale state of a thread object (at this time the system thread isn't created).
|
|
VXTS_MAIN = 0x00000001L, // The thread is the main thread
|
|
VXTS_CREATED = 0x00000002L, // The system thread associated with the current thread object was correctly created.
|
|
VXTS_STARTED = 0x00000004L, // The thread has been started.
|
|
VXTS_JOINABLE = 0x00000008L // The thread is joinable (it means you can call VxThread::Join). Under Windows thread are always joinable.
|
|
} VXTHREAD_STATE;
|
|
|
|
/*************************************************
|
|
Summary: VxThread FLAGS
|
|
|
|
Remark: Win32 specific
|
|
See also: VxThread, VxThread::Join.
|
|
*************************************************/
|
|
typedef enum VXTHREADWIN32_FLAGS
|
|
{
|
|
VXTF_USECOINITIALIZEEX = 0x00000001, // The ThreadFunc will call CoInitializeEx and CoUninitialize.
|
|
VXTF_USECOINITIALIZE = 0x00000002, // The ThreadFunc will call CoInitialize and CoUninitialize. (default)
|
|
VXTF_NOCOINITIALIZE = 0x00000004, // The ThreadFunc will call neither CoInitialize, nor CoInitializeEx, nor CoUninitialize.
|
|
} VXTHREADWIN32_FLAGS;
|
|
|
|
|
|
/*************************************************
|
|
Summary: Enumeration of possible priority for a thread.
|
|
|
|
See also: VxThread,VxThread::SetPriority(unsigned int priority).
|
|
*************************************************/
|
|
typedef enum VXTHREAD_PRIORITY
|
|
{
|
|
VXTP_NORMAL = 0,
|
|
VXTP_ABOVENORMAL = 1,
|
|
VXTP_BELOWNORMAL = 2,
|
|
VXTP_HIGHLEVEL = 3,
|
|
VXTP_LOWLEVEL = 4,
|
|
VXTP_IDLE = 5,
|
|
VXTP_TIMECRITICAL = 6,
|
|
} VXTHREAD_PRIORITY;
|
|
|
|
|
|
/*************************************************
|
|
Summary: Thread is still active.
|
|
{PartOf:VxThread::GetExitCode}
|
|
*************************************************/
|
|
const unsigned int VXT_STILLACTIVE = 1000000;
|
|
|
|
|
|
/*************************************************
|
|
Summary: Thread has been terminated with VxThread::Terminate.
|
|
{PartOf:VxThread::GetExitCode}
|
|
*************************************************/
|
|
const unsigned int VXT_TERMINATEFORCED = 1000001;
|
|
|
|
|
|
//#if !defined(_LINUX) && !defined(macintosh)
|
|
/*************************************************
|
|
Summary: Prototype of a function which will be executed by a VxThread.
|
|
|
|
Remarks:
|
|
You can also overload VxThread::Run instead of creating an external function
|
|
Return value:
|
|
You must return a value greater than 0 if you want define your own return value.
|
|
Otherwise you can return a NKERROR value.
|
|
|
|
See also: VxThread, VxThread::Run, NKERROR.
|
|
*************************************************/
|
|
typedef unsigned int VxThreadFunction(void* args);
|
|
/*#else
|
|
typedef void* (*VxThreadFunction)(void* args);
|
|
#endif*/
|
|
|
|
/*************************************************
|
|
Summary: Using an opaque interface for thread data
|
|
on Mac and Linux platforms to avoid header dependencies
|
|
with underlying implementation
|
|
*************************************************/
|
|
|
|
#if defined(_LINUX) || defined(macintosh)
|
|
|
|
struct CThreadData;
|
|
|
|
#endif
|
|
|
|
/*************************************************
|
|
Summary: Represents a system thread.
|
|
|
|
Remarks:
|
|
There is to way to use thread :
|
|
|
|
1) you can inherit from the VxThread class and overload
|
|
the VxThread::Run() method.
|
|
|
|
2) or you can associate a ThreadFunction to you're
|
|
while the creation.
|
|
|
|
See also: VxThread::Run,VxThread::CreateThread,VxMutex.
|
|
*************************************************/
|
|
class VxThread
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
VX_EXPORT VxThread();
|
|
VX_EXPORT virtual ~VxThread();
|
|
|
|
VX_EXPORT BOOL CreateThread(VxThreadFunction* func=0,void* args=0);
|
|
VX_EXPORT void SetPriority(unsigned int priority);
|
|
VX_EXPORT void SetName(const char* name);
|
|
VX_EXPORT void Close();
|
|
VX_EXPORT const XString& GetName() const;
|
|
VX_EXPORT unsigned int GetPriority() const;
|
|
VX_EXPORT BOOL IsCreated() const;
|
|
VX_EXPORT BOOL IsJoinable() const;
|
|
VX_EXPORT BOOL IsMainThread() const;
|
|
VX_EXPORT BOOL IsStarted() const;
|
|
VX_EXPORT static VxThread* GetCurrentVxThread();
|
|
|
|
|
|
#if !defined(_LINUX) && !defined(macintosh)
|
|
VX_EXPORT int Wait(unsigned int* status=0,unsigned int timeout=0);
|
|
VX_EXPORT const GENERIC_HANDLE GetHandle() const;
|
|
VX_EXPORT DWORD GetID() const;
|
|
VX_EXPORT BOOL GetExitCode(unsigned int& status);
|
|
VX_EXPORT BOOL Terminate(unsigned int* status=0);
|
|
VX_EXPORT static DWORD GetCurrentVxThreadId();
|
|
#else
|
|
// Cast in pthread_t
|
|
VX_EXPORT const void* GetHandle() const;
|
|
VX_EXPORT int Wait(void** status=0,unsigned int timeout=0);
|
|
#endif
|
|
|
|
|
|
protected:
|
|
|
|
/*************************************************
|
|
Summary: Method to be executed by the thread if it was created
|
|
without ThreadFunction.
|
|
|
|
Return Value:
|
|
The exit code of the thread.
|
|
By default this method return VXT_OK.
|
|
Otherwise you can return your own return value (must be greater than 0)
|
|
or a NKERROR.
|
|
|
|
Remarks:
|
|
If you create the thread without ThreadFunction you need
|
|
create your own thread object which derived VxThread
|
|
and to overload the Run method.
|
|
|
|
See also: CreateThread, ThreadFunction.
|
|
*************************************************/
|
|
virtual unsigned int Run() {return VXT_OK;}
|
|
|
|
|
|
|
|
XString m_Name;
|
|
|
|
|
|
private:
|
|
|
|
|
|
friend void InitVxMath();
|
|
|
|
friend void ShutDownVxMath();
|
|
|
|
|
|
VxThread(const VxThread&);
|
|
|
|
VxThread& operator=(const VxThread&);
|
|
|
|
|
|
void SetPriority();
|
|
|
|
static VxMutex& GetMutex();
|
|
|
|
|
|
#if !defined(_LINUX) && !defined(macintosh)
|
|
static XHashTable<VxThread*,GENERIC_HANDLE>& GetHashThread();
|
|
#endif
|
|
|
|
|
|
#if defined(_LINUX) || defined(PSX2)|| defined(PSP) || defined(macintosh)
|
|
static void* ThreadFunc(void* args);
|
|
#endif
|
|
|
|
#if defined(WIN32) || defined(_XBOX)
|
|
static DWORD __stdcall ThreadFunc(void* args);
|
|
#endif
|
|
|
|
|
|
#if defined(_LINUX) || defined(macintosh)
|
|
CThreadData* m_ThreadData;
|
|
#else
|
|
|
|
GENERIC_HANDLE m_Thread;
|
|
|
|
unsigned int m_ThreadID;
|
|
#endif
|
|
|
|
|
|
|
|
unsigned int m_State;
|
|
|
|
unsigned int m_Priority;
|
|
|
|
VxThreadFunction* m_Func;
|
|
|
|
void* m_Args;
|
|
|
|
|
|
static VxThread* m_MainThread;
|
|
|
|
|
|
#if defined(_LINUX) || defined(macintosh)
|
|
static VxMutex m_MutexForHash;
|
|
#endif
|
|
|
|
#ifdef WIN32
|
|
public:
|
|
|
|
DWORD m_Win32Flags;
|
|
private:
|
|
#endif
|
|
};
|
|
|
|
|
|
#endif // VXTHREAD_H
|