TP3

	public class Pile {
    public final static int TAILLE_PAR_DEFAUT = 5;

    private Object[] zone;
    private int ptr;
    /**
     * Constructeur par initialisation de la taille de la pile.
     * 
     * @param taille : nombre d'éléments dans la pile.
     */
    
    public Pile(int taille) {
        if (taille < 0)
            taille = TAILLE_PAR_DEFAUT;
        this.zone = new Object[taille];
        this.ptr = 0;
    }
    /**
     * Constructeur par défaut de la pile.
     */
    public Pile() {
        this(TAILLE_PAR_DEFAUT);
    }
    
    /**
     * Ajoute un objet à la pile.
     * 
     * @param Object i : object à ajouter.
     */
    public void empiler(Object i) throws PilePleineException {
        if (estPleine())
            throw new PilePleineException();
        this.zone[this.ptr] = i;
        this.ptr++;
    }

    /**
     * Supprime l'objet de la pile.
     * 
     */
    public Object depiler() throws PileVideException {
        if (estVide())
            throw new PileVideException();
        this.ptr--;
        return zone[ptr];
    }
    
    /**
     * Contrôle si la pile est vide.
     * Si vide renvoie true.
     */
    public boolean estVide() {
        return ptr == 0;
    }

    /**
     * Contrôle si la pile est pleine.
     * Si pleine renvoie true.
     */
    public boolean estPleine() {
        return ptr == zone.length;
    }

    /**
     * Méthode d'affichage de la pile.
     */
    public String toString() {
        StringBuffer sb = new StringBuffer("[");
        for (int i = ptr - 1; i >= 0; i--) {
            sb.append(zone[i].toString());
            if (i > 0)
                sb.append(", ");
        }
        sb.append("]");
        return sb.toString();
    }
	}
	

	public void actionPerformed(ActionEvent ae) {
        if (ae.getActionCommand().equals("empiler")) {
            try {
                // p.empiler(Integer.parseInt(donnee.getText())); // à modiifer
                p.empiler(donnee.getText()); 
                contenu.setText(p.toString());
            } catch (PilePleineException e) {
                contenu.setText(p.toString() + " estPleine !");
            } catch (NumberFormatException nfe) {
                contenu.setText(p.toString() + " error : " + nfe.getMessage());
            }
        } else {
            try {
                //sommet.setText(Integer.toString(p.depiler()));
                sommet.setText(p.depiler().toString());
                contenu.setText(p.toString());
            } catch (PileVideException e) {
                contenu.setText(p.toString() + " estVide !");
            }
        }
    }
	

	public class Pile implements PileI {
    private Object[] zone;
    private int ptr;
    /**
     * Constructeur par initialisation
     * @param taille : nombre d'éléments de la pile.
     */
    public Pile(int taille) {
        if (taille <= 0){
            taille = CAPACITE_PAR_DEFAUT;
        }
        this.zone = new Object[taille];
        this.ptr = 0;
    }
    
    /**
     * Constructeur par défaut.
     */
    public Pile() {
        this(PileI.CAPACITE_PAR_DEFAUT);
    }
    
    /**
     * Ajoute un objet à la pile.
     * @param Object o : l'élément ajouté.
     */
    public void empiler(Object o) throws PilePleineException {
        if (estPleine())
            throw new PilePleineException();
        this.zone[this.ptr] =o;
        this.ptr++;
    }
    
    /**
     * Supprime le dernier élément entré.
     */
    public Object depiler() throws PileVideException {
        if (estVide())
            throw new PileVideException();
        this.ptr--;
        return this.zone[ptr];
    }
    
    /**
     * Retourne le dernier élément ajouté.
     */
    public Object sommet() throws PileVideException {

        if (estVide())
            throw new PileVideException();

        return this.zone[ptr-1];
    }
    
    /**
     * Donne le nombre maximum d'éléments que peut contenir la pile.
     */
    public int capacite() {
        return this.zone.length;
    }
    
    /**
     * Donne le nombre d'éléments que contient la pile à cet instant.
     */
    public int taille() { 
        if(estVide()){
            ptr = 0;
        }
        return this.ptr;
    }
    
    /**
     * Méthode retournant true si la pile est vide.
     */
    public boolean estVide() {
        return this.ptr == 0;
    }
    
    /**
     * Méthode retournant true si la pile est pleine.
     */
    public boolean estPleine() {
        return this.ptr == this.zone.length;
    }
    
   
 public boolean equals(Object o) {

        if( this== o ){
            return true;
        }      
        if(!(o instanceof Pile)){
            return false;
        }
        Pile p1 = (Pile)o;

        if (p1.taille() == this.taille() && p1.capacite() == this.capacite()){
            boolean estEgale = false;
            for(int i=zone.length - 1; i >=0; i--){
                Object tmp = zone[i];
                boolean egal = false;
                for(int j = zone.length-1; j>=0; j--){
                    if(tmp == p1.zone[i]){
                        egal = true;
                    }       
                }
                if(egal){
                    estEgale = true;
                }else{
                    return false;
                }
            }
            return true;
        }                
        return false;
    }

    // fonction fournie
    public int hashCode() {
        return toString().hashCode();
    }

    public String toString() {
        StringBuffer sb = new StringBuffer("[");
        for (int i = ptr - 1; i >= 0; i--) {
            sb.append(zone[i].toString());
            if (i > 0)
                sb.append(", ");
        }
        sb.append("]");
        return sb.toString();
    }
	}
	

