import java.util.*;

////////////////////////////////////////////////////////////
//Déclarations préliminaires pour les exs d'après
////////////////////////////////////////////////////////////


class Truc<T>{
    T x;


    void set(T xx){
	x=xx;
    }
}

class Mere {
    void show() { System.out.println("Je suis une Mere"); }
}

class FilleUn extends Mere {
    void show() { System.out.println("Je suis une FilleUn"); }
}

class FilleDeux extends Mere {
    void show() { System.out.println("Je suis une FilleDeux"); }
}


////////////////////////////////////////////////////////////
//<T extends ..> vs <? extends ..> : les propriétés des sous type en generique classique vs wildcard
////////////////////////////////////////////////////////////

class TestUn{

    public static void main(String[] args){
	///////////////////////////////////////////////////////////////////////////////////////////////////
	//////  Propriété "non héritage avec généricité" : Truc<Fille> PAS sous type de Truc<Mere> ///////
	///////////////////////////////////////////////////////////////////////////////////////////////////
	
	Truc<Mere> tMere = new Truc<>();
	Truc<FilleUn> tFille = new Truc<>();
	//si Truc<FilleUn> sous type de Truc<Mere> alors on pourrait faire
	//tMere = tFille;
	//tMere.set(new Mere()); //et là on aurait tFille donc le x est Mere!

	

	///////////////////////////////////////////////////////////////////////////////////////////////////////
	//////Propriété "héritage avec les wildcard" : Truc<FilleUn> EST sous type de Truc<? extends Mere> ////
	////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	Truc<FilleUn> trucFilleUn = new Truc<>();
	Truc<? extends Mere> trucWild = new Truc<>();

	trucWild = trucFilleUn;

	//attention  Truc<? extends Mere> n'EST PAS sous type de Truc<Mere>, sinon par transitivité on aurait Truc<Fille> sous type Truc<Mere>  ////
	//et on pourrait alors faire tMere = trucWild;  et comme avant on aurait un tMere qui point vers un tFille

	
	//trucWild.set(new Mere());
	//comme Truc<FilleUn> sous type de Truc<? extends Mere>, penser quand on a un objet Truc<? extends Mere> que c'est peut etre un Truc<FilleUn> qui pointe dessus,
	//et donc aucune opération permettant de changer un FilleUn en Mere sera autorisée (après à voir comment le compilo track ça, ici avec juste l'affectation)

	
    }
}



////////////////////////////////////////////////////////////////
//////  avantage de la propriété d'héritage des wildcard ///////
////////////////////////////////////////////////////////////////

//ex0:  TP6, 
// interface IJeu{
//                 ..
// 		    ArrayList<? extends Ijeu> genererFils(); //
// }

// avec cette interface, alors on ajoute juste "class Taquin IMPLEMENTS IJeu", et tout est ok
// (en particulier ArrayList<Taquin> genererFils(); est ok)

// alors que avec 
// interface IJeu{
//                 ..
// 		    ArrayList<Ijeu> genererFils(); //
// }
// si on ajoute juste "class Taquin IMPLEMENTS IJeu", ne compile pas
    

//ex1:  cours Mr Valicov :
	//   calculerSalaires(AL<Employe> l) // fait somme l.get(i).getSalaire()
	//   bof écrit comme cela car pas utilisable sur AL<commercial>
	//V2:calculerSalaires(AL<? extends Employe> l)
     	//   là utilisable avec AL<commercial> car sous type de AL<? extends Employe>

//ex1 bis:
class Test{
    public static double sumOfList(List<? extends Number> list) {
	double s = 0.0;
	for (Number n : list)
	    s += n.doubleValue();
	return s;
    }
    public static void main(String[] args){
	ArrayList<Double> l = new ArrayList<>();
	l.add(3.5);
	sumOfList(l);

    }
}


/////////////////////////////////////////////////////////////////////////////////////////
//////  Conséquence de la propriété des wildcard: le "read only" ///
/////////////////////////////////////////////////////////////////////////////////////////

