Improve collection setters, change back builder setters to functions

Author: swallez

java-client/src/main/java/co/elastic/clients/util/ModelTypeHelper.java

@@ -80,7 +80,8 @@ public static <T> T requireNonNull(T value, Object obj, String name) {
 
  //----- Lists
 
- private static final List<Object> UNDEFINED_LIST = new AbstractList<Object>() {
+ /** Immutable empty list implementation so that we can create marker list objects */
+ static class EmptyList extends AbstractList<Object> {
  @Override
  public Object get(int index) {
  throw new IndexOutOfBoundsException();
@@ -97,6 +98,9 @@ public Iterator<Object> iterator() {
  }
  };
 
+ static final List<Object> UNDEFINED_LIST = new EmptyList();
+ static final List<Object> RESET_LIST = new EmptyList();
+
  /**
  * Returns an empty list that is undefined from a JSON perspective. It will not be serialized
  * when used as the value of an array property in API objects.
@@ -106,6 +110,11 @@ public static <T> List<T> undefinedList() {
  return (List<T>)UNDEFINED_LIST;
  }
 
+ @SuppressWarnings("unchecked")
+ public static <T> List<T> resetList() {
+ return (List<T>)RESET_LIST;
+ }
+
  /**
  * Is {@code list} defined according to JSON/JavaScript semantics?
  *
@@ -141,12 +150,15 @@ public static <T> List<T> unmodifiableRequired(List<T> list, Object obj, String
 
  //----- Maps
 
- private static final Map<Object, Object> UNDEFINED_MAP = new AbstractMap<Object, Object>() {
+ static class EmptyMap extends AbstractMap<Object, Object> {
  @Override
  public Set<Entry<Object, Object>> entrySet() {
  return Collections.emptySet();
  }
- };
+ }
+
+ static final Map<Object, Object> UNDEFINED_MAP = new EmptyMap();
+ static final Map<Object, Object> RESET_MAP = new ModelTypeHelper.EmptyMap();
 
  /**
  * Returns an empty list that is undefined from a JSON perspective. It will not be serialized
@@ -157,6 +169,11 @@ public static <K, V> Map<K, V> undefinedMap() {
  return (Map<K, V>)UNDEFINED_MAP;
  }
 
+ @SuppressWarnings("unchecked")
+ public static <K, V> Map<K, V> resetMap() {
+ return (Map<K, V>)RESET_MAP;
+ }
+
  /**
  * Is {@code map} defined according to JSON/JavaScript semantics?
  *

java-client/src/main/java/co/elastic/clients/util/ObjectBuilderBase.java

@@ -19,6 +19,13 @@
 
 package co.elastic.clients.util;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 public class ObjectBuilderBase {
  private boolean _used = false;
 
@@ -28,4 +35,95 @@ protected void _checkSingleUse() {
  }
  this._used = true;
  }
+
+ //----- List utilities
+
+ /** A private extension of ArrayList so that we can recognize our own creations */
+ static final class InternalList<T> extends ArrayList<T> {
+ InternalList() {
+ }
+
+ InternalList(Collection<? extends T> c) {
+ super(c);
+ }
+ };
+
+ /** Get a mutable list from the current list value of an object builder property */
+ private static <T> List<T> _mutableList(List<T> list) {
+ if (list == null) {
+ return new InternalList<>();
+ } else if (list instanceof InternalList) {
+ return list;
+ } else {
+ // Adding to a list we don't own: make a defensive copy, also ensuring it is mutable.
+ return new InternalList<>(list);
+ }
+ }
+
+ /** Add a value to a (possibly {@code null}) list */
+ @SafeVarargs
+ protected static <T> List<T> _listAdd(List<T> list, T value, T... values) {
+ list = _mutableList(list);
+ list.add(value);
+ if (values.length > 0) {
+ list.addAll(Arrays.asList(values));
+ }
+ return list;
+ }
+
+ /** Add all elements of a list to a (possibly {@code null}) list */
+ protected static <T> List<T> _listAddAll(List<T> list, List<T> values) {
+ if (list == null) {
+ // Keep the original list to avoid an unnecessary copy.
+ // It will be copied if we add more values.
+ return values;
+ } else if (values == ModelTypeHelper.RESET_LIST) {
+ return null;
+ } else {
+ list = _mutableList(list);
+ list.addAll(values);
+ return list;
+ }
+ }
+
+ //----- Map utilities
+
+ /** A private extension of HashMap so that we can recognize our own creations */
+ private static final class InternalMap<K, V> extends HashMap<K, V> {
+ InternalMap() {
+ }
+
+ InternalMap(Map<? extends K, ? extends V> m) {
+ super(m);
+ }
+ }
+
+ /** Get a mutable map from the current map value of an object builder property */
+ private static <K, V> Map<K, V> _mutableMap(Map<K, V> map) {
+ if (map == null) {
+ return new InternalMap<>();
+ } else if (map instanceof InternalMap) {
+ return map;
+ } else {
+ // Adding to a map we don't own: make a defensive copy, also ensuring it is mutable.
+ return new InternalMap<>(map);
+ }
+ }
+
+ /** Add a value to a (possibly {@code null}) map */
+ protected static <K, V> Map<K, V> _mapPut(Map<K, V> map, K key, V value) {
+ map = _mutableMap(map);
+ map.put(key, value);
+ return map;
+ }
+
+ /** Add all elements of a list to a (possibly {@code null}) map */
+ protected static <K, V> Map<K, V> _mapPutAll(Map<K, V> map, Map<K, V> entries) {
+ if (entries == ModelTypeHelper.RESET_MAP) {
+ return null;
+ }
+ map = _mutableMap(map);
+ map.putAll(entries);
+ return map;
+ }
 }

java-client/src/test/java/co/elastic/clients/elasticsearch/end_to_end/RequestTest.java

@@ -189,16 +189,13 @@ public void testDataIngestion() throws Exception {
  // MSearch: 1st search on an existing index, 2nd one on a non-existing index
  final MsearchResponse<AppData> msearch = client.msearch(_0 -> _0
  .searches(_1 -> _1
- .add(_2 -> _2
- .header(_3 -> _3.index(index))
- .body(_3 -> _3.query(_4 -> _4.matchAll(_5 -> {})))
- )
- .add(_2 -> _2
- .header(_3 -> _3.index("non-existing"))
- .body(_3 -> _3.query(_4 -> _4.matchAll(_5 -> {})))
- )
+ .header(_3 -> _3.index(index))
+ .body(_3 -> _3.query(_4 -> _4.matchAll(_5 -> _5)))
+ ).searches(_1 -> _1
+ .header(_3 -> _3.index("non-existing"))
+ .body(_3 -> _3.query(_4 -> _4.matchAll(_5 -> _5)))
  )
-  , AppData.class);
+ , AppData.class);
 
  assertEquals(2, msearch.responses().size());
  assertTrue(msearch.responses().get(0).isResult());
@@ -210,7 +207,7 @@ public void testDataIngestion() throws Exception {
  @Test
  public void testCatRequest() throws IOException {
  // Cat requests should have the "format=json" added by the transport
- NodesResponse nodes = client.cat().nodes(_0 -> {});
+ NodesResponse nodes = client.cat().nodes(_0 -> _0);
  System.out.println(ModelTestCase.toJson(nodes, mapper));
 
  assertEquals(1, nodes.valueBody().size());
@@ -225,20 +222,17 @@ public void testBulkRequest() throws IOException {
 
  BulkResponse bulk = client.bulk(_0 -> _0
  .operations(_1 -> _1
- .add(_2 -> _2
- .create(_3 -> _3
- .index("foo")
- .id("abc")
- .document(appData)
- )
- ).add(_2 -> _2
- .create(_3 -> _3
- .index("foo")
- .id("def")
- .document(appData)
- )
- )
- )
+ .create(_2 -> _2
+ .index("foo")
+ .id("abc")
+ .document(appData)
+ ))
+ .operations(_1 -> _1
+ .create(_2 -> _2
+ .index("foo")
+ .id("def")
+ .document(appData)
+ ))
  );
 
  assertFalse(bulk.errors());
@@ -324,16 +318,14 @@ public void testSearchAggregation() throws IOException {
  SearchResponse<Product> searchResponse = client.search(_1 -> _1
  .index("products")
  .size(0)
- .aggregations(_2 -> _2
- .put("prices", _3 -> _3
- .histogram(_4 -> _4
- .field("price")
- .interval(10.0)
- ).aggregations(_4 -> _4
- .put("average", _5 -> _5
- .avg(_6 -> _6.field("price"))
- )
- )
+ .aggregations(
+ "prices", _3 -> _3
+ .histogram(_4 -> _4
+ .field("price")
+ .interval(10.0)
+ ).aggregations(
+ "average", _5 -> _5
+ .avg(_6 -> _6.field("price"))
  )
  )
  , Product.class
@@ -360,15 +352,15 @@ public void testGetMapping() throws Exception {
 
  client.indices().create(c -> c
  .index(index)
- .mappings(m -> m.properties(ps -> ps
- .put("id", text)
- .put("name", p -> p
- .object(o -> o.properties(fs -> fs
- .put("first", text)
- .put("last", text)
- ))
+ .mappings(m -> m
+ .properties("id", text)
+ .properties("name", p -> p
+ .object(o -> o
+ .properties("first", text)
+ .properties("last", text)
+ )
  )
- ))
+ )
  );
 
  GetMappingResponse mr = client.indices().getMapping(mrb -> mrb.index(index));