public class Pile2 implements PileI {
    /** par délégation : utilisation de la class Stack */
    private Stack<Object> stk;

    /** la capacité de la pile */
    private int capacité;

    /**
     * Création d'une pile.
     * 
     * @param taille
     *            la taille de la pile, la taille doit être > 0
     */
    public Pile2(int taille) {
        if (taille <= 0){
            taille = CAPACITE_PAR_DEFAUT;
        }
        this.stk = new Stack<Object>();
        this.capacité = taille;
    }

    // constructeur fourni
    public Pile2() {
        this(PileI.CAPACITE_PAR_DEFAUT);
    }

    public void empiler(Object o) throws PilePleineException {
        if(estPleine()){
            throw new PilePleineException();
        }
        this.stk.push(o);
    }

    public Object depiler() throws PileVideException {
        if (estVide())
            throw new PileVideException();
        return this.stk.pop();
    }

    public Object sommet() throws PileVideException {
        if (estVide())
            throw new PileVideException();
        return this.stk.peek();
    }

    /**
     * Effectue un test de l'état de la pile.
     * 
     * @return vrai si la pile est vide, faux autrement
     */
    public boolean estVide() {
        return this.stk.empty();
    }

    /**
     * Effectue un test de l'état de la pile.
     * 
     * @return vrai si la pile est pleine, faux autrement
     */
    public boolean estPleine() {
        return this.stk.size() == this.capacité;
    }

    /**
     * Retourne une représentation en String d'une pile, contenant la
     * représentation en String de chaque élément.
     * 
     * @return une représentation en String d'une pile
     */
    public String toString() {
        String s = "[";
        for (int i = this.stk.size() - 1; i >= 0; i--) {
            s+= this.stk.get(i).toString();
            if(i >0){
                s+= ", ";
            }       
        }
        return s + "]"; 
    }

   
public boolean equals(Object o) {
        if( this== o ){
            return true;
        }      
        if(!(o instanceof Pile2)){
            return false;
        }
        Pile2 p1 = (Pile2)o;

        if (p1.taille() == this.taille() && p1.capacite() == this.capacite()){
            boolean estEgale = false;
            for(int i= stk.size()-1; i>=0 ; i--){
                Object temp = this.stk.get(i);
                boolean existe = false;
                for(int j = this.stk.size() - 1; j >= 0; j--){
                    if((temp == p1.stk.get(i))){
                        existe = true;
                    }
                }
                if(existe){
                    estEgale = true;
                } else{
                    return false;
                }

            }
            return true;
        }
        return false;
    }


