public Okv set(Map map) { super.putAll(map); return this; }
public Okv set(Okv okv) { super.putAll(okv); return this; }
public void put(HttpHeaders headers) { if (headers != null) { if (headers.headersMap != null && !headers.headersMap.isEmpty()) headersMap.putAll(headers.headersMap); } }
public JZDataSource(LinkedHashMap urlsMap) { this.urlsMap.clear(); this.urlsMap.putAll(urlsMap); currentUrlIndex = 0; }
public JZDataSource(LinkedHashMap urlsMap, String title) { this.urlsMap.clear(); this.urlsMap.putAll(urlsMap); this.title = title; currentUrlIndex = 0; }
public Map<String, ScalarTypeDefinition> scalars() { LinkedHashMap<String, ScalarTypeDefinition> scalars = new LinkedHashMap<>(ScalarInfo.STANDARD_SCALAR_DEFINITIONS); scalars.putAll(scalarTypes); return scalars; }
public void addAggregationExprsForClause(String clause, LinkedHashMap<String, ASTNode> aggregationTrees) { if (destToAggregationExprs.containsKey(clause)) { destToAggregationExprs.get(clause).putAll(aggregationTrees); } else { destToAggregationExprs.put(clause, aggregationTrees); } }
@VisibleForTesting static ImmutableMap<File, ClassLoader> getClassPathEntries(ClassLoader classloader) { LinkedHashMap<File, ClassLoader> entries = Maps.newLinkedHashMap(); // Search parent first, since it's the order ClassLoader#loadClass() uses. ClassLoader parent = classloader.getParent(); if (parent != null) { entries.putAll(getClassPathEntries(parent)); } for (URL url : getClassLoaderUrls(classloader)) { if (url.getProtocol().equals("file")) { File file = toFile(url); if (!entries.containsKey(file)) { entries.put(file, classloader); } } } return ImmutableMap.copyOf(entries); }
public RowResolver duplicate() { RowResolver resolver = new RowResolver(); resolver.rowSchema = new RowSchema(rowSchema); resolver.rslvMap.putAll(rslvMap); resolver.invRslvMap.putAll(invRslvMap); resolver.altInvRslvMap.putAll(altInvRslvMap); resolver.expressionMap.putAll(expressionMap); resolver.isExprResolver = isExprResolver; resolver.ambiguousColumns.putAll(ambiguousColumns); resolver.checkForAmbiguity = checkForAmbiguity; return resolver; }
@Override protected LinkedHashMap<String, Callable<? extends ChannelHandler>> getChannelHandlers(MessageInput input) { final LinkedHashMap<String, Callable<? extends ChannelHandler>> handlers = new LinkedHashMap<>(super.getChannelHandlers(input)); handlers.put("traffic-counter", () -> throughputCounter); handlers.put("udp-datagram", () -> DatagramPacketHandler.INSTANCE); handlers.putAll(getChildChannelHandlers(input)); return handlers; }
@Override protected LinkedHashMap<String, Callable<? extends ChannelHandler>> getCustomChildChannelHandlers(MessageInput input) { final LinkedHashMap<String, Callable<? extends ChannelHandler>> childChannelHandlers = new LinkedHashMap<>(); childChannelHandlers.put("framer", () -> new LenientDelimiterBasedFrameDecoder(maxFrameLength, delimiter)); childChannelHandlers.putAll(super.getCustomChildChannelHandlers(input)); return childChannelHandlers; }
static public Map<String, Object> getAllValues() { LinkedHashMap<String, Object> m = new LinkedHashMap<>(); for (ServerMetrics metric : ServerMetrics.values()) { m.putAll(metric.getValues()); } return m; }
private void resolveWaitingFutures() { final LinkedHashMap<CustomSettableFuture, Counter> waitingFuturesCopy = new LinkedHashMap<>(); synchronized (waitingFutures) { waitingFuturesCopy.putAll(waitingFutures); waitingFutures.clear(); } for (Map.Entry<CustomSettableFuture, Counter> e : waitingFuturesCopy.entrySet()) { try { e.getKey().set(getRequestsSinceWithoutWait(e.getValue())); } catch (Exception ex) { e.getKey().setException(ex); } } }
public void replaceAllEntriesInCacheWith(List<GoDashboardPipeline> newPipelinesToCache) { cache.clear(); cache.putAll(createMapFor(newPipelinesToCache)); cacheHasChanged(); }
void replaceAllEntriesInCacheWith(List<ProjectStatus> projectStatuses) { this.cache.clear(); this.cache.putAll(createReplacementItems(projectStatuses)); cacheHasChanged(); }
@VisibleForTesting static ImmutableMap<File, ClassLoader> getClassPathEntries(ClassLoader classloader) { LinkedHashMap<File, ClassLoader> entries = Maps.newLinkedHashMap(); // Search parent first, since it's the order ClassLoader#loadClass() uses. ClassLoader parent = classloader.getParent(); if (parent != null) { entries.putAll(getClassPathEntries(parent)); } for (URL url : getClassLoaderUrls(classloader)) { if (url.getProtocol().equals("file")) { File file = toFile(url); if (!entries.containsKey(file)) { entries.put(file, classloader); } } } return ImmutableMap.copyOf(entries); }
Many(final Credential c1, final Many subsequent) { LinkedHashMap<Key, Credential> map = new LinkedHashMap<>(subsequent.map.size() + 1); map.put(Key.of(c1), c1); map.putAll(subsequent.map); this.map = map; int hc = 0; for (Credential credential : map.values()) { hc ^= typeHash(credential); } hashCode = hc; assert size() > 2; }
public void putAll(List<ProjectStatus> statuses) { cache.putAll(createReplacementItems(statuses)); cacheHasChanged(); }
@VisibleForTesting static ImmutableMap<File, ClassLoader> getClassPathEntries(ClassLoader classloader) { LinkedHashMap<File, ClassLoader> entries = Maps.newLinkedHashMap(); // Search parent first, since it's the order ClassLoader#loadClass() uses. ClassLoader parent = classloader.getParent(); if (parent != null) { entries.putAll(getClassPathEntries(parent)); } for (URL url : getClassLoaderUrls(classloader)) { if (url.getProtocol().equals("file")) { File file = toFile(url); if (!entries.containsKey(file)) { entries.put(file, classloader); } } } return ImmutableMap.copyOf(entries); }