template<typename T>
class Array {
T* data;
int size;

public:
Array () {
this->data = new T[0];
this->size = 0;
}

Array (T* data, int size) {
this->data = data;
this->size = size;
}

Array (Array<T> data) {
this->data = data.data;
this->size = data.size;
}

T add (T value) {
return this->add(new T[] { value }, 1);
}

T add (T value, int index) {
return this->add(new T[] { value }, 1, index);
}

T add (Array<T> value) {
return this->add(value.data, value.size);
}

T add (Array<T> value, int index) {
return this->add(value.data, value.size, index);
}

T add (T* value, int len) {
this->expand(len);
this->set(value, this->size, len);
this->size += len;
return value;
}

T add (T* value, int len, int index) {
this->expand(len);
int size = this->size - index;
Array<T> after = this->get(index, size);
this->set(after.data, index + len, size);
this->set(value, index, len);
this->size++;
return value;
}

Array<T> operator + (T value) {
this->clone().add(value);
return *this;
}

Array<T> operator + (Array<T> value) {
this->clone().add(value);
return *this;
}

Array<T> operator += (T value) {
this->add(value);
return *this;
}

Array<T> operator += (Array<T> value) {
this->add(value);
return *this;
}

T remove (int index) {
if (index < 0) return NULL;
if (index >= this->size) return NULL;
T value = this->data[index];
if (index != this->size - 1) {
int size = this->size - index;
T* after = this->get(index, size);
this->set(after, index - 1, size);
}
this->data[this->size - 1] = NULL;
this->size--;
return value;
}

T remove (T value) {
return this->remove(this->indexOf(value));
}

Array<T> remove (Array<T> value) {
return this->remove(value.data, value.size);
}

Array<T> remove (T* value, int len) {
Array<T> array = Array<T>();
for (int i = 0; i < len; i++) {
if (this->remove(value[i]) != NULL)
array.add(value[i]);
}
return array;
}

Array<T> operator - (int index) {
this->clone().remove(index);
return *this;
}

Array<T> operator - (T value) {
this->clone().remove(value);
return *this;
}

Array<T> operator - (Array<T> value) {
this->clone().remove(value);
return *this;
}

Array<T> operator -= (int index) {
this->remove(index);
return *this;
}

Array<T> operator -= (T value) {
this->remove(value);
return *this;
}

Array<T> operator -= (Array<T> value) {
this->remove(value);
return *this;
}

Array<T> retain (Array<T> value) {
return this->retain(value.data, value.size);
}

Array<T> retain (T* value, int len) {
Array<T> array = Array<T>();
for (int i = 0; i < len; i++) {
if (this->indexOf(value[i]) != -1)
array.add(value[i]);
}
this->data = array.data;
this->size = array.size;
return array;
}

Array<T> operator * (Array<T> value) {
this->clone().retain(value);
return *this;
}

Array<T> operator *= (Array<T> value) {
this->retain(value);
return *this;
}

int compare (Array<T> value) {
if (this->size != value.size) return this->size - value.size;
for (int i = 0; i < this->size; i++)
if (this->data[i] != value.data[i])
return i;
return 0;
}

bool operator == (Array<T> value) {
return this->compare(value) == 0;
}

bool operator != (Array<T> value) {
return this->compare(value) != 0;
}

T* operator & () {
return this->data;
}

Array<T> operator << (T value) {
this->add(value);
return *this;
}

Array<T> operator << (Array<T> value) {
this->add(value);
return *this;
}

T operator >> (T* value) {
value = this->get(0);
return *value;
}

Array<T> operator >> (Array<T>* value) {
value = this->clone();
return *value;
}

T operator [] (int target) {
return this->get(target);
}

int operator [] (T target) {
return this->indexOf(target);
}

int indexOf (T target) {
for (int i = 0; i < this->size; i++)
if (this->data[i] == target)
return i;
return -1;
}

bool contains (T target) {
return this->indexOf(target) != -1;
}

bool containsAll (Array<T> target) {
if (target.size > this->size) return false;
for (int i = 0; i < target.size; i++)
if (!this->contains(target[i]))
return false;
return true;
}

bool containsAny (Array<T> target) {
for (int i = 0; i < target.size; i++)
if (this->contains(target[i]))
return true;
return false;
}

Array<T> clone () {
T nt[this->size];
for (int i = 0; i < this->size; i++)
nt[i] = this->data[i];
return Array<T>(nt, this->size);
}

T get (int index) {
if (index < 0) return NULL;
if (index >= this->size) return NULL;
return this->data[index];
}

bool isEmpty () {
return this->size == 0;
}

Array<T> reverse () {
T nt[this->size];
for (int i = 0; i < this->size; i++)
nt[this->size - 1 - i] = this->data[i];
this->data = nt;
return this;
}

T replace (T value, int index) {
T old = this.get(index);
if (old) this->data[index] = value;
return old;
}

int getSize () {
return this->size;
}

Array<T> get (int index, int length) {
return new Array<T>(this->data[index], length);
}

private:
void set (T* value, int index, int length) {
for (int i = 0; i < length; i++)
this->data[index + i] = value[i];
}
}