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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
#pragma once
namespace nall {
//nall::vector acts internally as a deque (double-ended queue)
//it does this because it's essentially free to do so, only costing an extra integer in sizeof(vector)
template<typename T> auto vector<T>::reset() -> void {
if(!_pool) return;
for(u64 n : range(_size)) _pool[n].~T();
memory::free(_pool - _left);
_pool = nullptr;
_size = 0;
_left = 0;
_right = 0;
}
//acquire ownership of allocated memory
template<typename T> auto vector<T>::acquire(T* data, u64 size, u64 capacity) -> void {
reset();
_pool = data;
_size = size;
_left = 0;
_right = capacity ? capacity : size;
}
//release ownership of allocated memory
template<typename T> auto vector<T>::release() -> T* {
auto pool = _pool;
_pool = nullptr;
_size = 0;
_left = 0;
_right = 0;
return pool;
}
//reserve allocates memory for objects, but does not initialize them
//when the vector desired size is known, this can be used to avoid growing the capacity dynamically
//reserve will not actually shrink the capacity, only expand it
//shrinking the capacity would destroy objects, and break amortized growth with reallocate and resize
template<typename T> auto vector<T>::reserveLeft(u64 capacity) -> bool {
if(_size + _left >= capacity) return false;
u64 left = bit::round(capacity);
auto pool = memory::allocate<T>(left + _right) + (left - _size);
for(u64 n : range(_size)) new(pool + n) T(move(_pool[n]));
memory::free(_pool - _left);
_pool = pool;
_left = left - _size;
return true;
}
template<typename T> auto vector<T>::reserveRight(u64 capacity) -> bool {
if(_size + _right >= capacity) return false;
u64 right = bit::round(capacity);
auto pool = memory::allocate<T>(_left + right) + _left;
for(u64 n : range(_size)) new(pool + n) T(move(_pool[n]));
memory::free(_pool - _left);
_pool = pool;
_right = right - _size;
return true;
}
//reallocation is meant for POD types, to avoid the overhead of initialization
//do not use with non-POD types, or they will not be properly constructed or destructed
template<typename T> auto vector<T>::reallocateLeft(u64 size) -> bool {
if(size < _size) { //shrink
_pool += _size - size;
_left += _size - size;
_size = size;
return true;
}
if(size > _size) { //grow
reserveLeft(size);
_pool -= size - _size;
_left -= size - _size;
_size = size;
return true;
}
return false;
}
template<typename T> auto vector<T>::reallocateRight(u64 size) -> bool {
if(size < _size) { //shrink
_right += _size - size;
_size = size;
return true;
}
if(size > _size) { //grow
reserveRight(size);
_right -= size - _size;
_size = size;
return true;
}
return false;
}
//resize is meant for non-POD types, and will properly construct objects
template<typename T> auto vector<T>::resizeLeft(u64 size, const T& value) -> bool {
if(size < _size) { //shrink
for(u64 n : range(_size - size)) _pool[n].~T();
_pool += _size - size;
_left += _size - size;
_size = size;
return true;
}
if(size > _size) { //grow
reserveLeft(size);
_pool -= size - _size;
for(u64 n : nall::reverse(range(size - _size))) new(_pool + n) T(value);
_left -= size - _size;
_size = size;
return true;
}
return false;
}
template<typename T> auto vector<T>::resizeRight(u64 size, const T& value) -> bool {
if(size < _size) { //shrink
for(u64 n : range(size, _size)) _pool[n].~T();
_right += _size - size;
_size = size;
return true;
}
if(size > _size) { //grow
reserveRight(size);
for(u64 n : range(_size, size)) new(_pool + n) T(value);
_right -= size - _size;
_size = size;
return true;
}
return false;
}
}
|
