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;
/**
* Implementation of {@link Multisets#unmodifiableSortedMultiset(SortedMultiset)}, split out into
* its own file so it can be GWT emulated (to deal with the differing elementSet() types in GWT and
* non-GWT).
*
* @author Louis Wasserman
*/
@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;
// TODO(b/418181860): This method creates retain cycles in J2ObjC. In order to break the cycle,
// there needs to be separate classes for primary and descending multiset, where the primary one
// would hold {@code @LazyInit @RetainedWith @Nullable} reference to its descending multiset, and
// the other {@code final} reference.
@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 is well-structured with clear separation of concerns, following a standard class pattern for immutable collection wrappers. The class has a clear purpose and is documented. Methods are concise, each performing a single action, and the code length is proportional to the functionality required. Nesting is minimal, limited to a single null check pattern in descendingMultiset(). Reading flow is generally natural, with methods grouped logically. Minor readability drawbacks include the generic type declaration with `@Nullable Object`, which adds cognitive overhead, and the one-liner field declaration `@LazyInit private transient @Nullable UnmodifiableSortedMultiset<E> descendingMultiset;` which combines multiple modifiers. The TODO comment is helpful but slightly verbose. Overall, it's readable code that would be easy for experienced Guava contributors to understand, but the specialized annotations and type constraints require domain familiarity.
Run 2
The code is highly readable with clear structure and intent. It follows a consistent pattern of delegating to an underlying SortedMultiset while wrapping results in unmodifiable views, which aligns with the class purpose. Nesting is minimal—only the descendingMultiset() method has one level of conditional logic, which is straightforward. Action granularity is excellent: each method performs a single, clear operation, often a one-line delegation or wrapper call. The reading flow is natural, with methods organized logically (overrides, then first/last entry accessors, then mutators, then range views). The class-level Javadoc explains why the file exists, and the TODO comment adds helpful context about a known issue. The main readability challenges stem from the verbose generic type signatures and annotations, which are inherent to Guava's style and add some visual noise but do not obscure the logic. Overall, the code is concise, well-organized, and easy to follow for experienced Java developers.
Run 3
The code is highly readable due to its clear structure and consistent patterns. The class has a single responsibility: wrapping a SortedMultiset to make it unmodifiable. Methods are short, flat, and delegate directly to the wrapped instance, making intent obvious. Nesting is minimal, with only one small conditional block in descendingMultiset(). Naming is descriptive, and annotations provide helpful context. The delegation pattern keeps action granularity at one primary operation per line. The only deductions are the TODO comment which introduces a minor distraction, and the slight cognitive overhead from generics and annotations, though these are inherent to the domain. Overall, the code follows clean, maintainable practices.
Run 1
Code Structure: Well-organized wrapper class with focused overrides and a documented purpose; placing the cached field among methods slightly weakens organization. Nesting: Almost entirely flat, with only one simple conditional. Clarity of intent: Descriptive names, explicit delegation, and unsupported mutation methods clearly communicate an unmodifiable sorted multiset. The lazy reciprocal cache requires some additional attention. Code length: Concise methods and minimal boilerplate for the interface; annotations and the platform-specific TODO add modest visual overhead. Action granularity: Nearly every statement performs one action, except the combined assignment and return in descendingMultiset(). Reading flow: Consistent formatting and predictable delegation make the class easy to scan, though superclass behavior and type casts require external context.
Run 2
Code Structure: Well-organized wrapper class with focused methods and consistent delegation; the cache field appearing midway through methods slightly disrupts organization. Nesting: Almost entirely flat, with only one shallow conditional. Clarity of intent: Descriptive names, class documentation, and explicit exceptions clearly communicate an unmodifiable sorted multiset; annotations and reciprocal cache references require some specialized knowledge. Code length: Concise for the interface implemented, with little unnecessary code; repetitive forwarding methods are appropriate. Action granularity: Most lines perform one action, though 'return descendingMultiset = result' combines assignment and return. Reading flow: Consistent formatting and predictable method patterns make scanning easy, although the lengthy platform-specific TODO and dense annotation declarations introduce minor interruptions.
Run 3
Code Structure: A cohesive wrapper class with small, logically grouped methods; the cache field could be placed nearer the top. Nesting: Almost entirely flat, with only one shallow conditional. Clarity of intent: Class documentation, descriptive names, delegation, and explicit exceptions clearly communicate an unmodifiable sorted multiset. Code length: Concise overall; repetitive forwarding methods are appropriate for the interface. Action granularity: Most lines perform one action, though 'return descendingMultiset = result' combines assignment and return. Reading flow: Consistent formatting and predictable method patterns support easy scanning. Minor friction comes from dense annotations, casts, and a lengthy platform-specific TODO interrupting the flow.