// vector - template osztály

#ifndef VECTORH_H
#define VECTORH_H
 
#include <iostream>
#include <ostream>
#include "String3.h"

using namespace std;
using namespace HomeMadeString;

template <class T>
class vector 
{

protected: 

	unsigned int elementNum;
	unsigned int curPos;
	T *pData;
	friend std::ostream& operator<<(std::ostream&,const vector&);


public:
	vector() {curPos=elementNum=0;pData=NULL;
	};

	vector(const vector &v){
	curPos=elementNum=0;pData=NULL;	
	*this = v;
	};

	~vector() {delete[]pData;}

const vector& operator =(const vector &v){
	if (pData!=NULL) delete []pData;
	pData = new T[elementNum=v.size()];
	for(int i=0;i<size();i++)
		pData[i] = v.pData[i];
	return *this;
	};

	const T & operator [](unsigned int pos)const{
	if (pos<size())
	return at(pos);
	else exit; //assert
	};
	
	T & operator [](unsigned int pos){ // Két operator[]. Az at() tagfüggvény operator formában is.
	if (pos<size())
	return at(pos);
	else exit; //assert
	};

vector operator +(const vector &v) const{
	vector c;
	unsigned int k,m; 
	k = (v.elementNum>elementNum) ? v.elementNum : elementNum;   // a nagyobb
	m = (v.elementNum>elementNum) ? elementNum   : v.elementNum; // a kisebb
	(c).pData = new T[(c).elementNum=k]; // helyfoglalas a nagyobbnak
	for(int i=0;i<m;i++)
		(c).pData[i] = pData[i]+v.pData[i];
	for(int i=m;i<k;i++)
		(v.elementNum>elementNum) ? c.pData[i]=v.pData[i] : c.pData[i]=pData[i];
	return c;
	};

 vector operator &&(const vector<T> &v) const{ //összefésül két tömböt
	vector<T>	 c;
	int k,n;
	k=n=0;
	c.pData = new T[c.elementNum=v.elementNum+elementNum];
	
	for (int i=0;i<c.elementNum;i++){ 
		if (!( (v.elementNum<=k)||(elementNum<=n) )){
			if (pData[n]<=v.pData[k]) {c.pData[i]=pData[n];n++;}
			else {c.pData[i]=v.pData[k];k++;};
		}
		else {
		if (v.elementNum<=k) {c.pData[i]=pData[n];n++;}
		else  {c.pData[i]=v.pData[k];k++;};
		};

	};
  return c;
 };

 vector mergesort(){
	 vector a,b;
	 int fele=elementNum/2;
	 a.pData=new T[a.elementNum=fele];              //a vektor egyik fele
	 for (int i=0;i<fele;i++) a.pData[i]=pData[i];
	 b.pData=new T[b.elementNum=elementNum-fele];   //a vektor másik fele
	 for (int i=fele;i<elementNum;i++) b.pData[i-fele]=pData[i];
	 
	 if (elementNum>1) {return (a.mergesort())&&(b.mergesort());} // ha elég hosszúak összefésüljük őket
	 else {if (a.elementNum>0) return a;
	      if (b.elementNum>0) return b;
		  }; 
 };


	int  size()const{return elementNum;} // Visszatér a tömb méretével

	int  getCpos()const{return curPos;} // Visszatér a tömb méretével
	int  incCpos() {curPos++;if (curPos > elementNum) curPos=elementNum; return 0;}

	void clear(){ // Törli a tömböt
		while(0<elementNum) erase(0);
	};

	bool erase(unsigned int pos){ // Törli a megadott indexu elemet	
		if ((pos>=0)&&(pos<elementNum)){ // érvényesség ellenőrzés
		T* ptr;
		elementNum--;
		ptr = new T[elementNum];
		for (int i=0;i<pos;i++) ptr[i]=pData[i]; // kihagyjuk a megadott elemet
		for (int i=pos;i<elementNum;i++) ptr[i]=pData[i+1];
		delete []pData;
		pData=ptr;
		return true;}
		else return false;
	};
	
