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;
@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")
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 clear and logically organized, following standard Guava patterns. Methods are short, with one primary action per line, and nesting is minimal. Naming conventions make intent obvious. However, readability is slightly reduced by the heavy use of null-checked lazy initialization, which adds boilerplate and interrupts natural flow. The file has redundant blank lines at the top, and some methods (like `subMultiset`) chain several calls in one line, reducing clarity. Overall it is readable but not maximally concise or flowing.
Run 2
This code is highly readable due to its clear logical structure, consistent naming, and straightforward delegation pattern. The class follows a single responsibility: reversing the order of a sorted multiset by delegating to an underlying forward multiset. Methods are short, focused, and named clearly (e.g., pollFirstEntry delegates to pollLastEntry). Nesting is minimal, with only one inner class and no deep conditionals. Lazy initialization is handled elegantly with a simple null-check ternary or if-statement. The code is concise without sacrificing clarity, and each line performs a single logical action. Annotations like @LazyInit and @WeakOuter add useful context. Minor deductions come from slightly verbose type annotations (e.g., @ParametricNullness) and a few wrapped method signatures that add visual noise, but overall the reading flow is natural and the intent is immediately clear.
Run 3
The code is generally clear and well-structured, with logical method organization and consistent delegation to a forwardMultiset(). Each method has a single clear purpose, and the lazy initialization pattern is applied consistently. However, readability is reduced by several factors: the generics and annotations are lengthy and visually dense, there is redundant null-check boilerplate across multiple methods, and some lines are very long (e.g., method signatures with annotations). The createEntrySet() inner class adds nesting and interrupts the flow slightly. Overall, the class is understandable for experienced Java developers familiar with Guava-style code, but the verbosity and repetition of null-handling prevent a higher score.
Run 1
Code Structure: Well-organized forwarding implementation with small, focused overrides and cached views placed near their accessors. Nesting: Mostly flat; the local EntrySetImpl class adds limited, manageable nesting. Clarity of intent: Descriptive method names and consistent reversal of first/last and head/tail operations clearly convey descending-view behavior, though reversed subMultiset arguments require attention. Code length: Concise for the interface implemented, with little unnecessary logic; excessive blank lines after imports add visual noise. Action granularity: Most lines perform a single action, but assignments embedded in returns and the entrySet ternary combine initialization and returning, slightly reducing clarity. Reading flow: Formatting and short methods support easy scanning, although inconsistent lazy-initialization styles and the placement of entryIterator between public methods mildly interrupt the flow.
Run 2
Code Structure: Well-organized forwarding class with small, focused overrides, though cached fields are interspersed with methods. Nesting: Mostly flat; lazy-initialization checks and one local class introduce only modest nesting. Clarity of intent: Descriptive names and explicit first/last and head/tail reversals clearly communicate descending behavior. Generic types and annotations add some visual complexity. Code length: Concise implementations with little unnecessary logic; repeated overrides are appropriate for the interface, but excessive blank lines add noise. Action granularity: Most statements perform one action, although assignment inside a return and a ternary expression combine caching and returning. Reading flow: Consistent formatting and straightforward delegation make the code easy to follow, with minor interruptions from scattered cache declarations and inconsistent lazy-initialization styles.
Run 3
Code Structure: Well-organized into small overriding methods, with related operations mostly grouped together; cached fields are somewhat scattered. Nesting: Shallow overall, with simple null checks and one local class adding modest nesting. Clarity of intent: Descriptive method names and explicit reversal of forward operations clearly communicate the descending-view behavior, though annotations and helper classes require library familiarity. Code length: Appropriately concise for the interface implementation, with little unnecessary logic; excessive blank lines before the class add clutter. Action granularity: Most lines perform a single action, but assignment inside a return and a ternary combines caching and returning, reducing immediate clarity. Reading flow: Consistent formatting and short delegation methods make the code easy to scan, although inconsistent lazy-initialization styles and interspersed fields slightly interrupt the flow.