public void testToImmutableMultiset() { BiPredicate<ImmutableMultiset<String>, ImmutableMultiset<String>> equivalence = (ms1, ms2) -> ms1.equals(ms2) && ms1.entrySet().asList().equals(ms2.entrySet().asList()); CollectorTester.of(ImmutableMultiset.<String>toImmutableMultiset(), equivalence) .expectCollects(ImmutableMultiset.of()) .expectCollects( ImmutableMultiset.of("a", "a", "b", "c", "c", "c"), "a", "a", "b", "c", "c", "c"); }
@Override protected Set<String> create(String[] elements) { return ImmutableMultiset.copyOf(elements).elementSet(); } })
/** * Returns an immutable multiset containing the given elements, in the "grouped iteration order" * described in the class documentation. * * @throws NullPointerException if any of {@code elements} is null */ public static <E> ImmutableMultiset<E> copyOf(Iterable<? extends E> elements) { if (elements instanceof ImmutableMultiset) { @SuppressWarnings("unchecked") // all supported methods are covariant ImmutableMultiset<E> result = (ImmutableMultiset<E>) elements; if (!result.isPartialView()) { return result; } } Multiset<? extends E> multiset = (elements instanceof Multiset) ? Multisets.cast(elements) : LinkedHashMultiset.create(elements); return copyFromEntries(multiset.entrySet()); }
private void testImmutableXXX() { assertEquals(5, ImmutableList.of(1, 2, 3, 4, 5).size()); assertEquals(5, ImmutableSet.of(1, 2, 3, 4, 5).size()); assertEquals(5, ImmutableSortedSet.of(1, 2, 3, 4, 5).size()); assertEquals(3, ImmutableMap.of(1, 2, 3, 4, 5, 6).size()); assertEquals(3, ImmutableSortedMap.of(1, 2, 3, 4, 5, 6).size()); assertEquals(9, ImmutableMultiset.of(1, 1, 2, 2, 3, 3, 4, 5, 6).size()); assertEquals(6, ImmutableMultiset.of(1, 1, 2, 2, 3, 3, 4, 5, 6).elementSet().size()); assertEquals(2, ImmutableMultiset.of(1, 1, 2, 2, 3, 3, 4, 5, 6).count(1)); } }
final void check() { runTester() .assertNonNullValues( Gender.MALE, Integer.valueOf(0), 0, "", "", ImmutableList.of(), ImmutableList.of(), ImmutableMap.of(), ImmutableMap.of(), ImmutableSet.of(), ImmutableSet.of(), ImmutableSortedSet.of(), ImmutableSortedSet.of(), ImmutableMultiset.of(), ImmutableMultiset.of(), ImmutableMultimap.of(), ImmutableMultimap.of(), ImmutableTable.of(), ImmutableTable.of()); } }
public void testGet_collections() { assertEquals(ImmutableSet.of().iterator(), ArbitraryInstances.get(Iterator.class)); assertFalse(ArbitraryInstances.get(PeekingIterator.class).hasNext()); assertFalse(ArbitraryInstances.get(ListIterator.class).hasNext()); assertEquals(ImmutableSet.of(), ArbitraryInstances.get(Iterable.class)); assertEquals(ImmutableSet.of(), ArbitraryInstances.get(Set.class)); assertEquals(ImmutableSet.of(), ArbitraryInstances.get(ImmutableSet.class)); assertEquals(ImmutableSortedMap.of(), ArbitraryInstances.get(SortedMap.class)); assertEquals(ImmutableSortedMap.of(), ArbitraryInstances.get(ImmutableSortedMap.class)); assertEquals(ImmutableMultiset.of(), ArbitraryInstances.get(Multiset.class)); assertEquals(ImmutableMultiset.of(), ArbitraryInstances.get(ImmutableMultiset.class)); assertTrue(ArbitraryInstances.get(SortedMultiset.class).isEmpty()); assertEquals(ImmutableMultimap.of(), ArbitraryInstances.get(Multimap.class));
public ClusterLayout(Constraints constraints, Multiset<NodeLayout> layout) { this.constraints = constraints; this.layout = ImmutableMultiset.copyOf(layout); this.serviceCounts = HashMultiset.create(); for (Multiset.Entry<NodeLayout> entry : layout.entrySet()) { for (String service : entry.getElement().getServiceNames()) { serviceCounts.add(service, entry.getCount()); } } }
public void testBuilderAddAllImmutableMultiset() { Multiset<String> a = ImmutableMultiset.of("a", "b", "b"); Multiset<String> b = ImmutableMultiset.of("c", "b"); ImmutableMultiset<String> multiset = new ImmutableMultiset.Builder<String>().addAll(a).addAll(b).build(); assertEquals(HashMultiset.create(asList("a", "b", "b", "b", "c")), multiset); }
ImmutableMultiset.toImmutableMultiset(); BiPredicate<ImmutableMultiset<TypeWithDuplicates>, ImmutableMultiset<TypeWithDuplicates>> equivalence = (ms1, ms2) -> { if (!ms1.equals(ms2)) { return false; List<TypeWithDuplicates> elements1 = ImmutableList.copyOf(ms1.elementSet()); List<TypeWithDuplicates> elements2 = ImmutableList.copyOf(ms2.elementSet()); for (int i = 0; i < ms1.elementSet().size(); i++) { if (!elements1.get(i).fullEquals(elements2.get(i))) { return false; CollectorTester.of(collector, equivalence) .expectCollects( ImmutableMultiset.<TypeWithDuplicates>builder().add(a).addCopies(b1, 2).add(c).build(), a, b1, c, b2); collector = ImmutableMultiset.toImmutableMultiset(e -> e, e -> 1); CollectorTester.of(collector, equivalence) .expectCollects( ImmutableMultiset.<TypeWithDuplicates>builder().add(a).addCopies(b1, 2).add(c).build(), a, b1,
public void testHighestCountFirst() { Multiset<String> multiset = HashMultiset.create(Arrays.asList("a", "a", "a", "b", "c", "c")); ImmutableMultiset<String> sortedMultiset = Multisets.copyHighestCountFirst(multiset); assertThat(sortedMultiset.entrySet()) .containsExactly( Multisets.immutableEntry("a", 3), Multisets.immutableEntry("c", 2), Multisets.immutableEntry("b", 1)) .inOrder(); assertThat(sortedMultiset).containsExactly("a", "a", "a", "c", "c", "b").inOrder(); assertThat(Multisets.copyHighestCountFirst(ImmutableMultiset.of())).isEmpty(); }
@Override public ImmutableSet<Variable> getRequiredVariables(IntermediateQuery query) { ImmutableMultiset<Variable> childrenVariableBag = query.getChildren(this).stream() .flatMap(c -> query.getVariables(c).stream()) .collect(ImmutableCollectors.toMultiset()); Stream<Variable> cooccuringVariableStream = childrenVariableBag.entrySet().stream() .filter(e -> e.getCount() > 1) .map(Multiset.Entry::getElement); return Stream.concat(cooccuringVariableStream, getLocallyRequiredVariables().stream()) .collect(ImmutableCollectors.toSet()); }
@Override public UnmodifiableIterator<E> iterator() { final Iterator<Entry<E>> entryIterator = entrySet().iterator(); return new UnmodifiableIterator<E>() { int remaining; @MonotonicNonNull E element; @Override public boolean hasNext() { return (remaining > 0) || entryIterator.hasNext(); } @Override public E next() { if (remaining <= 0) { Entry<E> entry = entryIterator.next(); element = entry.getElement(); remaining = entry.getCount(); } remaining--; return element; } }; }
public String getMostUsedArticleCasing() { HashMultiset<String> articleNames = HashMultiset.create(); String result; for (Writable writable: super.get()) { LinkWritable link = (LinkWritable)writable; articleNames.add(link.getArticle().toString()); } ImmutableMultiset<String> sorted = Multisets.copyHighestCountFirst(articleNames); result = (String)sorted.elementSet().toArray()[0]; return result; } }