Remove ImmutableOpenIntMap (#86447)

All uses of the class have been removed, so this commit now removes the
tests and the class itself.

relates #86239

Author: rjernst

server/src/main/java/org/elasticsearch/cluster/DiffableUtils.java

@@ -9,7 +9,6 @@
 package org.elasticsearch.cluster;
 
 import org.elasticsearch.Version;
-import org.elasticsearch.common.collect.ImmutableOpenIntMap;
 import org.elasticsearch.common.collect.ImmutableOpenMap;
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
@@ -81,33 +80,6 @@ public static <K, T> MapDiff<K, T, ImmutableOpenMap<K, T>> diff(
         return before.equals(after) ? emptyDiff() : ImmutableOpenMapDiff.create(before, after, keySerializer, valueSerializer);
     }
 
-    /**
-     * Calculates diff between two ImmutableOpenIntMaps of Diffable objects
-     */
-    public static <T extends Diffable<T>> MapDiff<Integer, T, ImmutableOpenIntMap<T>> diff(
-        ImmutableOpenIntMap<T> before,
-        ImmutableOpenIntMap<T> after,
-        KeySerializer<Integer> keySerializer
-    ) {
-        assert after != null && before != null;
-        return before.equals(after)
-            ? emptyDiff()
-            : ImmutableOpenIntMapDiff.create(before, after, keySerializer, DiffableValueSerializer.getWriteOnlyInstance());
-    }
-
-    /**
-     * Calculates diff between two ImmutableOpenIntMaps of non-diffable objects
-     */
-    public static <T> MapDiff<Integer, T, ImmutableOpenIntMap<T>> diff(
-        ImmutableOpenIntMap<T> before,
-        ImmutableOpenIntMap<T> after,
-        KeySerializer<Integer> keySerializer,
-        ValueSerializer<Integer, T> valueSerializer
-    ) {
-        assert after != null && before != null;
-        return before.equals(after) ? emptyDiff() : ImmutableOpenIntMapDiff.create(before, after, keySerializer, valueSerializer);
-    }
-
     /**
      * Calculates diff between two Maps of Diffable objects.
      */
@@ -151,17 +123,6 @@ public static <K, T> MapDiff<K, T, ImmutableOpenMap<K, T>> readImmutableOpenMapD
         return diffOrEmpty(new ImmutableOpenMapDiff<>(in, keySerializer, valueSerializer));
     }
 
-    /**
-     * Loads an object that represents difference between two ImmutableOpenMaps
-     */
-    public static <T> MapDiff<Integer, T, ImmutableOpenIntMap<T>> readImmutableOpenIntMapDiff(
-        StreamInput in,
-        KeySerializer<Integer> keySerializer,
-        ValueSerializer<Integer, T> valueSerializer
-    ) throws IOException {
-        return diffOrEmpty(new ImmutableOpenIntMapDiff<>(in, keySerializer, valueSerializer));
-    }
-
     /**
      * Loads an object that represents difference between two Maps of Diffable objects
      */
@@ -184,18 +145,6 @@ public static <K, T extends Diffable<T>> MapDiff<K, T, ImmutableOpenMap<K, T>> r
         return diffOrEmpty(new ImmutableOpenMapDiff<>(in, keySerializer, diffableValueReader));
     }
 
-    /**
-     * Loads an object that represents difference between two ImmutableOpenIntMaps of Diffable objects using Diffable proto object
-     */
-    public static <T extends Diffable<T>> MapDiff<Integer, T, ImmutableOpenIntMap<T>> readImmutableOpenIntMapDiff(
-        StreamInput in,
-        KeySerializer<Integer> keySerializer,
-        Reader<T> reader,
-        Reader<Diff<T>> diffReader
-    ) throws IOException {
-        return diffOrEmpty(new ImmutableOpenIntMapDiff<>(in, keySerializer, new DiffableValueReader<>(reader, diffReader)));
-    }
-
     /**
      * Loads an object that represents difference between two Maps of Diffable objects using Diffable proto object
      */
@@ -380,88 +329,6 @@ public ImmutableOpenMap<K, T> apply(ImmutableOpenMap<K, T> map) {
         }
     }
 
-    /**
-     * Represents differences between two ImmutableOpenIntMap of (possibly diffable) objects
-     *
-     * @param <T> the object type
-     */
-    private static class ImmutableOpenIntMapDiff<T> extends MapDiff<Integer, T, ImmutableOpenIntMap<T>> {
-
-        private ImmutableOpenIntMapDiff(
-            KeySerializer<Integer> keySerializer,
-            ValueSerializer<Integer, T> valueSerializer,
-            List<Integer> deletes,
-            List<Map.Entry<Integer, Diff<T>>> diffs,
-            List<Map.Entry<Integer, T>> upserts
-        ) {
-            super(keySerializer, valueSerializer, deletes, diffs, upserts);
-        }
-
-        private ImmutableOpenIntMapDiff(StreamInput in, KeySerializer<Integer> keySerializer, ValueSerializer<Integer, T> valueSerializer)
-            throws IOException {
-            super(in, keySerializer, valueSerializer);
-        }
-
-        private static <T> ImmutableOpenIntMapDiff<T> create(
-            ImmutableOpenIntMap<T> before,
-            ImmutableOpenIntMap<T> after,
-            KeySerializer<Integer> keySerializer,
-            ValueSerializer<Integer, T> valueSerializer
-        ) {
-            assert after != null && before != null;
-
-            int inserts = 0;
-            var upserts = new ArrayList<Map.Entry<Integer, T>>();
-            var diffs = new ArrayList<Map.Entry<Integer, Diff<T>>>();
-            for (Map.Entry<Integer, T> entry : after.entrySet()) {
-                T beforeValue = before.get(entry.getKey());
-                if (beforeValue == null) {
-                    upserts.add(entry);
-                    inserts++;
-                } else if (entry.getValue().equals(beforeValue) == false) {
-                    if (valueSerializer.supportsDiffableValues()) {
-                        diffs.add(new AbstractMap.SimpleEntry<>(entry.getKey(), valueSerializer.diff(entry.getValue(), beforeValue)));
-                    } else {
-                        upserts.add(entry);
-                    }
-                }
-            }
-
-            int expectedDeletes = before.size() + inserts - after.size();
-            var deletes = new ArrayList<Integer>(expectedDeletes);
-            if (expectedDeletes > 0) {
-                for (Integer key : before.keySet()) {
-                    if (after.containsKey(key) == false) {
-                        deletes.add(key);
-                        if (--expectedDeletes == 0) {
-                            break;
-                        }
-                    }
-                }
-            }
-
-            return new ImmutableOpenIntMapDiff<>(keySerializer, valueSerializer, deletes, diffs, upserts);
-        }
-
-        @Override
-        public ImmutableOpenIntMap<T> apply(ImmutableOpenIntMap<T> map) {
-            ImmutableOpenIntMap.Builder<T> builder = ImmutableOpenIntMap.builder(map);
-
-            for (Integer part : deletes) {
-                builder.remove(part);
-            }
-
-            for (Map.Entry<Integer, Diff<T>> diff : diffs) {
-                builder.put(diff.getKey(), diff.getValue().apply(builder.get(diff.getKey())));
-            }
-
-            for (Map.Entry<Integer, T> upsert : upserts) {
-                builder.put(upsert.getKey(), upsert.getValue());
-            }
-            return builder.build();
-        }
-    }
-
     /**
      * Represents differences between two maps of objects and is used as base class for different map implementations.
      *