Discussion :

[Galevsky]

Bonjour,

J'ai du mal avec le mot clé enum.

Comment dire qu'on passe une 'enum' en paramètre d'une méthode ? Le but étant de pouvoir faire un '.values() ' sur la variable... mais pour cela il faut que je sache qu'il s'agisse d'une enum. La FAQ est vide à ce propos...

Merci à vous.

[Invité]

Salut,
Il suffit que tu crées une enum, comme une classe come ceci :

Code Java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
public enum Toto {
    TOTO_1,
    TOTO_2,
    ...
}

Et pour ta méthode tu spécifies ton attribut en type Toto
Tschau

[Galevsky]

Et pour ta méthode tu spécifies ton attribut en type Toto
Tschau

Salut,

merci de ta réponse mais mon problème est différent: je veux passer un argument générique:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

methode(<? will be an enum> enumeration)

Comment dire que ce sera non pas une classe, mais une enum ?


Gal'

[the-gtm]

A moins que je n'ai loupé un truc, la méthode values() n'est pas définie dans la classe Enum, donc tu ne pourra pas l'appeler.
C'est probablement possible d'appeler .values() par réflection, sinon le plus simple c'est de passer le tableau des valeurs en argument de la méthode.

[Galevsky]

A moins que je n'ai loupé un truc, la méthode values() n'est pas définie dans la classe Enum, donc tu ne pourra pas l'appeler.

Non t'as rien loupé, et c'est mon soucis... je ne veux pas passer un objet de type 'Enum', mais le truc qui fait que un 'enum Toto{}' dispose de .values()
et je te dis pas comme je galère, parce que 'enum' est un mot clé du language et hormis le fait qu'il hérite de Enum -ce dont je me fous car ce qui m'intéresse c'est l'interface qui fait qu'il y a le .values()- je n'arrive pas à trouver un moyen de passer en paramètre "une enum X" générique afin de pouvoir faire le .values() de façon générique, sans connaître à l'avance le nom de l'enum.

C'est probablement possible d'appeler .values() par réflection, sinon le plus simple c'est de passer le tableau des valeurs en argument de la méthode.

Je vais devoir m'y résigner j'en ai bien peur.... je voulais faire une classe paramétrée (générique) dépendant d'une classe et d'une 'enum', mais apparemment c'est difficilement possible...

++
Gal'

[tchize_]

Le but d'une enum, c'est justement de limiter la liste des valeurs possible utilisées au ein d'une variable ou d'un parametre, et tu voudrais accepter n'importe quoi, c'est assez logique que le language ne prévoie pas ce coup là.... Et comme mentionné, la reflection permet de faire beaucoup de truc, meme si c'est plus chiant a écrire.

[Galevsky]

Le but d'une enum, c'est justement de limiter la liste des valeurs possible utilisées au ein d'une variable ou d'un parametre, et tu voudrais accepter n'importe quoi, c'est assez logique que le language ne prévoie pas ce coup là

Faux, je sais ce qu'est une enum, et c'est très bien comme ça. Ce que je veux, c'est pouvoir dire 'les classes filles auront besoin d'un enum de critères pour pouvoir exister'. Où tu vois que je veux accepter n'importe quoi ? Je ne veux pas n'importe quoi, je veux une enum... mais je ne peux pas la définir dans la classe abstraite par ce que ce seront les classes filles qui devront avoir leur propres enum. Où tu vois que c'est logique de ne pas pouvoir l'exprimer ? Je ne suis pas en train de te dire que les enum devraient supporter l'héritage, mais la possibilité de rendre générique le 'pattern' 'enum'
du language.

.... Et comme mentionné, la reflection permet de faire beaucoup de truc, meme si c'est plus chiant a écrire.

J'ai rien contre l'héritage, ceci-dit je n'ai pas vu de mention explicite ci-dessus.

Alors si tu peux m'en donner une, je te remercie.

