Meilleure initialisation pour un EnumSet <E> maintenu par l'instance de E

Question

Je fais face à certains travaux concernant des endroits où j'ai utilisé des représentations de chaîne ou int intempestives de partie du modèle, et en utilisant Enum et EnumSet les meilleures pratiques.

Une difficulté particulière est ce cas d'utilisation: un Enum où chaque instance est titulaire d'un EnumSet de [0..n] de ses propres sœurs.

Pour dépouiller à l'essentiel ma question que je reposeront sur StyleEnum de Joshua Bloch. Nous avons donc une enum de BOLD, ITALIQUE, UNDERLINE, STRIKETHROUGH .. et imaginons un B_AND_I qui tiendra {BOLD, ITALIC}.

S'il vous plaît, ne prenez pas beaucoup de sens l'exemple: dans le système réel c'est construit sur des sous-ensembles de base de certaines règles changeantes chargées @ temps de démarrage.

L'objectif est qu'une fois que ce calcul a eu lieu, rien ne peut changer par exemple gamme sous-EnumSet particulier. Alors je viens avec quelque chose comme ceci:

public enum StyleEnum { 
    NONE(0, "none"), BOLD(100, "B"), ITALIC(250, "i"), UNDERLINE(350, "u"), STRIKETHROUGH(9, "b"), B_AND_I(99,"Emphase"); 

//// Pure dream == private final EnumSet<StyleEnum> complexComputedSubSet = new EnumSet<StyleEnum>(); 
//// But not in the jdk 
    private final EnumSet<StyleEnum> complexComputedSubSet; 
    private final int intProp; 
    private final String strLabel; 

    StyleEnum(int intProp, String strLabel) { 
     this.intProp = intProp; 
     this.strLabel = strLabel; 
//// option 2 would have been be this   
//  complexComputedSubSet = EnumSet.of(NONE); 
//// But COMPILER :: illegal reference to static field from initializer 

    }//.... end of constructor 


    /** 
    * static initialzer will compute based on some rules a subset of (none) or 
    * others Enum, a particular enum instance can holds in his bag. 
    */ 
    static { 
//// at least, as option 3, why not this...   
//  for (StyleEnum e : EnumSet.allOf(StyleEnum.class)) { 
//   e.complexComputedSubSet = EnumSet.of(NONE); 
//  } 
//// COMPILER :: cannot assign a value to final variable complexComputedSubSet 

     // main handling here : at class loading 
     // compute a set (rules coming from whatever you want or can). 
     //Once this static class level init is done 
     // nothing can change the computed EnumSet 
     // it's getter will always return an unmodifiable computed EnumSet 
     //.... computing something 
    } 


    //.... 
    //getter(){} 
    //whateverelse(){} 

} 

Comme vous pouvez le voir rien est vraiment agréable ou tout au moins élégant ici.

Dans mes rêves:

private final EnumSet<StyleEnum> complexComputedSubSet= new EnumSet<StyleEnum>(); 
//.. 
//static initialzer 
static { 
    EnumSet.allOf(StyleEnum.class).forEach(e-> computeSubSet(e)); 
//.. 
} 
private static void computeSubSet(StyleEnum instance){ 
    //... 
    instance.complexComputedSubSet.addAll(someComputedCollection); 
} 

Et voilà!

Au lieu de cela, tout ce que je peux faire semble éloigner la finale sur le terrain

// getting away from the final keyword 
private EnumSet<StyleEnum> complexComputedSubSet; 

puis dans la boucle de bloc initialiseur statique theClass et instancier avec le marqueur (factice) (NONE) introduite seulement pour ce (stupide) but:

 for (StyleEnum e : EnumSet.allOf(StyleEnum.class)) { 
      e.complexComputedSubSet = EnumSet.of(NONE); 
     } 

Et seulement après cela calculer et stocker le sous-EnumSet.

Alors toute cette douleur, -mostly-, juste parce que l'on ne peut pas dire « nouvelle EnumSet(); » ? Il doit y avoir un meilleur moyen? Pouvez-vous s'il vous plaît me diriger vers la bonne direction?

Answer 1

J'abandonner maintenant le groupe auxiliaire dans un champ d'instance, et au lieu de mettre en œuvre comme une carte statique:

import java.util.Collections; 
import java.util.Map; 
import java.util.Set; 
import java.util.EnumMap; 
import java.util.EnumSet; 

public enum StyleEnum { 
    NONE(0, "none"), 
    BOLD(100, "B"), 
    ITALIC(250, "i"), 
    UNDERLINE(350, "u"), 
    STRIKETHROUGH(9, "b"), 
    B_AND_I(99,"Emphase"); 

    private static Map<StyleEnum, Set<StyleEnum>> complexSubsets; 

    private final int intProp; 
    private final String strLabel; 

    StyleEnum(int intProp, String strLabel) { 
     this.intProp = intProp; 
     this.strLabel = strLabel; 
    } 

    public Set<StyleEnum> getComplexSubset() { 
     initSubsets(); 
     return complexSubsets.get(this); 
    } 

    private static void initSubsets() { 
     if (complexSubsets == null) { 
      Map<StyleEnum, Set<StyleEnum>> map = new EnumMap<>(StyleEnum.class); 
      map.put(NONE, Collections.unmodifiableSet(EnumSet.of(
       BOLD, ITALIC))); 
      map.put(BOLD, Collections.unmodifiableSet(EnumSet.of(
       UNDERLINE))); 
      map.put(ITALIC, Collections.unmodifiableSet(EnumSet.of(
       UNDERLINE))); 
      map.put(UNDERLINE, Collections.emptySet()); 
      map.put(STRIKETHROUGH, Collections.unmodifiableSet(EnumSet.of(
       NONE))); 
      map.put(B_AND_I, Collections.unmodifiableSet(EnumSet.of(
       BOLD, ITALIC))); 
      complexSubsets = Collections.unmodifiableMap(map); 

      assert complexSubsets.keySet().containsAll(
       EnumSet.allOf(StyleEnum.class)) : 
       "Not all values have subsets defined"; 
     } 
    } 
}