    // fonction fournie
    public int hashCode() {
        return toString().hashCode();
    }

    /**
     * Retourne le nombre d'élément d'une pile.
     * 
     * @return le nombre d'élément
     */
    public int taille() {
        return this.stk.size();
    }

    /**
     * Retourne la capacité de cette pile.
     * 
     * @return le nombre d'élément
     */
    public int capacite() {
        return this.capacité;
    }

}

public class Pile3 implements PileI {
    private Vector<Object> v;
    private int capacité;
    
    /**
     * Constructeur par défaut.
     */
    public Pile3() {
        this(PileI.CAPACITE_PAR_DEFAUT);
    }
    
    /**
     * Constructeur par initialisation.
     * @param taille : nombre d'éléments de la pile.
     */
    public Pile3(int taille) {
        if (taille <= 0){
            taille = CAPACITE_PAR_DEFAUT;
        }
        this.v = new Vector<Object>();
        this.capacité = taille;
    }
    
    
    /**
     * Ajoute un élément à la pile si celle-ci n'est pas pleine.
     * @param Object o : l'élément ajouté.
     */
    public void empiler(Object o) throws PilePleineException {
        if(estPleine()){
            throw new PilePleineException();
        }
        this.v.add(o);
    }
    
    /**
     * Supprime le dernier élément ajouté à la pile.
     */
    public Object depiler() throws PileVideException {
        if (estVide()){
            throw new PileVideException();
        }
        int d = v.lastIndexOf(sommet());    
        return this.v.remove(d);
    }
    
    
    /**
     * Retourne le dernier élément ajouté.
     */
    public Object sommet() throws PileVideException {
        if (estVide())
            throw new PileVideException();
        return this.v.lastElement();
    }
    
    /**
     * Retourne le nombre d'éléments que contient la pile à cet instant.
     */
    public int taille() {
        return this.v.size();
    }
    
    /**
     * Retourne le nombre d'éléments que peut contenir la pile.
     */
    public int capacite() {
        return this.capacité;
    }
    
    /**
     * Méthode retournant true si la pile est vide.
     */
    public boolean estVide() {
        return this.v.isEmpty();
    }
    
    
    /**
     * Méthode retournant true si la pile est pleine.
     */
    public boolean estPleine() {
        return this.v.size()==this.capacité;
    }

    public String toString() {
        String s = "[";
        for (int i = this.v.size() - 1; i >= 0; i--) {
            s+= this.v.get(i).toString();
            if(i >0){
                s+= ", ";
            }

        }
        return s + "]"; 
    }

 
	public boolean equals(Object o) {
		if( this== o ){
            return true;
        }
        if(!(o instanceof Pile3)){
            return false;
        }
        Pile3 p = (Pile3) o;
        if(this.taille() == p.taille()){
            if(this.capacite() == p.capacite()){
               boolean estEgale = false; 
               for (int i = this.v.size() - 1; i >= 0; i--) {
                    Object tmp = this.v.get(i);
                    boolean existe = false;
                    for(int j = this.v.size() - 1; j >= 0; j--){
                        if((tmp == p.v.get(i))){
                               existe = true;
                        }
                    }
                    if(existe){
                        estEgale = true;
                    } else{
                        return false;
                    }
                   
               }
                return true;
            }
                
        }
        return false;
    }


    // fonction fournie
    public int hashCode() {
        return toString().hashCode();
    }

}

public class Pile4 implements PileI, Cloneable {
    /** la liste des Maillons/Elements */
    private Maillon stk;
    /** la capacité de la pile */
    private int capacite;
    /** le nombre */
    private int nombre;

    /**
     * Classe interne "statique" contenant chaque élément de la chaine c'est une
     * proposition, vous pouvez l'ignorer !
     */
    private static class Maillon implements Cloneable {
        private Object element;
        private Maillon suivant;

        public Maillon(Object element, Maillon suivant) {
            this.element = element;
            this.suivant = suivant;
        }

        public Maillon suivant() {
            return this.suivant;
        }

