Rappresenta tutti i valori possibili o un sottoinsieme di valori

Ho una classe che deve restituire un insieme di valori, ad esempio

public abstract class AbstractRule {

   public abstract String getName();
   //Property is an example here.
   public abstract Set<Property> getApplicability();
}

public class ConstrainedRule extends AbstractRule {

  @Override
  public String getName() {
    return "ConstrainedRule";
  }

  @Override
  public Set<Property> getApplicability() {
    return ImmutableSet.of(propertyA,propertyB);
  }
}

public class GlobalRule extends AbstractRule {

  @Override
  public String getName() {
    return "GlobalRule";
  }

  @Override
  public Set<Property> getApplicability() {
    // This Rule is applicable on all properties.
    return ImmutableSet.of(propertyA, propertyB, ...);
  }
}

Qui desidero definire una regola applicabile a tutte le proprietà, che sarebbe stato facile se conoscessi l'universo di proprietà esistenti, cosa che non lo so.

Quale sarebbe un buon modo per rappresentare tale Applicabilità?

Un'opzione sarebbe quella di modellare il Set di proprietà come una classe dire:

class PropertyApplicability {

   public static final PropertyApplicability ALL = new PropertyApplicability(true, ImmutableSet.of());

   private final Set<Property> applicables;
   private final boolean applicableToAll;

   private Applicability(boolean applicableToAll, Set<Property> applicables) {
       Preconditions.checkNotNull(applicables);
       this.applicables = ImmutableSet.copyOf(applicables);
       this.applicableToAll = applicableToAll;
}

   //Only way to create applicability with a set of properties
   public Applicability(Set<Property> applicables) {
     Preconditions.checkArgument(applicables.size() > 0);
     this(false, applicables);      
   }

   //Getters
}

Ma mi sono chiesto se esiste una soluzione più elegante.