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

// this was changed.
ArrayT::ArrayT() {
    data = new int[10];
    capacity = 10;
    size = 0;
}

// this is new
void CopyArray(int src[], int dest[], size_t size) {
    size_t i;

    for(i=0;i<size;i++) {
        dest[i] = src[i];
    }
    return;
}

// new
ArrayT::ArrayT(const ArrayT & src){
    // this is a constructor, so not pointing to data.
    data = new int[src.capacity];
    size = src.size;
    capacity = src.capacity;
    
    CopyArray(src.data, data, size);
}

// new
ArrayT::~ArrayT(){
    delete [] data;
    return;
}

// new
ArrayT & ArrayT::operator =(const ArrayT & src){
    // it is currently pointing to valid data, do delte it.
    delete [] data;

    // allocate new memory
    data = new int[src.capacity];

    // set up the other values.
    size = src.size;
    capacity = src.capacity;

    // copy the data over
    CopyArray(src.data, data, size);

    // return a reference to ourself
    return * this;
}

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

// changed
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){
    bool good = true;
    int * tmp;

    // this was changed
    // no space, so make some.
    if (size == capacity) {
        capacity *=2;

        tmp = new int[capacity ];

        CopyArray(data, tmp, size);

        delete [] data;
        data = tmp;
    } 

    // and add the element.
    data[size] = value;
    size++;

    return good;
}

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

    return;
}