Remove redundant switch on enum (elastic#133821)

It's a bit of a code smell to have a switch on an enum like this, so I've replaced it with a required enum parameter. This makes it clear to anyone adding to the enum that this is a required field. While I was at it, I also removed the other switch, since it was redundant with the name field anyway.

Author: not-napoleon

test/framework/src/main/java/org/elasticsearch/datageneration/FieldType.java

@@ -30,87 +30,55 @@
 import org.elasticsearch.datageneration.fields.leaf.UnsignedLongFieldDataGenerator;
 import org.elasticsearch.datageneration.fields.leaf.WildcardFieldDataGenerator;
 
+import java.util.function.BiFunction;
+
 /**
  * Lists all leaf field types that are supported for data generation by default.
  */
 public enum FieldType {
-    KEYWORD("keyword"),
-    LONG("long"),
-    UNSIGNED_LONG("unsigned_long"),
-    INTEGER("integer"),
-    SHORT("short"),
-    BYTE("byte"),
-    DOUBLE("double"),
-    FLOAT("float"),
-    HALF_FLOAT("half_float"),
-    SCALED_FLOAT("scaled_float"),
-    COUNTED_KEYWORD("counted_keyword"),
-    BOOLEAN("boolean"),
-    DATE("date"),
-    GEO_POINT("geo_point"),
-    TEXT("text"),
-    IP("ip"),
-    CONSTANT_KEYWORD("constant_keyword"),
-    PASSTHROUGH("passthrough"), // For now this field type does not have default generators.
-    WILDCARD("wildcard"),
-    MATCH_ONLY_TEXT("match_only_text");
+    KEYWORD("keyword", (fn, ds) -> new KeywordFieldDataGenerator(ds)),
+    LONG("long", LongFieldDataGenerator::new),
+    UNSIGNED_LONG("unsigned_long", UnsignedLongFieldDataGenerator::new),
+    INTEGER("integer", IntegerFieldDataGenerator::new),
+    SHORT("short", ShortFieldDataGenerator::new),
+    BYTE("byte", ByteFieldDataGenerator::new),
+    DOUBLE("double", DoubleFieldDataGenerator::new),
+    FLOAT("float", FloatFieldDataGenerator::new),
+    HALF_FLOAT("half_float", HalfFloatFieldDataGenerator::new),
+    SCALED_FLOAT("scaled_float", ScaledFloatFieldDataGenerator::new),
+    COUNTED_KEYWORD("counted_keyword", CountedKeywordFieldDataGenerator::new),
+    BOOLEAN("boolean", (fn, ds) -> new BooleanFieldDataGenerator(ds)),
+    DATE("date", (fn, ds) -> new DateFieldDataGenerator(ds)),
+    GEO_POINT("geo_point", (fn, ds) -> new GeoPointFieldDataGenerator(ds)),
+    TEXT("text", (fn, ds) -> new TextFieldDataGenerator(ds)),
+    IP("ip", (fn, ds) -> new IpFieldDataGenerator(ds)),
+    CONSTANT_KEYWORD("constant_keyword", (fn, ds) -> new ConstantKeywordFieldDataGenerator()),
+    PASSTHROUGH("passthrough", (fn, ds) -> {
+        // For now this field type does not have default generators.
+        throw new IllegalArgumentException("Passthrough field type does not have a default generator");
+    }),
+    WILDCARD("wildcard", (fn, ds) -> new WildcardFieldDataGenerator(ds)),
+    MATCH_ONLY_TEXT("match_only_text", (fn, ds) -> new MatchOnlyTextFieldDataGenerator(ds)),;
 
     private final String name;
+    private final BiFunction<String, DataSource, FieldDataGenerator> fieldDataGenerator;
 
-    FieldType(String name) {
+    FieldType(String name, BiFunction<String, DataSource, FieldDataGenerator> fieldDataGenerator) {
         this.name = name;
+        this.fieldDataGenerator = fieldDataGenerator;
     }
 
     public FieldDataGenerator generator(String fieldName, DataSource dataSource) {
-        return switch (this) {
-            case KEYWORD -> new KeywordFieldDataGenerator(dataSource);
-            case LONG -> new LongFieldDataGenerator(fieldName, dataSource);
-            case UNSIGNED_LONG -> new UnsignedLongFieldDataGenerator(fieldName, dataSource);
-            case INTEGER -> new IntegerFieldDataGenerator(fieldName, dataSource);
-            case SHORT -> new ShortFieldDataGenerator(fieldName, dataSource);
-            case BYTE -> new ByteFieldDataGenerator(fieldName, dataSource);
-            case DOUBLE -> new DoubleFieldDataGenerator(fieldName, dataSource);
-            case FLOAT -> new FloatFieldDataGenerator(fieldName, dataSource);
-            case HALF_FLOAT -> new HalfFloatFieldDataGenerator(fieldName, dataSource);
-            case SCALED_FLOAT -> new ScaledFloatFieldDataGenerator(fieldName, dataSource);
-            case COUNTED_KEYWORD -> new CountedKeywordFieldDataGenerator(fieldName, dataSource);
-            case BOOLEAN -> new BooleanFieldDataGenerator(dataSource);
-            case DATE -> new DateFieldDataGenerator(dataSource);
-            case GEO_POINT -> new GeoPointFieldDataGenerator(dataSource);
-            case TEXT -> new TextFieldDataGenerator(dataSource);
-            case IP -> new IpFieldDataGenerator(dataSource);
-            case CONSTANT_KEYWORD -> new ConstantKeywordFieldDataGenerator();
-            case WILDCARD -> new WildcardFieldDataGenerator(dataSource);
-            case MATCH_ONLY_TEXT -> new MatchOnlyTextFieldDataGenerator(dataSource);
-            case PASSTHROUGH -> throw new IllegalArgumentException("Passthrough field type does not have a default generator");
-        };
+        return fieldDataGenerator.apply(fieldName, dataSource);
     }
 
     public static FieldType tryParse(String name) {
-        return switch (name) {
-            case "keyword" -> FieldType.KEYWORD;
-            case "long" -> FieldType.LONG;
-            case "unsigned_long" -> FieldType.UNSIGNED_LONG;
-            case "integer" -> FieldType.INTEGER;
-            case "short" -> FieldType.SHORT;
-            case "byte" -> FieldType.BYTE;
-            case "double" -> FieldType.DOUBLE;
-            case "float" -> FieldType.FLOAT;
-            case "half_float" -> FieldType.HALF_FLOAT;
-            case "scaled_float" -> FieldType.SCALED_FLOAT;
-            case "counted_keyword" -> FieldType.COUNTED_KEYWORD;
-            case "boolean" -> FieldType.BOOLEAN;
-            case "date" -> FieldType.DATE;
-            case "geo_point" -> FieldType.GEO_POINT;
-            case "text" -> FieldType.TEXT;
-            case "ip" -> FieldType.IP;
-            case "constant_keyword" -> FieldType.CONSTANT_KEYWORD;
-            case "wildcard" -> FieldType.WILDCARD;
-            case "passthrough" -> FieldType.PASSTHROUGH;
-            case "match_only_text" -> FieldType.MATCH_ONLY_TEXT;
-            // Custom types will fail to parse and will return null
-            default -> null;
-        };
+        for (FieldType fieldType : FieldType.values()) {
+            if (fieldType.name.equals(name)) {
+                return fieldType;
+            }
+        }
+        return null;
     }
 
     @Override