EHS
Array.h
Go to the documentation of this file.
1#pragma once
2
3#include "Types.h"
4#include "BaseObj.h"
5
6#include <initializer_list>
7#include <algorithm>
8
9namespace ehs
10{
14 template<typename T, typename N = UInt_64>
15 class Array
16 {
17 protected:
18 T* data;
20
21 public:
24 {
25 delete[] data;
26 }
27
30 : data(nullptr), size(0)
31 {
32 }
33
36 explicit Array(const N size)
37 : data(new T[size]), size(size)
38 {
39 }
40
43 Array(std::initializer_list<T> list)
44 : data(new T[list.size()]), size(list.size())
45 {
46 N i = 0;
47 for (auto v = list.begin(); v != list.end(); ++v)
48 data[i++] = std::move(*v);
49 }
50
54 Array(const T* const data, const N size)
55 : data(new T[size]), size(size)
56 {
57 for (N i = 0; i < size; ++i)
58 this->data[i] = data[i];
59 }
60
61 Array(Array&& array) noexcept
62 : data(array.data), size(array.size)
63 {
64 array.data = nullptr;
65 array.size = 0;
66 }
67
70 Array(const Array& array)
71 : data(new T[array.size]), size(array.size)
72 {
73 for (N i = 0; i < size; ++i)
74 data[i] = array.data[i];
75 }
76
77 Array<T, N>& operator=(Array&& array) noexcept
78 {
79 if (this == &array)
80 return *this;
81
82 delete[] data;
83 data = array.data;
84 size = array.size;
85
86 array.data = nullptr;
87 array.size = 0;
88
89 return *this;
90 }
91
96 {
97 if (this == &array)
98 return *this;
99
100 delete[] data;
101 data = new T[array.size];
102 for (N i = 0; i < array.size; ++i)
103 data[i] = array.data[i];
104
105 size = array.size;
106
107 return *this;
108 }
109
113 Array& operator=(std::initializer_list<T> list)
114 {
115 delete[] data;
116 data = new T[list.size];
117
118 N i = 0;
119 for (auto v = list.begin(); v != list.end(); ++v)
120 data[i++] = std::move(*v);
121
122 size = list.size();
123
124 return *this;
125 }
126
130 {
131 T* result = new T[size + value.size];
132
133 for (N i = 0; i < size; ++i)
134 result[i] = std::move(data[i]);
135
136 for (N i = 0; i < value.size; ++i)
137 result[size + i] = std::move(value[i]);
138
139 delete[] data;
140
141 data = result;
142 size += value.size;
143
144 return *this;
145 }
146
147 bool operator==(const Array& in) const
148 {
149 if (size != in.size)
150 return false;
151
152 return Util::Compare(data, in.data, size);
153 }
154
155 bool operator!=(const Array& in) const
156 {
157 if (size != in.size)
158 return true;
159
160 return !Util::Compare(data, in.data, size);
161 }
162
165 Array& operator+=(std::initializer_list<T> value)
166 {
167 T* result = new T[size + value.size()];
168
169 for (N i = 0; i < size; ++i)
170 result[i] = std::move(data[i]);
171
172 N i = 0;
173 for (auto v = value.begin(); v != value.end(); ++v)
174 result[size + i++] = std::move(*v);
175
176 delete[] data;
177
178 data = result;
179 size += value.size();
180
181 return *this;
182 }
183
186 Array& operator+=(const T value)
187 {
188 T* result = new T[size + 1];
189
190 for (N i = 0; i < size; ++i)
191 result[i] = std::move(data[i]);
192
193 result[size] = std::move(value);
194
195 delete[] data;
196
197 data = result;
198 ++size;
199
200 return *this;
201 }
202
204 operator T* () const
205 {
206 return data;
207 }
208
212 void Swap(N a, N b) const
213 {
214 T tmp = std::move(data[a]);
215
216 data[a] = std::move(data[b]);
217 data[b] = std::move(tmp);
218 }
219
223 void Insert(const N index, const T value)
224 {
225 N newSize = 0;
226 if (index > size - 1)
227 newSize = size + ((index + 1) - size);
228 else
229 newSize = size + 1;
230
231 T* result = new T[newSize];
232
233 for (N i = 0; i < index; ++i)
234 result[i] = std::move(data[i]);
235
236 result[index] = std::move(value);
237
238 for (N i = index; i < size; ++i)
239 result[i + 1] = std::move(data[i]);
240
241 delete[] data;
242 data = result;
243
244 size = newSize;
245 }
246
250 T Remove(const N index)
251 {
252 T popped = {};
253
254 if (!size || index >= size)
255 return popped;
256
257 popped = std::move(data[index]);
258
259 N newSize = size - 1;
260 T* result = new T[newSize];
261
262 for (N i = 0; i < index; ++i)
263 result[i] = std::move(data[i]);
264
265 for (N i = index + 1; i < size; ++i)
266 result[i - 1] = std::move(data[i]);
267
268 delete[] data;
269 data = result;
270 size = newSize;
271
272 return popped;
273 }
274
278 void Push(const T* const value, const N size)
279 {
280 T* result = new T[this->size + size];
281
282 for (N i = 0; i < this->size; ++i)
283 result[i] = std::move(this->data[i]);
284
285 for (N i = 0; i < size; ++i)
286 result[this->size + i] = value[i];
287
288 delete[] data;
289
290 this->data = result;
291 this->size += size;
292 }
293
296 void Push(Array value)
297 {
298 T* result = new T[size + value.size];
299
300 for (N i = 0; i < size; ++i)
301 result[i] = std::move(data[i]);
302
303 for (N i = 0; i < value.size; ++i)
304 result[size + i] = std::move(value[i]);
305
306 delete[] data;
307
308 data = result;
309 size += value.size;
310 }
311
314 void Push(std::initializer_list<T> value)
315 {
316 T* result = new T[size + value.size()];
317
318 for (N i = 0; i < size; ++i)
319 result[i] = std::move(data[i]);
320
321 N i = 0;
322 for (auto v = value.begin(); v != value.end(); ++v)
323 result[size + i++] = std::move(*v);
324
325 delete[] data;
326
327 data = result;
328 size += value.size();
329 }
330
333 void Push(T value)
334 {
335 T* result = new T[size + 1];
336
337 for (N i = 0; i < size; ++i)
338 result[i] = std::move(data[i]);
339
340 result[size] = std::move(value);
341
342 delete[] data;
343
344 data = result;
345 ++size;
346 }
347
350 T Pop()
351 {
352 T* result = new T[--size];
353
354 T popped = (T&&)data[size];
355
356 for (N i = 0; i < size; ++i)
357 result[i] = (T&&)data[i];
358
359 delete[] data;
360
361 data = result;
362
363 return popped;
364 }
365
369 T Pop(const N index)
370 {
371 if (!size)
372 return {};
373
374 N lastIndex = size - 1;
375
376 if (index < lastIndex)
377 Swap(index, lastIndex);
378
379 return Pop();
380 }
381
383 void Clear()
384 {
385 if (!data)
386 return;
387
388 delete[] data;
389 data = nullptr;
390 size = 0;
391 }
392
395 void Resize(const N newSize)
396 {
397 if (size == newSize)
398 return;
399
400 T* result = new T[newSize];
401
402 for (N i = 0; i < newSize && i < size; ++i)
403 result[i] = std::move(data[i]);
404
405 delete[] data;
406
407 data = result;
408 size = newSize;
409 }
410
413 N Size() const
414 {
415 return size;
416 }
417
420 N End() const
421 {
422 return size - 1;
423 }
424 };
425}
Definition: Array.h:16
Array(Array &&array) noexcept
Definition: Array.h:61
Array< T, N > & operator=(const Array &array)
Definition: Array.h:95
T Pop(const N index)
Definition: Array.h:369
Array< T, N > & operator=(Array &&array) noexcept
Definition: Array.h:77
T Pop()
Definition: Array.h:350
Array(const T *const data, const N size)
Definition: Array.h:54
void Push(Array value)
Definition: Array.h:296
Array(const N size)
Definition: Array.h:36
N Size() const
Definition: Array.h:413
void Clear()
Releases the resources of the array.
Definition: Array.h:383
Array()
Default members initialization.
Definition: Array.h:29
Array & operator+=(Array value)
Definition: Array.h:129
Array & operator=(std::initializer_list< T > list)
Definition: Array.h:113
T * data
Definition: Array.h:18
void Resize(const N newSize)
Definition: Array.h:395
Array(const Array &array)
Definition: Array.h:70
~Array()
Frees any data created on the heap.
Definition: Array.h:23
N size
Definition: Array.h:19
bool operator==(const Array &in) const
Definition: Array.h:147
Array & operator+=(const T value)
Definition: Array.h:186
void Insert(const N index, const T value)
Definition: Array.h:223
void Swap(N a, N b) const
Definition: Array.h:212
void Push(T value)
Definition: Array.h:333
bool operator!=(const Array &in) const
Definition: Array.h:155
N End() const
Definition: Array.h:420
T Remove(const N index)
Definition: Array.h:250
void Push(std::initializer_list< T > value)
Definition: Array.h:314
void Push(const T *const value, const N size)
Definition: Array.h:278
Array(std::initializer_list< T > list)
Definition: Array.h:43
Array & operator+=(std::initializer_list< T > value)
Definition: Array.h:165
static bool Compare(const void *a, const void *b, UInt_64 size)
Definition: Util.cpp:9
Definition: Anchor.h:6