        /** Teste si un suivant.
         * Méthode qui facilite le toString()
         * en testant si un suivant existe
         */
        public boolean hasNext(){
            return this.suivant != null;
        }

        public Object element() {
            return this.element;
        }

        public Object clone() throws CloneNotSupportedException {
            Maillon m = (Maillon) super.clone();
            m.element = element;
            return m;
        }
    }

    /**
     * Création d'une pile.
     * 
     * @param taille
     *            la taille de la pile, la taille doit être > 0
     */
    public Pile4(int taille) {
        if (taille <= 0)
            taille = CAPACITE_PAR_DEFAUT;
        this.stk = null;
        this.capacite = taille;
    }

    public Pile4() {
        this(PileI.CAPACITE_PAR_DEFAUT);
    }

    /**
     * empiler à la pile un élément en paramètre.
     * @Param o
     *      objet à empiler dans la pile
     * @throw PilePleineException
     *      -si pile est pleine, ne peut pas empiler
     */
    public void empiler(Object o) throws PilePleineException {
        if (estPleine())
            throw new PilePleineException();
        stk = new Maillon (o,stk);     
        this.nombre++;            
    }

    /**
     * depiler supprime de la pile le dernier objet entré, 
     * retourne cet objet.
     * @return Object 
     * @throw PileVideException
     *      -si pile n'a aucun élémnet
     */
    public Object depiler() throws PileVideException {
        if (estVide())
            throw new PileVideException();
        Maillon tmp = this.stk;
        this.stk = this.stk.suivant;
        nombre--;
        return tmp.element;
    }

    public Object sommet() throws PileVideException {
        if (estVide())
            throw new PileVideException();
        return stk.element ;
    }

    /**
     * Effectue un test de l'état de la pile.
     * 
     * @return vrai si la pile est vide, faux autrement
     */
    public boolean estVide() {
        return stk == null; 
    }

    /**
     * Effectue un test de l'état de la pile.
     * 
     * @return vrai si la pile est pleine, faux autrement
     */
    public boolean estPleine() {
        return this.taille() >= capacite; 
    }

    /**
     * Retourne une représentation en String d'une pile, contenant la
     * représentation en String de chaque élément.
     * 
     * @return une représentation en String d'une pile
     * Utilise la méthode hasNext() de Maillon
     */
    public String toString() {
        String s = "[";
        Maillon tmp = stk;
        while (tmp != null){
            s = s + tmp.element() ;
            tmp = tmp.suivant();
            if (tmp !=null) {s = s + ", ";}  
        }  
        return s + "]"; 
    }

   
	public boolean equals(Object o) {
		boolean b = true;
        Pile4 p1;
        if (o instanceof Pile4) {
            p1 = (Pile4)o;
            Maillon m1;
            Maillon m2;
            try{
                if (p1.taille() == this.taille() && p1.capacite() == this.capacite()){
                m1 = stk;
                m2 = p1.stk;
                    for (int i = this.nombre - 1; i >= 0; i--) {
                        if(!(m1.element() == m2.element())){
                            b = false;
                        }
                        m1 = m1.suivant();
                        m2 = m2.suivant();
                    }
                }
                else{
                    b = false;
                }
            }catch (Exception e){
                b = false;
            }
            
        }else{
            b = false;
        }
        return b;
    }


    public int capacite() {
        return this.capacite;
    }

    public int hashCode() {
        return toString().hashCode();
    }

    public int taille() {
        return nombre;
    }
}

public class Pile2Test extends junit.framework.TestCase {
    private PileI p1;
    private PileI p2;
    private PileI p3;
    private PileI p4;

    protected void setUp() // throws java.lang.Exception
    {
        p1 = new question2.Pile2();
        p2 = new question2.Pile2();
    }

    public void test_Pile_capacite() {
        assertEquals(PileI.CAPACITE_PAR_DEFAUT, p1.capacite());
    }

