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))) {} else {
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))) {} else {
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
The code is generally well-structured and follows clear organizational patterns. The class has a single responsibility and delegates most operations to the forward multiset, which keeps methods concise. Most methods are short and have a clear purpose. The ordering of methods is logical, grouping related functionality together. However, readability is slightly reduced by the unusual `if (!((result == null))) {} else { ... }` pattern in `comparator()` and `elementSet()`, where a simple `if (result == null)` would be clearer. The reverse argument order in `subMultiset()` (passing `toElement` first) is intentional but slightly confusing without documentation. The lazy initialization pattern is consistent, and the use of `@LazyInit` and nullness annotations adds clarity. Overall, it reads naturally for a Guava collection implementation, with reasonable nesting and granularity.
Run 2
The code is generally well-structured and readable, with clear class purpose, logical organization, and concise method implementations. Most methods are flat and follow a natural reading flow. However, several factors reduce readability: the lazy initialization pattern in comparator() and elementSet() uses an awkward if-else structure (empty if block with logic in else) that disrupts natural reading flow; the class deals with non-trivial bidirectional relationships between views (headMultiset/tailMultiset/subMultiset) that require careful reading; and the anonymous inner class EntrySetImpl adds nesting. The file assumes familiarity with Guava collection patterns like ForwardingMultiset, SortedMultiset, and Multisets.EntrySet, making it less accessible to newcomers. Action granularity is mostly good, with one operation per line. Code length is appropriate—methods are short and focused. The abstract methods forwardMultiset() and entryIterator() clearly define the extension contract. Nullability annotations are consistent but add visual noise. Overall, this is professional-grade code with minor style inconsistencies that prevent a higher score.
Run 3
The code is moderately readable as a Guava-style abstract class with clear method names and logical delegation to a forward multiset. However, several issues reduce clarity. The lazy initialization pattern `if (!((result == null))) {} else { ... }` is unnecessarily awkward; a simple null check would be far more readable. The use of `@Nullable`, `@ParametricNullness`, and interleaved annotations adds noise, though this is partly due to nullness checker requirements. Nesting is low overall, but the `EntrySetImpl` inner class and ternary expression in `entrySet()` add minor complexity. Action granularity is mostly one action per line, which helps. Reading flow follows a natural progression, but the odd conditional style breaks comprehension. The class could be improved by simplifying the lazy-init conditionals, reducing annotation clutter via imports or convention, and standardizing lazy initialization with a helper method.
Run 1
Code Structure: Well-organized skeletal implementation with focused overrides, cached views, and a small local entry-set class. Nesting: Mostly flat; the local class adds modest, manageable nesting. Clarity of intent: Descriptive names and documentation clearly convey descending-order delegation, but negated null checks with empty branches obscure straightforward lazy initialization. Code length: Most methods are concise; interface-driven boilerplate is reasonable, though the empty branches are unnecessary. Action granularity: Most lines perform one action, but assignment within return expressions combines caching and returning, particularly in the ternary expression. Reading flow: Consistent formatting and simple forwarding methods support natural reading, while unusual conditionals and inconsistent lazy-initialization styles interrupt it.
Run 2
Code Structure: Well-organized skeletal implementation with focused methods and consistent delegation, although cached fields are interspersed with methods. Nesting: Mostly flat; the local entry-set class adds limited, manageable nesting. Clarity of intent: Documentation, descriptive names, and reversed delegation clearly convey descending behavior. However, negated null checks with redundant parentheses and empty branches obscure straightforward lazy initialization. Code length: Appropriately concise for the interface, with little unnecessary code beyond the awkward conditionals. Action granularity: Most lines perform one clear action, but assignment within return statements and a ternary combines caching and returning. Reading flow: Consistent formatting and short methods support natural reading; inconsistent lazy-initialization styles and empty if branches interrupt it.
Run 3
Code Structure: Well-organized implementation with short methods, consistent overrides, and localized caching. Nesting: Mostly flat; the local entry-set class adds modest, purposeful nesting. Clarity of intent: Descriptive names and documentation make descending-view delegation clear, but negated null checks with redundant parentheses and empty branches obscure simple lazy initialization. Code length: Concise overall, with necessary interface implementations and little duplication beyond delegation. Action granularity: Most lines perform one action, though assignment inside a return and a ternary combines caching with returning values. Reading flow: Consistent formatting and straightforward forwarding methods support natural reading; unusual conditionals and inconsistent caching styles interrupt it.