Java MapBuilder.put方法代码示例

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包/类
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包/类
@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包/类
@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 void addFieldMapper(String field, FieldMapper fieldMapper, MapBuilder<String, FieldMappingMetaData> fieldMappings, boolean includeDefaults) {
    if (fieldMappings.containsKey(field)) {
        return;
    }
    try {
        XContentBuilder builder = XContentFactory.contentBuilder(XContentType.JSON);
        builder.startObject();
        fieldMapper.toXContent(builder, includeDefaults ? includeDefaultsParams : ToXContent.EMPTY_PARAMS);
        builder.endObject();
        fieldMappings.put(field, new FieldMappingMetaData(fieldMapper.fieldType().name(), builder.bytes()));
    } catch (IOException e) {
        throw new ElasticsearchException("failed to serialize XContent of field [" + field + "]", e);
    }
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入方法依赖的package包/类
private CrateComponentLoader(Settings settings) {
    ServiceLoader<CrateComponent> crateComponents = ServiceLoader.load(CrateComponent.class);
    plugins = new ArrayList<>();
    MapBuilder<Plugin, List<OnModuleReference>> onModuleReferences = MapBuilder.newMapBuilder();
    for (CrateComponent crateComponent : crateComponents) {
        logger.trace("Loading crateComponent: {}", crateComponent);
        Plugin plugin = crateComponent.createPlugin(settings);
        plugins.add(plugin);
        List<OnModuleReference> list = Lists.newArrayList();
        for (Method method : plugin.getClass().getDeclaredMethods()) {
            if (!method.getName().equals("onModule")) {
                continue;
            }
            if (method.getParameterTypes().length == 0 || method.getParameterTypes().length > 1) {
                logger.warn("Plugin: {} implementing onModule with no parameters or more than one parameter", plugin.name());
                continue;
            }
            Class moduleClass = method.getParameterTypes()[0];
            if (!Module.class.isAssignableFrom(moduleClass)) {
                logger.warn("Plugin: {} implementing onModule by the type is not of Module type {}", plugin.name(), moduleClass);
                continue;
            }
            method.setAccessible(true);
            //noinspection unchecked
            list.add(new OnModuleReference(moduleClass, method));
        }
        if (!list.isEmpty()) {
            onModuleReferences.put(plugin, list);
        }
    }
    this.onModuleReferences = onModuleReferences.immutableMap();
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入方法依赖的package包/类
/**
 * Registers the given stream and associate it with the given types.
 *
 * @param stream    The streams to register
 * @param types     The types associated with the streams
 */
public static synchronized void registerStream(Stream stream, BytesReference... types) {
    MapBuilder<BytesReference, Stream> uStreams = MapBuilder.newMapBuilder(streams);
    for (BytesReference type : types) {
        uStreams.put(type, stream);
    }
    streams = uStreams.immutableMap();
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入方法依赖的package包/类
/**
 * Registers the given stream and associate it with the given types.
 *
 * @param stream    The streams to register
 * @param types     The types associated with the streams
 */
public static synchronized void registerStream(Stream stream, BytesReference... types) {
    MapBuilder<BytesReference, Stream> uStreams = MapBuilder.newMapBuilder(STREAMS);
    for (BytesReference type : types) {
        uStreams.put(type, stream);
    }
    STREAMS = uStreams.immutableMap();
}
 

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

import org.elasticsearch.common.collect.MapBuilder; //导入方法依赖的package包/类
@Inject
public TransportProxyClient(Settings settings, TransportService transportService, TransportClientNodesService nodesService, Map<String, GenericAction> actions) {
    this.nodesService = nodesService;
    MapBuilder<Action, TransportActionNodeProxy> actionsBuilder = new MapBuilder<>();
    for (GenericAction action : actions.values()) {
        if (action instanceof Action) {
            actionsBuilder.put((Action) action, new TransportActionNodeProxy(settings, action, transportService));
        }
    }
    this.proxies = actionsBuilder.immutableMap();
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入方法依赖的package包/类
@Inject
public JvmMonitorService(Settings settings, ThreadPool threadPool) {
    super(settings);
    this.threadPool = threadPool;

    this.enabled = this.settings.getAsBoolean("monitor.jvm.enabled", true);
    this.interval = this.settings.getAsTime("monitor.jvm.interval", timeValueSeconds(1));

    MapBuilder<String, GcThreshold> gcThresholds = MapBuilder.newMapBuilder();
    Map<String, Settings> gcThresholdGroups = this.settings.getGroups("monitor.jvm.gc");
    for (Map.Entry<String, Settings> entry : gcThresholdGroups.entrySet()) {
        String name = entry.getKey();
        TimeValue warn = entry.getValue().getAsTime("warn", null);
        TimeValue info = entry.getValue().getAsTime("info", null);
        TimeValue debug = entry.getValue().getAsTime("debug", null);
        if (warn == null || info == null || debug == null) {
            logger.warn("ignoring gc_threshold for [{}], missing warn/info/debug values", name);
        } else {
            gcThresholds.put(name, new GcThreshold(name, warn.millis(), info.millis(), debug.millis()));
        }
    }
    if (!gcThresholds.containsKey(GcNames.YOUNG)) {
        gcThresholds.put(GcNames.YOUNG, new GcThreshold(GcNames.YOUNG, 1000, 700, 400));
    }
    if (!gcThresholds.containsKey(GcNames.OLD)) {
        gcThresholds.put(GcNames.OLD, new GcThreshold(GcNames.OLD, 10000, 5000, 2000));
    }
    if (!gcThresholds.containsKey("default")) {
        gcThresholds.put("default", new GcThreshold("default", 10000, 5000, 2000));
    }

    this.gcThresholds = gcThresholds.immutableMap();

    logger.debug("enabled [{}], interval [{}], gc_threshold [{}]", enabled, interval, this.gcThresholds);
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入方法依赖的package包/类
private void addFieldMapper(String field, FieldMapper fieldMapper, MapBuilder<String, FieldMappingMetaData> fieldMappings, boolean includeDefaults) {
    if (fieldMappings.containsKey(field)) {
        return;
    }
    try {
        XContentBuilder builder = XContentFactory.contentBuilder(XContentType.JSON);
        builder.startObject();
        fieldMapper.toXContent(builder, includeDefaults ? includeDefaultsParams : ToXContent.EMPTY_PARAMS);
        builder.endObject();
        fieldMappings.put(field, new FieldMappingMetaData(fieldMapper.fieldType().names().fullName(), builder.bytes()));
    } catch (IOException e) {
        throw new ElasticsearchException("failed to serialize XContent of field [" + field + "]", e);
    }
}
 

import org.elasticsearch.common.collect.MapBuilder; //导入方法依赖的package包/类
@Inject
@SuppressWarnings("unchecked")
public ProxyActionMap(Settings settings, TransportService transportService, Map<String, GenericAction> actions) {
    MapBuilder<Action, TransportActionNodeProxy> actionsBuilder = new MapBuilder<>();
    for (GenericAction action : actions.values()) {
        if (action instanceof Action) {
            actionsBuilder.put((Action) action, new TransportActionNodeProxy(settings, action, transportService));
        }
    }
    this.proxies = actionsBuilder.immutableMap();
}