#include <iostream>
#include <list>

using namespace std;

/* ispis genericke liste */
template <typename T> void ispis(list<T> l){
	for(typename list<T>::iterator it=l.begin(); it!=l.end(); it++){
		cout<<(*it)<<endl;
	}
}

/* ucitavanje genericke liste */
template <typename T> void ucitaj(list<T> &l){
	cout<<"Broj elemenata: "<<endl;
	int n;
	T x;
	cin>>n;
	for(int i=0; i<n; i++){
		cin>>x;
		l.push_back(x);
	}

}

template <class T1,  class T2>
class Par{
	private:
		T1 prvi;
		T2 drugi;
	public:
		Par(){}

		Par(T1 p, T2 d){
			prvi = p;
			drugi = d;
		}
		
		void setPrvi(T1 pr){
			prvi=pr;
		}
		
		void setDrugi(T2 dr){
			drugi=dr;
		}
		
		~Par(){}
		
		friend istream& operator>>(istream& in, Par &p){
			in>>p.prvi;
			in>>p.drugi;
			return in;
		}

		friend ostream& operator<<(ostream& out, Par &p){
		out<<"("<<p.prvi<<", "<<p.drugi<<")";
		return out;
	}
};

/* genericka funkcija koja spaja dve liste tako sto formira listu uredjenih parova:
od listi [1,2,3,4,5] i [2,3.3,4,5,6,7,5] formira [(1,2),(2,3.3),(3,4),(4,5),(5,6)] */
template <typename T1, typename T2> list< Par<T1,T2> > spoji(list<T1> l1, list<T2> l2){
	list< Par <T1,T2> > l3;
	Par <T1,T2> p1;
	typename list<T1>::iterator it1=l1.begin(); 
	typename list<T2>::iterator it2=l2.begin(); 
	/* idemo do duzine krace liste */
	while(it1!=l1.end()&&it2!=l2.end()){
		p1.setPrvi(*it1);
		p1.setDrugi(*it2);
		l3.push_back( p1 );
		it1++;
		it2++;
	}
	return l3;
}

/* genericka funkcija koja menja zadatu listu tako sto zadrzava
samo one elemente koji ispunjavaju prosledjeni uslov */
template<typename T> 
void zadrzi( list<T>& lista, bool(*uslov)(T)){
		typename list<T>::iterator it=lista.begin(); 
		while(it!=lista.end()){
			/* ovde je bitna inkrementacija it++ u erase pozivu
			kako bi se preslo na sledeci element liste. 
			da je inkrementacija uradjena nakon erase poziva
			izgubila bi se referenca ka trenutnoj vrednosti pokazivaca, 
			a samim tim i mogucnost prelaska na sledeci element liste, jer
			trenutni element ima pokazivac ka sledecem */
			if(!uslov(*it))
				lista.erase(it++);
			else
				it++;	
		}
}

/* opstija varijanta funkcije zadrzi koja omogucava i prosledjivanje funkcionala */
template<typename T, typename Predikat > 
void zadrzi2( list<T>& lista, Predikat p){
		typename list<T>::iterator it=lista.begin(); 
		while(it!=lista.end()){
			if(!p(*it))
			 lista.erase(it++);
			else
			it++; 
		}
}

/* primer uslova za funkciju zadrzi */
bool u1(int x){
	return x%2==0;
}

template < class T>
class Linear{
	private:
		float a;
		float b;
	public:
		Linear(float a1, float b1){
			a=a1;
			b=b1;
		}
		
		Linear(){}
		
		/* operator () omogucava objektima ove klase da se 
		ponasaju kao funkcije samo dodatno ovi objekti mogu da se
		parametrizuju dinamicki od strane korisnika u fazi izvrsavanja
		sto se ne moze postici pokazivacima na funkcije i statickim
		sablon promenljivama */
		bool operator()(T x){
					return (x*a+b)>0;
		}
};

int main(int argc, char** argv) {
	Par<int,int> p1(3,4);
	list<float> l1; 
	list<int> l2;
	list<  Par <float, int> > l3;
	//testiramo ispis liste par
	cout<<p1<<endl;
	//ucitavanje liste realnih brojeva
	ucitaj(l1);
	//testiranje ispisa liste realnih brojeva
	ispis(l1); 
	//ucitavanje liste realnih brojeva
	ucitaj(l2);
	//ispis ove liste
	ispis(l2);
	//testiranje funkcije spoji
	l3=spoji(l1,l2);
	ispis(l3);
	//testiranje funkcije zadrzi
	zadrzi(l2,u1);	
	ispis(l2);
	//glumi funkciju uslova koja zadrzava brojeva x za koje vazi 2x-14>0
	Linear <int> lin1(2, -14);
	zadrzi2(l2, lin1);
	ispis(l2);
	return 0;
}