/*******************************************************
this is the impementation file for DynamicArray class
Author: Lalka Rieger
Date: November 18, 2014
Known Bugs: None
*******************************************************/

#include <iostream>
#include <stdlib.h>
#include "DynamicArray.h"

using namespace std;

//default constructor with no parameters
DynamicArray::DynamicArray()
{
	capacity = 20;
	array = new int[capacity];
	length = 0;
}

//constructor with 2 arguments
DynamicArray::DynamicArray (int values[], int values_len)
{
	array = new int[values_len+5];
	capacity = values_len+5;
	length = values_len;
	for(int i = 0; i < length; i++)
		array[i]=values[i];
} 

//copy constructor
DynamicArray::DynamicArray(const DynamicArray& source)
{
	length = source.length;
	capacity = source.capacity;
	array = new int[capacity];
	for(int i = 0; i < length; i++)
		array[i] = source.array[i];
}

//destructor
DynamicArray::~DynamicArray()
{
	delete [] array;
}


//overloaded assignment operator
DynamicArray& DynamicArray::operator =(const DynamicArray& right)
{
	length = right.length;
	if(length > capacity)
	{
		delete [] array;
		array = new int[length +10];
		capacity = length+10;
	}
	for(int i = 0; i <right.length; i++)
		array[i]=right.array[i];
	return *this;
}

//overloaded indexing operator []
int& DynamicArray::operator[](int index) const
{
	if(index>=length || index < 0)
	{
		cout<<"Error: out of bounds. 0th element returned.";
		return array[0];
	}

	return array[index];
}

//overloaded input operator >>
istream& operator>>(istream& ins, DynamicArray& dyn)
{
	int input = 0;//stores intput
	dyn.length = 0;//reset length
	dyn.capacity = 20;//reset capacity
	delete [] dyn.array;//clear memory. We should shrink the array in case 
                       // the array to be overwritten is much larger than we need for the new array
	dyn.array = new int[dyn.capacity];
	ins>>input;
	for(int i = 0; input != -1; i++)//appending will stop if the input is -1
	{
		dyn.append(input);//append each input to the new empty array
		ins>>input;
	}
	return ins;
}

//overloaded + operator (appends two arrays together)
DynamicArray operator +(const DynamicArray& a1, const DynamicArray& a2)
{
	DynamicArray temp;
	temp.length = a1.length+a2.length;//new length
	temp.capacity = a1.capacity+a2.capacity;//new capacity

	delete [] temp.array;

	temp.array = new int[temp.capacity];//temp points to a new array of temp.capacity size
	for(int i = 0; i <a1.length; i++)//put a1's elements in temp's array
		temp.array[i] = a1.array[i];
	for(int i = 0; i < a2.length; i++)//put a2's elements in temp's array after a1's elements
		temp.array[i+a1.length] = a2.array[i];
	return temp;
}


//output function
ostream & operator<< (ostream & outs, const DynamicArray & a)
{
	int i = 0;
	outs<<"{";
	for(i = 0; i < a.length-1; i++)
	{
		outs<<a.array[i]<<", ";
	}
	if(a.length > 0)
		outs<<a.array[i];
	outs<<"}";
	return outs;
}

//append function
void DynamicArray::append(int apendee)
{
	if(length == capacity)// expand array if at capacity; cap += 10
	{
		//EZ: we can save this first round of copy 
		//EZ: If we create a new array, copy array to it, ... 
		int * temp = new int[capacity];
		for(int i = 0; i < length; i++)//copy array elements to temp
		{
			temp[i] = array[i];
		}

		delete[] array;//empty array
		array = new int[capacity+10];//increase array's capacity
		capacity += 10;
		for(int i = 0; i < length; i++)//copy temp's elements back to array
		{
			array[i] = temp[i];
		}
	}
	array[length] = apendee;
	length++;
}	

//length retreiveal function
int DynamicArray::get_length() const
{
	return length;
}

//capacity retreival function
int DynamicArray::get_capacity() const
{
	return capacity;
}