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 is highly readable. It follows a clear, logical structure with methods organized by functionality. Nesting is minimal and mostly flat, with only one small inner class that is well-scoped. Intent is clear: each method explicitly delegates to the forward multiset, making the reverse-order behavior obvious. The code is concise, avoiding redundancy through delegation. Action granularity is appropriate, with single responsibilities per line or expression. Reading flow is natural, from comparator to element set to entry operations. Minor deductions: the lazy initialization pattern is slightly repetitive (three fields with similar null-check logic), and a few long lines reduce readability, but overall this is excellent code.
Run 3
The code is well-structured and readable. It follows a consistent pattern of delegating to the forward multiset with reversed operations, making the intent clear. The class uses lazy initialization for comparator, elementSet, and entrySet, which is a common and understandable pattern. Methods are concise and have clear purposes, with meaningful names. Nesting is minimal except for one inner class, which is appropriately used. Action granularity is good, with most methods containing one logical operation. Nullability annotations and Javadoc improve clarity. The reading flow is logical, grouping related operations together. Minor deductions: some one-line return statements combine assignment and return, slightly reducing readability. The inner class could be extracted but is acceptable given its tight coupling. Overall, this is well-written library code.
Run 1
Code Structure: Well-organized skeleton implementation with small, focused methods, though cached fields are interspersed with methods. Nesting: Mostly flat; lazy-initialization checks and a small local class introduce only modest nesting. Clarity of intent: Descriptive names and class documentation clearly convey the descending-view behavior; reversed delegation makes the implementation easy to understand. Code length: Concise for its responsibilities, with necessary interface overrides and little unnecessary logic. Action granularity: Most lines perform one action, but assignment within return expressions and the entrySet ternary combine caching and returning, slightly reducing readability. Reading flow: Consistent formatting and straightforward delegation support natural reading, although related first/last operations are separated and lazy initialization uses inconsistent styles. Annotations and generic types add visual complexity but provide useful contract information.
Run 2
Code Structure: Well-organized adapter with focused overrides and localized caching fields, though related methods could be grouped more consistently. Nesting: Mostly flat; only simple conditionals and a small local class introduce nesting. Clarity of intent: Descriptive names, class documentation, and explicit first/last and head/tail reversals clearly communicate descending-view behavior. Code length: Concise delegation avoids unnecessary implementation detail; annotations and generic signatures add some visual weight. Action granularity: Most statements perform one action, but assignment inside a return and a ternary combines caching with result selection. Reading flow: Consistent formatting and short methods make scanning easy, although inconsistent lazy-initialization styles and scattered related operations slightly interrupt the flow.
Run 3
Code Structure: Well-organized skeletal implementation with focused overrides and localized caching logic, though related reversed operations could be grouped more closely. Nesting: Mostly flat methods; the local entry-set class adds only modest nesting. Clarity of intent: Descriptive names and class documentation clearly convey the descending-view purpose, with straightforward delegation and reversal. Generic types and annotations add some visual complexity. Code length: Concise for the functionality provided; most methods are short, without unnecessary logic. Action granularity: Generally one action per line, but assignment within return statements and the entrySet ternary combine caching and returning, slightly reducing clarity. Reading flow: Consistent formatting and predictable delegation make scanning easy, although differing lazy-initialization styles and scattered related methods mildly interrupt the flow.