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
The code is generally well-structured and readable. It follows a clear logical organization with methods grouped by functionality. The class has a single responsibility: implementing a descending view of a multiset. Nesting is minimal — only one inner class exists with flat, simple methods. The lazy initialization pattern for `comparator`, `elementSet`, and `entrySet` is consistent and clear. Method names accurately describe their intent, and the delegation pattern makes the code's purpose obvious. However, some lines (like the ternary with assignment in `entrySet()`) combine multiple actions, slightly reducing clarity. The return type with assignment (`return elementSet = new ...`) is terse but potentially confusing. Overall, the code maintains strong readability with only minor opportunities for improvement in action granularity and expression clarity.
Run 2
The code demonstrates excellent readability with clear structure and intent. It follows a logical organization with related methods grouped together (comparator, elementSet, entry operations, delegation). Nesting is minimal, with only one inner class implementation. Each method has a single, clear purpose and is concise. Lazy initialization patterns are consistently applied and easy to follow. The naming is descriptive and follows Java conventions. Reading flow is natural—methods delegate cleanly to forwardMultiset() with reversed semantics. Action granularity is appropriate, with one logical operation per line. Comments and annotations provide useful context without clutter. The abstract contract is well-defined at the top, making the implementation's purpose immediately clear. Minor deductions for slight complexity in null-check ternaries and the inner EntrySetImpl class placement, but overall this represents production-quality, maintainable code that balances conciseness with clarity.
Run 3
The code demonstrates clear structure with logical method grouping: comparators, element sets, entry manipulation, range views, and collection operations. Nesting is minimal—only one inner class with three straightforward methods. Intent is unambiguous: each method name clearly expresses its purpose, and the descending multiset wrapper pattern is consistently applied via delegation to forwardMultiset(). Lazy initialization fields with @LazyInit annotations are idiomatically handled with clear null checks. Code length is appropriate—no redundant methods; each override implements a distinct SortedMultiset contract. Action granularity is mostly one action per line, particularly in delegation methods like pollFirstEntry() and headMultiset(). Reading flow is natural: related operations are adjacent, and the delegation pattern makes the reversal logic immediately apparent. Minor deductions: the ternary in entrySet() slightly reduces readability compared to if/else style used elsewhere, and the @WeakOuter annotation and nullness annotation noise (though standard for Google's codebase) adds visual clutter for general readers.
Run 1
Code Structure: Well-organized skeleton implementation with focused overrides and related cached fields near their accessors. Nesting: Mostly flat; lazy initialization and the local entry-set class add only modest nesting. Clarity of intent: Descriptive names, documentation, and explicit first/last and head/tail reversals clearly communicate descending-view behavior, though framework-specific helpers require familiarity. Code length: Concise methods avoid unnecessary logic; repeated delegation is appropriate for the interface. Action granularity: Most statements perform one action, but assignments embedded in returns and the entrySet ternary combine caching with result selection. Reading flow: Consistent formatting and straightforward delegation make the class easy to follow, although differing lazy-initialization styles and scattered entry-related methods slightly reduce consistency.
Run 2
Code Structure: Well-organized implementation with small methods and clear delegation, though cached fields are interspersed with methods. Nesting: Mostly flat, with simple conditionals and one manageable local class. Clarity of intent: Descriptive names and the class documentation clearly communicate the descending-view behavior; reversed operations are easy to recognize. Code length: Concise, with little unnecessary logic despite numerous interface overrides. Action granularity: Most statements perform one action, but assignment within a return and a ternary combines caching and returning, slightly reducing clarity. Reading flow: Consistent formatting and straightforward delegation support smooth reading; annotations, generic types, and differing lazy-initialization styles introduce minor visual complexity.
Run 3
Code Structure: Well-organized overrides and small methods clearly implement a descending view through delegation, although grouping all related operations together would improve organization. Nesting: Mostly flat, with only simple cache checks and a modest local class. Clarity of intent: Descriptive names, documentation, and explicit first/last and head/tail reversals make the purpose clear; framework-specific annotations and helpers require background knowledge. Code length: Concise for the functionality provided, with little unnecessary code. Action granularity: Most statements perform one action, but assignment within returns and the caching ternary combine operations. Reading flow: Consistent formatting and straightforward delegation support smooth reading, slightly interrupted by scattered cache fields and differing lazy-initialization styles.