Small refactor removing duplicate code

Author: davidkyle

libs/x-content/src/main/java/org/elasticsearch/common/xcontent/ConstructingObjectParser.java

@@ -26,7 +26,6 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
@@ -207,16 +206,15 @@ public <T> void declareField(BiConsumer<Value, T> consumer, ContextParser<Contex
             throw new IllegalArgumentException("[type] is required");
         }
 
-        if (consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER || consumer == OPTIONAL_CONSTRUCTOR_ARG_MARKER) {
+        if (isConstructorArg(consumer)) {
             /*
-             * Constructor arguments are detected by these "marker" consumers. It keeps the API looking clean even if it is a bit sleezy. We
-             * then build a new consumer directly against the object parser that triggers the "constructor arg just arrived behavior" of the
-             * parser. Conveniently, we can close over the position of the constructor in the argument list so we don't need to do any fancy
+             * Build a new consumer directly against the object parser that
+             * triggers the "constructor arg just arrived behavior" of the
+             * parser. Conveniently, we can close over the position of the
+             * constructor in the argument list so we don't need to do any fancy
              * or expensive lookups whenever the constructor args come in.
              */
-            int position = constructorArgInfos.size();
-            boolean required = consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER;
-            constructorArgInfos.add(new ConstructorArgInfo(parseField, required));
+            int position = addConstructorArg(consumer, parseField);
             objectParser.declareField((target, v) -> target.constructorArg(position, v), parser, parseField, type);
         } else {
             numberOfFields += 1;
@@ -237,19 +235,15 @@ public <T> void declareNamedObject(BiConsumer<Value, T> consumer, NamedObjectPar
             throw new IllegalArgumentException("[parseField] is required");
         }
 
-        if (consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER || consumer == OPTIONAL_CONSTRUCTOR_ARG_MARKER) {
+        if (isConstructorArg(consumer)) {
             /*
-             * Constructor arguments are detected by this "marker" consumer. It
-             * keeps the API looking clean even if it is a bit sleezy. We then
-             * build a new consumer directly against the object parser that
+             * Build a new consumer directly against the object parser that
              * triggers the "constructor arg just arrived behavior" of the
              * parser. Conveniently, we can close over the position of the
              * constructor in the argument list so we don't need to do any fancy
              * or expensive lookups whenever the constructor args come in.
              */
-            int position = constructorArgInfos.size();
-            boolean required = consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER;
-            constructorArgInfos.add(new ConstructorArgInfo(parseField, required));
+            int position = addConstructorArg(consumer, parseField);
             objectParser.declareNamedObject((target, v) -> target.constructorArg(position, v), namedObjectParser, parseField);
         } else {
             numberOfFields += 1;
@@ -260,6 +254,7 @@ public <T> void declareNamedObject(BiConsumer<Value, T> consumer, NamedObjectPar
     @Override
     public <T> void declareNamedObjects(BiConsumer<Value, List<T>> consumer, NamedObjectParser<T, Context> namedObjectParser,
             ParseField parseField) {
+
         if (consumer == null) {
             throw new IllegalArgumentException("[consumer] is required");
         }
@@ -270,19 +265,15 @@ public <T> void declareNamedObjects(BiConsumer<Value, List<T>> consumer, NamedOb
             throw new IllegalArgumentException("[parseField] is required");
         }
 
-        if (consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER || consumer == OPTIONAL_CONSTRUCTOR_ARG_MARKER) {
+        if (isConstructorArg(consumer)) {
             /*
-             * Constructor arguments are detected by this "marker" consumer. It
-             * keeps the API looking clean even if it is a bit sleezy. We then
-             * build a new consumer directly against the object parser that
+             * Build a new consumer directly against the object parser that
              * triggers the "constructor arg just arrived behavior" of the
              * parser. Conveniently, we can close over the position of the
              * constructor in the argument list so we don't need to do any fancy
              * or expensive lookups whenever the constructor args come in.
              */
-            int position = constructorArgInfos.size();
-            boolean required = consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER;
-            constructorArgInfos.add(new ConstructorArgInfo(parseField, required));
+            int position = addConstructorArg(consumer, parseField);
             objectParser.declareNamedObjects((target, v) -> target.constructorArg(position, v), namedObjectParser, parseField);
         } else {
             numberOfFields += 1;
@@ -306,19 +297,15 @@ public <T> void declareNamedObjects(BiConsumer<Value, List<T>> consumer, NamedOb
             throw new IllegalArgumentException("[parseField] is required");
         }
 
-        if (consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER || consumer == OPTIONAL_CONSTRUCTOR_ARG_MARKER) {
+        if (isConstructorArg(consumer)) {
             /*
-             * Constructor arguments are detected by this "marker" consumer. It
-             * keeps the API looking clean even if it is a bit sleezy. We then
-             * build a new consumer directly against the object parser that
+             * Build a new consumer directly against the object parser that
              * triggers the "constructor arg just arrived behavior" of the
              * parser. Conveniently, we can close over the position of the
              * constructor in the argument list so we don't need to do any fancy
              * or expensive lookups whenever the constructor args come in.
              */
-            int position = constructorArgInfos.size();
-            boolean required = consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER;
-            constructorArgInfos.add(new ConstructorArgInfo(parseField, required));
+            int position = addConstructorArg(consumer, parseField);
             objectParser.declareNamedObjects((target, v) -> target.constructorArg(position, v), namedObjectParser,
                     wrapOrderedModeCallBack(orderedModeCallback), parseField);
         } else {
@@ -327,6 +314,27 @@ public <T> void declareNamedObjects(BiConsumer<Value, List<T>> consumer, NamedOb
                     wrapOrderedModeCallBack(orderedModeCallback), parseField);
         }
     }
+
+    /**
+     * Constructor arguments are detected by this "marker" consumer. It
+     * keeps the API looking clean even if it is a bit sleezy.
+     */
+    private boolean isConstructorArg(BiConsumer<?, ?> consumer) {
+        return consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER || consumer == OPTIONAL_CONSTRUCTOR_ARG_MARKER;
+    }
+
+    /**
+     * Add a constructor argument
+     * @param consumer Either {@link #REQUIRED_CONSTRUCTOR_ARG_MARKER} or {@link #REQUIRED_CONSTRUCTOR_ARG_MARKER}
+     * @param parseField Parse field
+     * @return The argument position
+     */
+    private int addConstructorArg(BiConsumer<?, ?> consumer, ParseField parseField) {
+        int position = constructorArgInfos.size();
+        boolean required = consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER;
+        constructorArgInfos.add(new ConstructorArgInfo(parseField, required));
+        return position;
+    }
 
     @Override
     public String getName() {