class TestDeux{
    public static void main(String[] args){
	Truc<FilleUn> trucFilleUn = new Truc<>();
	Truc<? extends Mere> trucWild = new Truc<>();
	trucWild = trucFilleUn;
	
	//trucWild.set(new Mere()); //on ne peut pas faire cela, et heureusement sinon le trucFilleUn aurait un x de type Mere

	//autrement dit, quand on a un objet Truc<? extends Mere>, penser que c'est peut etre un Truc<FilleUn> qui pointe dessus,
	//et donc aucune opération permettant de changer "dans cet objet" un FilleUn en Mere ne sera autorisée

	
    }
    	//et donc quand manipule du Truc<? extends Mere>, on est en read only:
        //ne compile pas (et heureusement, sinon imaginez avec en paramètre une List<Fille>
        //public static void sumOfListEssaiWrite(List<? extends Mere> list) {
        //  list.add(new Mere());
        //	}

}



/////////////////////////////////////////////////////////////////////////////////////////
//////  <? extends ...> vs <T extends ..> : round 2
/////////////////////////////////////////////////////////////////////////////////////////
    //on peut parfois transformer l'utiilisation d'une wild card en version générique:
    //reprenons l'ex précédent

//Ex1 
class TestTrois{
     public static <T extends Number> double sumOfListV2(List<T> list) {
     	double s = 0.0;
     	for (Number n : list)
     	    s += n.doubleValue();
    	return s;
     }

}
//point positif : ici, même si c'est inutile, nous ne sommes plus "read onlye" (on pourrait faire quelque chose comme list.add(list.get(0)))

//Ex2 : TP6
interface Ijeu<T extends Ijeu<T>>{
    ArrayList<T> genererFils();
}

class Taquin implements Ijeu<Taquin>{
    public ArrayList<Taquin> genererFils(){return null;}//return null juste pour que cela compile
}

//point positif : ici le genereFils de Taquin doit retourner une AL ne contenant que des taquins,
//alors que avec ArrayList<? extends IJeu> dans l'interface Ijeu, il aurait pu retourner une AL avec des taquins et des hanoi
//point négatif : si on avait Taquin et Ijeu qui pré-existaient (sans généricité) et qu'on passe Ijeu en générique, force à génériciser Taquin





//EX3 inspiré de "effective java" 
class Stack<E> {
    E x; //pour simplifier je code un stack ne pouvant stocker qu'un seul élément 
    
    public void push(E e){
	x=e;
    }

    public E pop(){
	E res = x;
	x = null;
	return res;
    }

    public boolean isEmpty(){
	return x==null;
    }
    
    public void pushAll(Iterable<? extends E> src) {
	for (E e : src)
	    push(e);
    }

    //ici on peut réécrire
    public <T extends E>  void pushAllV2(Iterable<T> src) {
	for (T e : src)
	    push(e);
    }

    public void popAll(Collection<? super E> dst) {
	while (!isEmpty())
	    dst.add(pop());
    }

    //par contre pour popALl on est coincé, on ne peut pas écrire
    //(je ne sais pas pourquoi <T super E> est interdit d'ailleurs
    
    // public <T super E> void  popAllV2(Collection<T> dst) {
    // 	while (!isEmpty())
    // 	    dst.add(pop());
    // }

        
}



//Ex4 : 

class CollectionTrucsSousMere{
    List<? extends Mere> l;
    
    public void set(List<? extends Mere> l2){
	l=l2;
    }
    //on veut pouvoir faire du set(ArrayList<FilleUn> l2)
    //on veut pouvoir faire du set(ArrayList<FilleDeux> l2)
    
}

//on a besoin du ? car
//- si on avait List<Mere> l et set(List<Mere> l2) alors on pourrai pas faire set(ArrayList<FilleUn> l2) car List<FilleUn> pas sous type de List<Mere>
//- si on générisait la class avec CollectionTrucsSousMere<T extends Mere>{ .. puis utiliser T partout}, alors on pourrait pas mettre FilleUn puis FilleDeux, il faudrait
//fixer le type au début, en ce sens ? est plus souple