#ifndef WEK_H
#define WEK_H

#include<vector>
#include "class.h"

template<typename T,unsigned int rozmiar> class Wektor{
	private:
		vector<T> wek;
	public:
		Wektor();
		void back_push(T a);
		void erase(unsigned int ktora);
		void print();
		T back_pop();
		T& operator[](unsigned int pozycja);
		void sprZakres();
		void sprTyp();
		class WyZakres{public:WyZakres(){}};
		class WyTyp{public:WyTyp(){}};

};

template<typename T,unsigned int rozmiar> class Wektor<T*, rozmiar>{
	private:
		vector<T> wek;
		Wektor(){};
	public:
		void back_push(T a);
		void erase(unsigned int ktora);
		void print();
		T back_pop();
		T& operator[](unsigned int pozycja);
};

template<unsigned int rozmiar> class Wektor<int, rozmiar>{
	private:
		vector<int> wek;
public:
		Wektor();
		void back_push(int a);
		void erase(unsigned int ktora);
		void print();
		void sort(int poczatek,int koniec);
		int wielkosc();
		void back_pop();
		int& operator[](unsigned int pozycja);
		void sprZakres();
		void sprTyp();
		class WyZakres{public:WyZakres(){}};
		class WyTyp{public:WyTyp(){}};
};

template<unsigned int rozmiar> class Wektor<double, rozmiar>{
	private:
		vector<double> wek;
public:
		Wektor();
		void back_push(double a);
		void erase(unsigned int ktora);
		void print();
		void sort(int poczatek, int koniec);
		int wielkosc();
		void back_pop();
		double& operator[](unsigned int pozycja);
		void sprZakres();
		void sprTyp();
		class WyZakres{public:WyZakres(){}};
		class WyTyp{public:WyTyp(){}};

};

template<unsigned int rozmiar> class Wektor<LiczbaMax, rozmiar>{
	private:
		vector<LiczbaMax> wek;
	public:
		Wektor();
		void back_push(LiczbaMax a);
		void erase(unsigned int ktora);
		void print();
		void sort();
		void back_pop();
		LiczbaMax& operator[](unsigned int pozycja);
		void sprZakres();
		void sprTyp();
		class WyZakres{public:WyZakres(){}};
		class WyTyp{public:WyTyp(){}};

};

//===================Metody szabkonow-Klasa podstawowa wzorca============================
template<typename T,unsigned int rozmiar> Wektor<T,rozmiar>::Wektor(){
	//sprTyp();
};

template<typename T,unsigned int rozmiar> void Wektor<T,rozmiar>::back_push(T a){
	sprTyp();
};

template<typename T,unsigned int rozmiar> void Wektor<T,rozmiar>::erase(unsigned int ktora){
	sprTyp();
};

template<typename T,unsigned int rozmiar> void Wektor<T,rozmiar>::print(){
	sprTyp();	
};


template<typename T,unsigned int rozmiar> T Wektor<T,rozmiar>::back_pop(){
	sprTyp();
	return wek[wek.size()-1];
};

template<typename T,unsigned int rozmiar> T& Wektor<T,rozmiar>::operator[](unsigned int pozycja){
	sprTyp();
	return wek[pozycja];
};

template<typename T,unsigned int rozmiar> void Wektor<T,rozmiar>::sprZakres(){
	throw WyZakres();
};

template<typename T,unsigned int rozmiar> void Wektor<T,rozmiar>::sprTyp(){
	throw WyTyp();

};

//================================Metody klas specjalizowanych-int================================
template<unsigned int rozmiar> Wektor<int, rozmiar>::Wektor(){
};

template<unsigned int rozmiar> void Wektor<int, rozmiar>::back_push(int a){
	if(wek.size()<rozmiar){wek.push_back(a); return;}
	sprZakres();
};

template<unsigned int rozmiar> void Wektor<int, rozmiar>::erase(unsigned int ktora){
	if(ktora<wek.size()){
		for(int i=ktora;i<wek.size()-1;i++){
			wek[i]=wek[i+1];
		}
		back_pop();
	}
	sprZakres();
};

template<unsigned int rozmiar> void Wektor<int, rozmiar>::print(){
	for(int i=0; i<wek.size();i++){
		cout<<wek[i]<<" ";
	}
	cout<<endl;
};

template<unsigned int rozmiar> void Wektor<int, rozmiar>::sort(int poczatek,int koniec){ //sortowanie za pomoca quicksorta

	int i, j, k, l, e;
	int x, tmp;
	e=(poczatek+koniec)/2;
	i=poczatek;
	j=koniec;
	x=wek[e];
	do
   	{
      		while (wek[i]<x)
		{
		k=i; i++;
		}
      		while (wek[j]>x)
		{
		l=j; j--;
		}
      		if (i<=j)
      		{
		k=i; l=j; tmp=wek[i]; wek[i]=wek[j]; wek[j]=tmp; i++; j--;
      		}
	}while(i<=j);
   	if (poczatek<j) sort(poczatek,j);
	if (i<koniec) sort(i,koniec);
};

