Java ObjectObjectCursor类代码示例

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
@Override
public void writeTo(final StreamOutput out) throws IOException {
    out.writeVInt(termStatistics.size());

    for (ObjectObjectCursor<Term, TermStatistics> c : termStatistics()) {
        Term term = c.key;
        out.writeString(term.field());
        out.writeBytesRef(term.bytes());
        TermStatistics stats = c.value;
        out.writeBytesRef(stats.term());
        out.writeVLong(stats.docFreq());
        out.writeVLong(DfsSearchResult.addOne(stats.totalTermFreq()));
    }

    DfsSearchResult.writeFieldStats(out, fieldStatistics);
    out.writeVLong(maxDoc);
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
@Override
public void writeTo(StreamOutput out) throws IOException {
    out.writeVLong(count);
    out.writeLong(memoryInBytes);
    out.writeLong(termsMemoryInBytes);
    out.writeLong(storedFieldsMemoryInBytes);
    out.writeLong(termVectorsMemoryInBytes);
    out.writeLong(normsMemoryInBytes);
    out.writeLong(pointsMemoryInBytes);
    out.writeLong(docValuesMemoryInBytes);
    out.writeLong(indexWriterMemoryInBytes);
    out.writeLong(versionMapMemoryInBytes);
    out.writeLong(bitsetMemoryInBytes);
    out.writeLong(maxUnsafeAutoIdTimestamp);

    out.writeVInt(fileSizes.size());
    for (ObjectObjectCursor<String, Long> entry : fileSizes) {
        out.writeString(entry.key);
        out.writeLong(entry.value.longValue());
    }
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
private Table buildTable(RestRequest request, ClusterStateResponse clusterStateResponse, String patternString) {
    Table table = getTableWithHeader(request);
    MetaData metadata = clusterStateResponse.getState().metaData();
    for (ObjectObjectCursor<String, IndexTemplateMetaData> entry : metadata.templates()) {
        IndexTemplateMetaData indexData = entry.value;
        if (patternString == null || Regex.simpleMatch(patternString, indexData.name())) {
            table.startRow();
            table.addCell(indexData.name());
            table.addCell("[" + String.join(", ", indexData.patterns()) + "]");
            table.addCell(indexData.getOrder());
            table.addCell(indexData.getVersion());
            table.endRow();
        }
    }
    return table;
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
private Table buildTable(RestRequest request, GetAliasesResponse response) {
    Table table = getTableWithHeader(request);

    for (ObjectObjectCursor<String, List<AliasMetaData>> cursor : response.getAliases()) {
        String indexName = cursor.key;
        for (AliasMetaData aliasMetaData : cursor.value) {
            table.startRow();
            table.addCell(aliasMetaData.alias());
            table.addCell(indexName);
            table.addCell(aliasMetaData.filteringRequired() ? "*" : "-");
            String indexRouting = Strings.hasLength(aliasMetaData.indexRouting()) ? aliasMetaData.indexRouting() : "-";
            table.addCell(indexRouting);
            String searchRouting = Strings.hasLength(aliasMetaData.searchRouting()) ? aliasMetaData.searchRouting() : "-";
            table.addCell(searchRouting);
            table.endRow();
        }
    }

    return table;
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
/**
 * Fills the shard fetched data with new (data) nodes and a fresh NodeEntry, and removes from
 * it nodes that are no longer part of the state.
 */
private void fillShardCacheWithDataNodes(Map<String, NodeEntry<T>> shardCache, DiscoveryNodes nodes) {
    // verify that all current data nodes are there
    for (ObjectObjectCursor<String, DiscoveryNode> cursor : nodes.getDataNodes()) {
        DiscoveryNode node = cursor.value;
        if (shardCache.containsKey(node.getId()) == false) {
            shardCache.put(node.getId(), new NodeEntry<T>(node.getId()));
        }
    }
    // remove nodes that are not longer part of the data nodes set
    for (Iterator<String> it = shardCache.keySet().iterator(); it.hasNext(); ) {
        String nodeId = it.next();
        if (nodes.nodeExists(nodeId) == false) {
            it.remove();
        }
    }
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
private static ImmutableLevelHolder[] generateLevelHolders(Set<ClusterBlock> global,
                                                           ImmutableOpenMap<String, Set<ClusterBlock>> indicesBlocks) {
    ImmutableLevelHolder[] levelHolders = new ImmutableLevelHolder[ClusterBlockLevel.values().length];
    for (final ClusterBlockLevel level : ClusterBlockLevel.values()) {
        Predicate<ClusterBlock> containsLevel = block -> block.contains(level);
        Set<ClusterBlock> newGlobal = unmodifiableSet(global.stream()
            .filter(containsLevel)
            .collect(toSet()));

        ImmutableOpenMap.Builder<String, Set<ClusterBlock>> indicesBuilder = ImmutableOpenMap.builder();
        for (ObjectObjectCursor<String, Set<ClusterBlock>> entry : indicesBlocks) {
            indicesBuilder.put(entry.key, unmodifiableSet(entry.value.stream()
                .filter(containsLevel)
                .collect(toSet())));
        }

        levelHolders[level.id()] = new ImmutableLevelHolder(newGlobal, indicesBuilder.build());
    }
    return levelHolders;
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
@Override
public void writeTo(StreamOutput out) throws IOException {
    out.writeVInt(entries.size());
    for (Entry entry : entries) {
        entry.snapshot().writeTo(out);
        out.writeBoolean(entry.includeGlobalState());
        out.writeBoolean(entry.partial());
        out.writeByte(entry.state().value());
        out.writeVInt(entry.indices().size());
        for (IndexId index : entry.indices()) {
            index.writeTo(out);
        }
        out.writeLong(entry.startTime());
        out.writeVInt(entry.shards().size());
        for (ObjectObjectCursor<ShardId, ShardSnapshotStatus> shardEntry : entry.shards()) {
            shardEntry.key.writeTo(out);
            out.writeOptionalString(shardEntry.value.nodeId());
            out.writeByte(shardEntry.value.state().value());
        }
        if (out.getVersion().onOrAfter(REPOSITORY_ID_INTRODUCED_VERSION)) {
            out.writeLong(entry.repositoryStateId);
        }
    }
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public void writeTo(StreamOutput out) throws IOException {
    out.writeVInt(entries.size());
    for (Entry entry : entries) {
        entry.snapshot().writeTo(out);
        out.writeByte(entry.state().value());
        out.writeVInt(entry.indices().size());
        for (String index : entry.indices()) {
            out.writeString(index);
        }
        out.writeVInt(entry.shards().size());
        for (ObjectObjectCursor<ShardId, ShardRestoreStatus> shardEntry : entry.shards()) {
            shardEntry.key.writeTo(out);
            shardEntry.value.writeTo(out);
        }
    }
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
/**
 * Returns a set of custom meta data types when any custom metadata for the cluster has changed
 * between the previous cluster state and the new cluster state. custom meta data types are
 * returned iff they have been added, updated or removed between the previous and the current state
 */
public Set<String> changedCustomMetaDataSet() {
    Set<String> result = new HashSet<>();
    ImmutableOpenMap<String, MetaData.Custom> currentCustoms = state.metaData().customs();
    ImmutableOpenMap<String, MetaData.Custom> previousCustoms = previousState.metaData().customs();
    if (currentCustoms.equals(previousCustoms) == false) {
        for (ObjectObjectCursor<String, MetaData.Custom> currentCustomMetaData : currentCustoms) {
            // new custom md added or existing custom md changed
            if (previousCustoms.containsKey(currentCustomMetaData.key) == false
                    || currentCustomMetaData.value.equals(previousCustoms.get(currentCustomMetaData.key)) == false) {
                result.add(currentCustomMetaData.key);
            }
        }
        // existing custom md deleted
        for (ObjectObjectCursor<String, MetaData.Custom> previousCustomMetaData : previousCustoms) {
            if (currentCustoms.containsKey(previousCustomMetaData.key) == false) {
                result.add(previousCustomMetaData.key);
            }
        }
    }
    return result;
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
/**
 * Check if any of the indices to be closed are currently being restored from a snapshot and fail closing if such an index
 * is found as closing an index that is being restored makes the index unusable (it cannot be recovered).
 */
public static void checkIndexClosing(ClusterState currentState, Set<IndexMetaData> indices) {
    RestoreInProgress restore = currentState.custom(RestoreInProgress.TYPE);
    if (restore != null) {
        Set<Index> indicesToFail = null;
        for (RestoreInProgress.Entry entry : restore.entries()) {
            for (ObjectObjectCursor<ShardId, RestoreInProgress.ShardRestoreStatus> shard : entry.shards()) {
                if (!shard.value.state().completed()) {
                    IndexMetaData indexMetaData = currentState.metaData().index(shard.key.getIndex());
                    if (indexMetaData != null && indices.contains(indexMetaData)) {
                        if (indicesToFail == null) {
                            indicesToFail = new HashSet<>();
                        }
                        indicesToFail.add(shard.key.getIndex());
                    }
                }
            }
        }
        if (indicesToFail != null) {
            throw new IllegalArgumentException("Cannot close indices that are being restored: " + indicesToFail);
        }
    }
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
@Override
protected void masterOperation(GetIndexTemplatesRequest request, ClusterState state, ActionListener<GetIndexTemplatesResponse> listener) {
    List<IndexTemplateMetaData> results;

    // If we did not ask for a specific name, then we return all templates
    if (request.names().length == 0) {
        results = Arrays.asList(state.metaData().templates().values().toArray(IndexTemplateMetaData.class));
    } else {
        results = new ArrayList<>();
    }

    for (String name : request.names()) {
        if (Regex.isSimpleMatchPattern(name)) {
            for (ObjectObjectCursor<String, IndexTemplateMetaData> entry : state.metaData().templates()) {
                if (Regex.simpleMatch(name, entry.key)) {
                    results.add(entry.value);
                }
            }
        } else if (state.metaData().templates().containsKey(name)) {
            results.add(state.metaData().templates().get(name));
        }
    }

    listener.onResponse(new GetIndexTemplatesResponse(results));
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeVInt(storeStatuses.size());
    for (ObjectObjectCursor<String, ImmutableOpenIntMap<List<StoreStatus>>> indexShards : storeStatuses) {
        out.writeString(indexShards.key);
        out.writeVInt(indexShards.value.size());
        for (IntObjectCursor<List<StoreStatus>> shardStatusesEntry : indexShards.value) {
            out.writeInt(shardStatusesEntry.key);
            out.writeVInt(shardStatusesEntry.value.size());
            for (StoreStatus storeStatus : shardStatusesEntry.value) {
                storeStatus.writeTo(out);
            }
        }
    }
    out.writeVInt(failures.size());
    for (ShardOperationFailedException failure : failures) {
        failure.writeTo(out);
    }
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
private void sendSetBanRequest(DiscoveryNodes nodes, BanParentTaskRequest request, ActionListener<Void> listener) {
    for (ObjectObjectCursor<String, DiscoveryNode> node : nodes.getNodes()) {
        logger.trace("Sending ban for tasks with the parent [{}] to the node [{}], ban [{}]", request.parentTaskId, node.key,
            request.ban);
        transportService.sendRequest(node.value, BAN_PARENT_ACTION_NAME, request,
            new EmptyTransportResponseHandler(ThreadPool.Names.SAME) {
                @Override
                public void handleResponse(TransportResponse.Empty response) {
                    listener.onResponse(null);
                }

                @Override
                public void handleException(TransportException exp) {
                    logger.warn("Cannot send ban for tasks with the parent [{}] to the node [{}]", request.parentTaskId, node.key);
                    listener.onFailure(exp);
                }
            });
    }
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
public void testSegmentsStatsIncludingFileSizes() throws Exception {
    try (Store store = createStore();
        Engine engine = createEngine(defaultSettings, store, createTempDir(), NoMergePolicy.INSTANCE)) {
        assertThat(engine.segmentsStats(true).getFileSizes().size(), equalTo(0));

        ParsedDocument doc = testParsedDocument("1", "test", null, testDocumentWithTextField(), B_1, null);
        engine.index(indexForDoc(doc));
        engine.refresh("test");

        SegmentsStats stats = engine.segmentsStats(true);
        assertThat(stats.getFileSizes().size(), greaterThan(0));
        assertThat(() -> stats.getFileSizes().valuesIt(), everyItem(greaterThan(0L)));

        ObjectObjectCursor<String, Long> firstEntry = stats.getFileSizes().iterator().next();

        ParsedDocument doc2 = testParsedDocument("2", "test", null, testDocumentWithTextField(), B_2, null);
        engine.index(indexForDoc(doc2));
        engine.refresh("test");

        assertThat(engine.segmentsStats(true).getFileSizes().get(firstEntry.key), greaterThan(firstEntry.value));
    }
}
 

import com.carrotsearch.hppc.cursors.ObjectObjectCursor; //导入依赖的package包/类
public void testCloseIndexDefaultBehaviour() throws Exception {
    if (randomBoolean()) {
        Settings settings = Settings.builder()
                .put(DestructiveOperations.REQUIRES_NAME_SETTING.getKey(), false)
                .build();
        assertAcked(client().admin().cluster().prepareUpdateSettings().setTransientSettings(settings));
    }

    createIndex("index1", "1index");

    if (randomBoolean()) {
        assertAcked(client().admin().indices().prepareClose("_all").get());
    } else {
        assertAcked(client().admin().indices().prepareClose("*").get());
    }

    ClusterState state = client().admin().cluster().prepareState().get().getState();
    for (ObjectObjectCursor<String, IndexMetaData> indexMetaDataObjectObjectCursor : state.getMetaData().indices()) {
        assertEquals(IndexMetaData.State.CLOSE, indexMetaDataObjectObjectCursor.value.getState());
    }
}