Génériques et classe & lt ;? extends Enum & lt;? & gt ;, EnumSet.allOf (classe) vs class.getEnumConstants ()

J'ai le texte suivant BeanValidation code qui fonctionne très bien, et permet de valider qu'un haricot annoté avec:

  @EnumValue(enumClass = MyTestEnum.class)
  private String field;

  public enum MyTestEnum {
    VAL1, VAL2;
  }

Sera validée uniquement si la valeur du champ est "VAL1" ou "VAL2".

public class EnumNameValidator implements ConstraintValidator<EnumValue, String> {

  private Set<String> AVAILABLE_ENUM_NAMES;

  @Override
  public void initialize(EnumValue enumValue) {
    Class<? extends Enum<?>> enumSelected = enumValue.enumClass();
    Set<? extends Enum<?>> enumInstances = Sets.newHashSet(enumSelected.getEnumConstants());
    AVAILABLE_ENUM_NAMES = FluentIterable
            .from(enumInstances)
            .transform(PrimitiveGuavaFunctions.ENUM_TO_NAME)
            .toImmutableSet();
  }

  @Override
  public boolean isValid(String value, ConstraintValidatorContext context) {
    if ( value == null ) {
      return true;
    } else {
      return AVAILABLE_ENUM_NAMES.contains(value);
    }
  }

}

Ce que je ne comprends pas, c'est pourquoi ma première tentative a échoué. En utilisant à la place de la enumSelected.getEnumConstants() ci-dessus le code suivant:

Set<? extends Enum<?>> enumInstances = EnumSet.allOf(enumSelected);

Intellij 12 ne met pas en évidence aucune erreur, mais le compilateur dit:

java: method allOf in class java.util.EnumSet<E> cannot be applied to given types;
  required: java.lang.Class<E>
  found: java.lang.Class<capture#1 of ? extends java.lang.Enum<?>>
  reason: inferred type does not conform to declared bound(s)
    inferred: capture#1 of ? extends java.lang.Enum<?>
    bound(s): java.lang.Enum<capture#1 of ? extends java.lang.Enum<?>>

Je ne comprends pas le problème, et j'ai ce code qui fonctionne très bien:

  private static <T extends Enum<T> & EnumAlternativeName> T safeGetByAlternativeName(Class<T> enumClass, String alternativeName) {
    for ( T t : EnumSet.allOf(enumClass) ) {
      if ( t.getAlternativeName().equals(alternativeName) ) {
        return t;
      }
    }
    return null;
  }

source d'informationauteur Sebastien Lorber

Mon sentiment est que, dans ? extends Enum<?> les deux ? pourraient être différents, alors que allOf s'attend à un T extends Enum<T> où les deux T sont les mêmes.

Par exemple, considérons le code suivant:

static enum MyEnum {}
static class EnumValue<T extends Enum<T>> {
    Class<T> enumClass;
    EnumValue(Class<T> enumClass) {
        this.enumClass = enumClass;
    }
    Class<T> enumClass() { return enumClass; }
}

Ces lignes de compilation:

EnumValue<?> enumValue = new EnumValue(MyEnum.class); //raw constructor
Set<? extends Enum<?>> enumInstances = EnumSet.allOf(enumValue.enumClass());

parce que nous savons que les deux T dans enumValue.enumClass() sont les mêmes, mais ce ne sera pas le cas:

EnumValue enumValue = new EnumValue(MyEnum.class);
Class<? extends Enum<?>> enumSelected = enumValue.enumClass();
Set<? extends Enum<?>> enumInstances = EnumSet.allOf(enumSelected);

parce que vous avez perdu de l'information à l'aide d'un Class<? extends Enum<?>> comme une étape intermédiaire.

3

Mon explication sur @assylias la solution:

Ce que nous voulons exprimer à propos du type de la classe, c'est que c'est un
```
Class<E>, for some E, that E <: Enum<E>
```
mais Java ne permet pas d'introduire une variable de type E dans un corps de méthode.

Généralement, nous pouvons exploiter générique et générique de capture d'introduire un type masqué variable
```
class G<T extends b(T)> { ... }  //b(T) is a type expression that may contain T

G<? extends A>   --capture-->   G<T>, for some T, that T <: A & b(T)
```
Mais cela ne fonctionne pas dans notre cas, depuis T dans Class<T> ne dispose pas d'un bond qui le fait fonctionner.

Donc nous avons besoin d'introduire un nouveau type avec le désiré lié
```
class EnumClass<E extends Enum<E>>   //called EnumValue in assylias's solution

    EnumClass(Class<E> enumClass) 

    Class<E> enumClass()

EnumClass<?>   --capture-->    EnumClass<E>, for some E, that E <: Enum<E>
```
Nous appelons alors EnumClass<E>.enumClass() pour donner un
```
Class<E>, for some E, that E <: Enum<E>
```
qui est l'objectif que nous avons tenté de le faire.

Mais comment peut-on appeler le constructeur de EnumClass? L'origine du problème est que nous n'avons pas un type approprié pour les enumClasspourtant, le constructeur de EnumClass veut correctement tapé enumClass.
```
Class<not-proper> enumClass = ...;
new EnumClass<...>(enumClass);  //wont work
```
Heureusement(?) la crue de type d'aide ici qui désactive les génériques de vérification de type
```
EnumClass raw = new EnumClass(enumClass);  //no generics
EnumClass<?> wild = raw; 
```
De sorte que le minimum de gymnastique nous avons besoin d'effectuer de jeter la classe pour le type désiré est
```
((EnumClass<?>)new EnumClass(enumClass)).enumClass()
```

Vous devez vous connecter pour publier un commentaire.