blob: f6f29a71109cc0fcbd5f57ce06cc6c2a3449593c (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
/* $Id$ */
/** @file thread.h Base of all threads. */
#ifndef THREAD_H
#define THREAD_H
typedef void (*OTTDThreadFunc)(void *);
/**
* A Thread Object which works on all our supported OSes.
*/
class ThreadObject {
public:
/**
* Virtual destructor to allow 'delete' operator to work properly.
*/
virtual ~ThreadObject() {};
/**
* Check if the thread is currently running.
* @return True if the thread is running.
*/
virtual bool IsRunning() = 0;
/**
* Waits for the thread to exit.
* @return True if the thread has exited.
*/
virtual bool WaitForStop() = 0;
/**
* Exit this thread.
*/
virtual bool Exit() = 0;
/**
* Join this thread.
*/
virtual void Join() = 0;
/**
* Check if this thread is the current active thread.
* @return True if it is the current active thread.
*/
virtual bool IsCurrent() = 0;
/**
* Get the unique ID of this thread.
* @return A value unique to each thread.
*/
virtual uint GetId() = 0;
/**
* Create a thread; proc will be called as first function inside the thread,
* with optinal params.
* @param proc The procedure to call inside the thread.
* @param param The params to give with 'proc'.
* @return True if the thread was started correctly.
*/
static ThreadObject *New(OTTDThreadFunc proc, void *param);
/**
* Convert the current thread to a new ThreadObject.
* @return A new ThreadObject with the current thread attached to it.
*/
static ThreadObject *AttachCurrent();
/**
* Find the Id of the current running thread.
* @return The thread ID of the current active thread.
*/
static uint CurrentId();
};
/**
* Cross-platform Thread Semaphore. Wait() waits for a Set() of someone else.
*/
class ThreadSemaphore {
public:
static ThreadSemaphore *New();
/**
* Virtual Destructor to avoid compiler warnings.
*/
virtual ~ThreadSemaphore() {};
/**
* Signal all threads that are in Wait() to continue.
*/
virtual void Set() = 0;
/**
* Wait until we are signaled by a call to Set().
*/
virtual void Wait() = 0;
};
#endif /* THREAD_H */
|
