private static void patchHiDPI(UIDefaults defaults) { if (!JBUI.isHiDPI()) return; List<String> myIntKeys = Arrays.asList("Tree.leftChildIndent", "Tree.rightChildIndent"); List<String> patched = new ArrayList<String>(); for (Map.Entry<Object, Object> entry : defaults.entrySet()) { Object value = entry.getValue(); String key = entry.getKey().toString(); if (value instanceof DimensionUIResource) { entry.setValue(JBUI.size((DimensionUIResource) value).asUIResource()); } else if (value instanceof InsetsUIResource) { entry.setValue(JBUI.insets(((InsetsUIResource) value)).asUIResource()); } else if (value instanceof Integer) { if (key.endsWith(".maxGutterIconWidth") || myIntKeys.contains(key)) { if (!"true".equals(defaults.get(key + ".hidpi.patched"))) { entry.setValue(Integer.valueOf(JBUI.scale((Integer) value))); patched.add(key); } } } } for (String key : patched) { defaults.put(key + ".hidpi.patched", "true"); } }
/** * Utility method that replaces the values of a {@link Map}, which must be instances of {@link * List}, with unmodifiable equivalents. * * @param map The map whose values are to be made unmodifiable. */ protected static void makeMappedListsUnmodifiable(Map map) { for (Iterator it = map.entrySet().iterator(); it.hasNext(); ) { Map.Entry entry = (Map.Entry) it.next(); List value = (List) entry.getValue(); if (value.size() == 0) { entry.setValue(Collections.EMPTY_LIST); } else { entry.setValue(Collections.unmodifiableList(value)); } } }
/* * (non-Javadoc) * * @see jaskell.compiler.JaskellVisitor#visit(jaskell.compiler.core.Module) */ public Object visit(Namespace a) { /* set current namespace */ ns = a; /* * visit definitions We set an infinite loop to cope with modifications * introduced by visiting sub expressions. When something is modified - * through lift - we restart the whole process. TODO : change this to defer * registering new bindings at end */ while (true) { try { Iterator it = a.getAllBindings().entrySet().iterator(); while (it.hasNext()) { Map.Entry entry = (Map.Entry) it.next(); String functionName = (String) entry.getKey(); Expression def = (Expression) entry.getValue(); if (def instanceof Abstraction) ((Abstraction) def).setClassName(ns.getName() + "." + functionName); log.finest("Analyzing lifting for " + functionName); lift = false; entry.setValue((Expression) def.visit(this)); } break; } catch (ConcurrentModificationException cmex) { /* restart the process */ } } return a; }
private void resolveVariables(Context ctx, Properties initProps) { for (Map.Entry<Object, Object> entry : initProps.entrySet()) { if (entry.getValue() != null) { entry.setValue(ctx.replaceTokens((String) entry.getValue())); } } }
public void testSimple() throws Exception { File tmp = new File("tmp"); PersistentMap<String> pm = new PersistentMap<String>(new File(tmp, "simple"), String.class); try { assertNull(pm.put("abc", "def")); assertEquals("def", pm.get("abc")); pm.close(); PersistentMap<String> pm2 = new PersistentMap<String>(new File(tmp, "simple"), String.class); assertEquals("def", pm2.get("abc")); assertEquals(Arrays.asList("abc"), new ArrayList<String>(pm2.keySet())); for (Map.Entry<String, String> e : pm2.entrySet()) { e.setValue("XXX"); } assertEquals("XXX", pm2.get("abc")); pm2.close(); } finally { pm.close(); IO.delete(tmp); } }
public static HashMap<Character, Integer> Count( ArrayList<String> inputList, ArrayList<Character> inputCharList) { ArrayList<String> tempList = inputList; ArrayList<Character> tempCharList = inputCharList; HashMap<Character, Integer> result = new HashMap<Character, Integer>(); for (int i = 0; i < 33; i++) { result.put(tempCharList.get(i), 0); } for (int i = 0; i < 10; i++) { char[] listItemToCharArray = tempList.get(i).toCharArray(); for (Map.Entry<Character, Integer> pair : result.entrySet()) { for (int j = 0; j < listItemToCharArray.length; j++) { if (listItemToCharArray[j] == pair.getKey()) { int charCount = pair.getValue(); charCount++; pair.setValue(charCount); } } } } return result; }
private void makePriorInfluence(Map<String, Double> probabilites) { if (probabilites != null) { model.priorDenominator++; for (Map.Entry<String, Double> e : model.categoryPriors.entrySet()) { e.setValue(e.getValue() + probabilites.get(e.getKey())); } } }
private void undoPriorInfluence(Map<String, Double> probabilites) { if (probabilites != null && probabilites.size() > 0) { model.priorDenominator--; for (Map.Entry<String, Double> e : model.categoryPriors.entrySet()) { e.setValue(e.getValue() - probabilites.get(e.getKey())); } } }
// Called with lock held protected void flushAccumulatedCredits() { if (accumulated_credits > 0) { for (Map.Entry<Address, Long> entry : this.credits.entrySet()) { entry.setValue(Math.max(0, entry.getValue().longValue() - accumulated_credits)); } accumulated_credits = 0; } }
/* * (non-Javadoc) * * @see jaskell.compiler.JaskellVisitor#visit(jaskell.compiler.core.Alternative) */ public Object visit(Alternative a) { Iterator it = a.getChoices(); while (it.hasNext()) { Map.Entry entry = (Map.Entry) it.next(); Expression body = (Expression) entry.getValue(); entry.setValue(body.visit(this)); } return a; }
@Test public void main() { Map m = new AHTMap(); m.put(key, oldValue); Map.Entry e = (Map.Entry) m.entrySet().iterator().next(); Object returnVal = e.setValue(newValue); assertTrue(returnVal.equals(oldValue)); assertEquals(m.get(key), newValue); }
protected void initAuFeatureMap() { if (definitionMap.containsKey(DefinableArchivalUnit.KEY_AU_FEATURE_URL_MAP)) { Map<String, ?> featMap = definitionMap.getMap(DefinableArchivalUnit.KEY_AU_FEATURE_URL_MAP); for (Map.Entry ent : featMap.entrySet()) { Object val = ent.getValue(); if (val instanceof Map) { ent.setValue(MapUtil.expandAlternativeKeyLists((Map) val)); } } } }
public void replenishAll() { lock.lock(); try { flushAccumulatedCredits(); for (Map.Entry<Address, Long> entry : credits.entrySet()) entry.setValue(max_credits); min_credits = computeLowestCredit(); credits_available.signalAll(); } finally { lock.unlock(); } }
/** * Decrements credits bytes from all elements and add new_credits to member (if non null). The * lowest credit needs to be greater than min_credits. Needs to be called with lock held * * @param member The member to which new_credits are added. NOP if null * @param new_credits Number of bytes to add to member. NOP if 0. */ protected void decrementAndAdd(Address member, long new_credits) { boolean replenish = member != null && new_credits > 0; if (accumulated_credits > 0) { for (Map.Entry<Address, Long> entry : this.credits.entrySet()) { entry.setValue(Math.max(0, entry.getValue().longValue() - accumulated_credits)); if (replenish) { Address tmp = entry.getKey(); if (tmp.equals(member)) entry.setValue(Math.min(max_credits, entry.getValue().longValue() + new_credits)); } } accumulated_credits = 0; } else { if (replenish) { Long val = this.credits.get(member); if (val != null) this.credits.put(member, Math.min(max_credits, val.longValue() + new_credits)); } } }
/** * Assumes the input map always has String keys and the values are of types: String, Version, * Long, Double or List of the previous types. Lists are copied and Version objects are converted * to String objects. */ private static Map<String, Object> newAttributesMapDTO(Map<String, Object> map) { Map<String, Object> dto = new HashMap<String, Object>(map); /* Lists are copied and Version objects are converted to String objects. */ for (Map.Entry<String, Object> entry : dto.entrySet()) { Object value = entry.getValue(); if (value instanceof Version) { entry.setValue(String.valueOf(value)); continue; } if (value instanceof List) { List<Object> newList = new ArrayList<Object>((List<?>) value); for (ListIterator<Object> iter = newList.listIterator(); iter.hasNext(); ) { Object element = iter.next(); if (element instanceof Version) { iter.set(String.valueOf(element)); } } entry.setValue(newList); continue; } } return dto; }
public static void main(String[] args) { long start = System.currentTimeMillis(); Scanner input = new Scanner(System.in); int numberOfTestCases = input.nextInt(); ArrayList<Integer> order = new ArrayList<Integer>(numberOfTestCases); int previousKey = -1; int previousValue = 0; int cycleNumber = 0; Map<Integer, Integer> testCases = new TreeMap<Integer, Integer>(); for (int i = 0; i < numberOfTestCases; i++) { int numberOfCycles = input.nextInt(); testCases.put(numberOfCycles, 1); order.add(numberOfCycles); } for (Map.Entry<Integer, Integer> entry : testCases.entrySet()) { int numberOfCycles; int initialHeight; if (previousKey == -1) { numberOfCycles = entry.getKey(); initialHeight = entry.getValue(); } else { numberOfCycles = entry.getKey() - previousKey; initialHeight = previousValue; } for (int i = 0; i < numberOfCycles; i++) { if (cycleNumber % 2 == 0) { initialHeight *= 2; } else { initialHeight += 1; } cycleNumber++; } entry.setValue(initialHeight); previousKey = entry.getKey(); previousValue = initialHeight; } for (Integer element : order) { System.out.println(testCases.get(element)); } long elapsed = System.currentTimeMillis() - start; System.out.println("time: " + elapsed); }
public Expression transform(Expression exp) { if (exp == null) return null; if (exp.getClass() == VariableExpression.class) { return transformVariableExpression((VariableExpression) exp); } if (exp.getClass() == BinaryExpression.class) { return transformBinaryExpression((BinaryExpression) exp); } if (exp.getClass() == PropertyExpression.class) { return transformPropertyExpression((PropertyExpression) exp); } if (exp.getClass() == MethodCallExpression.class) { return transformMethodCallExpression((MethodCallExpression) exp); } if (exp.getClass() == ClosureExpression.class) { return transformClosureExpression((ClosureExpression) exp); } if (exp.getClass() == ConstructorCallExpression.class) { return transformConstructorCallExpression((ConstructorCallExpression) exp); } if (exp.getClass() == ArgumentListExpression.class) { Expression result = exp.transformExpression(this); if (inPropertyExpression) { foundArgs = result; } return result; } if (exp instanceof ConstantExpression) { Expression result = exp.transformExpression(this); if (inPropertyExpression) { foundConstant = result; } if (inAnnotation && exp instanceof AnnotationConstantExpression) { ConstantExpression ce = (ConstantExpression) result; if (ce.getValue() instanceof AnnotationNode) { // replicate a little bit of AnnotationVisitor here // because we can't wait until later to do this AnnotationNode an = (AnnotationNode) ce.getValue(); Map<String, Expression> attributes = an.getMembers(); for (Map.Entry<String, Expression> entry : attributes.entrySet()) { Expression attrExpr = transform(entry.getValue()); entry.setValue(attrExpr); } } } return result; } return exp.transformExpression(this); }
@Test public void canUseEntrySet() { Map<String, String> map = new HashMap<>(); map.put("key1", "value1"); map.put("key2", "value2"); map.put("key3", "value3"); Set<Map.Entry<String, String>> entries = map.entrySet(); for (Map.Entry<String, String> entry : entries) { entry.setValue("bob"); } assertEquals("bob", map.get("key1")); assertEquals("bob", map.get("key2")); assertEquals("bob", map.get("key3")); }
// This function will add elements in timeoutTargets boolean timeout() { timeoutTargets.clear(); for (Map.Entry<ActorRef, Boolean> probeEntry : probes.entrySet()) { if (!probeEntry.getValue()) { int timeoutTime = timeoutTimes.get(probeEntry.getKey()); ++timeoutTime; System.out.println("Timeout!!!!!!!!!!!!!!!!!!TimeoutTime: " + timeoutTime); if (timeoutTime >= reactionFactor) { timeoutTargets.offer(probeEntry.getKey()); timeoutTimes.put(probeEntry.getKey(), 0); // It's time to do split, we don't want the history } else timeoutTimes.put(probeEntry.getKey(), timeoutTime); } probeEntry.setValue(false); } ++currentId; // Probes with old id will be treated as timeout probe return !timeoutTargets.isEmpty(); }
private void refreshLineMarkers() { for (Map.Entry<RangeMarker, LineMarkerInfo> entry : myLineMarkerInfos.entrySet()) { RangeMarker rangeMarker = entry.getKey(); int startOffset = rangeMarker.getStartOffset(); int endOffset = rangeMarker.getEndOffset(); LineMarkerInfo value = entry.getValue(); PsiElement element = value.getElement(); assert element != null : value; TextRange range = new TextRange(startOffset, endOffset); final String tooltip = value.getLineMarkerTooltip(); LineMarkerInfo markerInfo = new LineMarkerInfo<>( element, range, null, value.updatePass, e -> tooltip, null, GutterIconRenderer.Alignment.RIGHT); entry.setValue(markerInfo); } }
void bar(List<String> list, HashMap<String, Integer> map) { char c = "a".charAt(0); byte b = new Integer(10).byteValue(); int i = new Double(10.1).intValue(); float f = new Double(10.1).floatValue(); long l = new Double(10.1).longValue(); short s = new Double(10.1).shortValue(); try { String removed = list.remove(10); Boolean isRemoved = list.remove("a"); } catch (Exception e) { System.err.println(e.getMessage()); throw new RuntimeException(e.getCause()); } for (Map.Entry<String, Integer> entry : map.entrySet()) { String key = entry.getKey(); Integer value = entry.getValue(); entry.setValue(value + 1); } }
/** * Removes all members from a given view which don't have us in their view * (https://jira.jboss.org/browse/JGRP-1061). Example: * * <pre> * A: AB * B: AB * C: ABC * </pre> * * becomes * * <pre> * A: AB * B: AB * C: C // A and B don't have C in their views * </pre> * * @param map A map of members and their associated views */ public static void sanitizeViews(Map<Address, View> map) { if (map == null) return; for (Map.Entry<Address, View> entry : map.entrySet()) { Address key = entry.getKey(); Collection<Address> members = new ArrayList<Address>(entry.getValue().getMembers()); boolean modified = false; for (Iterator<Address> it = members.iterator(); it.hasNext(); ) { Address val = it.next(); if (val.equals(key)) // we can always talk to ourself ! continue; View view = map.get(val); final Collection<Address> tmp_mbrs = view != null ? view.getMembers() : null; if (tmp_mbrs != null && !tmp_mbrs.contains(key)) { it.remove(); modified = true; } } if (modified) { View old_view = entry.getValue(); entry.setValue(new View(old_view.getVid(), members)); } } }
private void refreshLineMarkers() { for (Map.Entry<RangeMarker, LineMarkerInfo> entry : lineMarkerInfos.entrySet()) { RangeMarker rangeMarker = entry.getKey(); int startOffset = rangeMarker.getStartOffset(); int endOffset = rangeMarker.getEndOffset(); final LineMarkerInfo value = entry.getValue(); LineMarkerInfo markerInfo = new LineMarkerInfo<PsiElement>( value.getElement(), new TextRange(startOffset, endOffset), null, value.updatePass, new Function<PsiElement, String>() { @Override public String fun(PsiElement psiElement) { return value.getLineMarkerTooltip(); } }, null, GutterIconRenderer.Alignment.RIGHT); entry.setValue(markerInfo); } }
/** pollLastEntry returns entries in order */ public void testDescendingPollLastEntry() { ConcurrentNavigableMap map = dmap5(); Map.Entry e = map.pollLastEntry(); assertEquals(m5, e.getKey()); assertEquals("E", e.getValue()); e = map.pollLastEntry(); assertEquals(m4, e.getKey()); map.put(m5, "E"); e = map.pollLastEntry(); assertEquals(m5, e.getKey()); assertEquals("E", e.getValue()); e = map.pollLastEntry(); assertEquals(m3, e.getKey()); map.remove(m2); e = map.pollLastEntry(); assertEquals(m1, e.getKey()); try { e.setValue("E"); shouldThrow(); } catch (UnsupportedOperationException success) { } e = map.pollLastEntry(); assertNull(e); }
/** pollLastEntry returns entries in order */ public void testPollLastEntry() { ConcurrentNavigableMap map = map5(); Map.Entry e = map.pollLastEntry(); assertEquals(five, e.getKey()); assertEquals("E", e.getValue()); e = map.pollLastEntry(); assertEquals(four, e.getKey()); map.put(five, "E"); e = map.pollLastEntry(); assertEquals(five, e.getKey()); assertEquals("E", e.getValue()); e = map.pollLastEntry(); assertEquals(three, e.getKey()); map.remove(two); e = map.pollLastEntry(); assertEquals(one, e.getKey()); try { e.setValue("E"); shouldThrow(); } catch (UnsupportedOperationException success) { } e = map.pollLastEntry(); assertNull(e); }
public Object setValue(Object o) { if (!predicate.evaluate(o)) { throw new IllegalArgumentException("Cannot set value - Predicate rejected it"); } return entry.setValue(o); }
private void recalculateWalkMap() { for (Map.Entry<Point, Integer> entry : walkAt.entrySet()) { entry.setValue(getMinesNear(entry.getKey())); } }
public V setValue(V value) { V old = internalEntry.getValue(); Checker.checkType(value); internalEntry.setValue(value); return old; }
static void twoMapTest2(Map s, Object[] key, Object[] absent) { int size = key.length; Map s2 = newMap(); putAllTest("Add Absent ", size, s, s2); putAllTest("Modify Present ", size, s, s2); Object lastkey = kitTest(s2, size); Object hold = s2.get(lastkey); int sum = 0; timer.start("Traverse entry ", size * 12); // 12 until finish int sh1 = s.hashCode() - s2.hashCode(); reallyAssert(sh1 == 0); boolean eq1 = s2.equals(s); boolean eq2 = s.equals(s2); reallyAssert(eq1 && eq2); Set es2 = s2.entrySet(); for (Iterator it = s.entrySet().iterator(); it.hasNext(); ) { Object entry = it.next(); if (es2.contains(entry)) ++sum; } reallyAssert(sum == size); s2.put(lastkey, MISSING); int sh2 = s.hashCode() - s2.hashCode(); reallyAssert(sh2 != 0); eq1 = s2.equals(s); eq2 = s.equals(s2); reallyAssert(!eq1 && !eq2); sum = 0; for (Iterator it = s.entrySet().iterator(); it.hasNext(); ) { Map.Entry e = (Map.Entry) it.next(); e.setValue(absent[sum++]); } reallyAssert(sum == size); for (Iterator it = s2.entrySet().iterator(); it.hasNext(); ) { Map.Entry e = (Map.Entry) it.next(); e.setValue(s.get(e.getKey())); } timer.finish(); int rmiss = 0; timer.start("Remove Present ", size * 2); Iterator s2i = s2.entrySet().iterator(); Set es = s.entrySet(); while (s2i.hasNext()) { if (!es.remove(s2i.next())) ++rmiss; } timer.finish(); reallyAssert(rmiss == 0); clrTest(size, s2); reallyAssert(s2.isEmpty() && s.isEmpty()); }
public static void main(String[] args) { MovesReader reader = new MovesReader(); // reader.setNewFomat(true); // reader.setFilterDays("0,1,2,3,4,5"); reader.load("/Users/emilio/Desktop/GraphStreamTest/files/export_lunesCOPY.txt"); Graph g = reader.getG(); Iterator<Node> it = reader.getG().iterator(); ArrayList<ClusterWert> services = new ArrayList<ClusterWert>(); Date date = new Date(); try { BufferedWriter writer = new BufferedWriter(new FileWriter("resultado" + date.toString() + ".csv")); // Transforming data stored into GraphStream into ClusterWert data structure while (it.hasNext()) { Node next = it.next(); Service s = new Service(next.getId()); if (s.fillIn(next)) { ClusterWert cluster = new ClusterWert(s); services.add(cluster); } else System.out.println("Error al procesar " + s.toString()); } CachedDistance cache = CachedDistance.getInstance(); double lastBestdistance = Double.MAX_VALUE; long startTime = System.nanoTime(); if (true) { // HashSet<ClusterWertDistance> distances = new HashSet<ClusterWertDistance>(); TreeMap<ClusterWertDistance, Double> distances = new TreeMap<ClusterWertDistance, Double>(); do { if (services.size() == 497) System.out.println("a"); int bestPosI = 0; int bestPosJ = 0; double bestDistance = Double.MAX_VALUE; ClusterWertDistance best = new ClusterWertDistance(); int skiped = 0; for (int j = 0; j < services.size(); j++) { ClusterWert cIni = services.get(j); ClusterWertDistance distance = new ClusterWertDistance(cIni); // Distance measured in milliseconds. double lowerBoundDistance = (cIni.getDistance() == -1) ? cIni.getServices().get(0).getDuration() * 60 * 1000 : cIni.getDistance(); double lowerDistance = (distances.firstEntry() != null) ? distances.firstEntry().getValue() : Double.MAX_VALUE; if (!distances.containsKey(distance) && lowerBoundDistance < lowerDistance) { for (int i = j + 1; i < services.size(); i++) { // lowerBoundDistance += (services.get(j).getDistance()==-1) ? // services.get(j).getServices().get(0).getDuration()*60*1000 : // services.get(j).getDistance(); // if(lowerBoundDistance < lowerDistance){ ClusterWert aux = cache.getMinimumDistanceOther(cIni, services.get(i)); double auxDistance = aux.getDistance(); if (auxDistance != -1) { distance.addElement(auxDistance, aux, services.get(i)); } // } } if (distance.getBest_distance() != -1) distances.put(distance, distance.getBest_distance()); } else skiped++; } Iterator<Map.Entry<ClusterWertDistance, Double>> iter = distances.entrySet().iterator(); while (iter.hasNext()) { Map.Entry<ClusterWertDistance, Double> pair = iter.next(); ClusterWertDistance aux = pair.getKey(); double auxDistance = aux.getBest_distance(); if (auxDistance != -1 && auxDistance < bestDistance) { if (services.contains(aux.getOrigin())) { bestDistance = auxDistance; best = pair.getKey(); } else distances.remove(pair.getKey()); } } if (bestDistance < lastBestdistance) System.out.println("ERRROR "); ArrayList<ClusterWert> toDelete = new ArrayList<ClusterWert>(); if (bestDistance != Double.MAX_VALUE) { Double firstKey = best.getDistances().firstKey(); ClusterWert original = best.getOriginal().get(best.getDistances().get(firstKey)); System.out.println( "MIx " + services.indexOf(best.getOrigin()) + " con " + services.indexOf(original) + " currentSize " + services.size() + " distance: " + bestDistance + " skipped: " + skiped); System.out.println( "Cache Size " + cache.getCache1().size() + " A: " + cache.getAciertos() + " F: " + cache.getFallos()); services.remove(best.getOrigin()); toDelete.add(best.getOrigin()); services.remove(original); toDelete.add(original); Double bestKey = best.getDistances().firstKey(); services.add(0, best.getDistances().get(bestKey)); distances.remove(best); lastBestdistance = bestDistance; } else { System.out.println("TODOS LEJOS"); break; } iter = distances.entrySet().iterator(); /* while(iter.hasNext()) { Map.Entry<ClusterWertDistance,Double> pair = iter.next(); ClusterWertDistance aux = pair.getKey(); double auxDistance = aux.getBest_distance(); if(auxDistance!=-1 && auxDistance < bestDistance){ if(services.contains(aux.getOrigin())){ bestDistance = auxDistance; best = pair.getKey(); }else distances.remove(pair); } } */ while (iter.hasNext()) { Map.Entry<ClusterWertDistance, Double> pair = iter.next(); double auxDistance = pair.getValue(); ClusterWertDistance aux = pair.getKey(); for (ClusterWert w : toDelete) aux.removeOriginalCluster(w); if (!services.contains(aux.getOrigin()) || aux.getDistances().size() == 0) iter.remove(); pair.setValue(pair.getKey().getBest_distance()); } // equals.remove(i); // TODO iterate over equals in order to mix all other elements up. } while (services.size() > 1); } String strLine; int i = 1; writer.write( "ID\tIDServices\tNum Services\tH first \tH last\tLast Service Time (includes duration)\tDistance\tService Time\tTravel Time\tWaiting time"); writer.newLine(); for (ClusterWert c : services) { writer.write(i + "\t" + c.toCSV()); writer.newLine(); i++; } long elapsedTime = System.nanoTime() - startTime; writer.write(String.valueOf(elapsedTime / 1000000)); writer.flush(); writer.close(); GoogleMaps google = new GoogleMaps(false); date = new Date(); google.generateHtml(services, "prueba" + date.toString() + ".html"); System.out.print("ASDASD"); } catch (IOException e) { e.printStackTrace(); } }