/** * The inventories list is flushed with the current inventory list, so all that remains is the * ones still around this scan process. All packets we sent last tick, we'll remove from this * round, because no point sending them so quickly. NOTE: This means it's once a second by * default. * * <p>We clear the packetRequest list, so we can begin anew. Add all the inventories we want to * view. Clear the temp list, because we have no need of it, until next tick. */ public void setLists() { inventories.retainAll(tempInv); tempInv.removeAll(requestedList); requestedList.clear(); requestedList.addAll(tempInv); tempInv.clear(); }
private static double jaccardSimilarity(String similar1, String similar2) { HashSet<String> h1 = new HashSet<String>(); HashSet<String> h2 = new HashSet<String>(); for (String s : similar1.split("\\s+")) { h1.add(s); } for (String s : similar2.split("\\s+")) { h2.add(s); } int sizeh1 = h1.size(); // Retains all elements in h3 that are contained in h2 ie intersection h1.retainAll(h2); // h1 now contains the intersection of h1 and h2 h2.removeAll(h1); // h2 now contains unique elements // Union int union = sizeh1 + h2.size(); int intersection = h1.size(); return (double) intersection / union; }
@Override public synchronized void afterCompletion(int status) { completed = true; synchronizations.remove(id); if (transactionMode == TransactionMode.ISOLATE_READS) { for (TempTable table : tables.values()) { table.getActive().decrementAndGet(); } } else { HashSet<TempTable> current = new HashSet<TempTable>(tempTables.values()); current.retainAll(tables.values()); for (TempTable table : current) { table.getActive().set(0); table.getTree().clearClonedFlags(); } } for (TransactionCallback callback : callbacks) { if (status == Status.STATUS_COMMITTED) { callback.commit(); } else { callback.rollback(); } } callbacks.clear(); }
/** * pathway overlap * * @param source * @param target * @return HashSet<String> */ public static HashSet<String> pathwayOverlap(HashSet<String> source, HashSet<String> target) { HashSet<String> inter = new HashSet<String>(); for (String s : source) { inter.add(s); } inter.retainAll(target); return inter; }
public Row join(Row pRow, String pField) { // dbgMsg("Join!"); RowFormat newFormat = mFormat.join(pRow.mFormat, pField); Row newRow = (Row) newFormat.getRowFactory().makeRow(); // String[] ourFieldNames = mFormat.getFieldNames(); // String[] theirFieldNames =pRow.mFormat.getFieldNames(); // dbgMsg("ourFieldNames="+StringUtils.arrayToString(ourFieldNames, ", ")); // dbgMsg("theirFieldNames="+StringUtils.arrayToString(theirFieldNames, ", ")); HashSet ourFields = new HashSet(Arrays.asList(mFormat.getFieldNames())); HashSet theirFields = new HashSet(Arrays.asList(pRow.mFormat.getFieldNames())); ourFields.remove(pField); theirFields.remove(pField); HashSet commonFields = new HashSet(ourFields); commonFields.retainAll(theirFields); ourFields.removeAll(commonFields); theirFields.removeAll(commonFields); // dbgMsg("join field "+pField); // dbgMsg("our fields: "+StringUtils.collectionToString(ourFields, " ")); // dbgMsg("their fields: "+StringUtils.collectionToString(theirFields, " ")); // dbgMsg("common fields: "+StringUtils.collectionToString(commonFields, " ")); // copy join field newRow.set(pField, get(pField)); // (copied arbitrarily from...us, as should be same!) // copy our fields Iterator ourFieldsIter = ourFields.iterator(); while (ourFieldsIter.hasNext()) { String field = (String) ourFieldsIter.next(); newRow.set(field, (get(field))); } // copy their fields Iterator theirFieldsIter = theirFields.iterator(); while (theirFieldsIter.hasNext()) { String field = (String) theirFieldsIter.next(); newRow.set(field, (pRow.get(field))); } // copy common fields (renaming fields becomes necessary) Iterator commonFieldsIter = commonFields.iterator(); while (commonFieldsIter.hasNext()) { String field = (String) commonFieldsIter.next(); newRow.set(field + "1", (get(field))); newRow.set(field + "2", (pRow.get(field))); } return newRow; }
/** * Find the closest common superclass of multiple classes * * @param cs * @return */ @SuppressWarnings("rawtypes") public static Class FindCommonSuperclass(Class[] cs) { if (cs.length == 0) { return Object.class; } else if (cs.length == 1) { return cs[0]; } // if any items fail getSuperclass in the passed in array, // simply return object. boolean isSame = true; boolean hasNullSuperclass = false; for (Class c : cs) { if (c == null) throw new NullPointerException(); if (c != cs[0]) isSame = false; if (c.getSuperclass() == null) hasNullSuperclass = true; } // no need to do further calculations.. all the same if (isSame) return cs[0]; // at least one item in the list failed getSuperclass... return object if (hasNullSuperclass) return Object.class; Class c1 = cs[0]; Class c2 = null; HashSet<Class> s1 = new HashSet<>(); HashSet<Class> s2 = new HashSet<>(); for (int i = 1; i < cs.length; i++) { s1.clear(); s2.clear(); c2 = cs[i]; do { s1.add(c1); s2.add(c2); if (c1 != Object.class) { c1 = c1.getSuperclass(); } if (c2 != Object.class) { c2 = c2.getSuperclass(); } } while (Collections.disjoint(s1, s2)); s1.retainAll(s2); c1 = s1.iterator().next(); // there can only be one if (c1 == Object.class) break; // no superclass above object } return c1; }
public static void main(String[] args) { ConsumerTool consumerTool = new ConsumerTool(); String[] unknown = CommandLineSupport.setOptions(consumerTool, args); HashSet<String> set1 = new HashSet<String>(Arrays.asList(unknown)); ProducerTool producerTool = new ProducerTool(); unknown = CommandLineSupport.setOptions(producerTool, args); HashSet<String> set2 = new HashSet<String>(Arrays.asList(unknown)); set1.retainAll(set2); if (set1.size() > 0) { System.out.println("Unknown options: " + set1); System.exit(-1); } consumerTool.run(); producerTool.run(); }
/** Test extended and built in formats. */ @Test public void testExtendedAndBuiltInFormats() { final Calendar cal = Calendar.getInstance(); cal.set(2007, Calendar.JANUARY, 23, 18, 33, 05); final Object[] args = new Object[] {"John Doe", cal.getTime(), Double.valueOf("12345.67")}; final String builtinsPattern = "DOB: {1,date,short} Salary: {2,number,currency}"; final String extendedPattern = "Name: {0,upper} "; final String pattern = extendedPattern + builtinsPattern; final HashSet<Locale> testLocales = new HashSet<Locale>(); testLocales.addAll(Arrays.asList(DateFormat.getAvailableLocales())); testLocales.retainAll(Arrays.asList(NumberFormat.getAvailableLocales())); testLocales.add(null); for (final Locale locale : testLocales) { final MessageFormat builtins = createMessageFormat(builtinsPattern, locale); final String expectedPattern = extendedPattern + builtins.toPattern(); DateFormat df = null; NumberFormat nf = null; ExtendedMessageFormat emf = null; if (locale == null) { df = DateFormat.getDateInstance(DateFormat.SHORT); nf = NumberFormat.getCurrencyInstance(); emf = new ExtendedMessageFormat(pattern, registry); } else { df = DateFormat.getDateInstance(DateFormat.SHORT, locale); nf = NumberFormat.getCurrencyInstance(locale); emf = new ExtendedMessageFormat(pattern, locale, registry); } final StringBuilder expected = new StringBuilder(); expected.append("Name: "); expected.append(args[0].toString().toUpperCase()); expected.append(" DOB: "); expected.append(df.format(args[1])); expected.append(" Salary: "); expected.append(nf.format(args[2])); assertPatternsEqual( "pattern comparison for locale " + locale, expectedPattern, emf.toPattern()); assertEquals(String.valueOf(locale), expected.toString(), emf.format(args)); } }
private void visitObjModel(IObject objModel) { // A reference to a design model is used to check whether a potential // decorator extends or implements one of its constructor parameter // types. if (designModel == null) return; // Build up a set of components that the object may decorate. HashSet<String> possibleComponents = new HashSet<String>(); // The object may decorate one of its constructor parameter types. for (IMethod m : objModel.getAllMethodModels()) { if (m.isConstructor() && (m.getAccessLevel() == AccessLevel.Public) || (m.getAccessLevel() == AccessLevel.Protected)) { Collection<String> paramTypes = Arrays.asList(m.getParamTypeNames()); possibleComponents.addAll(paramTypes); } } // The object may decorate a type if the object extends or implements // the type. (This assumes that a class cannot decorate itself. This may // not be correct.) possibleComponents.remove(objModel.getName()); List<String> possibleComponentsList = new ArrayList<String>(possibleComponents); for (String possibleComp : possibleComponentsList) { if (!designModel.isSubType(objModel.getName(), possibleComp)) { possibleComponents.remove(possibleComp); } } // The object may decorate a type if it also has a field of that type. Set<String> fieldTypes = new HashSet<String>(); for (IField field : objModel.getAllFieldModels()) { fieldTypes.add(field.getTypeName()); } possibleComponents.retainAll(fieldTypes); // Record the components that this object decorates. if (!possibleComponents.isEmpty()) { decoratorToComponents.put(objModel.getName(), possibleComponents); } }
Match(Set<String> parameterNames, M method) { this.method = method; // The number of matched parameters HashSet<String> a = new HashSet<String>(parameterNames); a.retainAll(getParameterNames(method)); this.score1 = a.size(); // The number of unmatched arguments a = new HashSet<String>(getParameterNames(method)); a.removeAll(parameterNames); this.score2 = a.size(); // The number of unmatched parameters a = new HashSet<String>(parameterNames); a.removeAll(getParameterNames(method)); this.score3 = a.size(); // The default method this.score4 = isDefault(method) ? 0 : 1; }
public Arc(Node n0, Node n1) { if (n0 != n1) { // create separator /* * if (n0.mb.bucket == n1.mb.bucket) * separator.add(n0.mb.bucket.bucketNode); else { */ separator = (HashSet<BeliefNode>) n0.nodes.clone(); separator.retainAll(n1.nodes); // } // arc informations nodes.add(n0); nodes.add(n1); n0.addArc(n1, this); n1.addArc(n0, this); outMessage.put(n0, new HashSet<MessageFunction>()); outMessage.put(n1, new HashSet<MessageFunction>()); outCPTMessage.put(n0, new HashSet<BeliefNode>()); outCPTMessage.put(n1, new HashSet<BeliefNode>()); } else throw new RuntimeException("1-node loop in graph"); }
@Override public void onReferencesBuild(RefElement refElement) { if (refElement instanceof RefClass) { final PsiClass psiClass = (PsiClass) refElement.getElement(); if (psiClass != null) { if (refElement.isEntry()) { ((RefClassImpl) refElement).setFlag(false, CAN_BE_FINAL_MASK); } PsiMethod[] psiMethods = psiClass.getMethods(); PsiField[] psiFields = psiClass.getFields(); HashSet<PsiVariable> allFields = new HashSet<PsiVariable>(); ContainerUtil.addAll(allFields, psiFields); ArrayList<PsiVariable> instanceInitializerInitializedFields = new ArrayList<PsiVariable>(); boolean hasInitializers = false; for (PsiClassInitializer initializer : psiClass.getInitializers()) { PsiCodeBlock body = initializer.getBody(); hasInitializers = true; ControlFlow flow; try { flow = ControlFlowFactory.getInstance(body.getProject()) .getControlFlow( body, LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance(), false); } catch (AnalysisCanceledException e) { flow = ControlFlow.EMPTY; } Collection<PsiVariable> writtenVariables = new ArrayList<PsiVariable>(); ControlFlowUtil.getWrittenVariables(flow, 0, flow.getSize(), false, writtenVariables); for (PsiVariable psiVariable : writtenVariables) { if (allFields.contains(psiVariable)) { if (instanceInitializerInitializedFields.contains(psiVariable)) { allFields.remove(psiVariable); instanceInitializerInitializedFields.remove(psiVariable); } else { instanceInitializerInitializedFields.add(psiVariable); } } } for (PsiVariable psiVariable : writtenVariables) { if (!instanceInitializerInitializedFields.contains(psiVariable)) { allFields.remove(psiVariable); } } } for (PsiMethod psiMethod : psiMethods) { if (psiMethod.isConstructor()) { PsiCodeBlock body = psiMethod.getBody(); if (body != null) { hasInitializers = true; ControlFlow flow; try { flow = ControlFlowFactory.getInstance(body.getProject()) .getControlFlow( body, LocalsOrMyInstanceFieldsControlFlowPolicy.getInstance(), false); } catch (AnalysisCanceledException e) { flow = ControlFlow.EMPTY; } Collection<PsiVariable> writtenVariables = ControlFlowUtil.getWrittenVariables(flow, 0, flow.getSize(), false); for (PsiVariable psiVariable : writtenVariables) { if (instanceInitializerInitializedFields.contains(psiVariable)) { allFields.remove(psiVariable); instanceInitializerInitializedFields.remove(psiVariable); } } List<PsiMethod> redirectedConstructors = HighlightControlFlowUtil.getChainedConstructors(psiMethod); if (redirectedConstructors == null || redirectedConstructors.isEmpty()) { List<PsiVariable> ssaVariables = ControlFlowUtil.getSSAVariables(flow); ArrayList<PsiVariable> good = new ArrayList<PsiVariable>(ssaVariables); good.addAll(instanceInitializerInitializedFields); allFields.retainAll(good); } else { allFields.removeAll(writtenVariables); } } } } for (PsiField psiField : psiFields) { if ((!hasInitializers || !allFields.contains(psiField)) && psiField.getInitializer() == null) { final RefFieldImpl refField = (RefFieldImpl) myManager.getReference(psiField); if (refField != null) { refField.setFlag(false, CAN_BE_FINAL_MASK); } } } } } else if (refElement instanceof RefMethod) { final RefMethod refMethod = (RefMethod) refElement; if (refMethod.isEntry()) { ((RefMethodImpl) refMethod).setFlag(false, CAN_BE_FINAL_MASK); } } }
@Override protected Object doExecute() throws Exception { OsgiModuleRegistry registry = Activator.registry; List<ModuleRegistry.Module> modules = registry.getApplicationModules(); Map<VersionedDependencyId, Bundle> installed = registry.getInstalled(); for (ModuleRegistry.Module module : modules) { if (name.equals(module.getName())) { HashSet<VersionedDependencyId> s = new HashSet<VersionedDependencyId>(module.getVersionIds()); s.retainAll(installed.keySet()); boolean isInstalled = !s.isEmpty(); if (isInstalled && !force) { throw new Exception("The module is already installed"); } ModuleRegistry.VersionedModule versionedModule = null; if (version != null) { versionedModule = module.getVersions().get(version); if (versionedModule == null) { throw new Exception("Invalid version: " + version); } } else { versionedModule = module.latest(); } VersionedDependencyId id = versionedModule.getId(); String v = version != null ? version : id.getVersion(); List<String> extensionAdjustments = Arrays.asList(extensions); if (!extensionAdjustments.isEmpty()) { List<String> enabled = new ArrayList<String>(versionedModule.getDefaultExtensions()); for (String adjustment : extensionAdjustments) { if (adjustment.startsWith("+")) { String name = adjustment.substring(1); enabled.add(name); } else if (adjustment.startsWith("-")) { String name = adjustment.substring(1); enabled.remove(name); } else { throw new IllegalArgumentException( "Expected extension argument '" + adjustment + "' to be prefixed with '+' or '-'"); } } versionedModule.setEnabledExtensions(enabled); if (!enabled.isEmpty()) { println("Enabling extensions: " + join(enabled, ", ")); } } // String url = "fab:mvn:" + id.getGroupId() + "/" + id.getArtifactId() + "/" + v + "/" + id.getExtension() + (id.getClassifier() == null ? "" : "/" + id.getClassifier()); println("Installing: " + url); Bundle bundle = install(url); if (bundle != null) { println("Installed bundle: %d", bundle.getBundleId()); if (!noStart) { bundle.start(); } } } } return null; }
@DSLMethod(production = "p0 ⋂ p1") public Set intersection(Set a, Set b) { HashSet set = new HashSet(a); set.retainAll(b); return set; }
// Given two input synsets, finds the least common subsumer (LCS) of them. // If there are multiple candidates for the LCS (due to multiple inheritance in WordNet), the LCS // with the // greatest depth is chosen (i.e., the candidate whose shortest path to the root is the longest). public HashSet<ISynsetID> getLCSbyDepth(ISynset synset1, ISynset synset2, String pos) { HashSet<ISynsetID> lcs = new HashSet<ISynsetID>(); if (synset1.equals(synset2)) { HashSet<ISynsetID> identity = new HashSet<ISynsetID>(); identity.add(synset1.getID()); return (identity); } // !!! could be <roots>, in which case there is no subsumer !!! double d1 = getSynsetDepth(synset1, pos); double d2 = getSynsetDepth(synset2, pos); if (d1 == 0.0 && d2 == 0.0) { return (lcs); // !!! return empty set !!! } // !!! *1* of them could be a <root>, in which case there is no subsumer !!! // double d1 = getSynsetDepth(synset1, pos); // double d2 = getSynsetDepth(synset2, pos); if (d1 == 0.0 || d2 == 0.0) { if (d1 == 0.0) { lcs.add(synset1.getID()); } if (d2 == 0.0) { lcs.add(synset2.getID()); } return (lcs); // !!! return !!! } TreeMap<Integer, HashSet<ISynsetID>> map = new TreeMap<Integer, HashSet<ISynsetID>>(); // synset 1 <hypernyms> HashSet<ISynsetID> s1 = new HashSet<ISynsetID>(); s1.add(synset1.getID()); HashSet<ISynsetID> h1 = new HashSet<ISynsetID>(); getHypernyms(s1, h1); // i.e. fill 'h1' with <hypernyms> of synset1 // synset 2 <hypernyms> HashSet<ISynsetID> s2 = new HashSet<ISynsetID>(); s2.add(synset2.getID()); HashSet<ISynsetID> h2 = new HashSet<ISynsetID>(); getHypernyms(s2, h2); // i.e. fill 'h2' with <hypernyms> of synset2 h1.retainAll(h2); // System.out.println(h1); for (ISynsetID h : h1) { // System.out.println(dict.getSynset(h)); // System.out.println(h + "\t\t\t" + getSynsetDepth(h.getOffset(), pos)); TreeMap<Integer, HashSet<ISynsetID>> set = getSynsetDepth(h.getOffset(), pos); for (Integer i : set.keySet()) { HashSet<ISynsetID> subset = set.get(i); // EasyIn.pause(h + "\t" + i + "\t<" + subset + ">"); if (map.containsKey(i)) { HashSet<ISynsetID> store = map.get(i); store.add(h); map.put(i, store); } else { HashSet<ISynsetID> store = new HashSet<ISynsetID>(); store.add(h); map.put(i, store); } } } int key = map.lastKey(); lcs = map.get(key); return (lcs); }
/** * Returns the intersection between this mapping and that. * * @param that The mapping to be intersected to this mapping. * @return The intersection bewteen this and that. */ public Alignment getIntersection(Alignment that) { HashSet<Correspondence> thisCSet = this.getCorrespondencesAsSet(); HashSet<Correspondence> thatCSet = that.getCorrespondencesAsSet(); thisCSet.retainAll(thatCSet); return (new Alignment(thisCSet)); }