Bouton annuler : pattern memento

Bouton annuler : pattern memento - Java - Programmation

Marsh Posté le 25-11-2013 à 15:34:55    

bonjour,
 
Je suis quelque peu coincé sur une utilisation d'un rollback sur une petite appli faite en java.  
J'ai 3 classes :  
-> ChapitreJava qui contient 3 méthodes :
     - List<String> listeDesMots() qui va me retourner une liste de mots à partir d'une constante
     - Map<String, Integer> occurrencesDesMots(List<String> liste) qui retourne une liste de couples <String,Integer>, à chaque mot de la liste est associé son nombre d'occurrences
     - final String CHAPITRE2 =(....) : mon texte à analyser
 
-> AppletListe : mon applet
 
C'est surtout sur la 3e classe (IHMListe) que je bloque. Le but est de construire une IHM où je peux manipuler le texte : taper un mot dans un champ de saisie et regarder si ce mot est présent, compter le nombre d'occurrences de ce mot, voire le retirer du texte. De même, je peux classer par ordre croissant suivant les occurrences les mots du texte (et ordre décroissant). Jusque là, ça fonctionne bien. Là où je bloque, c'est dans l'utilisation d'un bouton annuler me permettant de faire un rollback sur le tri, ou le retrait du mot. Visiblement, le pattern Memento pourrait y répondre mais je ne vois pas comment faire.  
 
voici le code source de cette classe IHMListe :  
 

Code :
  1. //les imports
  3. public class IHMListe extends JPanel implements ActionListener, ItemListener {
  5.     private JPanel cmd = new JPanel();
  6.     private JLabel afficheur = new JLabel();
  7.     private JTextField saisie = new JTextField();
  9.     private JPanel panelBoutons = new JPanel();
  10.     private JButton boutonRechercher = new JButton("rechercher" );
  11.     private JButton boutonRetirer = new JButton("retirer" );
  13.     private CheckboxGroup mode = new CheckboxGroup();
  14.     private Checkbox ordreCroissant = new Checkbox("croissant", mode, false);
  15.     private Checkbox ordreDecroissant = new Checkbox("décroissant", mode, false);
  17.     private JButton boutonOccurrences = new JButton("occurrence" );
  19.     private JButton boutonAnnuler = new JButton("annuler" );
  21.     private TextArea texte = new TextArea();
  23.     private List<String> liste;
  24.     private Map<String, Integer> occurrences;
  26.     public IHMListe(List<String> liste, Map<String, Integer> occurrences) {
  27.         this.liste = liste;
  28.         this.occurrences = occurrences;
  30.         cmd.setLayout(new GridLayout(3, 1));
  32.         cmd.add(afficheur);
  33.         cmd.add(saisie);
  35.         panelBoutons.setLayout(new FlowLayout(FlowLayout.LEFT));
  36.         panelBoutons.add(boutonRechercher);
  37.         panelBoutons.add(boutonRetirer);
  38.         panelBoutons.add(new JLabel("tri du texte :" ));
  39.         panelBoutons.add(ordreCroissant);
  40.         panelBoutons.add(ordreDecroissant);
  41.         panelBoutons.add(boutonOccurrences);
  42.         panelBoutons.add(boutonAnnuler);
  43.         cmd.add(panelBoutons);
  45.         afficheur.setText(liste.getClass().getName() + " et "
  46.             + occurrences.getClass().getName());
  47.         texte.setText(liste.toString());
  49.         setLayout(new BorderLayout());
  51.         add(cmd, "North" );
  52.         add(texte, "Center" );
  54.         boutonRechercher.addActionListener(this);
  55.         boutonRetirer.addActionListener(this);
  56.         boutonOccurrences.addActionListener(this);
  57.         boutonAnnuler.addActionListener(this);
  58.        
  59.         ordreCroissant.addItemListener(this);
  60.         ordreDecroissant.addItemListener(this);
  62.     }
  64.     public void actionPerformed(ActionEvent ae) {
  65.         try {
  66.             boolean res = false;
  67.             if (ae.getSource() == boutonRechercher || ae.getSource() == saisie) {
  68.                 res = liste.contains(saisie.getText());
  69.                 Integer occur = occurrences.get(saisie.getText());
  70.                 afficheur.setText("résultat de la recherche de : "
  71.                     + saisie.getText() + " -->  " + res);
  72.             } else if (ae.getSource() == boutonRetirer) {
  73.                 res = retirerDeLaListeTousLesElementsCommencantPar(saisie
  74.                     .getText());
  75.                 afficheur
  76.                 .setText("résultat du retrait de tous les éléments commençant par -->  "
  77.                     + saisie.getText() + " : " + res);
  78.             } else if (ae.getSource() == boutonOccurrences) {
  79.                 Integer occur = occurrences.get(saisie.getText());
  80.                 if (occur != null)
  81.                     afficheur.setText(" -->  " + occur + " occurrence(s)" );
  82.                 else
  83.                     afficheur.setText(" -->  ??? " );
  84.             }
  85.             texte.setText(liste.toString());
  87.         } catch (Exception e) {
  88.             afficheur.setText(e.toString());
  89.         }
  90.     }
  92.     public void itemStateChanged(ItemEvent ie) {
  93.         if (ie.getSource() == ordreCroissant)
  94.           Collections.sort(liste);
  95.         else if (ie.getSource() == ordreDecroissant) {
  96.            Stack<String> stack = new Stack<String>();
  97.            Collections.sort(liste);
  98.            for (Iterator<String> it = liste.iterator() ;  it.hasNext();) {
  99.              stack.push(it.next()) ;
  100.             }
  101.             liste.clear(); //vider liste
  102.             while (!stack.isEmpty()) {
  103.               liste.add(stack.pop());
  104.             }
  105.         }
  106.         texte.setText(liste.toString());
  107.     }
  109.     private boolean retirerDeLaListeTousLesElementsCommencantPar(String prefixe) {
  110.         boolean resultat = false;
  111.         for (Iterator <String> it = liste.iterator() ; it.hasNext();) {
  112.          String s = it.next();
  113.          if (s.startsWith(prefixe)) {
  114.            it.remove();
  115.            occurrences.put(prefixe, 0);
  116.            resultat = true;
  117.           }
  118.         }
  119.         return resultat;
  120.     }
  122. }


