Remove Iterable interface from immutable maps (#84649)

Since entrySet() was previously implemented on the immutable map
classes, the Iterator interface is no longer used. This commit removes
Iterator from the classes.

client/rest-high-level/src/main/java/org/elasticsearch/client/ilm/GetLifecyclePolicyResponse.java

@@ -8,8 +8,6 @@
 
 package org.elasticsearch.client.ilm;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.elasticsearch.common.collect.ImmutableOpenMap;
 import org.elasticsearch.xcontent.ToXContent;
 import org.elasticsearch.xcontent.ToXContentObject;
@@ -36,8 +34,8 @@ public class GetLifecyclePolicyResponse implements ToXContentObject {
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
         builder.startObject();
-        for (ObjectObjectCursor<String, LifecyclePolicyMetadata> stringLifecyclePolicyObjectObjectCursor : policies) {
-            builder.field(stringLifecyclePolicyObjectObjectCursor.key, stringLifecyclePolicyObjectObjectCursor.value);
+        for (var entry : policies.entrySet()) {
+            builder.field(entry.getKey(), entry.getValue());
         }
         builder.endObject();
         return builder;

server/src/internalClusterTest/java/org/elasticsearch/index/IndexingPressureIT.java

@@ -416,7 +416,16 @@ public class IndexingPressureIT extends ESIntegTestCase {
     }
 
     private String getCoordinatingOnlyNode() {
-        return client().admin().cluster().prepareState().get().getState().nodes().getCoordinatingOnlyNodes().iterator().next().value
+        return client().admin()
+            .cluster()
+            .prepareState()
+            .get()
+            .getState()
+            .nodes()
+            .getCoordinatingOnlyNodes()
+            .values()
+            .iterator()
+            .next()
             .getName();
     }
 

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

@@ -685,8 +685,8 @@ public class ClusterState implements ToXContentFragment, Diffable<ClusterState>
         }
 
         public Builder customs(ImmutableOpenMap<String, Custom> customs) {
-            customs.forEach(entry -> Objects.requireNonNull(entry.value, entry.key));
-            this.customs.putAll(customs);
+            customs.forEach((key, value) -> Objects.requireNonNull(value, key));
+            this.customs.putAllFromMap(customs);
             return this;
         }
 

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

@@ -61,7 +61,8 @@ public class RestoreInProgress extends AbstractNamedDiffable<Custom> implements
     @Override
     public String toString() {
         StringBuilder builder = new StringBuilder("RestoreInProgress[");
-        entries.forEach(entry -> builder.append("{").append(entry.key).append("}{").append(entry.value.snapshot).append("},"));
+        entries.entrySet()
+            .forEach(entry -> builder.append("{").append(entry.getKey()).append("}{").append(entry.getValue().snapshot).append("},"));
         builder.setCharAt(builder.length() - 1, ']');
         return builder.toString();
     }
@@ -86,7 +87,7 @@ public class RestoreInProgress extends AbstractNamedDiffable<Custom> implements
         public Builder() {}
 
         public Builder(RestoreInProgress restoreInProgress) {
-            entries.putAll(restoreInProgress.entries);
+            entries.putAllFromMap(restoreInProgress.entries);
         }
 
         public Builder add(Entry entry) {

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

@@ -844,9 +844,9 @@ public class SnapshotsInProgress extends AbstractNamedDiffable<Custom> implement
             }
             final Set<String> indexNames = indices.keySet();
             final Set<String> indexNamesInShards = new HashSet<>();
-            shards.iterator().forEachRemaining(s -> {
-                indexNamesInShards.add(s.key.getIndexName());
-                assert source == null || s.value.nodeId == null
+            shards.entrySet().forEach(s -> {
+                indexNamesInShards.add(s.getKey().getIndexName());
+                assert source == null || s.getValue().nodeId == null
                     : "Shard snapshot must not be assigned to data node when copying from snapshot [" + source + "]";
             });
             assert source == null || indexNames.isEmpty() == false : "No empty snapshot clones allowed";

server/src/main/java/org/elasticsearch/cluster/metadata/IndexMetadata.java

@@ -1152,10 +1152,10 @@ public class IndexMetadata implements Diffable<IndexMetadata>, ToXContentFragmen
             builder.mapping = mappings.apply(
                 ImmutableOpenMap.<String, MappingMetadata>builder(1).fPut(MapperService.SINGLE_MAPPING_NAME, part.mapping).build()
             ).get(MapperService.SINGLE_MAPPING_NAME);
-            builder.aliases.putAll(aliases.apply(part.aliases));
-            builder.customMetadata.putAll(customData.apply(part.customData));
+            builder.aliases.putAllFromMap(aliases.apply(part.aliases));
+            builder.customMetadata.putAllFromMap(customData.apply(part.customData));
             builder.inSyncAllocationIds.putAll((Map<Integer, Set<String>>) inSyncAllocationIds.apply(part.inSyncAllocationIds));
-            builder.rolloverInfos.putAll(rolloverInfos.apply(part.rolloverInfos));
+            builder.rolloverInfos.putAllFromMap(rolloverInfos.apply(part.rolloverInfos));
             builder.system(isSystem);
             builder.timestampRange(timestampRange);
             return builder.build();

server/src/main/java/org/elasticsearch/cluster/metadata/IndexTemplateMetadata.java

@@ -133,7 +133,7 @@ public class IndexTemplateMetadata implements SimpleDiffable<IndexTemplateMetada
         if (this.mappings.isEmpty()) {
             return null;
         }
-        return this.mappings.iterator().next().value;
+        return this.mappings.values().iterator().next();
     }
 
     public CompressedXContent getMappings() {

server/src/main/java/org/elasticsearch/cluster/metadata/Metadata.java

@@ -1296,34 +1296,34 @@ public class Metadata extends AbstractCollection<IndexMetadata> implements Diffa
         public Builder indices(ImmutableOpenMap<String, IndexMetadata> indices) {
             previousIndicesLookup = null;
 
-            for (var cursor : indices) {
-                put(cursor.value, false);
+            for (var value : indices.values()) {
+                put(value, false);
             }
             return this;
         }
 
         void updateAliases(IndexMetadata previous, IndexMetadata current) {
             if (previous == null && current != null) {
-                for (var cursor : current.getAliases()) {
-                    putAlias(cursor.key, current.getIndex());
+                for (var key : current.getAliases().keySet()) {
+                    putAlias(key, current.getIndex());
                 }
             } else if (previous != null && current == null) {
-                for (var cursor : previous.getAliases()) {
-                    removeAlias(cursor.key, previous.getIndex());
+                for (var key : previous.getAliases().keySet()) {
+                    removeAlias(key, previous.getIndex());
                 }
             } else if (previous != null && current != null) {
                 if (Objects.equals(previous.getAliases(), current.getAliases())) {
                     return;
                 }
 
-                for (var currentCursor : current.getAliases()) {
-                    if (previous.getAliases().containsKey(currentCursor.key) == false) {
-                        putAlias(currentCursor.key, current.getIndex());
+                for (var key : current.getAliases().keySet()) {
+                    if (previous.getAliases().containsKey(key) == false) {
+                        putAlias(key, current.getIndex());
                     }
                 }
-                for (var previousCursor : previous.getAliases()) {
-                    if (current.getAliases().containsKey(previousCursor.key) == false) {
-                        removeAlias(previousCursor.key, current.getIndex());
+                for (var key : previous.getAliases().keySet()) {
+                    if (current.getAliases().containsKey(key) == false) {
+                        removeAlias(key, current.getIndex());
                     }
                 }
             }
@@ -1378,7 +1378,7 @@ public class Metadata extends AbstractCollection<IndexMetadata> implements Diffa
         }
 
         public Builder templates(ImmutableOpenMap<String, IndexTemplateMetadata> templates) {
-            this.templates.putAll(templates);
+            this.templates.putAllFromMap(templates);
             return this;
         }
 
@@ -1602,8 +1602,8 @@ public class Metadata extends AbstractCollection<IndexMetadata> implements Diffa
         }
 
         public Builder customs(ImmutableOpenMap<String, Custom> customs) {
-            customs.forEach(entry -> Objects.requireNonNull(entry.value, entry.key));
-            this.customs.putAll(customs);
+            customs.forEach((key, value) -> Objects.requireNonNull(value, key));
+            this.customs.putAllFromMap(customs);
             return this;
         }
 
@@ -1749,11 +1749,12 @@ public class Metadata extends AbstractCollection<IndexMetadata> implements Diffa
             }
 
             var aliasedIndices = this.aliasedIndices.build();
-            for (var cursor : aliasedIndices) {
-                List<IndexMetadata> aliasIndices = cursor.value.stream()
+            for (var entry : aliasedIndices.entrySet()) {
+                List<IndexMetadata> aliasIndices = entry.getValue()
+                    .stream()
                     .map(idx -> indicesMap.get(idx.getName()))
                     .collect(Collectors.toList());
-                validateAlias(cursor.key, aliasIndices);
+                validateAlias(entry.getKey(), aliasIndices);
             }
             final DataStreamMetadata dataStreamMetadata = (DataStreamMetadata) this.customs.get(DataStreamMetadata.TYPE);
             ensureNoNameCollisions(aliasedIndices.keySet(), indicesMap, allIndices, dataStreamMetadata);
@@ -1967,17 +1968,16 @@ public class Metadata extends AbstractCollection<IndexMetadata> implements Diffa
             }
 
             Map<String, List<IndexMetadata>> aliasToIndices = new HashMap<>();
-            for (var entry : indices) {
-                final String name = entry.key;
-                final IndexMetadata indexMetadata = entry.value;
+            for (var entry : indices.entrySet()) {
+                final String name = entry.getKey();
+                final IndexMetadata indexMetadata = entry.getValue();
                 final IndexAbstraction.DataStream parent = indexToDataStreamLookup.get(name);
                 assert parent == null || parent.getIndices().stream().anyMatch(index -> name.equals(index.getName()))
                     : "Expected data stream [" + parent.getName() + "] to contain index " + indexMetadata.getIndex();
                 IndexAbstraction existing = indicesLookup.put(name, new ConcreteIndex(indexMetadata, parent));
                 assert existing == null : "duplicate for " + indexMetadata.getIndex();
 
-                for (var aliasCursor : indexMetadata.getAliases()) {
-                    AliasMetadata aliasMetadata = aliasCursor.value;
+                for (var aliasMetadata : indexMetadata.getAliases().values()) {
                     List<IndexMetadata> aliasIndices = aliasToIndices.computeIfAbsent(aliasMetadata.getAlias(), k -> new ArrayList<>());
                     aliasIndices.add(indexMetadata);
                 }

server/src/main/java/org/elasticsearch/cluster/node/DiscoveryNodes.java

@@ -158,7 +158,7 @@ public class DiscoveryNodes extends AbstractCollection<DiscoveryNode> implements
      */
     public ImmutableOpenMap<String, DiscoveryNode> getMasterAndDataNodes() {
         ImmutableOpenMap.Builder<String, DiscoveryNode> nodes = ImmutableOpenMap.builder(dataNodes);
-        nodes.putAll(masterNodes);
+        nodes.putAllFromMap(masterNodes);
         return nodes.build();
     }
 

server/src/main/java/org/elasticsearch/common/collect/ImmutableOpenIntMap.java

@@ -38,7 +38,7 @@ import java.util.function.Consumer;
  * Can be constructed using a {@link #builder()}, or using {@link #builder(org.elasticsearch.common.collect.ImmutableOpenIntMap)}
  * (which is an optimized option to copy over existing content and modify it).
  */
-public final class ImmutableOpenIntMap<VType> implements Map<Integer, VType>, Iterable<IntObjectCursor<VType>> {
+public final class ImmutableOpenIntMap<VType> implements Map<Integer, VType> {
 
     private final IntObjectHashMap<VType> map;
 
@@ -137,29 +137,6 @@ public final class ImmutableOpenIntMap<VType> implements Map<Integer, VType>, It
         return keySet;
     }
 
-    /**
-     * Returns a cursor over the entries (key-value pairs) in this map. The iterator is
-     * implemented as a cursor and it returns <b>the same cursor instance</b> on every
-     * call to {@link java.util.Iterator#next()}. To read the current key and value use the cursor's
-     * public fields. An example is shown below.
-     * <pre>
-     * for (IntShortCursor c : intShortMap)
-     * {
-     *     System.out.println(&quot;index=&quot; + c.index
-     *       + &quot; key=&quot; + c.key
-     *       + &quot; value=&quot; + c.value);
-     * }
-     * </pre>
-     * <p>
-     * The <code>index</code> field inside the cursor gives the internal index inside
-     * the container's implementation. The interpretation of this index depends on
-     * to the container.
-     */
-    @Override
-    public Iterator<IntObjectCursor<VType>> iterator() {
-        return map.iterator();
-    }
-
     /**
      * Returns a direct iterator over the keys.
      */

server/src/main/java/org/elasticsearch/common/collect/ImmutableOpenMap.java

@@ -36,7 +36,7 @@ import java.util.function.Consumer;
  * Can be constructed using a {@link #builder()}, or using {@link #builder(ImmutableOpenMap)} (which is an optimized
  * option to copy over existing content and modify it).
  */
-public final class ImmutableOpenMap<KType, VType> implements Map<KType, VType>, Iterable<ObjectObjectCursor<KType, VType>> {
+public final class ImmutableOpenMap<KType, VType> implements Map<KType, VType> {
 
     private final ObjectObjectHashMap<KType, VType> map;
 
@@ -127,29 +127,6 @@ public final class ImmutableOpenMap<KType, VType> implements Map<KType, VType>,
         return map.isEmpty();
     }
 
-    /**
-     * Returns a cursor over the entries (key-value pairs) in this map. The iterator is
-     * implemented as a cursor and it returns <b>the same cursor instance</b> on every
-     * call to {@link Iterator#next()}. To read the current key and value use the cursor's
-     * public fields. An example is shown below.
-     * <pre>
-     * for (IntShortCursor c : intShortMap)
-     * {
-     *     System.out.println(&quot;index=&quot; + c.index
-     *       + &quot; key=&quot; + c.key
-     *       + &quot; value=&quot; + c.value);
-     * }
-     * </pre>
-     * <p>
-     * The <code>index</code> field inside the cursor gives the internal index inside
-     * the container's implementation. The interpretation of this index depends on
-     * to the container.
-     */
-    @Override
-    public Iterator<ObjectObjectCursor<KType, VType>> iterator() {
-        return map.iterator();
-    }
-
     public Set<Map.Entry<KType, VType>> entrySet() {
         Set<Map.Entry<KType, VType>> es;
         return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;

server/src/main/java/org/elasticsearch/rest/action/admin/indices/RestGetAliasesAction.java

@@ -143,13 +143,13 @@ public class RestGetAliasesAction extends BaseRestHandler {
                 builder.field("status", status.getStatus());
             }
 
-            for (final var entry : responseAliasMap) {
-                if (aliasesExplicitlyRequested == false || indicesToDisplay.contains(entry.key)) {
-                    builder.startObject(entry.key);
+            for (final var entry : responseAliasMap.entrySet()) {
+                if (aliasesExplicitlyRequested == false || indicesToDisplay.contains(entry.getKey())) {
+                    builder.startObject(entry.getKey());
                     {
                         builder.startObject("aliases");
                         {
-                            for (final AliasMetadata alias : entry.value) {
+                            for (final AliasMetadata alias : entry.getValue()) {
                                 AliasMetadata.Builder.toXContent(alias, builder, ToXContent.EMPTY_PARAMS);
                             }
                         }

server/src/main/java/org/elasticsearch/snapshots/SnapshotsService.java

@@ -864,15 +864,15 @@ public class SnapshotsService extends AbstractLifecycleComponent implements Clus
     private static ShardGenerations buildGenerations(SnapshotsInProgress.Entry snapshot, Metadata metadata) {
         ShardGenerations.Builder builder = ShardGenerations.builder();
         if (snapshot.isClone()) {
-            snapshot.shardsByRepoShardId().forEach(c -> builder.put(c.key.index(), c.key.shardId(), c.value));
+            snapshot.shardsByRepoShardId().entrySet().forEach(c -> builder.put(c.getKey().index(), c.getKey().shardId(), c.getValue()));
         } else {
-            snapshot.shardsByRepoShardId().forEach(c -> {
-                final Index index = snapshot.indexByName(c.key.indexName());
+            snapshot.shardsByRepoShardId().entrySet().forEach(c -> {
+                final Index index = snapshot.indexByName(c.getKey().indexName());
                 if (metadata.index(index) == null) {
                     assert snapshot.partial() : "Index [" + index + "] was deleted during a snapshot but snapshot was not partial.";
                     return;
                 }
-                builder.put(c.key.index(), c.key.shardId(), c.value);
+                builder.put(c.getKey().index(), c.getKey().shardId(), c.getValue());
             });
         }
         return builder.build();
@@ -1625,10 +1625,10 @@ public class SnapshotsService extends AbstractLifecycleComponent implements Clus
 
         // Figure out which indices have unsuccessful shards
         Set<String> indicesWithUnsuccessfulShards = new HashSet<>();
-        entry.shardsByRepoShardId().iterator().forEachRemaining(shard -> {
-            final ShardState shardState = shard.value.state();
+        entry.shardsByRepoShardId().entrySet().forEach(shard -> {
+            final ShardState shardState = shard.getValue().state();
             if (shardState.failed() || shardState.completed() == false) {
-                indicesWithUnsuccessfulShards.add(shard.key.indexName());
+                indicesWithUnsuccessfulShards.add(shard.getKey().indexName());
             }
         });
 
@@ -1910,7 +1910,7 @@ public class SnapshotsService extends AbstractLifecycleComponent implements Clus
             entries.add(entryToUpdate);
         } else {
             final ImmutableOpenMap.Builder<ShardId, ShardSnapshotStatus> updatedStatus = ImmutableOpenMap.builder(entryToUpdate.shards());
-            updatedStatus.putAll(updatedShardAssignments.build());
+            updatedStatus.putAllFromMap(updatedShardAssignments.build());
             entries.add(entryToUpdate.withShardStates(updatedStatus.build()));
         }
     }
@@ -1926,7 +1926,7 @@ public class SnapshotsService extends AbstractLifecycleComponent implements Clus
             final ImmutableOpenMap.Builder<RepositoryShardId, ShardSnapshotStatus> updatedStatus = ImmutableOpenMap.builder(
                 entryToUpdate.shardsByRepoShardId()
             );
-            updatedStatus.putAll(updatedShardAssignments.build());
+            updatedStatus.putAllFromMap(updatedShardAssignments.build());
             entries.add(entryToUpdate.withClones(updatedStatus.build()));
         }
     }

server/src/test/java/org/elasticsearch/action/admin/indices/alias/get/GetAliasesResponseTests.java

@@ -49,7 +49,7 @@ public class GetAliasesResponseTests extends AbstractWireSerializingTestCase<Get
         if (randomBoolean()) {
             ImmutableOpenMap.Builder<String, List<AliasMetadata>> builder = ImmutableOpenMap.builder(aliases);
             ImmutableOpenMap<String, List<AliasMetadata>> list = createIndicesAliasesMap(1, 2).build();
-            list.forEach(e -> builder.put(e.key, e.value));
+            list.entrySet().forEach(e -> builder.put(e.getKey(), e.getValue()));
             return builder.build();
         }
 

server/src/test/java/org/elasticsearch/cluster/action/shard/ShardStateActionTests.java

@@ -513,7 +513,7 @@ public class ShardStateActionTests extends ESTestCase {
     private void setUpMasterRetryVerification(int numberOfRetries, AtomicInteger retries, CountDownLatch latch, LongConsumer retryLoop) {
         shardStateAction.setOnBeforeWaitForNewMasterAndRetry(() -> {
             DiscoveryNodes.Builder masterBuilder = DiscoveryNodes.builder(clusterService.state().nodes());
-            masterBuilder.masterNodeId(clusterService.state().nodes().getMasterNodes().iterator().next().value.getId());
+            masterBuilder.masterNodeId(clusterService.state().nodes().getMasterNodes().values().iterator().next().getId());
             setState(clusterService, ClusterState.builder(clusterService.state()).nodes(masterBuilder));
         });
 

server/src/test/java/org/elasticsearch/cluster/metadata/MetadataCreateIndexServiceTests.java

@@ -1052,7 +1052,7 @@ public class MetadataCreateIndexServiceTests extends ESTestCase {
 
         // adds alias from new index to existing index
         BiConsumer<Metadata.Builder, IndexMetadata> metadataTransformer = (builder, indexMetadata) -> {
-            AliasMetadata newAlias = indexMetadata.getAliases().iterator().next().value;
+            AliasMetadata newAlias = indexMetadata.getAliases().values().iterator().next();
             IndexMetadata myIndex = builder.get("my-index");
             builder.put(IndexMetadata.builder(myIndex).putAlias(AliasMetadata.builder(newAlias.getAlias()).build()));
         };

server/src/test/java/org/elasticsearch/common/collect/ImmutableOpenMapTests.java

@@ -8,8 +8,6 @@
 
 package org.elasticsearch.common.collect;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.elasticsearch.common.Randomness;
 import org.elasticsearch.common.util.Maps;
 import org.elasticsearch.core.Tuple;
@@ -85,9 +83,9 @@ public class ImmutableOpenMapTests extends ESTestCase {
             .collect(Collectors.groupingBy(e -> e.getKey() % 2, Collectors.mapping(Map.Entry::getValue, Collectors.toList())));
 
         Map<Long, String> sortedMap = new TreeMap<>();
-        for (ObjectObjectCursor<Long, String> cursor : map) {
-            if (cursor.key > 0) {
-                sortedMap.put(cursor.key, cursor.value);
+        for (var entry : map.entrySet()) {
+            if (entry.getKey() > 0) {
+                sortedMap.put(entry.getKey(), entry.getValue());
             }
         }
         int i = 0;
@@ -136,9 +134,9 @@ public class ImmutableOpenMapTests extends ESTestCase {
         List<Long> collectedViaStream = map.keySet().stream().filter(e -> e > 0).sorted().limit(limit).collect(Collectors.toList());
 
         SortedSet<Long> positiveNumbers = new TreeSet<>();
-        for (ObjectObjectCursor<Long, String> cursor : map) {
-            if (cursor.key > 0) {
-                positiveNumbers.add(cursor.key);
+        for (var key : map.keySet()) {
+            if (key > 0) {
+                positiveNumbers.add(key);
             }
         }
         int i = 0;
@@ -214,9 +212,9 @@ public class ImmutableOpenMapTests extends ESTestCase {
             .collect(Collectors.toList());
 
         SortedSet<String> filteredSortedStrings = new TreeSet<>();
-        for (ObjectObjectCursor<Long, String> cursor : map) {
-            if ((cursor.value.contains("ab") || cursor.value.contains("cd") || cursor.value.contains("ef")) == false) {
-                filteredSortedStrings.add(cursor.value);
+        for (var value : map.values()) {
+            if ((value.contains("ab") || value.contains("cd") || value.contains("ef")) == false) {
+                filteredSortedStrings.add(value);
             }
         }
         int i = 0;

test/framework/src/main/java/org/elasticsearch/test/InternalTestCluster.java

@@ -8,8 +8,6 @@
 package org.elasticsearch.test;
 
 import com.carrotsearch.hppc.ObjectLongMap;
-import com.carrotsearch.hppc.cursors.IntObjectCursor;
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
 import com.carrotsearch.randomizedtesting.RandomizedTest;
 import com.carrotsearch.randomizedtesting.SeedUtils;
 import com.carrotsearch.randomizedtesting.generators.RandomNumbers;
@@ -39,8 +37,6 @@ import org.elasticsearch.cluster.node.DiscoveryNode;
 import org.elasticsearch.cluster.node.DiscoveryNodeRole;
 import org.elasticsearch.cluster.node.DiscoveryNodes;
 import org.elasticsearch.cluster.routing.IndexRouting;
-import org.elasticsearch.cluster.routing.IndexRoutingTable;
-import org.elasticsearch.cluster.routing.IndexShardRoutingTable;
 import org.elasticsearch.cluster.routing.OperationRouting;
 import org.elasticsearch.cluster.routing.ShardRouting;
 import org.elasticsearch.cluster.routing.allocation.DiskThresholdSettings;
@@ -1421,9 +1417,9 @@ public final class InternalTestCluster extends TestCluster {
     public void assertSeqNos() throws Exception {
         assertBusy(() -> {
             final ClusterState state = clusterService().state();
-            for (ObjectObjectCursor<String, IndexRoutingTable> indexRoutingTable : state.routingTable().indicesRouting()) {
-                for (IntObjectCursor<IndexShardRoutingTable> indexShardRoutingTable : indexRoutingTable.value.shards()) {
-                    ShardRouting primaryShardRouting = indexShardRoutingTable.value.primaryShard();
+            for (var indexRoutingTable : state.routingTable().indicesRouting().entrySet()) {
+                for (var indexShardRoutingTable : indexRoutingTable.getValue().shards().values()) {
+                    ShardRouting primaryShardRouting = indexShardRoutingTable.primaryShard();
                     final IndexShard primaryShard = getShardOrNull(state, primaryShardRouting);
                     if (primaryShard == null) {
                         continue; // just ignore - shard movement
@@ -1441,7 +1437,7 @@ public final class InternalTestCluster extends TestCluster {
                         primarySeqNoStats.getGlobalCheckpoint(),
                         not(equalTo(SequenceNumbers.UNASSIGNED_SEQ_NO))
                     );
-                    for (ShardRouting replicaShardRouting : indexShardRoutingTable.value.replicaShards()) {
+                    for (ShardRouting replicaShardRouting : indexShardRoutingTable.replicaShards()) {
                         final IndexShard replicaShard = getShardOrNull(state, replicaShardRouting);
                         if (replicaShard == null) {
                             continue; // just ignore - shard movement
@@ -1471,9 +1467,9 @@ public final class InternalTestCluster extends TestCluster {
     public void assertSameDocIdsOnShards() throws Exception {
         assertBusy(() -> {
             ClusterState state = client().admin().cluster().prepareState().get().getState();
-            for (ObjectObjectCursor<String, IndexRoutingTable> indexRoutingTable : state.routingTable().indicesRouting()) {
-                for (IntObjectCursor<IndexShardRoutingTable> indexShardRoutingTable : indexRoutingTable.value.shards()) {
-                    ShardRouting primaryShardRouting = indexShardRoutingTable.value.primaryShard();
+            for (var indexRoutingTable : state.routingTable().indicesRouting().values()) {
+                for (var indexShardRoutingTable : indexRoutingTable.shards().values()) {
+                    ShardRouting primaryShardRouting = indexShardRoutingTable.primaryShard();
                     IndexShard primaryShard = getShardOrNull(state, primaryShardRouting);
                     if (primaryShard == null) {
                         continue;
@@ -1484,7 +1480,7 @@ public final class InternalTestCluster extends TestCluster {
                     } catch (AlreadyClosedException ex) {
                         continue;
                     }
-                    for (ShardRouting replicaShardRouting : indexShardRoutingTable.value.replicaShards()) {
+                    for (ShardRouting replicaShardRouting : indexShardRoutingTable.replicaShards()) {
                         IndexShard replicaShard = getShardOrNull(state, replicaShardRouting);
                         if (replicaShard == null) {
                             continue;

x-pack/plugin/ccr/src/main/java/org/elasticsearch/xpack/ccr/repository/CcrRepository.java

@@ -7,8 +7,6 @@
 
 package org.elasticsearch.xpack.ccr.repository;
 
-import com.carrotsearch.hppc.cursors.IntObjectCursor;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
@@ -104,7 +102,6 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.LongConsumer;
@@ -262,8 +259,8 @@ public class CcrRepository extends AbstractLifecycleComponent implements Reposit
         imdBuilder.putMapping(leaderIndexMetadata.mapping());
         imdBuilder.setRoutingNumShards(leaderIndexMetadata.getRoutingNumShards());
         // We assert that insync allocation ids are not empty in `PrimaryShardAllocator`
-        for (IntObjectCursor<Set<String>> entry : leaderIndexMetadata.getInSyncAllocationIds()) {
-            imdBuilder.putInSyncAllocationIds(entry.key, Collections.singleton(IN_SYNC_ALLOCATION_ID));
+        for (var key : leaderIndexMetadata.getInSyncAllocationIds().keySet()) {
+            imdBuilder.putInSyncAllocationIds(key, Collections.singleton(IN_SYNC_ALLOCATION_ID));
         }
 
         return imdBuilder.build();

x-pack/plugin/ccr/src/test/java/org/elasticsearch/xpack/ccr/action/AutoFollowCoordinatorTests.java

@@ -6,8 +6,6 @@
  */
 package org.elasticsearch.xpack.ccr.action;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.elasticsearch.Version;
 import org.elasticsearch.action.admin.cluster.state.ClusterStateResponse;
 import org.elasticsearch.action.support.replication.ClusterStateCreationUtils;
@@ -1791,10 +1789,10 @@ public class AutoFollowCoordinatorTests extends ESTestCase {
         assertThat(results, notNullValue());
         assertThat(results.size(), equalTo(1));
 
-        for (ObjectObjectCursor<String, IndexMetadata> index : remoteState.metadata().indices()) {
-            boolean expect = index.value.getState() == IndexMetadata.State.OPEN;
-            assertThat(results.get(0).autoFollowExecutionResults.containsKey(index.value.getIndex()), is(expect));
-            assertThat(followedIndices.contains(index.key), is(expect));
+        for (var index : remoteState.metadata().indices().entrySet()) {
+            boolean expect = index.getValue().getState() == IndexMetadata.State.OPEN;
+            assertThat(results.get(0).autoFollowExecutionResults.containsKey(index.getValue().getIndex()), is(expect));
+            assertThat(followedIndices.contains(index.getKey()), is(expect));
         }
     }
 
@@ -1898,11 +1896,11 @@ public class AutoFollowCoordinatorTests extends ESTestCase {
         final List<String> autoFollowedIndices = autoFollowMetadata.getFollowedLeaderIndexUUIDs().get(pattern);
         assertThat(autoFollowedIndices.size(), equalTo(nbLeaderIndices));
 
-        for (ObjectObjectCursor<String, IndexMetadata> index : remoteState.metadata().indices()) {
-            final Index remoteIndex = index.value.getIndex();
+        for (var index : remoteState.metadata().indices().entrySet()) {
+            final Index remoteIndex = index.getValue().getIndex();
             boolean followed = remoteIndex.getName().startsWith("docs-excluded") == false;
-            assertThat(results.get(0).autoFollowExecutionResults.containsKey(index.value.getIndex()), is(followed));
-            assertThat(followedIndices.contains(index.key), is(followed));
+            assertThat(results.get(0).autoFollowExecutionResults.containsKey(index.getValue().getIndex()), is(followed));
+            assertThat(followedIndices.contains(index.getKey()), is(followed));
             assertThat(autoFollowedIndices.contains(remoteIndex.getUUID()), equalTo(followed));
         }
     }

x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/DataTiersUsageTransportAction.java

@@ -102,12 +102,12 @@ public class DataTiersUsageTransportAction extends XPackUsageFeatureTransportAct
     // Takes a registry of indices and returns a mapping of index name to which tier it most prefers. Always 1 to 1, some may filter out.
     static Map<String, String> tierIndices(ImmutableOpenMap<String, IndexMetadata> indices) {
         Map<String, String> indexByTier = new HashMap<>();
-        indices.forEach(entry -> {
-            String tierPref = entry.value.getSettings().get(DataTier.TIER_PREFERENCE);
+        indices.entrySet().forEach(entry -> {
+            String tierPref = entry.getValue().getSettings().get(DataTier.TIER_PREFERENCE);
             if (Strings.hasText(tierPref)) {
                 String[] tiers = tierPref.split(",");
                 if (tiers.length > 0) {
-                    indexByTier.put(entry.key, tiers[0]);
+                    indexByTier.put(entry.getKey(), tiers[0]);
                 }
             }
         });

x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ilm/WaitForActiveShardsStep.java

@@ -6,8 +6,6 @@
  */
 package org.elasticsearch.xpack.core.ilm;
 
-import com.carrotsearch.hppc.cursors.IntObjectCursor;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.elasticsearch.action.support.ActiveShardCount;
@@ -17,7 +15,6 @@ import org.elasticsearch.cluster.metadata.IndexAbstraction;
 import org.elasticsearch.cluster.metadata.IndexMetadata;
 import org.elasticsearch.cluster.metadata.Metadata;
 import org.elasticsearch.cluster.routing.IndexRoutingTable;
-import org.elasticsearch.cluster.routing.IndexShardRoutingTable;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.index.Index;
 import org.elasticsearch.xcontent.ParseField;
@@ -136,8 +133,8 @@ public class WaitForActiveShardsStep extends ClusterStateWaitStep {
 
         IndexRoutingTable indexRoutingTable = clusterState.routingTable().index(rolledIndexName);
         int currentActiveShards = 0;
-        for (final IntObjectCursor<IndexShardRoutingTable> shardRouting : indexRoutingTable.getShards()) {
-            currentActiveShards += shardRouting.value.activeShards().size();
+        for (var shardRouting : indexRoutingTable.getShards().values()) {
+            currentActiveShards += shardRouting.activeShards().size();
         }
         return new Result(enoughShardsActive, new ActiveShardsInfo(currentActiveShards, activeShardCount.toString(), enoughShardsActive));
     }

x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/cluster/metadata/MetadataMigrateToDataTiersRoutingService.java

@@ -7,8 +7,6 @@
 
 package org.elasticsearch.xpack.cluster.metadata;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.elasticsearch.client.internal.Client;
@@ -513,8 +511,7 @@ public final class MetadataMigrateToDataTiersRoutingService {
         String nodeAttrIndexRequireRoutingSetting = INDEX_ROUTING_REQUIRE_GROUP_SETTING.getKey() + nodeAttrName;
         String nodeAttrIndexIncludeRoutingSetting = INDEX_ROUTING_INCLUDE_GROUP_SETTING.getKey() + nodeAttrName;
         String nodeAttrIndexExcludeRoutingSetting = INDEX_ROUTING_EXCLUDE_GROUP_SETTING.getKey() + nodeAttrName;
-        for (ObjectObjectCursor<String, IndexMetadata> index : currentState.metadata().indices()) {
-            IndexMetadata indexMetadata = index.value;
+        for (var indexMetadata : currentState.metadata().indices().values()) {
             String indexName = indexMetadata.getIndex().getName();
             Settings currentSettings = indexMetadata.getSettings();
 
@@ -645,8 +642,8 @@ public final class MetadataMigrateToDataTiersRoutingService {
 
         List<String> migratedLegacyTemplates = new ArrayList<>();
 
-        for (ObjectObjectCursor<String, IndexTemplateMetadata> templateCursor : clusterState.metadata().templates()) {
-            IndexTemplateMetadata templateMetadata = templateCursor.value;
+        for (var template : clusterState.metadata().templates().entrySet()) {
+            IndexTemplateMetadata templateMetadata = template.getValue();
             if (templateMetadata.settings().keySet().contains(requireRoutingSetting)
                 || templateMetadata.settings().keySet().contains(includeRoutingSetting)) {
                 IndexTemplateMetadata.Builder templateMetadataBuilder = new IndexTemplateMetadata.Builder(templateMetadata);
@@ -657,7 +654,7 @@ public final class MetadataMigrateToDataTiersRoutingService {
                 templateMetadataBuilder.settings(settingsBuilder);
 
                 mb.put(templateMetadataBuilder);
-                migratedLegacyTemplates.add(templateCursor.key);
+                migratedLegacyTemplates.add(template.getKey());
             }
         }
         return migratedLegacyTemplates;

x-pack/plugin/ilm/src/main/java/org/elasticsearch/xpack/ilm/IndexLifecycleUsageTransportAction.java

@@ -72,8 +72,8 @@ public class IndexLifecycleUsageTransportAction extends XPackUsageFeatureTranspo
         final IndexLifecycleFeatureSetUsage usage;
         if (lifecycleMetadata != null) {
             Map<String, Integer> policyUsage = new HashMap<>();
-            metadata.indices().forEach(entry -> {
-                String policyName = entry.value.getLifecyclePolicyName();
+            metadata.indices().values().forEach(value -> {
+                String policyName = value.getLifecyclePolicyName();
                 Integer indicesManaged = policyUsage.get(policyName);
                 if (indicesManaged == null) {
                     indicesManaged = 1;

x-pack/plugin/ml/src/internalClusterTest/java/org/elasticsearch/xpack/ml/integration/AnnotationIndexIT.java

@@ -6,8 +6,6 @@
  */
 package org.elasticsearch.xpack.ml.integration;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.elasticsearch.action.admin.indices.alias.Alias;
 import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
 import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequestBuilder;
@@ -180,12 +178,12 @@ public class AnnotationIndexIT extends MlSingleNodeTestCase {
                 .getAliases();
             assertNotNull(aliases);
             List<String> indicesWithReadAlias = new ArrayList<>();
-            for (ObjectObjectCursor<String, List<AliasMetadata>> entry : aliases) {
-                for (AliasMetadata aliasMetadata : entry.value) {
+            for (var entry : aliases.entrySet()) {
+                for (AliasMetadata aliasMetadata : entry.getValue()) {
                     switch (aliasMetadata.getAlias()) {
-                        case AnnotationIndex.WRITE_ALIAS_NAME -> assertThat(entry.key, is(AnnotationIndex.LATEST_INDEX_NAME));
-                        case AnnotationIndex.READ_ALIAS_NAME -> indicesWithReadAlias.add(entry.key);
-                        default -> fail("Found unexpected alias " + aliasMetadata.getAlias() + " on index " + entry.key);
+                        case AnnotationIndex.WRITE_ALIAS_NAME -> assertThat(entry.getKey(), is(AnnotationIndex.LATEST_INDEX_NAME));
+                        case AnnotationIndex.READ_ALIAS_NAME -> indicesWithReadAlias.add(entry.getKey());
+                        default -> fail("Found unexpected alias " + aliasMetadata.getAlias() + " on index " + entry.getKey());
                     }
                 }
             }
@@ -262,11 +260,11 @@ public class AnnotationIndexIT extends MlSingleNodeTestCase {
             .get()
             .getAliases();
         if (aliases != null) {
-            for (ObjectObjectCursor<String, List<AliasMetadata>> entry : aliases) {
-                for (AliasMetadata aliasMetadata : entry.value) {
+            for (var aliasList : aliases.values()) {
+                for (AliasMetadata aliasMetadata : aliasList) {
                     assertThat("Annotations aliases should be hidden but are not: " + aliases, aliasMetadata.isHidden(), is(true));
                 }
-                count += entry.value.size();
+                count += aliasList.size();
             }
         }
         return count;

x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/MlInitializationService.java

@@ -6,8 +6,6 @@
  */
 package org.elasticsearch.xpack.ml;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.elasticsearch.action.ActionListener;
@@ -36,7 +34,6 @@ import org.elasticsearch.xpack.core.ml.annotations.AnnotationIndex;
 
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -181,13 +178,12 @@ public class MlInitializationService implements ClusterStateListener {
         // Step 4: Extract ML internal aliases that are not hidden and make them hidden.
         ActionListener<GetAliasesResponse> getAliasesResponseListener = ActionListener.wrap(getAliasesResponse -> {
             IndicesAliasesRequest indicesAliasesRequest = new IndicesAliasesRequest();
-            for (ObjectObjectCursor<String, List<AliasMetadata>> entry : getAliasesResponse.getAliases()) {
-                String index = entry.key;
-                for (AliasMetadata existingAliasMetadata : entry.value) {
+            for (var entry : getAliasesResponse.getAliases().entrySet()) {
+                for (AliasMetadata existingAliasMetadata : entry.getValue()) {
                     if (existingAliasMetadata.isHidden() != null && existingAliasMetadata.isHidden()) {
                         continue;
                     }
-                    indicesAliasesRequest.addAliasAction(aliasReplacementAction(index, existingAliasMetadata));
+                    indicesAliasesRequest.addAliasAction(aliasReplacementAction(entry.getKey(), existingAliasMetadata));
                 }
             }
             if (indicesAliasesRequest.getAliasActions().isEmpty()) {

x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/dataframe/MappingsMerger.java

@@ -6,8 +6,6 @@
  */
 package org.elasticsearch.xpack.ml.dataframe;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.action.admin.indices.mapping.get.GetMappingsAction;
 import org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest;
@@ -21,7 +19,6 @@ import org.elasticsearch.xpack.core.ml.dataframe.DataFrameAnalyticsSource;
 import org.elasticsearch.xpack.core.ml.utils.ExceptionsHelper;
 
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.Map;
 import java.util.Objects;
 import java.util.stream.Collectors;
@@ -77,10 +74,8 @@ public final class MappingsMerger {
     ) {
         Map<String, IndexAndMapping> mergedMappings = new HashMap<>();
 
-        Iterator<ObjectObjectCursor<String, MappingMetadata>> iterator = indexToMappings.iterator();
-        while (iterator.hasNext()) {
-            ObjectObjectCursor<String, MappingMetadata> indexMappings = iterator.next();
-            MappingMetadata mapping = indexMappings.value;
+        for (var indexMappings : indexToMappings.entrySet()) {
+            MappingMetadata mapping = indexMappings.getValue();
             if (mapping != null) {
                 Map<String, Object> currentMappings = mapping.getSourceAsMap();
                 if (currentMappings.containsKey(mappingsType.type)) {
@@ -100,14 +95,14 @@ public final class MappingsMerger {
                                         mappingsType.type,
                                         field,
                                         fieldMapping.getValue(),
-                                        indexMappings.key,
+                                        indexMappings.getKey(),
                                         existingIndexAndMapping.mapping,
                                         existingIndexAndMapping.index
                                     );
 
                                 }
                             } else {
-                                mergedMappings.put(field, new IndexAndMapping(indexMappings.key, fieldMapping.getValue()));
+                                mergedMappings.put(field, new IndexAndMapping(indexMappings.getKey(), fieldMapping.getValue()));
                             }
                         }
                     }

x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/dataframe/extractor/ExtractedFieldsDetectorFactory.java

@@ -6,8 +6,6 @@
  */
 package org.elasticsearch.xpack.ml.dataframe.extractor;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
@@ -41,7 +39,6 @@ import org.elasticsearch.xpack.core.ml.utils.ExceptionsHelper;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -190,10 +187,8 @@ public class ExtractedFieldsDetectorFactory {
             Integer minDocValueFieldsLimit = Integer.MAX_VALUE;
 
             ImmutableOpenMap<String, Settings> indexToSettings = getSettingsResponse.getIndexToSettings();
-            Iterator<ObjectObjectCursor<String, Settings>> iterator = indexToSettings.iterator();
-            while (iterator.hasNext()) {
-                ObjectObjectCursor<String, Settings> indexSettings = iterator.next();
-                Integer indexMaxDocValueFields = IndexSettings.MAX_DOCVALUE_FIELDS_SEARCH_SETTING.get(indexSettings.value);
+            for (var indexSettings : indexToSettings.values()) {
+                Integer indexMaxDocValueFields = IndexSettings.MAX_DOCVALUE_FIELDS_SEARCH_SETTING.get(indexSettings);
                 if (indexMaxDocValueFields < minDocValueFieldsLimit) {
                     minDocValueFieldsLimit = indexMaxDocValueFields;
                 }

x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/job/persistence/JobDataDeleter.java

@@ -6,8 +6,6 @@
  */
 package org.elasticsearch.xpack.ml.job.persistence;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.elasticsearch.action.ActionListener;
@@ -28,7 +26,6 @@ import org.elasticsearch.action.support.IndicesOptions;
 import org.elasticsearch.action.support.master.AcknowledgedResponse;
 import org.elasticsearch.client.internal.Client;
 import org.elasticsearch.cluster.ClusterState;
-import org.elasticsearch.cluster.metadata.AliasMetadata;
 import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver;
 import org.elasticsearch.common.util.concurrent.ThreadContext;
 import org.elasticsearch.core.CheckedConsumer;
@@ -497,12 +494,12 @@ public class JobDataDeleter {
     private IndicesAliasesRequest buildRemoveAliasesRequest(GetAliasesResponse getAliasesResponse) {
         Set<String> aliases = new HashSet<>();
         List<String> indices = new ArrayList<>();
-        for (ObjectObjectCursor<String, List<AliasMetadata>> entry : getAliasesResponse.getAliases()) {
+        for (var entry : getAliasesResponse.getAliases().entrySet()) {
             // The response includes _all_ indices, but only those associated with
             // the aliases we asked about will have associated AliasMetadata
-            if (entry.value.isEmpty() == false) {
-                indices.add(entry.key);
-                entry.value.forEach(metadata -> aliases.add(metadata.getAlias()));
+            if (entry.getValue().isEmpty() == false) {
+                indices.add(entry.getKey());
+                entry.getValue().forEach(metadata -> aliases.add(metadata.getAlias()));
             }
         }
         return aliases.isEmpty()

x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/job/persistence/JobResultsProvider.java

@@ -383,7 +383,7 @@ public class JobResultsProvider {
             // Expect one index. If this is not the case then it means the
             // index has been deleted almost immediately after being created, and this is
             // so unlikely that it's reasonable to fail the whole operation.
-            MappingMetadata indexMappings = getMappingsResponse.getMappings().iterator().next().value;
+            MappingMetadata indexMappings = getMappingsResponse.getMappings().values().iterator().next();
             addTermsMapping(indexMappings, indexName, termFields, listener);
         }, listener::onFailure);
 

x-pack/plugin/monitoring/src/main/java/org/elasticsearch/xpack/monitoring/exporter/local/LocalExporter.java

@@ -6,8 +6,6 @@
  */
 package org.elasticsearch.xpack.monitoring.exporter.local;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
@@ -21,7 +19,6 @@ import org.elasticsearch.cluster.ClusterChangedEvent;
 import org.elasticsearch.cluster.ClusterState;
 import org.elasticsearch.cluster.ClusterStateListener;
 import org.elasticsearch.cluster.block.ClusterBlockLevel;
-import org.elasticsearch.cluster.metadata.IndexMetadata;
 import org.elasticsearch.cluster.metadata.IndexTemplateMetadata;
 import org.elasticsearch.cluster.routing.IndexRoutingTable;
 import org.elasticsearch.cluster.service.ClusterService;
@@ -627,8 +624,8 @@ public class LocalExporter extends Exporter implements ClusterStateListener, Cle
             currents.add(MonitoringTemplateRegistry.ALERTS_INDEX_TEMPLATE_NAME);
 
             Set<String> indices = new HashSet<>();
-            for (ObjectObjectCursor<String, IndexMetadata> index : clusterState.getMetadata().indices()) {
-                String indexName = index.key;
+            for (var index : clusterState.getMetadata().indices().entrySet()) {
+                String indexName = index.getKey();
 
                 if (Regex.simpleMatch(indexPatterns, indexName)) {
                     // Never delete any "current" index (e.g., today's index or the most recent version no timestamp, like alerts)
@@ -636,7 +633,7 @@ public class LocalExporter extends Exporter implements ClusterStateListener, Cle
                         continue;
                     }
 
-                    long creationDate = index.value.getCreationDate();
+                    long creationDate = index.getValue().getCreationDate();
                     if (creationDate <= expirationTimeMillis) {
                         if (logger.isDebugEnabled()) {
                             logger.debug(

x-pack/plugin/ql/src/main/java/org/elasticsearch/xpack/ql/index/IndexResolver.java

@@ -6,8 +6,6 @@
  */
 package org.elasticsearch.xpack.ql.index;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.elasticsearch.ElasticsearchSecurityException;
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest;
@@ -656,9 +654,8 @@ public class IndexResolver {
 
         Set<String> resolvedAliases = new HashSet<>();
         if (aliases != null) {
-            Iterator<ObjectObjectCursor<String, List<AliasMetadata>>> iterator = aliases.iterator();
-            while (iterator.hasNext()) {
-                for (AliasMetadata alias : iterator.next().value) {
+            for (var aliasList : aliases.values()) {
+                for (AliasMetadata alias : aliasList) {
                     resolvedAliases.add(alias.getAlias());
                 }
             }
@@ -838,13 +835,11 @@ public class IndexResolver {
         Map<String, Set<String>> typesErrors = new HashMap<>(); // map holding aliases and a list of unique field types across its indices
         Map<String, Set<String>> aliasToIndices = new HashMap<>(); // map with aliases and their list of indices
 
-        Iterator<ObjectObjectCursor<String, List<AliasMetadata>>> iter = aliases.iterator();
-        while (iter.hasNext()) {
-            ObjectObjectCursor<String, List<AliasMetadata>> index = iter.next();
-            for (AliasMetadata aliasMetadata : index.value) {
+        for (var entry : aliases.entrySet()) {
+            for (AliasMetadata aliasMetadata : entry.getValue()) {
                 String aliasName = aliasMetadata.alias();
                 aliasToIndices.putIfAbsent(aliasName, new HashSet<>());
-                aliasToIndices.get(aliasName).add(index.key);
+                aliasToIndices.get(aliasName).add(entry.getKey());
             }
         }
 

x-pack/plugin/rollup/src/main/java/org/elasticsearch/xpack/rollup/action/TransportGetRollupCapsAction.java

@@ -6,8 +6,6 @@
  */
 package org.elasticsearch.xpack.rollup.action;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.action.support.ActionFilters;
 import org.elasticsearch.action.support.HandledTransportAction;
@@ -48,10 +46,10 @@ public class TransportGetRollupCapsAction extends HandledTransportAction<GetRoll
 
     static Map<String, RollableIndexCaps> getCaps(String indexPattern, ImmutableOpenMap<String, IndexMetadata> indices) {
         Map<String, List<RollupJobCaps>> allCaps = new TreeMap<>();
-        for (ObjectObjectCursor<String, IndexMetadata> entry : indices) {
+        for (var entry : indices.entrySet()) {
 
             // Does this index have rollup metadata?
-            TransportGetRollupCapsAction.findRollupIndexCaps(entry.key, entry.value).ifPresent(cap -> {
+            TransportGetRollupCapsAction.findRollupIndexCaps(entry.getKey(), entry.getValue()).ifPresent(cap -> {
 
                 List<RollupJobCaps> jobCaps;
                 if (indexPattern.equals(Metadata.ALL)) {

x-pack/plugin/watcher/src/internalClusterTest/java/org/elasticsearch/xpack/watcher/history/HistoryTemplateTimeMappingsTests.java

@@ -6,8 +6,6 @@
  */
 package org.elasticsearch.xpack.watcher.history;
 
-import com.carrotsearch.hppc.cursors.ObjectObjectCursor;
-
 import org.elasticsearch.ElasticsearchParseException;
 import org.elasticsearch.action.admin.indices.mapping.get.GetMappingsResponse;
 import org.elasticsearch.action.support.IndicesOptions;
@@ -55,15 +53,15 @@ public class HistoryTemplateTimeMappingsTests extends AbstractWatcherIntegration
                 .get();
             assertThat(mappingsResponse, notNullValue());
             assertThat(mappingsResponse.getMappings().isEmpty(), is(false));
-            for (ObjectObjectCursor<String, MappingMetadata> metadatas : mappingsResponse.getMappings()) {
-                if (metadatas.key.startsWith(HistoryStoreField.INDEX_PREFIX) == false) {
+            for (var metadatas : mappingsResponse.getMappings().entrySet()) {
+                if (metadatas.getKey().startsWith(HistoryStoreField.INDEX_PREFIX) == false) {
                     continue;
                 }
-                MappingMetadata metadata = metadatas.value;
+                MappingMetadata metadata = metadatas.getValue();
                 assertThat(metadata, notNullValue());
                 try {
                     Map<String, Object> source = metadata.getSourceAsMap();
-                    logger.info("checking index [{}] with metadata:\n[{}]", metadatas.key, metadata.source().toString());
+                    logger.info("checking index [{}] with metadata:\n[{}]", metadatas.getKey(), metadata.source().toString());
                     assertThat(extractValue("properties.trigger_event.properties.type.type", source), is((Object) "keyword"));
                     assertThat(extractValue("properties.trigger_event.properties.triggered_time.type", source), is((Object) "date"));
                     assertThat(

x-pack/plugin/watcher/src/internalClusterTest/java/org/elasticsearch/xpack/watcher/test/AbstractWatcherIntegrationTestCase.java

@@ -296,9 +296,9 @@ public abstract class AbstractWatcherIntegrationTestCase extends ESIntegTestCase
         if (watchesIsAlias) {
             GetAliasesResponse aliasesResponse = client().admin().indices().prepareGetAliases(originalIndexOrAlias).get();
             assertEquals(1, aliasesResponse.getAliases().size());
-            aliasesResponse.getAliases().forEach((aliasRecord) -> {
-                assertEquals(1, aliasRecord.value.size());
-                originalIndex.set(aliasRecord.key);
+            aliasesResponse.getAliases().entrySet().forEach((aliasRecord) -> {
+                assertEquals(1, aliasRecord.getValue().size());
+                originalIndex.set(aliasRecord.getKey());
             });
         }
         client().admin().indices().prepareDelete(originalIndex.get()).get();