/** * Returns a set of DN that matches the resource and subject indexes. * * @param indexes Resource search indexes. * @param subjectIndexes Subject search indexes * @param bSubTree <code>true</code> for sub tree search mode. * @return A set of DN that matches the resource and subject indexes. */ public Set<String> getMatchingEntries( ResourceSearchIndexes indexes, Set<String> subjectIndexes, boolean bSubTree) { rwlock.readLock().lock(); try { Set<String> results = new HashSet<String>(); boolean hasSubjectIndexes = (subjectIndexes != null) && !subjectIndexes.isEmpty(); if (hasSubjectIndexes) { for (String i : subjectIndexes) { Set<String> r = (Set<String>) subjectIndexCache.get(i); if (r != null) { results.addAll(r); } } results.retainAll(getHostIndexes(indexes)); } else { results.addAll(getHostIndexes(indexes)); } if (bSubTree) { results.retainAll(getPathParentIndexes(indexes)); } else { results.retainAll(getPathIndexes(indexes)); } return results; } finally { rwlock.readLock().unlock(); } }
/** * Checks if the generated elements from the first mapped element has either the desired value, or * has some value in common with the elements generated from second mapped element. * * @param match current pattern match * @param ind mapped indices * @return true if a value match is found */ @Override public boolean satisfies(Match match, int... ind) { assertIndLength(ind); // Collect values of the element group Set values = new HashSet(); for (BioPAXElement gen : con1.generate(match, ind)) { values.addAll(pa1.getValueFromBean(gen)); } // If emptiness is desired, check that if (value == EMPTY) return values.isEmpty(); // If cannot be empty, check it if (oper == Operation.NOT_EMPTY_AND_NOT_INTERSECT && values.isEmpty()) return false; // If the second element is desired value, check that else if (value == USE_SECOND_ARG) { BioPAXElement q = match.get(ind[1]); return oper == Operation.INTERSECT ? values.contains(q) : !values.contains(q); } // If element group is compared to preset value, but the value is actually a collection, // then iterate the collection, see if any of them matches else if (value instanceof Collection) { Collection query = (Collection) value; values.retainAll(query); if (oper == Operation.INTERSECT) return !values.isEmpty(); else return values.isEmpty(); } // If two set of elements should share a field value, check that else if (pa2 != null) { // Collect values of the second group Set others = new HashSet(); for (BioPAXElement gen : con2.generate(match, ind)) { others.addAll(pa2.getValueFromBean(gen)); } switch (oper) { case INTERSECT: others.retainAll(values); return !others.isEmpty(); case NOT_INTERSECT: others.retainAll(values); return others.isEmpty(); case NOT_EMPTY_AND_NOT_INTERSECT: if (others.isEmpty()) return false; others.retainAll(values); return others.isEmpty(); default: throw new RuntimeException("Unhandled operation: " + oper); } } // Check if the element field values contain the parameter value else if (oper == Operation.INTERSECT) return values.contains(value); else return !values.contains(value); }
public void testKeySetRetainAllNullFromEmpty() { final Map<K, V> map; try { map = makeEmptyMap(); } catch (UnsupportedOperationException e) { return; } Set<K> keySet = map.keySet(); if (supportsRemove) { try { keySet.retainAll(null); // Returning successfully is not ideal, but tolerated. } catch (NullPointerException e) { // Expected. } } else { try { keySet.retainAll(null); // We have to tolerate a successful return (Sun bug 4802647) } catch (UnsupportedOperationException e) { // Expected. } catch (NullPointerException e) { // Expected. } } assertInvariants(map); }
public static String conjuntos(int salto) throws InterruptedException { bienvenido(); Set a = new TreeSet(); Set b = new TreeSet(); a.add(2); a.add(4); a.add(6); a.add(8); b.add(6); b.add(8); b.add(10); b.add(12); System.out.println("\n\n\n Número de elementos en A { " + a.size() + " }"); System.out.println(" Elementos del conjunto A " + a + " "); espera_porciento(); System.out.println("\n Número de elementos en B " + b.size() + " "); System.out.println(" Elementos del conjunto B { " + b + " }"); espera_porciento(); a.retainAll(b); System.out.println("\n Conjunto A intersección B " + a); espera_porciento(); a.add(2); a.add(4); a.addAll(b); System.out.println("\n Conjunto A Unión B " + a); espera_porciento(); a.add(2); a.add(4); a.removeAll(b); System.out.println("\n Conjunto A diferencia de B " + a); espera_porciento(); a.addAll(b); a.retainAll(b); System.out.println("\n Diferencia simetrica a b: " + a); espera_porciento(); System.out.println("\n1. Volver al menú principal\n2. Volver al menú computación"); System.out.print("Seleccione una opción: "); opcion = dato.next(); while (!isNumber1(opcion)) { System.out.println("\nSolo puede ingresar datos numéricos"); System.out.print("Seleccione una opción, por favor: "); opcion = dato.next(); } if (opcion.equals("1")) { menu(salto); } if (opcion.equals("2")) { menu_comp(salto); } return null; }
/** * Returns a Set of current children to remove and modifies newChildren to only contain the * children not already in children and not subsumed by any WeakExplorerNode in children. * * <p>Note: newChildren will be modified by this call. * * <p>Note: It is expected that a WeakExplorerNode will not be reused and thus they will always * initially be slated for removal, and only those nodes are in fact used to check subsumption of * new nodes. New nodes are not checked among themselves for subsumtion. * * @param children is the list of current children. * @param newChildren is the list of expected children. * @return the Set of current children to remove. * @throws UnsupportedOperationException if newChildren doesn't support remove or removeAll. * @throws NullPointerException if either argument is null. */ private Set prepareAddRemoveSets(List children, List newChildren) { Set removeSet = new HashSet(); Set commonObjects = new HashSet(); if (children.size() < newChildren.size()) { commonObjects.addAll(children); commonObjects.retainAll(newChildren); } else { commonObjects.addAll(newChildren); commonObjects.retainAll(children); } newChildren.removeAll(commonObjects); removeSet.addAll(children); removeSet.removeAll(commonObjects); // Handle WeakExplorerNodes Iterator it = removeSet.iterator(); List weakNodes = null; while (it.hasNext()) { Object obj = it.next(); if (!(obj instanceof WeakExplorerNode)) { continue; } WeakExplorerNode node = (WeakExplorerNode) obj; if (weakNodes == null) { weakNodes = new LinkedList(); Iterator it2 = newChildren.iterator(); while (it2.hasNext()) { Object obj2 = it2.next(); if (obj2 instanceof WeakExplorerNode) { weakNodes.add(obj2); } } } Iterator it3 = weakNodes.iterator(); while (it3.hasNext()) { Object obj3 = it3.next(); if (node.subsumes(obj3)) { // Remove the node from removeSet it.remove(); // Remove obj3 from weakNodes and newChildren newChildren.remove(obj3); it3.remove(); break; } } } return removeSet; }
public static void main(String[] args) throws IOException { // input = new Scanner(System.in); // for stdin input = new Scanner(new FileReader(args[0])); // for file reading // output = System.out; // for stdout output = new PrintWriter(new FileWriter(args[1])); // for file writing Set<Integer> set1; Set<Integer> set2; Set<Integer> set3; String line = input.nextLine(); Scanner scline = new Scanner(line); int n = scline.nextInt(); for (int x = n; x >= 3; x -= 3) { line = input.nextLine(); scline = new Scanner(line); set1 = getSet(scline); line = input.nextLine(); scline = new Scanner(line); set2 = getSet(scline); line = input.nextLine(); scline = new Scanner(line); set3 = getSet(scline); set1.retainAll(set2); set1.retainAll(set3); output.println(set1); } scline.close(); output.flush(); input.close(); output.close(); }
/** * This method runs through all games, gets a list of all years represented in the database for * that game. Then, find the biggest year that is in common for all databases. If this year is the * same as the current year, just return an array containing this current year. If not, it will * contains every year from this year to the last year in the database inclusive. * * @return an array of years to update all games for */ private int[] getLastYear() { int max = Lottery.MIN_COMMON_YEAR; // come up with a maximum shared year for all games try { // find all shared years final Set<Integer> commonYears = getYearsFromGame(UPDATE_THESE[0]); for (int i = 1; i < UPDATE_THESE.length; i++) { commonYears.retainAll(getYearsFromGame(UPDATE_THESE[i])); } // find the max for (int year : commonYears) { if (year > max) { max = year; } } } catch (final FileNotFoundException e) { e.printStackTrace(); max = Lottery.MIN_COMMON_YEAR; } // compare with the current year and return a list of years between then // and now final int[] result; if (max == currentYear()) { result = new int[1]; result[0] = max; } else { result = new int[currentYear() - max + 1]; int year = max; for (int i = 0; i < result.length; i++) { result[i] = year; year++; } } return result; }
/** {@inheritDoc} */ @Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { if (roundEnv.processingOver()) return false; // We have: A sorted set of all priority levels: 'priorityLevels' // Step 1: Take all CUs which aren't already in the map. Give them the first priority level. for (Element element : roundEnv.getRootElements()) { JCCompilationUnit unit = toUnit(element); if (unit == null) continue; if (roots.containsKey(unit)) continue; roots.put(unit, priorityLevels[0]); } while (true) { // Step 2: For all CUs (in the map, not the roundEnv!), run them across all handlers at their // current prio level. for (long prio : priorityLevels) { List<JCCompilationUnit> cusForThisRound = new ArrayList<JCCompilationUnit>(); for (Map.Entry<JCCompilationUnit, Long> entry : roots.entrySet()) { Long prioOfCu = entry.getValue(); if (prioOfCu == null || prioOfCu != prio) continue; cusForThisRound.add(entry.getKey()); } transformer.transform(prio, processingEnv.getContext(), cusForThisRound); } // Step 3: Push up all CUs to the next level. Set level to null if there is no next level. Set<Long> newLevels = new HashSet<Long>(); for (int i = priorityLevels.length - 1; i >= 0; i--) { Long curLevel = priorityLevels[i]; Long nextLevel = (i == priorityLevels.length - 1) ? null : priorityLevels[i + 1]; for (Map.Entry<JCCompilationUnit, Long> entry : roots.entrySet()) { if (curLevel.equals(entry.getValue())) { entry.setValue(nextLevel); newLevels.add(nextLevel); } } } newLevels.remove(null); // Step 4: If ALL values are null, quit. Else, either do another loop right now or force a // resolution reset by forcing a new round in the annotation processor. if (newLevels.isEmpty()) return false; newLevels.retainAll(priorityLevelsRequiringResolutionReset); if (newLevels.isEmpty()) { // None of the new levels need resolution, so just keep going. continue; } else { // Force a new round to reset resolution. The next round will cause this method (process) to // be called again. forceNewRound((JavacFiler) processingEnv.getFiler()); return false; } } }
public void validateAlternateAlleles() { if (!hasGenotypes()) return; List<Allele> reportedAlleles = getAlleles(); Set<Allele> observedAlleles = new HashSet<Allele>(); observedAlleles.add(getReference()); for (final Genotype g : getGenotypes()) { if (g.isCalled()) observedAlleles.addAll(g.getAlleles()); } if (reportedAlleles.size() != observedAlleles.size()) throw new TribbleException.InternalCodecException( String.format( "the ALT allele(s) for the record at position %s:%d do not match what is observed in the per-sample genotypes", getChr(), getStart())); int originalSize = reportedAlleles.size(); // take the intersection and see if things change observedAlleles.retainAll(reportedAlleles); if (observedAlleles.size() != originalSize) throw new TribbleException.InternalCodecException( String.format( "the ALT allele(s) for the record at position %s:%d do not match what is observed in the per-sample genotypes", getChr(), getStart())); }
public static void intersectSet(Set<String> target, Set<String> set) { if (target.isEmpty()) { target.addAll(set); } else { target.retainAll(set); } }
public FloatWritable evaluate(final List<String> a, final List<String> b) { if (a == null && b == null) { return new FloatWritable(0.f); } else if (a == null || b == null) { return new FloatWritable(1.f); } final int asize = a.size(); final int bsize = b.size(); if (asize == 0 && bsize == 0) { return new FloatWritable(0.f); } else if (asize == 0 || bsize == 0) { return new FloatWritable(1.f); } union.addAll(a); union.addAll(b); float unionSize = union.size(); union.clear(); intersect.addAll(a); intersect.retainAll(b); float intersectSize = intersect.size(); intersect.clear(); float j = intersectSize / unionSize; return new FloatWritable(1.f - j); }
public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = in.nextInt(); while (n > 0) { String s1 = in.next(); String s2 = in.next(); Set<Character> alphaS1 = new HashSet<Character>(); for (int i = 0; i < s1.length(); i++) { alphaS1.add(s1.charAt(i)); } Set<Character> alphaS2 = new HashSet<Character>(); for (int i = 0; i < s2.length(); i++) { alphaS2.add(s2.charAt(i)); } alphaS1.retainAll(alphaS2); if (alphaS1.size() > 0) { System.out.println("YES"); } else { System.out.println("NO"); } n--; } }
protected boolean backScan(SequenceDatabase<T> sdb) { List<T> prefix = sdb.getPrefix(); prefix_loop: for (int i = 0; i < prefix.size(); i++) { Set<T> intersection = null; for (Sequence<T> sequence : sdb.getSequences()) { List<T> smp_i = sequence.getSemiMaximumPeriodOf(prefix, i); if (smp_i == null || smp_i.isEmpty()) { continue prefix_loop; } if (intersection == null) { intersection = new HashSet<T>(smp_i); } else { intersection.retainAll(smp_i); if (intersection.isEmpty()) { continue prefix_loop; } } } if (logger.isTraceEnabled()) { logger.trace( "Pruned: Search space was pruned by the BackScan method. Items {} exists in each of the {} semi-maximum period.", intersection, toOrdinal(i)); } return true; } return false; }
/** * A dumb vector space model that counts each word's co-occurences with a predefined set of * content words and uses these co-occurence vectors directly as word representations. The context * in which a word occurs is the set of content words in an entire sentence. * * <p>N.B. Most people would probably not consider this an embedding model, since the words have * not been embedded in a lower dimensional subspace. However, it is a good starting point. * * <p>Since this approach does not share any information between representations of different * words, we can filter the training data to only include sentences that contain words of * interest. In other approaches this may not be a good idea. * * @param dataPath * @param targetVocab * @param contentVocab * @return */ private static HashMap<String, float[]> getEmbeddings( String dataPath, HashMap<String, Integer> contentVocab, Set<String> targetVocab) { HashMap<String, float[]> embeddingMatrix = new HashMap<String, float[]>(); for (String target_word : targetVocab) { embeddingMatrix.put(target_word, new float[contentVocab.size()]); } Collection<List<String>> sentenceCollection = SentenceCollection.Reader.readSentenceCollection(dataPath); for (List<String> sentence : sentenceCollection) { Set<String> sw = new HashSet<String>(sentence); sw.retainAll(targetVocab); for (String word : sentence) { if (!contentVocab.containsKey(word)) continue; int contentWordId = contentVocab.get(word); for (String targetWord : sw) { embeddingMatrix.get(targetWord)[contentWordId] = embeddingMatrix.get(targetWord)[contentWordId] + 1; } } } return embeddingMatrix; }
@Test public void keySet_retainAll() { // a map with a null key MutableMap<Integer, Integer> map = this.newMapWithKeyValue(null, 0); MutableList<Object> retained = Lists.mutable.of(); retained.add(null); Assert.assertFalse(map.keySet().retainAll(retained)); Verify.assertContains(null, map.keySet()); // a map with a chain containing empty slots MutableMap<Integer, Integer> map2 = this.mapWithCollisionsOfSize(5); Assert.assertFalse(map2.keySet().retainAll(FastList.<Integer>newListWith(0, 17, 34, 51, 68))); Verify.assertContainsAll(map2.keySet(), 0, 17, 34, 51, 68); // a map with no chaining, nothing retained MutableMap<Integer, String> map3 = this.newMapWithKeyValue(1, "One"); Assert.assertTrue(map3.keySet().retainAll(FastList.<Integer>newListWith(9))); Verify.assertEmpty(map3); Set<Integer> keys = this.newMapWithKeysValues(1, "One", 2, "Two", 3, "Three", 4, "Four").keySet(); Assert.assertTrue(keys.retainAll(FastList.<Integer>newListWith(1, 2, 3))); Verify.assertContainsAll(keys, 1, 2, 3); }
/** * Hides nodes from the tree that do not match <code>text</code>. * * @param text search text */ public void filterByText(String text) { text = normalize(text); if (text == null || text.length() == 0) { visibleNodes = null; } else { visibleNodes = new HashSet<Object>(); String[] keywords = text.split(" "); for (int i = 0; i < keywords.length; i++) { SortedMap<String, List<Object>> nodeListByKey = getMatches(text); if (i == 0) { for (List<Object> nodes : nodeListByKey.values()) { visibleNodes.addAll(nodes); } } else { Set<Object> allNew = new HashSet<Object>(); for (List<Object> nodes : nodeListByKey.values()) { allNew.addAll(nodes); } visibleNodes.retainAll(allNew); } } ensureParentsVisible(); } TreeModelEvent event = new TreeModelEvent(this, new Object[] {model.getRoot()}); for (TreeModelListener listener : listeners) { listener.treeStructureChanged(event); } }
@Override protected void getCandidates(ChunkTypeRequest request, Set<IIdentifier> results) { boolean firstInsertion = true; FastSet<IIdentifier> tmp = FastSet.newInstance(); for (IConditionalSlot slot : request.getConditionalSlots()) if (slot.getName().equals(IAuralModule.KIND_SLOT)) { tmp.clear(); String kind = transformKind(slot.getValue()); switch (slot.getCondition()) { case IConditionalSlot.NOT_EQUALS: not(kind, tmp); break; default: equals(kind, tmp); break; } if (firstInsertion) { results.addAll(tmp); firstInsertion = false; } else results.retainAll(tmp); } FastSet.recycle(tmp); }
@Test public void retainAll() { toTest.add("Test1"); toTest.add("Test2"); toTest.add("Test3"); assertFalse(toTest.retainAll(toTest)); try { toTest.retainAll(null); fail("It should be thrown an exception."); } catch (NullPointerException e) { } assertTrue(toTest.retainAll(Arrays.asList("Test2"))); assertTrue(toTest.size() == 1); }
private void afterDeploymentValidation( @Observes AfterDeploymentValidation adv, BeanManager manager) { Collection<CamelContext> contexts = new ArrayList<>(); for (Bean<?> context : manager.getBeans(CamelContext.class, ANY)) { contexts.add(getReference(manager, CamelContext.class, context)); } // Add type converters to Camel contexts CdiTypeConverterLoader loader = new CdiTypeConverterLoader(); for (Class<?> converter : converters) { for (CamelContext context : contexts) { loader.loadConverterMethods(context.getTypeConverterRegistry(), converter); } } // Add routes to Camel contexts boolean deploymentException = false; Set<Bean<?>> routes = new HashSet<>(manager.getBeans(RoutesBuilder.class, ANY)); routes.addAll(manager.getBeans(RouteContainer.class, ANY)); for (Bean<?> context : manager.getBeans(CamelContext.class, ANY)) { for (Bean<?> route : routes) { Set<Annotation> qualifiers = new HashSet<>(context.getQualifiers()); qualifiers.retainAll(route.getQualifiers()); if (qualifiers.size() > 1) { deploymentException |= !addRouteToContext(route, context, manager, adv); } } } // Let's return to avoid starting misconfigured contexts if (deploymentException) { return; } // Trigger eager beans instantiation (calling toString is necessary to force // the initialization of normal-scoped beans). // FIXME: This does not work with OpenWebBeans for bean whose bean type is an // interface as the Object methods does not get forwarded to the bean instances! eagerBeans.forEach(type -> getReferencesByType(manager, type.getJavaClass(), ANY).toString()); manager .getBeans(Object.class, ANY, STARTUP) .stream() .forEach(bean -> getReference(manager, bean.getBeanClass(), bean).toString()); // Start Camel contexts for (CamelContext context : contexts) { if (ServiceStatus.Started.equals(context.getStatus())) { continue; } logger.info("Camel CDI is starting Camel context [{}]", context.getName()); try { context.start(); } catch (Exception exception) { adv.addDeploymentProblem(exception); } } // Clean-up Stream.of(converters, camelBeans, eagerBeans, cdiBeans).forEach(Set::clear); Stream.of(producerBeans, producerQualifiers).forEach(Map::clear); }
protected boolean hasBackwardExtensionItem(SequenceDatabase<T> sdb) { List<T> prefix = sdb.getPrefix(); prefix_loop: for (int i = 0; i < prefix.size(); i++) { Set<T> intersection = null; for (Sequence<T> sequence : sdb.getSequences()) { List<T> mp_i = sequence.getMaximumPeriodOf(prefix, i); if (mp_i == null || mp_i.isEmpty()) { continue prefix_loop; } if (intersection == null) { intersection = new HashSet<T>(mp_i); } else { intersection.retainAll(mp_i); if (intersection.isEmpty()) { continue prefix_loop; } } } if (logger.isTraceEnabled()) { logger.trace( "Open: The prefix can be extended by backward extension items {}, found in each of the {} maximum period.", intersection, toOrdinal(i)); } return true; } return false; }
private Map<TrustedEntityId, TrustSimilarity> extractTrustSimilarity( final TrustedEntityId myTeid, final Map<String, Set<TrustEvidence>> trustEvidenceMap) throws TrustException { final Map<TrustedEntityId, TrustSimilarity> trustSimilarityMap = new LinkedHashMap<TrustedEntityId, TrustSimilarity>(); final Map<TrustedEntityId, Set<TrustedEntityId>> trustPrefsMap = this.extractTrustPrefs(trustEvidenceMap); LOG.info("extractTrustSimilarity: trustPrefsMap={}", trustPrefsMap); final Set<TrustedEntityId> myTrustees = (trustPrefsMap.get(myTeid) != null) ? trustPrefsMap.get(myTeid) : Collections.<TrustedEntityId>emptySet(); for (final Map.Entry<TrustedEntityId, Set<TrustedEntityId>> trustPrefs : trustPrefsMap.entrySet()) { if (trustPrefs.getKey().equals(myTeid)) { continue; } final Set<TrustedEntityId> sharedTrustees = new LinkedHashSet<TrustedEntityId>(trustPrefs.getValue()); sharedTrustees.retainAll(myTrustees); final Set<TrustedEntityId> unsharedTrustees = new LinkedHashSet<TrustedEntityId>(trustPrefs.getValue()); unsharedTrustees.removeAll(myTrustees); trustSimilarityMap.put( trustPrefs.getKey(), new TrustSimilarity(sharedTrustees, unsharedTrustees)); } return trustSimilarityMap; }
private void addProtein(final List<Protein> proteins, Protein current_protein) { if ((getMaxAllowedOverlap() != HmmscanPerDomainTableParser.MAX_ALLOWED_OVERLAP_DEFAULT) || isIgnoreEngulfedDomains()) { final int domains_count = current_protein.getNumberOfProteinDomains(); current_protein = SurfacingUtil.removeOverlappingDomains( getMaxAllowedOverlap(), isIgnoreEngulfedDomains(), current_protein); final int domains_removed = domains_count - current_protein.getNumberOfProteinDomains(); _domains_stored -= domains_removed; _domains_ignored_due_to_overlap += domains_removed; } if ((getFilterType() == FilterType.POSITIVE_PROTEIN) || (getFilterType() == FilterType.NEGATIVE_PROTEIN)) { final Set<DomainId> domain_ids_in_protein = new HashSet<DomainId>(); for (final Domain d : current_protein.getProteinDomains()) { domain_ids_in_protein.add(d.getDomainId()); } domain_ids_in_protein.retainAll(getFilter()); if (getFilterType() == FilterType.POSITIVE_PROTEIN) { if (domain_ids_in_protein.size() > 0) { actuallyAddProtein(proteins, current_protein); } else { ++_proteins_ignored_due_to_filter; } } else { if (domain_ids_in_protein.size() < 1) { actuallyAddProtein(proteins, current_protein); } else { ++_proteins_ignored_due_to_filter; } } } else { actuallyAddProtein(proteins, current_protein); } }
@Override public void prepare(Map conf, TopologyContext context, OutputCollector collector) { _fieldLocations = new HashMap<String, GlobalStreamId>(); _collector = collector; int timeout = ((Number) conf.get(Config.TOPOLOGY_MESSAGE_TIMEOUT_SECS)).intValue(); _pending = new TimeCacheMap<List<Object>, Map<GlobalStreamId, Tuple>>(timeout, new ExpireCallback()); _numSources = context.getThisSources().size(); Set<String> idFields = null; for (GlobalStreamId source : context.getThisSources().keySet()) { Fields fields = context.getComponentOutputFields(source.get_componentId(), source.get_streamId()); Set<String> setFields = new HashSet<String>(fields.toList()); if (idFields == null) idFields = setFields; else idFields.retainAll(setFields); for (String outfield : _outFields) { for (String sourcefield : fields) { if (outfield.equals(sourcefield)) { _fieldLocations.put(outfield, source); } } } } _idFields = new Fields(new ArrayList<String>(idFields)); if (_fieldLocations.size() != _outFields.size()) { throw new RuntimeException("Cannot find all outfields among sources"); } }
public List<NamedEntity> intersect(TSignature s2) { List<NamedEntity> ret = new ArrayList<NamedEntity>(); Set<NamedEntity> s = new HashSet<NamedEntity>(set); s.retainAll(s2.set); ret.addAll(s); return ret; }
private Set<Vertex> computeMinVertexCover(Set<Vertex> side1, Set<Vertex> side2) { Set<Vertex> konigSet = new HashSet<Vertex>(); Set<Vertex> unmatched = new TreeSet<Vertex>(side1); unmatched.removeAll(matches); // System.out.println("Matches: " + matches); // System.out.println("side 1 unmatched set: " + unmatched); for (Vertex v : unmatched) { konigDFS(konigSet, v, false); } // System.out.println("Konig set: " + konigSet); Set<Vertex> result = new HashSet<Vertex>(side2); result.retainAll(konigSet); // System.out.println("side 2 intersect konigSet: " + result); Set<Vertex> side1notInKonigSet = new HashSet<Vertex>(side1); side1notInKonigSet.removeAll(konigSet); // System.out.println("side 1 not in Konig set: " + side1notInKonigSet); result.addAll(side1notInKonigSet); return result; }
@Override public void update(Observable o, Object arg) { Set<Integer> oldSelection = new HashSet<Integer>(); oldSelection.addAll(selection); SortedSet<Feature> fs = model.selectionModel().getFeatureSelection(); // System.out.println(fs); // int prevIndex = selectedIndex; if (fs.size() > 0) { for (Feature f : fs) { selection.add(listModel.getRow(f)); } } else { selection.clear(); } oldSelection.retainAll(selection); if (oldSelection.size() != selection.size()) { fireValueChanged(false); } // getSelectionModel().setSelectionInterval(row, row); }
private static int getNumberGems(String[] a) { Set<Character> gemSet = new HashSet<>(); char[] firstString = a[0].toCharArray(); // Set<Character> gemSet1 = new HashSet<Character>(Arrays.asList(firstString)); // "abcdde" , baccd , eeabg for (char letter : firstString) { // "abcdde" // Only add first characterset to set. gemSet.add(letter); } // Iterate over each other string from array of Strings // abcdde , "baccd , eeabg" for (int j = 1; j < a.length; j++) { Set<Character> gemSet2 = new HashSet<>(); // accd char[] strC = a[j].toCharArray(); for (char letter : strC) { gemSet2.add(letter); } // Now find all character which are in gemSet2 and keep only those, // and store them back into getSet // Keep doing this with all string hence its set and gemSet // finally will have common letter only gemSet.retainAll(gemSet2); } return gemSet.size(); }
public ArrayList<FileSystemItem> getSelectedFiles() { // first make sure there are no leftover items in the selected set Set<FileSystemItem> selectedSet = selectionModel_.getSelectedSet(); selectedSet.retainAll(dataProvider_.getList()); return new ArrayList<FileSystemItem>(selectedSet); }
/** * Adds the given POP application satisfier set as a subset of this set, with the given * exceptions. The exceptions set must be a subset of the given satisfier set. If the given POP * application was already a subset of this set, then the new exceptions set is the intersection * of the given exceptions set with the old one. Otherwise, the exceptions set is the given one * minus any individual elements of this set that satisfy the given POP application. */ public void addSatisfiers(NumberVar popApp, ObjectSet satisfiers, Set newExceptions) { if (popAppSatisfiers.containsKey(popApp)) { // already in set; assume satisfiers the same Set curExceptions = (Set) popAppExceptions.get(popApp); int oldNumExceptions = curExceptions.size(); curExceptions.retainAll(newExceptions); size += (oldNumExceptions - curExceptions.size()); } else { popAppSatisfiers.put(popApp, satisfiers); Set oldIndivs = (Set) popAppIndivs.remove(popApp); for (Iterator iter = oldIndivs.iterator(); iter.hasNext(); ) { individuals.remove(iter.next()); } Set curExceptions = new HashSet(newExceptions); curExceptions.removeAll(oldIndivs); popAppExceptions.put(popApp, curExceptions); size += (satisfiers.size() - oldIndivs.size() // because they were already // here - curExceptions.size()); // because they weren't added } }
/** * Calculates data nodes for replicated caches on unstable topology. * * @param cctx Cache context for main space. * @param extraSpaces Extra spaces. * @return Collection of all data nodes owning all the caches or {@code null} for retry. */ private Collection<ClusterNode> replicatedUnstableDataNodes( final GridCacheContext<?, ?> cctx, List<String> extraSpaces) { assert cctx.isReplicated() : cctx.name() + " must be replicated"; Set<ClusterNode> nodes = replicatedUnstableDataNodes(cctx); if (F.isEmpty(nodes)) return null; // Retry. if (!F.isEmpty(extraSpaces)) { for (String extraSpace : extraSpaces) { GridCacheContext<?, ?> extraCctx = cacheContext(extraSpace); if (extraCctx.isLocal()) continue; if (!extraCctx.isReplicated()) throw new CacheException( "Queries running on replicated cache should not contain JOINs " + "with tables in partitioned caches [rCache=" + cctx.name() + ", pCache=" + extraSpace + "]"); Set<ClusterNode> extraOwners = replicatedUnstableDataNodes(extraCctx); if (F.isEmpty(extraOwners)) return null; // Retry. nodes.retainAll(extraOwners); if (nodes.isEmpty()) return null; // Retry. } } return nodes; }