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 and follows clean patterns. It uses inheritance and delegation effectively, with clear method names reflecting intent. Nesting is minimal, with only one simple conditional in descendingMultiset(). Action granularity is excellent—each line performs a single clear action. Reading flow is natural, organizing methods logically: construction, overridden infrastructure, view methods, then mutators that throw. The class-level Javadoc explains the split rationale. Minor readability challenges come from the heavy use of generic type parameters and annotations, which add visual noise. The lazy-initialization block in descendingMultiset(), while logically compact, packs several actions into a conditional branch, slightly reducing immediate clarity. Overall, this is maintainable, idiomatic Guava-style code that would be readable to developers familiar with Java collection frameworks.
Run 2
The code is highly readable. It has a clear, logical structure with a single class extending a base class and implementing a sorted multiset. Nesting is minimal, with only one conditional block in the descendingMultiset() method. Intent is clear: the class provides an unmodifiable wrapper for sorted multisets, with methods delegating to the underlying implementation and mutating methods throwing UnsupportedOperationException. Code length is concise, with methods being short and focused. Action granularity is appropriate, typically one action per line. Reading flow is natural, with methods organized logically: constructor, overridden accessors, element set methods, descending multiset handling, entry operations, and range-view methods. The only minor drawbacks are the slightly complex descendingMultiset() lazy initialization logic and the verbose TODO comment, but these are well-documented and justified.
Run 3
The code is highly readable with a clear logical structure: class declaration, constructor, delegate accessor, element set creation, view methods, and mutation-unsupported operations are grouped logically. Nesting is minimal—only a single if-block for lazy initialization. Intent is explicit through method names, Javadoc, and consistent delegation to the wrapped SortedMultiset. Code length is appropriate for an unmodifiable wrapper; each method is concise and delegates to a single action. Action granularity is strong, with one primary operation per line (e.g., delegate().firstEntry()). Reading flow is natural, following the SortedMultiset interface contract from comparator through views to serialization. The only slight readability deduction comes from the TODO comment and the transient field ordering, but these are minor and well-documented.
Run 1
Code Structure: Well-organized wrapper class with small, focused methods and clear delegation; placing the cached field among methods slightly weakens organization. Nesting: Almost entirely flat, with only one simple conditional in lazy initialization. Clarity of intent: Descriptive names, class documentation, and explicit exceptions clearly communicate an unmodifiable sorted multiset; annotations and casts add minor complexity. Code length: Concise implementation with necessary interface overrides and little unnecessary code. Action granularity: Most lines perform one action, though returning an assignment in descendingMultiset combines caching and returning. Reading flow: Consistent formatting and predictable method patterns make scanning easy; the detailed platform-specific TODO briefly interrupts the otherwise straightforward flow.
Run 2
Code Structure: A logically organized wrapper class with focused delegation methods and explicit rejection of mutating operations. Nesting: Nearly flat, with only one simple conditional in the lazy initialization method. Clarity of intent: Descriptive names, class documentation, and consistent unmodifiable wrapping make the purpose clear; casts and platform-specific annotations add minor complexity. Code length: Concise for the interface implemented, with little unnecessary logic; the lengthy TODO slightly interrupts the otherwise compact presentation. Action granularity: Most statements perform one action, although 'return descendingMultiset = result' combines assignment and return. Reading flow: Consistent formatting and predictable method patterns make scanning easy, but the cache field placed between methods and densely grouped annotations slightly disrupt the flow.
Run 3
Code Structure: A well-organized wrapper class with focused methods and consistent delegation; the cached field appearing between methods slightly interrupts organization. Nesting: Almost entirely flat, with only one simple conditional in descendingMultiset(). Clarity of intent: Descriptive names, class documentation, unmodifiable wrappers, and explicit exceptions clearly convey the purpose. Generic casts and platform-specific annotations require some background knowledge. Code length: Concise implementations with little unnecessary code; repetitive overrides are appropriate for the interface. Action granularity: Most lines perform one action, although return descendingMultiset = result combines assignment and return. Reading flow: Consistent formatting and predictable method patterns make scanning easy; the lengthy platform-specific TODO and densely annotated declarations introduce minor distractions.