Source code
package com.google.common.collect;
import static com.google.common.collect.Sets.unmodifiableNavigableSet;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.collect.Multisets.UnmodifiableMultiset;
import com.google.errorprone.annotations.concurrent.LazyInit;
import java.util.Comparator;
import java.util.NavigableSet;
import org.jspecify.annotations.Nullable;
@GwtCompatible
final class UnmodifiableSortedMultiset<E extends @Nullable Object> extends UnmodifiableMultiset<E>
implements SortedMultiset<E> {
UnmodifiableSortedMultiset(SortedMultiset<E> delegate) {
super(delegate);
}
@Override
protected SortedMultiset<E> delegate() {
return (SortedMultiset<E>) super.delegate();
}
@Override
public Comparator<? super E> comparator() {
return delegate().comparator();
}
@Override
NavigableSet<E> createElementSet() {
return unmodifiableNavigableSet(delegate().elementSet());
}
@Override
public NavigableSet<E> elementSet() {
return (NavigableSet<E>) super.elementSet();
}
@LazyInit private transient @Nullable UnmodifiableSortedMultiset<E> descendingMultiset;
@Override
public SortedMultiset<E> descendingMultiset() {
UnmodifiableSortedMultiset<E> result = descendingMultiset;
if (result == null) {
result = new UnmodifiableSortedMultiset<>(delegate().descendingMultiset());
result.descendingMultiset = this;
return descendingMultiset = result;
}
return result;
}
@Override
public @Nullable Entry<E> firstEntry() {
return delegate().firstEntry();
}
@Override
public @Nullable Entry<E> lastEntry() {
return delegate().lastEntry();
}
@Override
public @Nullable Entry<E> pollFirstEntry() {
throw new UnsupportedOperationException();
}
@Override
public @Nullable Entry<E> pollLastEntry() {
throw new UnsupportedOperationException();
}
@Override
public SortedMultiset<E> headMultiset(@ParametricNullness E upperBound, BoundType boundType) {
return Multisets.unmodifiableSortedMultiset(delegate().headMultiset(upperBound, boundType));
}
@Override
public SortedMultiset<E> subMultiset(
@ParametricNullness E lowerBound,
BoundType lowerBoundType,
@ParametricNullness E upperBound,
BoundType upperBoundType) {
return Multisets.unmodifiableSortedMultiset(
delegate().subMultiset(lowerBound, lowerBoundType, upperBound, upperBoundType));
}
@Override
public SortedMultiset<E> tailMultiset(@ParametricNullness E lowerBound, BoundType boundType) {
return Multisets.unmodifiableSortedMultiset(delegate().tailMultiset(lowerBound, boundType));
}
@GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
}
Run 1
The code demonstrates clear structure with logical grouping of methods, each serving a distinct purpose. Nesting is minimal with only one level in the lazy initialization pattern. Intent is evident for each method - most delegate to the underlying multiset while mutating operations throw exceptions. The class name and inheritance hierarchy are self-documenting. Code length is appropriate, without unnecessary verbosity or duplication. Action granularity is excellent - each line performs one operation. Reading flow is natural, following a logical sequence from constructor through comparators, element sets, descending views, entry access, and sub-multiset views. The lazy initialization for descendingMultiset is a standard readable pattern, though requires careful reading to understand the circular reference. Overall, this is well-organized production code that maintains high readability while implementing an unmodifiable wrapper pattern.
Run 2
The code is well-structured and readable. It has a clear single responsibility: wrapping a SortedMultiset to make it unmodifiable. Methods are short, follow standard naming conventions, and delegate logically. Nesting is minimal, with only one null-check block in descendingMultiset(). Intent is clear throughout—most methods simply delegate or throw UnsupportedOperationException. Line length is appropriate, and actions are one per line. The reading flow is natural, with methods ordered logically (construction, overrides, basic accessors, then range operations). Minor deductions: the static import is slightly less readable than fully qualified names, and some boilerplate type-casting adds noise. The null-check caching in descendingMultiset is slightly non-obvious but still readable.
Run 3
The code is well-structured with clear class hierarchy and consistent delegation pattern. Nesting is minimal, with only one level in the lazy initialization block. Intent is clear: an unmodifiable wrapper for SortedMultiset. Method names and overrides are self-documenting. Code length is appropriate—each method is concise and delegates to the underlying implementation. Action granularity is good, with one logical operation per line in most cases. Reading flow is natural, following a logical order from constructor through comparators, element access, and range views. Minor deductions: the lazy initialization block has slightly unusual flow with the circular reference assignment, and the empty comment block is unnecessary. The serialVersionUID placement at the end slightly disrupts flow. Overall, this is idiomatic Java collection wrapper code with clear separation of concerns.
Run 1
Code Structure: Well-organized wrapper class with focused overrides and consistent delegation. Nesting: Very shallow, with only one conditional in the lazy initialization method. Clarity of intent: Class and method names clearly communicate an unmodifiable sorted multiset; mutation methods explicitly throw exceptions. The reciprocal descending-view cache is slightly less obvious without explanation. Code length: Methods are concise, although excessive blank lines add visual noise. Action granularity: Most statements perform one action; returning an assignment combines cache update and return, slightly reducing clarity. Reading flow: Consistent formatting and straightforward delegation make the code easy to scan, but irregular whitespace and the cache field appearing between methods mildly interrupt the flow.
Run 2
Code Structure: Well-organized wrapper class with focused methods and consistent delegation. Nesting: Almost entirely flat, with only one simple conditional for lazy initialization. Clarity of intent: Descriptive class and method names make the unmodifiable sorted-multiset purpose clear; reciprocal caching in descendingMultiset requires slightly more interpretation. Code length: Methods are concise, though excessive blank lines add unnecessary visual length. Action granularity: Most lines perform a single action, but returning an assignment combines caching and return operations. Reading flow: Consistent overrides and formatting support natural scanning; stray whitespace and densely grouped annotations slightly interrupt the flow.
Run 3
Code Structure: Well-organized wrapper class with focused methods and consistent delegation. Nesting: Nearly flat; only the lazy initialization method contains a single conditional. Clarity of intent: Descriptive names and explicit rejection of mutating operations make the unmodifiable behavior clear, though reciprocal descending-view caching requires closer inspection. Code length: Concise methods with little unnecessary logic; excessive blank lines add visual noise. Action granularity: Most lines perform one action, but 'return descendingMultiset = result' combines assignment and return. Reading flow: Consistent method formatting and logical grouping support easy scanning, slightly weakened by irregular whitespace and densely combined annotations.