@SuppressWarnings({"unchecked", "rawtypes"}) protected void visitMap(Map<?, ?> mapVal) { Map newContent = new LinkedHashMap(); boolean entriesModified = false; for (Map.Entry entry : mapVal.entrySet()) { Object key = entry.getKey(); int keyHash = (key != null ? key.hashCode() : 0); Object newKey = resolveValue(key); int newKeyHash = (newKey != null ? newKey.hashCode() : 0); Object val = entry.getValue(); Object newVal = resolveValue(val); newContent.put(newKey, newVal); entriesModified = entriesModified || (newVal != val || newKey != key || newKeyHash != keyHash); } if (entriesModified) { mapVal.clear(); mapVal.putAll(newContent); } }
public static void resetExtensionLoader(Class type) { ExtensionLoader loader = EXTENSION_LOADERS.get(type); if (loader != null) { // Remove all instances associated with this loader as well Map<String, Class<?>> classes = loader.getExtensionClasses(); for (Map.Entry<String, Class<?>> entry : classes.entrySet()) { EXTENSION_INSTANCES.remove(entry.getValue()); } classes.clear(); EXTENSION_LOADERS.remove(type); } }
public void testStandardEntrySet() throws InvocationTargetException { @SuppressWarnings("unchecked") final Map<String, Boolean> map = mock(Map.class); Map<String, Boolean> forward = new ForwardingMap<String, Boolean>() { @Override protected Map<String, Boolean> delegate() { return map; } @Override public Set<Entry<String, Boolean>> entrySet() { return new StandardEntrySet() { @Override public Iterator<Entry<String, Boolean>> iterator() { return Iterators.emptyIterator(); } }; } }; callAllPublicMethods(new TypeToken<Set<Entry<String, Boolean>>>() {}, forward.entrySet()); // These are the methods specified by StandardEntrySet verify(map, atLeast(0)).clear(); verify(map, atLeast(0)).containsKey(anyObject()); verify(map, atLeast(0)).get(anyObject()); verify(map, atLeast(0)).isEmpty(); verify(map, atLeast(0)).remove(anyObject()); verify(map, atLeast(0)).size(); verifyNoMoreInteractions(map); }
@SuppressWarnings({ "rawtypes", "unchecked" }) public void setContextMap(Map contextMap) { Map old = org.apache.log4j.MDC.getContext(); if (old == null) { Iterator entrySetIterator = contextMap.entrySet().iterator(); while (entrySetIterator.hasNext()) { Map.Entry mapEntry = (Map.Entry) entrySetIterator.next(); org.apache.log4j.MDC.put((String) mapEntry.getKey(), mapEntry.getValue()); } } else { old.clear(); old.putAll(contextMap); } } }
public void testStandardValues() throws InvocationTargetException { @SuppressWarnings("unchecked") final Map<String, Boolean> map = mock(Map.class); Map<String, Boolean> forward = new ForwardingMap<String, Boolean>() { @Override protected Map<String, Boolean> delegate() { return map; } @Override public Collection<Boolean> values() { return new StandardValues(); } }; callAllPublicMethods(new TypeToken<Collection<Boolean>>() {}, forward.values()); // These are the methods specified by StandardValues verify(map, atLeast(0)).clear(); verify(map, atLeast(0)).containsValue(anyObject()); verify(map, atLeast(0)).isEmpty(); verify(map, atLeast(0)).size(); verify(map, atLeast(0)).entrySet(); verifyNoMoreInteractions(map); }
@Override public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) { this.delegate.replaceAll(function); inverse.delegate.clear(); Entry<K, V> broken = null; Iterator<Entry<K, V>> itr = this.delegate.entrySet().iterator(); while (itr.hasNext()) { Entry<K, V> entry = itr.next(); K k = entry.getKey(); V v = entry.getValue(); K conflict = inverse.delegate.putIfAbsent(v, k); if (conflict != null) { broken = entry; // We're definitely going to throw, but we'll try to keep the BiMap in an internally // consistent state by removing the bad entry. itr.remove(); } } if (broken != null) { throw new IllegalArgumentException("value already present: " + broken.getValue()); } }
/** * @param cmpId component ID. */ private void reinitNodeSpecData(int cmpId) { nodeSpecificData.clear(); for (Map.Entry<UUID, Map<Integer, Serializable>> e : DiscoveryDataBag.this.nodeSpecificData.entrySet()) { if (e.getValue() != null && e.getValue().containsKey(cmpId)) nodeSpecificData.put(e.getKey(), e.getValue().get(cmpId)); } } }
/** * Set the default headers to add to all requests made by this builder * instance. These values will replace any previously set default headers. * * @param headers map of header names & values. */ public void setHeaders(Map<?, ?> headers) { this.defaultRequestHeaders.clear(); if (headers == null) return; for (Object key : headers.keySet()) { Object val = headers.get(key); if (val == null) continue; this.defaultRequestHeaders.put(key.toString(), val.toString()); } }
/** * Configure path prefixes to apply to controller methods. * <p>Prefixes are used to enrich the mappings of every {@code @RequestMapping} * method whose controller type is matched by a corresponding * {@code Predicate} in the map. The prefix for the first matching predicate * is used, assuming the input map has predictable order. * <p>Consider using {@link org.springframework.web.method.HandlerTypePredicate * HandlerTypePredicate} to group controllers. * @param prefixes a map with path prefixes as key * @since 5.1 * @see org.springframework.web.method.HandlerTypePredicate */ public void setPathPrefixes(Map<String, Predicate<Class<?>>> prefixes) { this.pathPrefixes.clear(); prefixes.entrySet().stream() .filter(entry -> StringUtils.hasText(entry.getKey())) .forEach(entry -> this.pathPrefixes.put(entry.getKey(), entry.getValue())); }
public static void resetExtensionLoader(Class type) { ExtensionLoader loader = EXTENSION_LOADERS.get(type); if (loader != null) { // Remove all instances associated with this loader as well Map<String, Class<?>> classes = loader.getExtensionClasses(); for (Map.Entry<String, Class<?>> entry : classes.entrySet()) { EXTENSION_INSTANCES.remove(entry.getValue()); } classes.clear(); EXTENSION_LOADERS.remove(type); } }
public Map<String, List<ExprNodeDesc>> getResidualPredicates(boolean clear) { Map<String, List<ExprNodeDesc>> oldExprs = new HashMap<String, List<ExprNodeDesc>>(); for (Map.Entry<String, List<ExprNodeDesc>> entry : nonFinalPreds.entrySet()) { List<ExprNodeDesc> converted = new ArrayList<ExprNodeDesc>(); for (ExprNodeDesc newExpr : entry.getValue()) { converted.add(newToOldExprMap.get(newExpr)); } oldExprs.put(entry.getKey(), converted); } if (clear) { nonFinalPreds.clear(); } return oldExprs; }
public static <K,R,S,T> Map<K, R> zipWith(Function2<R,S,T> fn, Map<K, S> m1, Map<K, T> m2, Map<K, R> results){ Set<K> keySet = new HashSet<K>(); keySet.addAll(m1.keySet()); keySet.addAll(m2.keySet()); results.clear(); for (K key : keySet) { results.put(key, fn.eval(m1.get(key), m2.get(key))); } return results; }