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

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

    return;
}

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

     // copy the size
     size = rhs.size;

     // copy the capacity
     capacity = rhs.capacity;

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

     return;
}

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

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

     // I WILL already be pointing to some memory.
     // copy the size
     size = rhs.size;

     // copy the capacity
     capacity = rhs.capacity;

     // delete the existing data
     delete [] data;

     // copy the data
     //      allocate new memory
     data = new int[capacity];
     //      Copy the data from old to new.
     for(i=0;i<capacity; 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) {
       // the array is full  so .... increase capacity
       //
       // grab a bigger array
       // copy the old data to the new data.
       // change capacity
       // detlete the old array

       capacity *= 2;

       tmp = new int[capacity];

       for(i=0;i<size;i++) {
          tmp[i] = data[i];
       }

       delete [] data;
       data = tmp;

    }
    data[size] = value;
    size++;

    return true;
}

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

    return;
}