/* WARNING:  This is more of a CS311 example
 * I'm just telling you ahead of time
 */

/* Topics with objects
 * 	Constructors and Destructors
 * 	Why public and private
 * 	operator overloading
 * 	static, methods and properties
 * Along the way, more on heap memory
 */

/* Methods we'll need:
 * 	push_back
 * 	at or []
 * 	delete
 * 	size
 */
#include<iostream>
using namespace std;

// Just stores integers for now
template <class T>
class ourvector;

template <class T>
ostream& operator<<(ostream& output_stream, const ourvector<T>& ov);

template <class T>
class ov_iterator {
	size_t pos = 0;
	T* data;
public:
	ov_iterator(T* d, size_t p){
		data = d;
		pos = p;
	}
	ov_iterator operator++(){ // This is prefix ++, like ++i
		pos++;
		return *this;
	}
	bool operator!=(const ov_iterator& other){
		return pos != other.pos;
	}
	T& operator*(){
		return data[pos];
	}
};

template <class T>
class ourvector {
	size_t isize;
	size_t allocated_space; // how many integers we have space for
	T *data;
public:
	ourvector(){ // This is a constructor, note return type is omitted
		data = new T[10];
		isize = 0;
		allocated_space = 10;
	}

	void push_back(T n){
		if(isize == allocated_space){
			allocated_space *= 2;
			T *newdata = new T[allocated_space];
			for(int i = 0; i < isize; i++)
				newdata[i] = data[i];
			delete [] data;
			data = newdata;
		}
		data[isize] = n;
		isize++;
	}
	
	T at(size_t idx){
		if(idx >= isize)
			cout << "idx is too large!\n";
		return data[idx];
	}

	size_t size(){
		return isize;
	}

	T& operator[](size_t idx){
		if(idx >= isize)
			cout << "idx is too large!\n";
		return data[idx];
	}

	void remove_by_index(size_t idx){
		for(size_t i = idx; i < isize - 1; i++)
			data[i] = data[i+1];
		isize--;
	}

	~ourvector(){ // This is a destructor, runs automatically when object goes out of scope
		delete [] data;
	}

	ov_iterator<T> begin(){
		return ov_iterator(data, 0);
	}

	ov_iterator<T> end(){
		return ov_iterator(data, isize);
	}

	friend ostream& operator<< <>(ostream& output_stream, const ourvector<T>& ov);
};

template<class T>
ostream& operator<<(ostream& output_stream, const ourvector<T>& ov){
	output_stream << "[";
	for(size_t i = 0; i < ov.isize; i++)
		output_stream << ov.data[i] << ", ";
	output_stream << "\b\b]";
	return output_stream;
}

void test_ourvector(){
	/* test routine for our data structure */
	ourvector<int> ov;
	ov.push_back(7);
	ov.push_back(2);
	ov.push_back(654);
	ov.push_back(97);
	ov[1] = 60000;
	cout << ov << endl;
	for(int i = 0; i < 100; i++)
		ov.push_back(i);
	ov.remove_by_index(2);
	for(int i = 0; i < ov.size(); i++)
		cout << ov[i] << " ";
	cout << "\n";

	ourvector<float> flvector;
	flvector.push_back(2.43);
	flvector.push_back(3.29);
	for(float &n : flvector)
		n *= 2;
	// This is an iterator-based "for" loop
	for(auto i = flvector.begin(); i != flvector.end(); ++i)
		*i += 100;
	cout << flvector << "\n";


}

int main(){
	test_ourvector();
	return 0;
}