	T& at(unsigned int pos){ // Visszatér a megadott indexu elemmel, amely módosítható is egyben.
	if ((pos>0)&&(pos<elementNum)) return pData[pos]; //érvényesség ellenőrzés
	return pData[0];
	};

	const T& at(unsigned int pos)const{ // Visszatér a megadott indexu elemmel, amely csak olvasható.
	if ((pos>0)&&(pos<elementNum)) return pData[pos]; //érvényesség ellenőrzés
    return pData[0];
	};
	
	bool insert(unsigned int pos, T element){  // Beszúr egy elemet a megadott indexu helyre. 
		T *ptr;
	    if (pos<=elementNum){
		ptr = new T[elementNum+1];
		for (int i=0;i<pos;i++) ptr[i] = pData[i]; // másolás		       (0..pos-1)
		ptr[pos]=element;                          // beszúrjuk az elemet  (pos)
		for (int i=pos;i<elementNum;i++) ptr[i+1]=pData[i]; //másolás	   (pos+1..elementNum)
		
		delete []pData;
		pData=ptr;
		elementNum++;
		return false;}
		return true;
        /*
		else {								  // nullabeszúrásos buli
		ptr = new T[pos+1];                 // pos+1 helyet foglalunk
		int i;

		const T zero;
		for (i=0;i<pos;i++){
		if (i<elementNum) ptr[i]=pData[i];    // másolás			  (0..elementNum)
		else ptr[i]=zero;		                  // feltöltés 0-val	  (elementNum..pos-1)
		};

        ptr[pos]=element;					  // beszúrás             (pos) 
		
		delete []pData;
		pData=ptr;
		elementNum=pos+1;
		return false;};
		*/
	};

	bool insert_array(unsigned int NumberOfInserts,const vector<T> &v){  // Beszúr több elemet a következő helyre. 
		T *ptr;
		ptr = new T[elementNum+NumberOfInserts];
		for (int i=0;i<elementNum;i++) ptr[i] = pData[i];                               // másolás (0..pos-1)
		for (int i=elementNum;i<elementNum+NumberOfInserts;i++) ptr[i]=v[i-elementNum]; // beszúrjuk az elemet  (pos)
		delete []pData;
		pData=ptr;
		elementNum+=NumberOfInserts;
		return false;
	}

    bool insert_vect_fst(unsigned int NumberOfInserts,unsigned int SizeOfVector,unsigned int element){  // Beszúr több elemet a következő helyre. 
		T *ptr;
		vector<int> v; 

		for (int i=0;i<SizeOfVector;i++){v.insert(i,element);};

		ptr = new T[elementNum+NumberOfInserts];
		for (int i=0;i<elementNum;i++) ptr[i] = pData[i];                 // másolás (0..pos-1)
		for (int i=elementNum;i<elementNum+NumberOfInserts;i++) ptr[i]=v; // beszúrjuk az elemet  (pos)
		delete []pData;
		pData=ptr;
		elementNum+=NumberOfInserts;
		return false;
	}
};  // osztály vége

// kiírás által támogatott típusok: char, int, unsigned char, unsigned int, double

std::ostream & operator << (std::ostream& os,const vector<int>& v)
{
	for (int i=0;i<v.size();i++) os<<v[i]<<" ";
	return os;
	};
std::ostream & operator << (std::ostream& os,const vector<double>& v)
{
	for (int i=0;i<v.size();i++) os<<v[i]<<" ";
	return os;
	};
std::ostream & operator << (std::ostream& os,const vector<unsigned int>& v)
{
	for (int i=0;i<v.size();i++) os<<v[i]<<" ";
	return os;
	};
std::ostream & operator << (std::ostream& os,const vector<char>& v)
{
	for (int i=0;i<v.size();i++) os<<v[i]<<" ";
	return os;
	};
std::ostream & operator << (std::ostream& os,const vector<unsigned char>& v)
{
	for (int i=0;i<v.size();i++) os<<v[i]<<" ";
	return os;
	};

#endif //*VECTOR_H