Voici le problème:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
public abstract SearchEngine <T, XXXXX> {
 
public Set<T> getResults() {
   // Implementation qui renvoie les resultats de type T
   boucle sur chacun des critères {
      results.retain(getResultsForCriteria(currentCriteria));
   }
   return results;
}
 
public abstract Set<T> getResultsForCriteria(Criteria criteria); 
 
public void setCriteria(Map<String, String> urlMapContainingParameters) {
   boucle sur la urlMapContainingParameters {
      // Verifie que chaque param fait parti de l'enum XXX, puis classe par importance (grâce à l'index de l'enum) les paramètres.
      XXXXX
   }
}
 
 
}

Voilà, comme ça je peux créer un moteur de recherche de Cat simplement
en faisant une classe qui dit comment traiter chaque critère:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class CatSearch extends SearchEngine<Cat, CatSearchCriteria> {
 
public Set<Cat> getResultsForCriteria(Criteria criteria) {
   switch(criteria.getType()) {
      case AGE:
         //do something with database and criteria.getValue();
      case COLOR:
         //do something else      
...
  }
} 
 
}

ainsi qu'une enum contenant les critères de recherches pour cette recherche:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
enum CatSearchCriteria {AGE, COLOR, LENGTH}

Note: la place dans l'enum = importance du critère...


Voilà. Si tu peux me dire comment je fais -notamment ce que mets à la place de XXXXX-, je t'en serais énormément reconnaissant

Gal'

[the-gtm]

Euh... franchement si ton idée d'utiliser des enums je la trouve pas terrible, par exemple l'idée ordre de priorité = index de l'enum ... ok et si l'utilisateur a besoin de changer un jour ?
Si tu luttes autant c'est peut être parce que tu essaie d'utiliser quelque chose d'inadapté non?

[bouye]

Et comme mentionné, la reflection permet de faire beaucoup de truc, meme si c'est plus chiant a écrire.

