#include <iostream>
#include "ArrayT.h"

ArrayT::ArrayT() {
    size = 0;
    capacity = 10;
    data  = new int [capacity];

    return;
}

ArrayT::ArrayT(const ArrayT & rhs){
     size_t i;

     // copy size over
     size = rhs.size;

     // copy capacity
     capacity = rhs.capacity;

     // copy the data.
     // allocate memory.
     // copy the data to the new memory.
     data = new int [capacity];
     for(i=0;i<size;i++) {
        data[i] = rhs.data[i];
     }

     return;
}

ArrayT::~ArrayT(){
    delete [] data;
    data = nullptr;
    return;
}

ArrayT & ArrayT::operator =(const ArrayT & rhs){
     size_t i;

     size = rhs.size;
     capacity = rhs.capacity;

     delete [] data;

     data = new int [capacity];
     for(i=0;i<size;i++) {
        data[i] = rhs.data[i];
     }

     return * this;
}

size_t ArrayT::Size(void) const {
    return size;
}

size_t ArrayT::Capacity(void) const {
    return capacity;
}

int ArrayT::At(size_t pos) const {
     int rv = 0;
     if (pos < size) {
         rv = data[pos];
     }
     return rv;
}

bool ArrayT::Set(size_t pos, int value) {
     bool good = false;

     if (pos <size) {
        good = true;
        data[pos] = value;
     }

     return good;
}

bool ArrayT::Append(int value){
    int * tmp;
    size_t i;

    if (size == capacity) {
        capacity *= 2;

        // allocate new memory of size capacity
        tmp = new int[capacity];

        // copy the data to the new array
        for(i=0; i < size; i++) {
           tmp[i] = data[i];
        }

        // delete the old memory
        delete[] data;
        data = tmp;
    }

    data[size] = value;
    size++;

    return true;
}

void ArrayT::Delete(void) {
    if (size > 0) {
       size--;
    }

    return;
}