    public void test_Pile_estPleine() throws Exception {
        PileI p = new question2.Pile2(3);
        p.empiler(3);
        assertEquals(1, p.taille());
        p.empiler(2);
        assertEquals(2, p.taille());
        p.empiler(1);
        assertEquals(3, p.taille());

        assertEquals(true, p.estPleine());
        assertEquals(p.taille(), p.capacite());
        try {
            p.empiler(0);
            fail("La pile est pleine !");
        } catch (Exception e) {
            assertTrue(e instanceof question1.PilePleineException);
        }
    }

    public void test_Pile_sommet() throws Exception {
        PileI p = new question2.Pile2(3);
        assertEquals(true, p.estVide());

        p.empiler(new Integer(3));
        assertEquals(" sommet ?? ", new Integer(3), p.sommet());
        assertEquals(1, p.taille());
        assertEquals(" depiler ?? ", new Integer(3), p.depiler());
        assertEquals(0, p.taille());
    }

    public void test_Pile_estVide() throws Exception {
        PileI p = new question2.Pile2(3);
        assertEquals(true, p.estVide());
        try {
            Object r = p.depiler();
            fail("La pile est vide !");
        } catch (Exception e) {
            assertTrue(e instanceof question1.PileVideException);
        }
    }

    public void test_Pile_toString() throws Exception {
        PileI pile1 = new question2.Pile2(3);
        assertEquals("toString incorrect ? ", "[]", pile1.toString());
        pile1.empiler(4);
        assertEquals("toString incorrect ? ", "[4]", pile1.toString());
        pile1.empiler(5);
        assertEquals("toString incorrect ? ", "[5, 4]", pile1.toString());
        pile1.empiler(3);
        assertEquals("toString incorrect ? ", "[3, 5, 4]", pile1.toString());

    }

    public void test_Pile_TailleNegative() {
        PileI p = new question2.Pile2(-3);
        assertEquals(p.CAPACITE_PAR_DEFAUT, p.capacite());
    }

    public void test_Pile_equals() throws Exception {

        p1.empiler(3);
        p1.empiler(2);
        p1.empiler(1);

        p2.empiler(3);
        p2.empiler(2);
        p2.empiler(1);

        assertTrue("égalité de deux piles ? ", p1.equals(p2));
        assertTrue("égalité de deux piles ? ", p2.equals(p1));
        assertTrue("égalité de deux piles ? ", p1.equals(p1));

        p2.empiler(1);
        assertFalse("égalité de deux piles ? ", p1.equals(p2));

    }

    public void test_equals_contenu_different() throws Exception{ 
        PileI p1 = new Pile(6); PileI p11 = new Pile(6);
        PileI p2 = new Pile2(6);PileI p22 = new Pile2(6);
        PileI p3 = new Pile3(6);PileI p33 = new Pile3(6);
        PileI p4 = new Pile4(6);PileI p44 = new Pile4(6);

        p1.empiler(3);p1.empiler(2);p1.empiler(5);
        p11.empiler("3");p11.empiler("2");p11.empiler("5");

        p2.empiler(3);p2.empiler(2);p2.empiler(5);
        p22.empiler("3");p22.empiler("2");p22.empiler("5");

        p3.empiler(3);p3.empiler(2);p3.empiler(5);
        p33.empiler("3");p33.empiler("2");p33.empiler("5");

        p4.empiler(3);p4.empiler(2);p4.empiler(5);
        p44.empiler("3");p44.empiler("2");p44.empiler("5");

        assertEquals(" equals Pile ???", p2.toString(),p22.toString());
        assertEquals(" equals Pile ???", p22.toString(),p2.toString());
        assertEquals(" equals Pile ???", p3.toString(),p33.toString());
        assertEquals(" equals Pile ???", p33.toString(),p3.toString());
        assertEquals(" equals Pile ???", p4.toString(),p44.toString());
        assertEquals(" equals Pile ???", p44.toString(),p4.toString());

        assertEquals(" equals Pile ???", p1.hashCode(), p1.hashCode());
        assertFalse(" une pile d'entiers(1,2,3) == une pile de String(\"1\",\"2\",\"3\") ???",p1.equals(p11));
    }
}