forked from MarcoBuster/Magisk
155 lines
2.8 KiB
C++
155 lines
2.8 KiB
C++
#pragma once
|
|
|
|
#include <stdlib.h>
|
|
|
|
template <class T>
|
|
class Array {
|
|
public:
|
|
Array() : _data(0), _size(0), _capacity(0) {}
|
|
~Array() { delete []_data; }
|
|
|
|
class iterator {
|
|
friend class Array;
|
|
|
|
public:
|
|
iterator(T* n= 0): _node(n) {}
|
|
iterator(const iterator& i): _node(i._node) {}
|
|
~iterator() {} // Should NOT delete _node
|
|
|
|
const T& operator * () const { return (*_node); }
|
|
T& operator * () { return (*_node); }
|
|
iterator& operator ++ () {
|
|
++_node;
|
|
return (*this);
|
|
}
|
|
|
|
iterator operator ++ (int) {
|
|
iterator temp = *this;
|
|
++_node;
|
|
return temp;
|
|
}
|
|
|
|
iterator& operator -- () {
|
|
--_node;
|
|
return (*this);
|
|
}
|
|
|
|
iterator operator -- (int) {
|
|
iterator temp = *this;
|
|
--_node;
|
|
return temp;
|
|
}
|
|
|
|
iterator operator + (int i) const {
|
|
iterator temp = *this;
|
|
temp += i;
|
|
return temp;
|
|
}
|
|
|
|
iterator& operator += (int i) {
|
|
_node += i;
|
|
return (*this);
|
|
}
|
|
|
|
iterator& operator = (const iterator& i) {
|
|
_node = i._node;
|
|
return (*this);
|
|
}
|
|
|
|
bool operator != (const iterator& i) const {
|
|
return _node != i._node;
|
|
}
|
|
|
|
bool operator == (const iterator& i) const { return !(*this != i); }
|
|
|
|
private:
|
|
T* _node;
|
|
};
|
|
|
|
iterator begin() const { return iterator(_data); }
|
|
|
|
iterator end() const { return iterator(_data + _size); }
|
|
|
|
bool empty() const { return !_size; }
|
|
|
|
size_t size() const { return _size; }
|
|
|
|
T& operator [] (size_t i) { return _data[i]; }
|
|
|
|
const T& operator [] (size_t i) const { return _data[i]; }
|
|
|
|
const T& back() const { return _data[_size - 1]; }
|
|
|
|
void push_back(const T& x) {
|
|
if(_size == _capacity)
|
|
expand();
|
|
_data[_size] = x;
|
|
++_size;
|
|
}
|
|
|
|
void push_back(T&& x) {
|
|
if(_size == _capacity)
|
|
expand();
|
|
_data[_size] = (T&&) x;
|
|
++_size;
|
|
}
|
|
|
|
void pop_front() { erase(begin()); }
|
|
|
|
void pop_back() { if(_size) --_size; }
|
|
|
|
bool erase(iterator pos) {
|
|
T* d = pos._node;
|
|
if (_size == 0 || d < _data || d >= _data + _size)
|
|
return false;
|
|
for (; d < _data + _size - 1; ++d)
|
|
*d = (T&&) *(d + 1);
|
|
--_size;
|
|
return true;
|
|
|
|
}
|
|
|
|
bool erase(const T& x) {
|
|
for (T* i = _data; i < _data + _size; ++i) {
|
|
if(*i == x) {
|
|
erase(iterator(i));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void clear() { _size = 0; }
|
|
|
|
void sort() const {
|
|
qsort(_data, _size, sizeof(T), compare);
|
|
}
|
|
|
|
// void reserve(size_t n) { ... }
|
|
// void resize(size_t n) { ... }
|
|
|
|
private:
|
|
T* _data;
|
|
size_t _size; // number of valid elements
|
|
size_t _capacity; // max number of elements
|
|
static int(*_cmp)(T&, T&);
|
|
|
|
static int compare(const void *a, const void *b) {
|
|
return _cmp ? _cmp(*((T*) a), *((T*) b)) : 0;
|
|
}
|
|
|
|
void expand() {
|
|
if (_capacity == 0)
|
|
_capacity = 1;
|
|
else
|
|
_capacity *= 2;
|
|
T* temp = _data;
|
|
_data = new T[_capacity];
|
|
for(int i = 0; i < _size; ++i) _data[i] = (T&&) temp[i];
|
|
delete [] temp;
|
|
}
|
|
};
|
|
|
|
template<class T>
|
|
int(* Array<T>::_cmp)(T&, T&) = nullptr;
|