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
This code is highly readable with clear structure and purpose. The class extends a base unmodifiable multiset and implements SortedMultiset, with straightforward delegation methods. Nesting is minimal—only a simple null-check in descendingMultiset(). Action granularity is good, with one logical operation per line. The code length is appropriate; each method is concise and delegates to the underlying implementation. The reading flow follows a logical order: constructor, overridden accessors, element set methods, navigation methods, then sub-multiset views. The TODO comment and annotations provide helpful context. Minor deductions: the descendingMultiset() method has moderate complexity due to the lazy initialization cycle-handling, and the Javadoc could be slightly expanded. Overall, this is production-quality, maintainable code that clearly expresses intent.
Run 3
The code is well-structured and readable. It follows a logical class organization with clear method grouping: constructors, overrides, and delegate methods. Nesting is minimal—only one level in the descendingMultiset null-check. Intent is clear from descriptive method names and the class-level Javadoc explaining purpose. Code length is appropriate; each method is concise and follows the decorator pattern without redundancy. Action granularity is mostly one action per line, though the descendingMultiset method packs multiple operations (assignment, return, nested assignment) into a few lines, slightly reducing clarity. Reading flow is natural, with methods ordered intuitively. The anonymous field and TODO comment are informative. Overall, this is highly maintainable code with only minor readability friction in the descendingMultiset method.
Run 1
Code Structure: Well-organized wrapper class with small, focused overrides; the cached field's placement mid-class is a minor inconsistency. Nesting: Almost entirely flat, with only one shallow conditional. Clarity of intent: Naming, documentation, delegation, and explicit exceptions clearly communicate an unmodifiable sorted multiset. The descending-view cache requires slightly more attention but is understandable. Code length: Concise for the interface implemented; repetitive forwarding methods are justified. Action granularity: Most lines perform one action, though 'return descendingMultiset = result' combines assignment and return. Reading flow: Consistent formatting and related method grouping make the code easy to follow. Dense annotations, casts, and the platform-specific TODO introduce minor visual and conceptual overhead.
Run 2
Code Structure: Well-organized wrapper class with focused methods and consistent delegation; the cached field could be grouped with other fields. Nesting: Almost entirely flat, with only one simple conditional. Clarity of intent: Descriptive names, documentation, and explicit exceptions clearly communicate an unmodifiable sorted multiset; reciprocal caching requires slightly more attention. Code length: Concise implementations with little unnecessary code, though annotations and the lengthy compatibility TODO add visual overhead. Action granularity: Generally one action per line, except the combined assignment and return in descendingMultiset(), which slightly reduces clarity. Reading flow: Consistent formatting and predictable method patterns make navigation easy; inline annotations and scattered field placement are minor distractions.
Run 3
Code Structure: A well-organized wrapper class with small, focused overrides; the cache field appearing midway through methods slightly interrupts organization. Nesting: Almost entirely flat, with only one simple conditional. Clarity of intent: Class documentation, descriptive names, delegation, and explicit exceptions clearly communicate an unmodifiable sorted multiset; annotations and casts add minor complexity. Code length: Concise for the interface implemented, with necessary delegation boilerplate and a useful platform-specific TODO. 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, while the cache logic and lengthy TODO briefly interrupt the otherwise straightforward flow.