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 generally readable and well-structured, following clear patterns and conventions. It uses lazy initialization consistently, has a logical organization with related methods grouped together, and keeps nesting shallow. Method names clearly express intent, and each method performs a single focused action. However, readability is somewhat reduced by heavy use of type annotations and generics, which add visual noise. Some methods contain multiple actions in a single line (e.g., lazy initialization with assignment inside a return statement), slightly compromising the 'one action per line' principle. The inner class EntrySetImpl adds moderate nesting complexity, though it is isolated in a single method. Overall, the code is concise and follows natural reading flow, but the generic type annotations and inline lazy initialization patterns prevent it from achieving a higher score.
Run 3
The code is well-structured and readable. It follows a clear class hierarchy and delegates operations to a forward multiset, making the intent obvious. Nesting is minimal except for the inner EntrySetImpl class, which is appropriately scoped and annotated. Lazy initialization is handled consistently with clear patterns. Each method performs a single logical action, and method names clearly convey purpose. The code is concise, avoids unnecessary verbosity, and maintains a natural reading flow. Type annotations and nullability markers are used consistently. Some minor complexity arises from generic type parameters and nullability annotations, but this is typical for high-quality library code and does not significantly hinder readability.
Run 1
Code Structure: Well-organized skeleton implementation with small, focused methods and localized caching logic, although related reversal methods could be grouped more consistently. Nesting: Mostly flat; the local entry-set class introduces modest, manageable nesting. Clarity of intent: Descriptive names, the class documentation, and explicit first/last and head/tail reversals make the descending-view behavior clear. Code length: Concise for the interface implemented; repetitive forwarding methods are justified rather than unnecessary. Action granularity: Most lines perform one clear action, but assignments embedded in returns and the entrySet ternary combine caching and return behavior. Reading flow: Consistent formatting and simple delegation support natural reading, though interspersed cache fields and differing lazy-initialization styles slightly interrupt consistency.
Run 2
Code Structure: Well-organized overrides and cached views form a coherent descending-multiset implementation, though grouping related operations more tightly could improve navigation. Nesting: Mostly flat, with shallow conditionals and one small local class. Clarity of intent: Descriptive method names, documentation, and explicit first/last and head/tail reversals communicate the purpose clearly; framework-specific annotations require familiarity. Code length: Concise delegation keeps methods short, with little unnecessary code. Action granularity: Most statements perform one clear action, but assignment inside a return and a ternary expression combines caching and returning. Reading flow: Consistent formatting and straightforward delegation support natural reading, although inconsistent lazy-initialization styles and scattered related methods introduce minor friction.
Run 3
Code Structure: Well-organized overrides and localized cached views make responsibilities easy to follow, although cache fields are interspersed with methods. Nesting: Mostly flat, with simple null checks and one small local class. Clarity of intent: Descriptive names and class documentation clearly communicate a descending wrapper; reversed delegation is straightforward. Generic types and nullness annotations add some visual complexity. Code length: Appropriately concise, with short methods and little unnecessary logic. Action granularity: Most statements perform one action, but assignment inside returns and the entrySet ternary combine caching and returning, slightly reducing clarity. Reading flow: Consistent formatting and predictable delegation support natural reading, though related first/last operations could be grouped more closely and lazy initialization styles could be standardized.