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
100
101
102
|
#pragma once
//simple circular ring buffer
namespace nall {
template<typename T>
struct queue {
queue() = default;
queue(const queue& source) {
operator=(source);
}
queue(queue&& source) {
operator=(move(source));
}
auto operator=(const queue& source) -> queue& {
if(this == &source) return *this;
reset();
_size = source._size;
_data = new T[_size];
for(auto n : range(_size)) _data[n] = source._data[n];
_read = source._read;
_write = source._write;
return *this;
}
auto operator=(queue&& source) -> queue& {
if(this == &source) return *this;
_data = source._data;
_size = source._size;
_read = source._read;
_write = source._write;
source._data = nullptr;
source.reset();
return *this;
}
~queue() {
reset();
}
explicit operator bool() const {
return _size;
}
auto size() const -> uint {
return _size;
}
auto data() -> T* {
return _data;
}
auto data() const -> const T* {
return _data;
}
auto reset() {
delete[] _data;
_data = nullptr;
_size = 0;
_read = 0;
_write = 0;
}
auto resize(uint size, const T& value = {}) -> void {
reset();
_size = size;
_data = new T[_size];
for(auto n : range(_size)) _data[n] = value;
}
auto pending() const -> bool {
return _read != _write;
}
auto read() -> T {
T result = _data[_read];
if(++_read >= _size) _read = 0;
return result;
}
auto last() const -> T {
return _data[_write];
}
auto write(const T& value) -> void {
_data[_write] = value;
if(++_write >= _size) _write = 0;
}
private:
T* _data = nullptr;
uint _size = 0;
uint _read = 0;
uint _write = 0;
};
}
|