J'ai recement fait ca pour permettre de mettre une JComboBox dans un JTable quand on veut editer une cellule contenant une valeur d'une enum :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
  /** Properly configure the editor with given value.   
   * @param delegated The delegated editor.
   * @param value The source value.
   */
  protected void configureEditor(JComboBox delegated, Object value) {
    // Clear combo.
    delegated.removeAllItems();
    if (value instanceof Enum) {
      try {
        // Populate combo.
        Class<?> valueClass = value.getClass();
        Method method = valueClass.getMethod("values");
        Object[] values = (Object[]) method.invoke(null);
        for (Object val : values) {
          delegated.addItem(val);
        }
        // Select current value.
        delegated.setSelectedItem(value);
      }
      catch (IllegalAccessException ex) {
        Logger.getLogger(EnumCellEditor.class.getName()).log(Level.SEVERE, null, ex);
      }
      catch (IllegalArgumentException ex) {
        Logger.getLogger(EnumCellEditor.class.getName()).log(Level.SEVERE, null, ex);
      }
      catch (InvocationTargetException ex) {
        Logger.getLogger(EnumCellEditor.class.getName()).log(Level.SEVERE, null, ex);
      }
      catch (NoSuchMethodException ex) {
        Logger.getLogger(EnumCellEditor.class.getName()).log(Level.SEVERE, null, ex);
      }
      catch (SecurityException ex) {
        Logger.getLogger(EnumCellEditor.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
    else {
      delegated.addItem(value);
      delegated.setSelectedItem(value);
      delegated.setEnabled(false);
    }
  }

[bredelet]

Pourquoi pas simplement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public abstract SearchEngine <T, Criteria extends Enum> {

Et ensuite:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class CatSearch extends SearchEngine<Cat, CatSearchCriteria> {
 
public Set<Cat> getResultsForCriteria(Criteria criteria) {
   switch(criteria) {
      case AGE:
         //do something with database and criteria.getValue();
      case COLOR:
         //do something else      
...
  }
}

Tu peux utiliser criteria.ordinal() pour voir sa position dans l'enum.

[Galevsky]

Euh... franchement si ton idée d'utiliser des enums je la trouve pas terrible, par exemple l'idée ordre de priorité = index de l'enum ... ok et si l'utilisateur a besoin de changer un jour ?
Si tu luttes autant c'est peut être parce que tu essaie d'utiliser quelque chose d'inadapté non?

Ben bien au contraire je trouve que c'est on ne peut plus adapté... car simple.
Un user doit faire un nouveau moteur de recherche ? Ben il implémente juste le traitement des critères après avoir défini sa liste de critères dans une enum. De plus l'enum dispose de la notion d'ordre grâce à son indexage, donc suffit à l'utilisateur de définir son enum du critère le plus discriminant au moins discriminant.

Pour moi l'enum est de loin la solution la plus propre et facile. Pour l'instant, vu que je n'arrive pas à gérer l'enum, j'indique que le constructeur sans argument doit réaliser le remplissage d'un 'Set<Criteria> availableCriteria;' afin de renseigner quels sont les critères possible pour la recherche. Mais c'est du doc typing, et par essence dégueulasse et pas pro.

Si j'avais réussi à paramétrer ma classe en fonction de l'enum, il y aurait eu moins de sources d'erreur et cela aurait été plus propre, étant donné que cette enum est véritablement un paramétrage de ma classe SearchEngine.

Gal'

PS: et si l'utilisateur veut changer l'ordre de ses critères ? ben il change tout simplement l'ordre dans l'enum.

[Galevsky]

Pourquoi pas simplement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public abstract SearchEngine <T, Criteria extends Enum> {

Parce qu'il faut écrire aussi l'implémentation générique dans la classe abstraite:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
public void setCriteria(Map<String, String> urlMapContainingParameters) {
   boucle sur la urlMapContainingParameters {
      // Verifie que chaque param fait parti de l'enum XXX, puis classe par importance (grâce à l'index de l'enum) les paramètres.
      XXXXX
   }
}

Car il s'agit de code normalement générique, et pas à réécrire à chaque implémentation. Hors une fille de Enum sait pas fournir ses .values()

Donc paramètre inutilisable dans le code générique (donc ça sert pas à grand chose pour un paramètre ) Sinon ça aurait été bien...


Gal'

[Galevsky]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
    if (value instanceof Enum) {
      try {
        // Populate combo.
        Class<?> valueClass = value.getClass();
        Method method = valueClass.getMethod("values");
        Object[] values = (Object[]) method.invoke(null);
        for (Object val : values) {
          delegated.addItem(val);
        }
...

Merci à toi, c'est ce que je voulais voir.....

Pas top -disons bien plus compliqué que simplement paramétrer la classe avec une class capable de faire un .values() - cela s'avère être la meilleure solution à défaut de pouvoir faire ce que je voulais... visiblement, si c'est possible, la solution n'est pas connue de bcp de personnes.

++

Gal'

[bredelet]

Parce qu'il faut écrire aussi l'implémentation générique dans la classe abstraite:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
public void setCriteria(Map<String, String> urlMapContainingParameters) {
   boucle sur la urlMapContainingParameters {
      // Verifie que chaque param fait parti de l'enum XXX, puis classe par importance (grâce à l'index de l'enum) les paramètres.
      XXXXX
   }
}

Car il s'agit de code normalement générique, et pas à réécrire à chaque implémentation. Hors une fille de Enum sait pas fournir ses .values()

Donc paramètre inutilisable dans le code générique (donc ça sert pas à grand chose pour un paramètre ) Sinon ça aurait été bien...


Gal'

Je pige pas.
Et dans l'extrait de code de bouye, tu ajoute une methode a tes enum?? Je comprends vraiment pas.

[Galevsky]

Il y a:

- la classe abstraite SearchEngine<T, 'enum XXX'>:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
public Set<T> getResult() {
 // boucle sur les critères utilisés en appellant récursivement getResultPerCriteria(criteria) afin de constituer le Set résultat pour la réponse en faisant l'intersection des Set résultats de chaque critère. Elle doit commencer par le critère le plus discriminant pour ne pas faire des intersection de Set trop gros au début.
}
 
 
// Cette méthode switchera sur le critère, et renverra un Set de <T> qui va bien suivant le critère... donc à implémenter par les classes filles.
abstract Set <T> getResultPerCriteria(criteria);
 
 
// Et enfin, cette méthode définit quels sont les critères pour faire la recherche en cours. (X critères sur Y peuvent être utilisés avec  0 < X <= Y)
Ces critères viendront en fait de la Map de parameters d'une HttpServletRequest. Ils font donc que je cycle sur la Map de l'url, reconnaitre les paramètres qui sont des critères de recherche, les instancier dans une class Criteria que je ne présente pas ici mais qui contient un type (un entrée de l'enum définissant les paramètres possibles pour la recherche), une valeur, et un discriminantFactor. J'ai donc besoin de connapitre les valeurs dans l'enum qui définit les critères de la recherche.
public void setCriteria(Map<String, String> urlMapContainingParameters) {
   boucle sur la urlMapContainingParameters {
      // Verifie que chaque param fait parti de l'enum XXX, puis classe par importance (grâce à l'index de l'enum) les paramètres.
      XXXXX
   }

Exemple: CatSearch

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
class CatSearch extends SearchEngine<Cat, CatSearchCriteria> {
 
// Implemente le minimum requis: à savoir comment traiter chaque critère de recherche 
public Set<Cat> getResultsForCriteria(Criteria criteria) {
   switch(criteria.getType()) {
      case AGE:
         //recherche en base de ce qu'il faut... et renvoit un Set de Cat
      case COLOR:
         //do something else      
...
  }
} 
 
 
//ainsi que l'enum définissant quels sont les critères de recherche possible pour une recherche de Cat:
 
enum CatSearchCriteria {AGE, COLOR, LENGTH}

Mise en situation: je suis dans mon appli J2EE, j'ai une requête:

http://root/searchAction.do?color=grey&age=3

Voici ce que dois faire l'Action

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
 
// Traitement de la recherche
CatSearch catSearch  = new CatSearch();
// filer les param dans l'url pour reconnaitre les critères de la recherche
catSearch.setCriteria(request.getParameterMap());
Set<Cat> result = catSearch.getResult();
...

Le getResult fera lui deux appels à getResultPerCriteria, avec la première fois un Criteria (AGE, 3, 0) puis (COLOR, grey, 1) afin de ressortir les chats gris de 3 ans.

Voilà ce que j'appelle simple: grâce à ma classe abstraite, j'ai un moteur de recherche générique pour mon appli J2ee qui est très vite instancié à partir d'un enum de critère et de l'implémentation de traitement de ces critères (On peut pas faire plus minimaliste).

Gal'

[bouye]

Je pige pas.
Et dans l'extrait de code de bouye, tu ajoute une methode a tes enum?? Je comprends vraiment pas.

Non j'execute la methode values() de la classe concrete de l'enum par reflection. En effet, values() est une methode public static de la classe concrete (ici CatSearchCriteria) et non pas de la classe Enum.

Mon code etant celui d'un TableCellEditor generique et modulable, je ne veux absolument pas connaitre le type concret des enums presentes dans ma table... je dois donc traiter la classe Enum et non pas une de ses classes fille bien specifique.

[bredelet]

intersection des Set résultats de chaque critère.
...
J'ai donc besoin de connapitre les valeurs dans l'enum qui définit les critères de la recherche.

Bon la il te faut quelque chose comme t'a presente bouye.

Autrement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public void init(Criteria[] critValues) {...

A appeler avec CatSearchCriteria.values()...