2 #ifdef USE_INITIALIZER_LIST
3 #include "InitializerList.h"
67 return iterator(ptr + offset, offset);
69 bool operator==(
iterator it) {
return ptr == it.getPtr(); }
70 bool operator<(
iterator it) {
return ptr < it.getPtr(); }
71 bool operator<=(
iterator it) {
return ptr <= it.getPtr(); }
72 bool operator>(
iterator it) {
return ptr > it.getPtr(); }
73 bool operator>=(
iterator it) {
return ptr >= it.getPtr(); }
74 bool operator!=(
iterator it) {
return ptr != it.getPtr(); }
75 T &operator*() {
return *ptr; }
76 T *operator->() {
return ptr; }
77 T *getPtr() {
return ptr; }
78 size_t pos() {
return pos_; }
79 size_t operator-(
iterator it) {
return (ptr - it.getPtr()); }
82 #ifdef USE_INITIALIZER_LIST
85 Vector(std::initializer_list<T> iniList) {
86 resize(iniList.size());
88 for (
auto &obj : iniList) {
97 setAllocator(allocator);
104 setAllocator(allocator);
109 setAllocator(allocator);
111 for (
int j = 0; j < size; j++) {
131 this->p_allocator = copyFrom.p_allocator;
132 resize_internal(copyFrom.size(),
false);
133 for (
int j = 0; j < copyFrom.size(); j++) {
134 p_data[j] = copyFrom[j];
136 this->len = copyFrom.size();
141 resize_internal(copyFrom.size(),
false);
142 for (
int j = 0; j < copyFrom.size(); j++) {
143 p_data[j] = copyFrom[j];
145 this->len = copyFrom.size();
151 this->p_allocator = &allocator;
152 this->len = to - from;
153 resize_internal(this->len,
false);
154 for (
size_t j = 0; j < this->len; j++) {
162 void setAllocator(
Allocator &allocator) {
163 p_allocator = &allocator;
166 void clear() { len = 0; }
168 int size() {
return len; }
170 bool empty() {
return size() == 0; }
172 void push_back(T &&value) {
173 resize_internal(len + 1,
true);
178 void push_back(T &value) {
179 resize_internal(len + 1,
true);
184 void push_front(T &value) {
185 resize_internal(len + 1,
true);
187 for (
int j = len; j >= 0; j--) {
188 p_data[j + 1] = p_data[j];
194 void push_front(T &&value) {
195 resize_internal(len + 1,
true);
197 for (
int j = len; j >= 0; j--) {
198 p_data[j + 1] = p_data[j];
210 void pop_front() { erase(0); }
212 void assign(iterator v1, iterator v2) {
213 size_t newLen = v2 - v1;
214 resize_internal(newLen,
false);
217 for (
auto ptr = v1; ptr != v2; ptr++) {
218 p_data[pos++] = *ptr;
222 void assign(
size_t number, T value) {
223 resize_internal(number,
false);
225 for (
int j = 0; j < number; j++) {
230 void swap(Vector<T> &in) {
233 int bufferLenCpy = bufferLen;
238 bufferLen = in.bufferLen;
242 in.bufferLen = bufferLenCpy;
245 T &operator[](
int index) {
246 assert(p_data !=
nullptr);
247 return p_data[index];
250 T &operator[](
const int index)
const {
return p_data[index]; }
252 bool resize(
int newSize, T value) {
253 if (resize(newSize)) {
254 for (
int j = 0; j < newSize; j++) {
262 void shrink_to_fit() { resize_internal(this->len,
true,
true); }
264 int capacity() {
return this->bufferLen; }
266 bool resize(
int newSize) {
267 int oldSize = this->len;
268 resize_internal(newSize,
true);
270 return this->len != oldSize;
273 iterator begin() {
return iterator(p_data, 0); }
275 T &back() {
return *iterator(p_data + (len - 1), len - 1); }
277 iterator end() {
return iterator(p_data + len, len); }
280 void erase(iterator it) {
return erase(it.pos()); }
283 void erase(
int pos) {
285 int lenToEnd = len - pos - 1;
289 memmove((
void *)&p_data[pos], (
void *)(&p_data[pos + 1]),
290 lenToEnd *
sizeof(T));
293 p_data[len - 1] = T();
298 T *data() {
return p_data; }
300 operator bool()
const {
return p_data !=
nullptr; }
303 for (
int j = 0; j < size(); j++) {
304 if (p_data[j] == obj)
return j;
309 bool contains(T obj){
310 return indexOf(obj) >= 0;
314 void swap(T &other) {
316 int temp_blen = bufferLen;
318 T *temp_data = p_data;
320 bufferLen = other.bufferLen;
322 p_data = other.p_data;
324 other.bufferLen = temp_blen;
325 other.len = temp_len;
326 other.p_data = temp_data;
332 deleteArray(p_data, size());
340 Allocator *p_allocator = &DefaultAllocator;
342 void resize_internal(
int newSize,
bool copy,
bool shrink =
false) {
343 if (newSize <= 0)
return;
344 if (newSize > bufferLen || this->p_data ==
nullptr || shrink) {
346 int oldBufferLen = this->bufferLen;
347 p_data = newArray(newSize);
348 assert(p_data !=
nullptr);
349 this->bufferLen = newSize;
350 if (oldData !=
nullptr) {
351 if (copy && this->len > 0) {
353 memmove((
void*)p_data, (
void*)oldData, len *
sizeof(T));
355 memset((
void*)oldData, 0, len *
sizeof(T));
358 cleanup(oldData, newSize, oldBufferLen);
360 deleteArray(oldData, oldBufferLen);
365 T *newArray(
int newSize) {
368 data = p_allocator->createArray<T>(newSize);
370 data =
new T[newSize];
375 void deleteArray(T *oldData,
int oldBufferLen) {
377 p_allocator->removeArray(oldData, oldBufferLen);
384 void cleanup(T *data,
int from,
int to) {
385 for (
int j = from; j < to; j++) {