Message édité par roswellentongues le 25-11-2013 à 15:37:30
Reply

Marsh Posté le 25-11-2013 à 15:34:55   

Reply

Marsh Posté le 25-11-2013 à 19:58:05    

Sur chaque action, avant d'opérer la modification, tu stockes :
- la liste List<String>
- un memo String, par exemple "retirer mot mmm' ou "tri croissant"  
 
Donc tu crées un objet Etape avec ces deux attributs.
Et tu enrichis une ArrayList de Etape au fur et à mesure des actions.
 
Ensuite, en présentant les Etape.memo des étapes dans un ComboBox, le bouton annuler permet de recharger la Etape.list


Message édité par willy le kid le 25-11-2013 à 19:58:36
Reply

Marsh Posté le 26-11-2013 à 14:40:16    

Je pense être sur la bonne piste. Néanmoins, je suis confronté à un bug sur le nombre d'occurrences :
en gras les modif

Code :
  1. public class IHMListe2 extends JPanel implements ActionListener, ItemListener {
  2.    //blablabla
  4.     private List<String> liste;
  5.     private Map<String, Integer> occurrences;
  7.     private Stack<List<String>> pileSave ;
  8.    
  9.     public IHMListe2(List<String> liste, Map<String, Integer> occurrences) {
  10.         this.liste = liste;
  11.         this.occurrences = occurrences;
  12.         pileSave = new Stack();
  14.         //blablabla
  16.         panelBoutons.add(boutonAnnuler);
  17.         cmd.add(panelBoutons);
  19.         //blabla
  21.         boutonOccurrences.addActionListener(this);
  22.         boutonAnnuler.addActionListener(this);
  23.      
  24.         ordreCroissant.addItemListener(this);
  25.         ordreDecroissant.addItemListener(this);
  27.     }
  29.     public void actionPerformed(ActionEvent ae) {
  30.         try {
  31.             boolean res = false;
  32.             if (ae.getSource() == boutonRechercher || ae.getSource() == saisie) {
  33.                 res = liste.contains(saisie.getText());
  34.                 Integer occur = occurrences.get(saisie.getText());
  35.                 afficheur.setText("résultat de la recherche de : "
  36.                     + saisie.getText() + " -->  " + res);
  37.             } else if (ae.getSource() == boutonRetirer) {
  38.                 this.sauvegarder();
  39.                 res = retirerDeLaListeTousLesElementsCommencantPar(saisie
  40.                     .getText());
  41.                 afficheur
  42.                 .setText("résultat du retrait de tous les éléments commençant par -->  "
  43.                     + saisie.getText() + " : " + res);
  44.             } else if (ae.getSource() == boutonOccurrences) {
  45.                 //this.sauvegarder();
  46.                 Integer occur = occurrences.get(saisie.getText());
  47.                 if (occur != null)
  48.                     afficheur.setText(" -->  " + occur + " occurrence(s)" );
  49.                 else
  50.                     afficheur.setText(" -->  ??? " );
  51.             }
  52.             else if (ae.getSource() == boutonAnnuler) {
  53.               if (!pileSave.isEmpty()) {
  54.                 liste = (LinkedList) pileSave.pop() ;
  55.                 afficheur.setText("Modif annulee" );
  56.                 texte.setText(liste.toString());
  57.                  } else {
  58.                     afficheur.setText("Pas de modif" );
  59.                     }
  60.             }
  61.             texte.setText(liste.toString());
  63.         } catch (Exception e) {
  64.             afficheur.setText(e.toString());
  65.         }
  66.     }
  68.     public void itemStateChanged(ItemEvent ie) {
  69.         if (ie.getSource() == ordreCroissant){
  70.           this.sauvegarder();
  71.           Collections.sort(liste);
  72.         }
  73.         else if (ie.getSource() == ordreDecroissant) {
  74.           this.sauvegarder();
  75.            Stack<String> stack = new Stack<String>();
  76.            Collections.sort(liste);
  77.            for (Iterator<String> it = liste.iterator() ;  it.hasNext();) {
  78.              stack.push(it.next()) ;
  79.             }
  80.             liste.clear(); //vider liste
  81.             while (!stack.isEmpty()) {
  82.               liste.add(stack.pop());
  83.             }
  84.         }
  85.         texte.setText(liste.toString());
  86.     }
  88.    //blabla
  90.     private void sauvegarder() {
  91.       pileSave.push(new LinkedList (liste));
  92.     }
  93. }


 
Quand je fais une recherche dans ma liste de mot d'un terme, il me sort bien "true" en retour (signe qu'il l'a trouvé) et si je demande son nombre d'occurrences, c'est bien le bon nombre.
Si je retire ce terme, en faisant une recherche, j'obtiens un "false" en retour, signe qu'il a bien été retiré et 0 en occurrence.
Quand j'annule, il réapparaît bien dans ma liste, je le vois, si je fais une nouvelle recherche, j'ai un "true", mais toujours 0 en occurrence.  
Où est l'erreur ?
 
Merci d'avance


Message édité par roswellentongues le 26-11-2013 à 14:43:22
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed