Java MapBuilder类代码示例

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
public CodecService(@Nullable MapperService mapperService, Logger logger) {
    final MapBuilder<String, Codec> codecs = MapBuilder.<String, Codec>newMapBuilder();
    if (mapperService == null) {
        codecs.put(DEFAULT_CODEC, new Lucene62Codec());
        codecs.put(BEST_COMPRESSION_CODEC, new Lucene62Codec(Mode.BEST_COMPRESSION));
    } else {
        codecs.put(DEFAULT_CODEC,
                new PerFieldMappingPostingFormatCodec(Mode.BEST_SPEED, mapperService, logger));
        codecs.put(BEST_COMPRESSION_CODEC,
                new PerFieldMappingPostingFormatCodec(Mode.BEST_COMPRESSION, mapperService, logger));
    }
    codecs.put(LUCENE_DEFAULT_CODEC, Codec.getDefault());
    for (String codec : Codec.availableCodecs()) {
        codecs.put(codec, Codec.forName(codec));
    }
    this.codecs = codecs.immutableMap();
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
/**
 * Adds mapping that will be added when the index gets created.
 *
 * @param type   The mapping type
 * @param source The mapping source
 */
@SuppressWarnings("unchecked")
public CreateIndexRequest mapping(String type, Map source) {
    if (mappings.containsKey(type)) {
        throw new IllegalStateException("mappings for type \"" + type + "\" were already defined");
    }
    // wrap it in a type map if its not
    if (source.size() != 1 || !source.containsKey(type)) {
        source = MapBuilder.<String, Object>newMapBuilder().put(type, source).map();
    }
    try {
        XContentBuilder builder = XContentFactory.contentBuilder(XContentType.JSON);
        builder.map(source);
        return mapping(type, builder);
    } catch (IOException e) {
        throw new ElasticsearchGenerationException("Failed to generate [" + source + "]", e);
    }
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
@Override
public Map<String, BlobMetaData> listBlobsByPrefix(String account, LocationMode mode, String container, String keyPath, String prefix) throws URISyntaxException, StorageException {
    // NOTE: this should be here: if (prefix == null) prefix = "";
    // however, this is really inefficient since deleteBlobsByPrefix enumerates everything and
    // then does a prefix match on the result; it should just call listBlobsByPrefix with the prefix!

    logger.debug("listing container [{}], keyPath [{}], prefix [{}]", container, keyPath, prefix);
    MapBuilder<String, BlobMetaData> blobsBuilder = MapBuilder.newMapBuilder();
    CloudBlobClient client = this.getSelectedClient(account, mode);
    CloudBlobContainer blobContainer = client.getContainerReference(container);

    SocketAccess.doPrivilegedVoidException(() -> {
        if (blobContainer.exists()) {
            for (ListBlobItem blobItem : blobContainer.listBlobs(keyPath + (prefix == null ? "" : prefix))) {
                URI uri = blobItem.getUri();
                logger.trace("blob url [{}]", uri);

                // uri.getPath is of the form /container/keyPath.* and we want to strip off the /container/
                // this requires 1 + container.length() + 1, with each 1 corresponding to one of the /
                String blobPath = uri.getPath().substring(1 + container.length() + 1);

                CloudBlockBlob blob = blobContainer.getBlockBlobReference(blobPath);

                // fetch the blob attributes from Azure (getBlockBlobReference does not do this)
                // this is needed to retrieve the blob length (among other metadata) from Azure Storage
                blob.downloadAttributes();

                BlobProperties properties = blob.getProperties();
                String name = blobPath.substring(keyPath.length());
                logger.trace("blob url [{}], name [{}], size [{}]", uri, name, properties.getLength());
                blobsBuilder.put(name, new PlainBlobMetaData(name, properties.getLength()));
            }
        }
    });

    return blobsBuilder.immutableMap();
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
@Override
public Map<String, BlobMetaData> listBlobsByPrefix(String account, LocationMode mode, String container, String keyPath, String prefix) {
    MapBuilder<String, BlobMetaData> blobsBuilder = MapBuilder.newMapBuilder();
    blobs.forEach((String blobName, ByteArrayOutputStream bos) -> {
        final String checkBlob;
        if (keyPath != null && !keyPath.isEmpty()) {
            // strip off key path from the beginning of the blob name
            checkBlob = blobName.replace(keyPath, "");
        } else {
            checkBlob = blobName;
        }
        if (prefix == null || startsWithIgnoreCase(checkBlob, prefix)) {
            blobsBuilder.put(blobName, new PlainBlobMetaData(checkBlob, bos.size()));
        }
    });
    return blobsBuilder.immutableMap();
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
private CodecService(Index index, Settings indexSettings, MapperService mapperService) {
    super(index, indexSettings);
    this.mapperService = mapperService;
    MapBuilder<String, Codec> codecs = MapBuilder.<String, Codec>newMapBuilder();
    if (mapperService == null) {
        codecs.put(DEFAULT_CODEC, new Lucene54Codec());
        codecs.put(BEST_COMPRESSION_CODEC, new Lucene54Codec(Mode.BEST_COMPRESSION));
    } else {
        codecs.put(DEFAULT_CODEC, 
                new PerFieldMappingPostingFormatCodec(Mode.BEST_SPEED, mapperService, logger));
        codecs.put(BEST_COMPRESSION_CODEC, 
                new PerFieldMappingPostingFormatCodec(Mode.BEST_COMPRESSION, mapperService, logger));
    }
    codecs.put(LUCENE_DEFAULT_CODEC, Codec.getDefault());
    for (String codec : Codec.availableCodecs()) {
        codecs.put(codec, Codec.forName(codec));
    }
    this.codecs = codecs.immutableMap();
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
@Override
public ImmutableMap<String, BlobMetaData> listBlobsByPrefix(String blobNamePrefix) throws IOException {
    // using MapBuilder and not ImmutableMap.Builder as it seems like File#listFiles might return duplicate files!
    MapBuilder<String, BlobMetaData> builder = MapBuilder.newMapBuilder();

    blobNamePrefix = blobNamePrefix == null ? "" : blobNamePrefix;
    try (DirectoryStream<Path> stream = Files.newDirectoryStream(path, blobNamePrefix + "*")) {
        for (Path file : stream) {
            final BasicFileAttributes attrs = Files.readAttributes(file, BasicFileAttributes.class);
            if (attrs.isRegularFile()) {
                builder.put(file.getFileName().toString(), new PlainBlobMetaData(file.getFileName().toString(), attrs.size()));
            }
        }
    }
    return builder.immutableMap();
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
/**
 * Adds mapping that will be added when the index gets created.
 *
 * @param type   The mapping type
 * @param source The mapping source
 */
@SuppressWarnings("unchecked")
public CreateIndexRequest mapping(String type, Map source) {
    if (mappings.containsKey(type)) {
        throw new IllegalStateException("mappings for type \"" + type + "\" were already defined");
    }
    // wrap it in a type map if its not
    if (source.size() != 1 || !source.containsKey(type)) {
        source = MapBuilder.<String, Object>newMapBuilder().put(type, source).map();
    }
    try {
        XContentBuilder builder = XContentFactory.contentBuilder(XContentType.JSON);
        builder.map(source);
        return mapping(type, builder.string());
    } catch (IOException e) {
        throw new ElasticsearchGenerationException("Failed to generate [" + source + "]", e);
    }
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
@Test
public void testMapAccess() {
    Map<String, Object> vars = new HashMap<String, Object>();

    Map<String, Object> obj2 = MapBuilder.<String, Object>newMapBuilder().put("prop2", "value2").map();
    Map<String, Object> obj1 = MapBuilder.<String, Object>newMapBuilder().put("prop1", "value1").put("obj2", obj2).put("l", Lists.newArrayList("2", "1")).map();
    vars.put("obj1", obj1);
    Object o = se.execute(se.compile("obj1"), vars);
    assertThat(o, instanceOf(Map.class));
    obj1 = (Map<String, Object>) o;
    assertThat((String) obj1.get("prop1"), equalTo("value1"));
    assertThat((String) ((Map<String, Object>) obj1.get("obj2")).get("prop2"), equalTo("value2"));

    o = se.execute(se.compile("obj1.l[0]"), vars);
    assertThat(((String) o), equalTo("2"));
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
@Test
public void testAccessListInScript() {
    Map<String, Object> vars = new HashMap<String, Object>();
    Map<String, Object> obj2 = MapBuilder.<String, Object>newMapBuilder().put("prop2", "value2").map();
    Map<String, Object> obj1 = MapBuilder.<String, Object>newMapBuilder().put("prop1", "value1").put("obj2", obj2).map();
    vars.put("l", Lists.newArrayList("1", "2", "3", obj1));

    Object o = se.execute(se.compile("l.length"), vars);
    assertThat(((Number) o).intValue(), equalTo(4));

    o = se.execute(se.compile("l[0]"), vars);
    assertThat(((String) o), equalTo("1"));

    o = se.execute(se.compile("l[3]"), vars);
    obj1 = (Map<String, Object>) o;
    assertThat((String) obj1.get("prop1"), equalTo("value1"));
    assertThat((String) ((Map<String, Object>) obj1.get("obj2")).get("prop2"), equalTo("value2"));

    o = se.execute(se.compile("l[3].prop1"), vars);
    assertThat(((String) o), equalTo("value1"));
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
@Override
public Map<String, BlobMetaData> listBlobsByPrefix(
    String blobNamePrefix) throws IOException {
    try {
        final Vector<LsEntry> entries = blobStore.getClient().ls(path());
        if (entries.isEmpty()) {
            return new HashMap<>();
        }

        final String namePrefix = blobNamePrefix == null ? ""
            : blobNamePrefix;
        final MapBuilder<String, BlobMetaData> builder = MapBuilder
            .newMapBuilder();
        for (final LsEntry entry : entries) {
            if (entry.getAttrs().isReg()
                && entry.getFilename().startsWith(namePrefix)) {
                builder.put(entry.getFilename(), new PlainBlobMetaData(
                    entry.getFilename(), entry.getAttrs().getSize()));
            }
        }
        return builder.immutableMap();
    } catch (Exception e) {
        throw new IOException("Failed to load files in " + path().buildAsString("/"), e);
    }
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
public CommitStats(SegmentInfos segmentInfos) {
    // clone the map to protect against concurrent changes
    userData = MapBuilder.<String, String>newMapBuilder().putAll(segmentInfos.getUserData()).immutableMap();
    // lucene calls the current generation, last generation.
    generation = segmentInfos.getLastGeneration();
    id = Base64.getEncoder().encodeToString(segmentInfos.getId());
    numDocs = Lucene.getNumDocs(segmentInfos);
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
@Override
public void readFrom(StreamInput in) throws IOException {
    MapBuilder<String, String> builder = MapBuilder.newMapBuilder();
    for (int i = in.readVInt(); i > 0; i--) {
        builder.put(in.readString(), in.readString());
    }
    userData = builder.immutableMap();
    generation = in.readLong();
    id = in.readOptionalString();
    numDocs = in.readInt();
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
public void clear() {
    totalStats.clear();
    synchronized (this) {
        if (!groupsStats.isEmpty()) {
            MapBuilder<String, StatsHolder> typesStatsBuilder = MapBuilder.newMapBuilder();
            for (Map.Entry<String, StatsHolder> typeStats : groupsStats.entrySet()) {
                if (typeStats.getValue().totalCurrent() > 0) {
                    typeStats.getValue().clear();
                    typesStatsBuilder.put(typeStats.getKey(), typeStats.getValue());
                }
            }
            groupsStats = typesStatsBuilder.immutableMap();
        }
    }
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
private StatsHolder groupStats(String group) {
    StatsHolder stats = groupsStats.get(group);
    if (stats == null) {
        synchronized (this) {
            stats = groupsStats.get(group);
            if (stats == null) {
                stats = new StatsHolder();
                groupsStats = MapBuilder.newMapBuilder(groupsStats).put(group, stats).immutableMap();
            }
        }
    }
    return stats;
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入依赖的package包/类
private StatsHolder typeStats(String type) {
    StatsHolder stats = typesStats.get(type);
    if (stats == null) {
        synchronized (this) {
            stats = typesStats.get(type);
            if (stats == null) {
                stats = new StatsHolder();
                typesStats = MapBuilder.newMapBuilder(typesStats).put(type, stats).immutableMap();
            }
        }
    }
    return stats;
}