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
|
/*
* Licensed under BSD license. See LICENCE.TXT
*
* Produced by: Jeff Lait
*
* 7DRL Development
*
* NAME: queue.h ( Letter Hunt Library, C++ )
*
* COMMENTS:
* Implements a simple queue.
* Is threadsafe. Has the ability to block until an item
* is available.
*/
#ifndef __queue_h__
#define __queue_h__
#include "ptrlist.h"
#include "thread.h"
template <typename PTR>
class QUEUE
{
public:
QUEUE() { myMaxSize = 0; }
explicit QUEUE(int maxsize) { myMaxSize = maxsize; }
~QUEUE() {}
// Because we are multithreaded, this is not meant to remain valid
// outside of a lock.
bool isEmpty() const
{
return myList.entries() == 0;
}
// Non-blocking empty of the queue, no freeing of the results.
// May not be empty afterward due to multithreading!
void flush()
{
PTR item;
while (remove(item));
}
// Removes item, returns false if failed because queue is empty.
bool remove(PTR &item)
{
AUTOLOCK l(myLock);
if (isEmpty())
return false;
item = myList.removeFirst();
return true;
}
// Blocks till an element is ready.
PTR waitAndRemove()
{
AUTOLOCK l(myLock);
PTR result;
while (!remove(result))
{
myCond.wait(myLock);
}
return result;
}
bool append(const PTR &item)
{
AUTOLOCK l(myLock);
// Fail to append if we are full.
if (myMaxSize && myList.entries() >= myMaxSize)
return false;
myList.append(item);
myCond.trigger();
return true;
}
private:
// Copying locks scares me.
QUEUE(const QUEUE<PTR> &ref) {}
QUEUE<PTR> &operator=(const QUEUE<PTR> &ref) {}
PTRLIST<PTR> myList;
LOCK myLock;
CONDITION myCond;
int myMaxSize;
};
#endif
|
