@Override public UnmodifiableIterator<E> iterator() { Iterable<E> incidentEdges = (selfLoopCount == 0) ? Iterables.concat(inEdgeMap.keySet(), outEdgeMap.keySet()) : Sets.union(inEdgeMap.keySet(), outEdgeMap.keySet()); return Iterators.unmodifiableIterator(incidentEdges.iterator()); }
private Set<String> mergeColumns(final Set<String> arg1, final Set<String> arg2) { if (arg1.isEmpty()) { return arg2; } if (arg2.isEmpty()) { return arg1; } if (arg1.equals(arg2)) { return arg1; } return Sets.union(arg1, arg2); } }
public DimensionsSpec withDimensionExclusions(Set<String> dimExs) { return new DimensionsSpec( dimensions, ImmutableList.copyOf(Sets.union(dimensionExclusions, dimExs)), null ); }
@Override protected Set<String> create(String[] elements) { return Sets.union(Sets.<String>newHashSet(), Sets.newHashSet(elements)); } })
@Override protected Set<String> create(String[] elements) { return Sets.union(Sets.newHashSet(elements), Sets.<String>newHashSet()); } })
@Override protected Set<String> create(String[] elements) { return Sets.union( Sets.<String>newHashSet(elements[0], elements[1]), Sets.newHashSet(elements[1], elements[2])); } })
@Override protected Set<String> create(String[] elements) { return Sets.union(Sets.<String>newHashSet(), Sets.<String>newHashSet()); } })
@Override Set<E> createElementSet() { return Sets.union(multiset1.elementSet(), multiset2.elementSet()); }
@Override Set<E> createElementSet() { return Sets.union(multiset1.elementSet(), multiset2.elementSet()); }
@Override public Set<N> adjacentNodes() { return Sets.union(predecessors(), successors()); }
@Override protected Set<String> create(String[] elements) { checkArgument(elements.length == 1); return Sets.union(Sets.<String>newHashSet(elements), Sets.newHashSet(elements)); } })
@Override protected Set<String> create(String[] elements) { checkArgument(elements.length == 3); return Sets.union( Sets.newHashSet(elements[0]), Sets.newHashSet(elements[1], elements[2])); } })
@Override protected Set<String> create(String[] elements) { checkArgument(elements.length == 3); // Put the sets in different orders for the hell of it return Sets.union( Sets.newLinkedHashSet(asList(elements)), Sets.newLinkedHashSet(asList(elements[1], elements[0], elements[2]))); } })
@Override public Set<E> adjacentEdges(E edge) { EndpointPair<N> endpointPair = incidentNodes(edge); // Verifies that edge is in this network. Set<E> endpointPairIncidentEdges = Sets.union(incidentEdges(endpointPair.nodeU()), incidentEdges(endpointPair.nodeV())); return Sets.difference(endpointPairIncidentEdges, ImmutableSet.of(edge)); }
@Override protected Set<String> create(String[] elements) { int size = elements.length; // Remove last element, if size > 1 Set<String> set1 = (size > 1) ? Sets.newHashSet(Arrays.asList(elements).subList(0, size - 1)) : Sets.newHashSet(elements); // Remove first element, if size > 0 Set<String> set2 = (size > 0) ? Sets.newHashSet(Arrays.asList(elements).subList(1, size)) : Sets.<String>newHashSet(); return Sets.union(set1, set2); } })
private boolean containsCorrelation(PlanNode node, List<Symbol> correlation) { return Sets.union(SymbolsExtractor.extractUnique(node, lookup), SymbolsExtractor.extractOutputSymbols(node, lookup)).stream().anyMatch(correlation::contains); }
public void testUnion() { Set<String> all = Sets.union(friends, enemies); assertEquals(5, all.size()); ImmutableSet<String> immut = Sets.union(friends, enemies).immutableCopy(); HashSet<String> mut = Sets.union(friends, enemies).copyInto(new HashSet<String>()); enemies.add("Buck"); assertEquals(6, all.size()); assertEquals(5, immut.size()); assertEquals(5, mut.size()); }
public void testContainsAll() { ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers()); for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) { assertTrue(set.containsAll(subset)); } for (Set<Integer> subset : Sets.powerSet(ImmutableSet.of(1, 2, 3))) { assertFalse(set.containsAll(Sets.union(subset, ImmutableSet.of(9)))); } assertFalse(set.containsAll((Collection<?>) ImmutableSet.of("blah"))); }
@Test public void testUnion() { WrappedBitSetBitmap bitSet = new WrappedBitSetBitmap(IntSetTestUtility.createSimpleBitSet(IntSetTestUtility.getSetBits())); Set<Integer> extraBits = Sets.newHashSet(6, 9); WrappedBitSetBitmap bitExtraSet = new WrappedBitSetBitmap(IntSetTestUtility.createSimpleBitSet(extraBits)); Set<Integer> union = Sets.union(extraBits, IntSetTestUtility.getSetBits()); Assert.assertTrue(IntSetTestUtility.equalSets(union, (WrappedBitSetBitmap) bitSet.union(bitExtraSet))); }
public PlanNodeStatsAssertion equalTo(PlanNodeStatsEstimate expected) { assertEstimateEquals(actual.getOutputRowCount(), expected.getOutputRowCount(), "outputRowCount mismatch"); for (Symbol symbol : union(expected.getSymbolsWithKnownStatistics(), actual.getSymbolsWithKnownStatistics())) { assertSymbolStatsEqual(symbol, actual.getSymbolStatistics(symbol), expected.getSymbolStatistics(symbol)); } return this; }