Source code
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.concurrent.LazyInit;
import com.google.j2objc.annotations.WeakOuter;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NavigableSet;
import java.util.Set;
import org.jspecify.annotations.Nullable;
/**
* A skeleton implementation of a descending multiset. Only needs {@code forwardMultiset()} and
* {@code entryIterator()}.
*
* @author Louis Wasserman
*/
@GwtCompatible
abstract class DescendingMultiset<E extends @Nullable Object> extends ForwardingMultiset<E>
implements SortedMultiset<E> {
abstract SortedMultiset<E> forwardMultiset();
@LazyInit private transient @Nullable Comparator<? super E> comparator;
@Override
public Comparator<? super E> comparator() {
Comparator<? super E> result = comparator;
if (result == null) {
result = Ordering.from(forwardMultiset().comparator()).reverse();
comparator = result;
}
return result;
}
@LazyInit private transient @Nullable NavigableSet<E> elementSet;
@Override
public NavigableSet<E> elementSet() {
NavigableSet<E> result = elementSet;
if (result == null) {
return elementSet = new SortedMultisets.NavigableElementSet<>(this);
}
return result;
}
@Override
public @Nullable Entry<E> pollFirstEntry() {
return forwardMultiset().pollLastEntry();
}
@Override
public @Nullable Entry<E> pollLastEntry() {
return forwardMultiset().pollFirstEntry();
}
@Override
public SortedMultiset<E> headMultiset(@ParametricNullness E toElement, BoundType boundType) {
return forwardMultiset().tailMultiset(toElement, boundType).descendingMultiset();
}
@Override
public SortedMultiset<E> subMultiset(
@ParametricNullness E fromElement,
BoundType fromBoundType,
@ParametricNullness E toElement,
BoundType toBoundType) {
return forwardMultiset()
.subMultiset(toElement, toBoundType, fromElement, fromBoundType)
.descendingMultiset();
}
@Override
public SortedMultiset<E> tailMultiset(@ParametricNullness E fromElement, BoundType boundType) {
return forwardMultiset().headMultiset(fromElement, boundType).descendingMultiset();
}
@Override
protected Multiset<E> delegate() {
return forwardMultiset();
}
@Override
public SortedMultiset<E> descendingMultiset() {
return forwardMultiset();
}
@Override
public @Nullable Entry<E> firstEntry() {
return forwardMultiset().lastEntry();
}
@Override
public @Nullable Entry<E> lastEntry() {
return forwardMultiset().firstEntry();
}
abstract Iterator<Entry<E>> entryIterator();
@LazyInit private transient @Nullable Set<Entry<E>> entrySet;
@Override
public Set<Entry<E>> entrySet() {
Set<Entry<E>> result = entrySet;
return (result == null) ? entrySet = createEntrySet() : result;
}
Set<Entry<E>> createEntrySet() {
@WeakOuter
final class EntrySetImpl extends Multisets.EntrySet<E> {
@Override
Multiset<E> multiset() {
return DescendingMultiset.this;
}
@Override
public Iterator<Entry<E>> iterator() {
return entryIterator();
}
@Override
public int size() {
return forwardMultiset().entrySet().size();
}
}
return new EntrySetImpl();
}
@Override
public Iterator<E> iterator() {
return Multisets.iteratorImpl(this);
}
@Override
public @Nullable Object[] toArray() {
return standardToArray();
}
@Override
@SuppressWarnings("nullness") // b/192354773 in our checker affects toArray declarations
public <T extends @Nullable Object> T[] toArray(T[] array) {
return standardToArray(array);
}
@Override
public String toString() {
return entrySet().toString();
}
}
Run 1
This code is highly readable. The class has a clear single responsibility: providing a descending view of a multiset. The structure is logical, with methods grouped by concern and following the `SortedMultiset` contract. Nesting is minimal; the only inner class is justified for the entry set and has a clear purpose. Intent is evident from method names like `descendingMultiset()` and comments explaining deferred initialization. Code length is appropriate for the functionality, avoiding unnecessary boilerplate through delegation to `forwardMultiset()`. Each method performs one logical action, adhering to good action granularity. The reading flow is natural: constructors, comparator, element set, then mutating/derivative views. Layering with lazy initialization fields (`@LazyInit`) is a standard pattern here and does not obscure logic. Overall, only minor verbose annotations slightly reduce readability, but structure and clarity are excellent.
Run 2
The code demonstrates good structure with a clear class hierarchy and logical organization of methods. Nesting is minimal—only one deeply nested inner class appears in createEntrySet(). Intent is generally clear: the class provides a descending view of a multiset by delegating to a forward multiset with reversed semantics. Method delegations like headMultiset and subMultiset are concise and readable, with arguments swapped appropriately. Action granularity is mostly one operation per line, especially in comparator() and elementSet() lazy initialization. Reading flow is natural, following consistent ordering of related methods. Some minor readability drawbacks include the use of lazy initialization with null-check patterns repeated in three places, which adds slight boilerplate, and the compact ternary in entrySet() slightly reduces clarity. Type annotations like @ParametricNullness and @Nullable add noise but are necessary for nullness checking. Overall, the code is highly readable for an experienced Java developer familiar with Guava conventions.
Run 3
The code is highly readable with clear structure, flat nesting, and strong intent. It demonstrates excellent lazy initialization patterns and logical delegation to the forward multiset. Each method has a single responsibility and follows consistent conventions. The reading flow is natural, with methods grouped by functionality. Minor deductions: the entrySet() method uses a ternary with assignment that slightly reduces action granularity, and the toArray() method includes a suppression annotation that adds visual noise. The class-level Javadoc is brief but adequate. Overall, the code effectively balances conciseness with clarity, making the descending multiset implementation easy to understand despite the complexity of the underlying data structure.
Run 1
Code Structure: Well-organized forwarding implementation with small, focused methods, though cached fields are interspersed with methods. Nesting: Mostly flat; the local entry-set class adds modest nesting without tangled control flow. Clarity of intent: Descriptive names and class documentation clearly establish descending behavior; reversed operations are easy to recognize. Code length: Concise delegation avoids unnecessary logic, although override and annotation boilerplate adds visual weight. Action granularity: Most lines perform one action, but assignment within returns and the entrySet ternary combine caching and returning, slightly reducing readability. Reading flow: Consistent formatting and paired operations support natural reading; differing lazy-initialization styles introduce minor inconsistency.
Run 2
Code Structure: Well-organized forwarding implementation with small, focused overrides; cached fields are placed near their accessors. Nesting: Mostly flat, with simple null checks and one local class adding modest depth. Clarity of intent: Descriptive names and introductory documentation clearly explain the descending view; swapped first/last and head/tail operations communicate reversal naturally. Code length: Concise methods and standard helpers avoid unnecessary implementation detail, though forwarding boilerplate adds length. Action granularity: Most lines perform one action, but assignment within returns and the entrySet ternary combine caching and returning, slightly reducing clarity. Reading flow: Consistent formatting and straightforward delegation make the code easy to follow; inconsistent lazy-initialization styles and somewhat scattered related operations introduce minor friction.
Run 3
Code Structure: Well-organized implementation with small overrides and a localized entry-set helper, though cached fields are interspersed with methods. Nesting: Mostly flat, with only simple null checks and one local class. Clarity of intent: Descriptive names and the class documentation clearly explain the descending view; reversed delegation makes its behavior easy to follow. Code length: Concise methods avoid unnecessary logic, and repetitive overrides are justified by the interface. Action granularity: Most statements perform one action, but assignment within a return and the conditional expression in entrySet() combine caching and returning, slightly reducing clarity. Reading flow: Consistent formatting and predictable delegation support natural reading, although inconsistent lazy-initialization styles and annotation-heavy signatures introduce minor friction.