template<unsigned int rozmiar> int Wektor<int, rozmiar>::wielkosc(){
	return (wek.size()-1);
};

template<unsigned int rozmiar> void Wektor<int, rozmiar>::back_pop(){
	wek.pop_back();
};

template<unsigned int rozmiar> int& Wektor<int, rozmiar>::operator[](unsigned int pozycja){
	if(pozycja<wek.size()){return wek[pozycja];}
	sprZakres();
};

template<unsigned int rozmiar> void Wektor<int,rozmiar>::sprZakres(){
	throw WyZakres();
};

template<unsigned int rozmiar> void Wektor<int,rozmiar>::sprTyp(){
	throw WyTyp();
};

//================================Metody klas specjalizowanych-double================================
template<unsigned int rozmiar> Wektor<double, rozmiar>::Wektor(){
};

template<unsigned int rozmiar> void Wektor<double, rozmiar>::back_push(double a){
	if(wek.size()<rozmiar){wek.push_back(a); return;}
	sprZakres();
};

template<unsigned int rozmiar> void Wektor<double, rozmiar>::erase(unsigned int ktora){
	if(ktora<wek.size()){
		for(int i=ktora;i<wek.size()-1;i++){
			wek[i]=wek[i+1];
		}
		back_pop();
	}
	sprZakres();
};


template<unsigned int rozmiar> void Wektor<double, rozmiar>::print(){
	for(int i=0; i<wek.size();i++){
		cout<<wek[i]<<" ";
	}
	cout<<endl;
};

template<unsigned int rozmiar> void Wektor<double, rozmiar>::sort(int poczatek, int koniec){ //sortowanie za pomoca quicksorta
	int i, j, k, l, e;
	double x, tmp;
	e=(poczatek+koniec)/2; i=poczatek; j=koniec; x=wek[e];
	do
   	{
      		while (wek[i]<x)
		{
		k=i; i++;
		}
      		while (wek[j]>x)
		{
		l=j; j--;
		}
      		if (i<=j)
      		{
		k=i; l=j; tmp=wek[i]; wek[i]=wek[j]; wek[j]=tmp; i++; j--;
      		}
	}while(i<=j);
   	if (poczatek<j) sort(poczatek,j);
	if (i<koniec) sort(i,koniec);
};

template<unsigned int rozmiar> int Wektor<double, rozmiar>::wielkosc(){
	return (wek.size()-1);
};

template<unsigned int rozmiar> void Wektor<double, rozmiar>::back_pop(){
	wek.pop_back();
};

template<unsigned int rozmiar> double& Wektor<double, rozmiar>::operator[](unsigned int pozycja){
	if(pozycja<wek.size()){return wek[pozycja];}
	sprZakres();
};

template<unsigned int rozmiar> void Wektor<double,rozmiar>::sprZakres(){
	throw WyZakres();
};
template<unsigned int rozmiar> void Wektor<double,rozmiar>::sprTyp(){
	throw WyTyp();
};

//================================Metody klas specjalizowanych-LiczbaMax================================
template<unsigned int rozmiar> Wektor<LiczbaMax, rozmiar>::Wektor(){
};

template<unsigned int rozmiar> void Wektor<LiczbaMax, rozmiar>::back_push(LiczbaMax a){
	if(wek.size()<rozmiar){wek.push_back(a); return;}
	sprZakres();
};

template<unsigned int rozmiar> void Wektor<LiczbaMax, rozmiar>::erase(unsigned int ktora){
	if(ktora<wek.size()){
		for(int i=ktora;i<wek.size()-1;i++){
			wek[i]=wek[i+1];
		}
		back_pop();
	}
	sprZakres();
};

template<unsigned int rozmiar> void Wektor<LiczbaMax, rozmiar>::print(){
	for(int i=0; i<wek.size();i++){
		wek[i].wyswietl();
	}
};

template<unsigned int rozmiar> void Wektor<LiczbaMax, rozmiar>::sort(){
};

template<unsigned int rozmiar> void Wektor<LiczbaMax, rozmiar>::back_pop(){
	wek.pop_back();
};

template<unsigned int rozmiar> LiczbaMax& Wektor<LiczbaMax, rozmiar>::operator[](unsigned int pozycja){
	if(pozycja<wek.size()){return wek[pozycja];}
	sprZakres();
};

template<unsigned int rozmiar> void Wektor<LiczbaMax,rozmiar>::sprZakres(){
	throw WyZakres();
};
template<unsigned int rozmiar> void Wektor<LiczbaMax,rozmiar>::sprTyp(){
	throw WyTyp();
};


#endif