Source code
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.util.Comparator;
import java.util.Spliterator;
import org.jspecify.annotations.Nullable;
/**
* List returned by {@code ImmutableSortedSet.asList()} when the set isn't empty.
*
* @author Jared Levy
* @author Louis Wasserman
*/
@GwtCompatible
@SuppressWarnings("serial")
final class ImmutableSortedAsList<E> extends RegularImmutableAsList<E>
implements SortedIterable<E> {
ImmutableSortedAsList(ImmutableSortedSet<E> backingSet, ImmutableList<E> backingList) {
super(backingSet, backingList);
}
@Override
ImmutableSortedSet<E> delegateCollection() {
return (ImmutableSortedSet<E>) super.delegateCollection();
}
@Override
public Comparator<? super E> comparator() {
return delegateCollection().comparator();
}
// Override indexOf() and lastIndexOf() to be O(log N) instead of O(N).
@GwtIncompatible // ImmutableSortedSet.indexOf
// TODO(cpovirk): consider manual binary search under GWT to preserve O(log N) lookup
@Override
public int indexOf(@Nullable Object target) {
int index = delegateCollection().indexOf(target);
// TODO(kevinb): reconsider if it's really worth making feeble attempts at
// sanity for inconsistent comparators.
// The equals() check is needed when the comparator isn't compatible with
// equals().
return (index >= 0 && get(index).equals(target)) ? index : -1;
}
@GwtIncompatible // ImmutableSortedSet.indexOf
@Override
public int lastIndexOf(@Nullable Object target) {
return indexOf(target);
}
@Override
public boolean contains(@Nullable Object target) {
// Necessary for ISS's with comparators inconsistent with equals.
return indexOf(target) >= 0;
}
@GwtIncompatible // super.subListUnchecked does not exist; inherited subList is valid if slow
/*
* TODO(cpovirk): if we start to override indexOf/lastIndexOf under GWT, we'll want some way to
* override subList to return an ImmutableSortedAsList for better performance. Right now, I'm not
* sure there's any performance hit from our failure to override subListUnchecked under GWT
*/
@Override
ImmutableList<E> subListUnchecked(int fromIndex, int toIndex) {
ImmutableList<E> parentSubList = super.subListUnchecked(fromIndex, toIndex);
return new RegularImmutableSortedSet<E>(parentSubList, comparator()).asList();
}
@Override
public Spliterator<E> spliterator() {
return CollectSpliterators.indexed(
size(),
ImmutableList.SPLITERATOR_CHARACTERISTICS | Spliterator.SORTED | Spliterator.DISTINCT,
delegateList()::get,
comparator());
}
// redeclare to help optimizers with b/310253115
@SuppressWarnings("RedundantOverride")
@Override
@J2ktIncompatible
@GwtIncompatible
Object writeReplace() {
return super.writeReplace();
}
}
Run 1
The code is highly readable due to its clear structure, minimal nesting, and strong documentation. Each class and method has a well-defined purpose, with inherited methods documented via inline comments explaining complexity trade-offs (e.g., O(log N) optimizations). Naming is descriptive and follows Java conventions. The file is concise without sacrificing clarity; complex logic is isolated and justified. Comments address subtle concerns like comparator consistency and GWT compatibility, enhancing understanding without clutter. Most methods are one to three lines, keeping a natural reading flow. Slight deductions for the slightly awkward formatting of the last method’s annotation and rare reliance on comments to explain non-obvious invariant decisions, but overall this is exemplary readable code.
Run 2
The code is highly readable, with clear structure, minimal nesting, and well-defined intent. Each method is concise and performs a single logical action, making the flow natural. Comments explain non-obvious design decisions, and the use of overrides is straightforward. Minor room for improvement exists in the dense comment blocks and inconsistent indentation in the final method, but overall readability is excellent.
Run 3
The code is generally readable with clear class purpose and logical structure. It benefits from descriptive comments explaining design decisions and performance considerations (O(log N) vs O(N)). The methods are short and focused with single responsibilities. However, readability is affected by heavy annotation usage and some inconsistent indentation (notably writeReplace method). The nesting level is minimal, which aids comprehension. Import organization and class hierarchy are clear. The comments about GWT limitations and comparator inconsistency add context but also increase visual noise. Overall, the code demonstrates good practices in structure and intent clarity, though minor formatting issues and annotation density prevent a higher score.
Run 1
Code Structure: Well-organized class with small, focused overrides and consistent delegation. Nesting: Essentially flat; the conditional expression in indexOf is straightforward. Clarity of intent: Descriptive method names and comments explain performance optimizations and comparator-versus-equals behavior, though understanding some details requires familiarity with the superclass and library-specific annotations. Code length: Implementation is concise, but lengthy TODO comments add some clutter. Action granularity: Statements generally perform one clear action each; chained calls and bitwise flag combinations remain readable. Reading flow: Methods follow a logical progression from delegation and comparison to lookup, sublists, iteration, and serialization. Minor distractions include the inconsistent indentation of writeReplace, the unexplained ISS abbreviation, and an internal bug reference.
Run 2
Code Structure: Logically organized into small, focused overrides, with delegation keeping responsibilities clear. Nesting: Essentially flat; the only conditional logic is a straightforward ternary expression. Clarity of intent: Descriptive method names and comments explain performance goals and comparator-versus-equality subtleties, though framework dependencies and the unexplained issue reference require outside context. Code length: Implementation is concise, but lengthy TODO comments and compatibility annotations add visual overhead. Action granularity: Statements generally perform one action per line; chained calls and the combined index validation remain easy to understand. Reading flow: Consistent formatting and grouping support natural reading, with minor interruptions from annotation/comment blocks and inconsistent indentation on writeReplace().
Run 3
Code Structure: Well-organized class with small, focused overrides and clear delegation. Nesting: Essentially flat; the conditional expression in indexOf is straightforward. Clarity of intent: Descriptive names and comments explain logarithmic lookup and comparator/equals compatibility, though framework-specific annotations, abbreviations, and optimizer references require context. Code length: Implementation is concise, but lengthy TODO comments and a redundant override add some reading overhead. Action granularity: Statements generally perform one action per line; fluent expressions remain manageable. Reading flow: Methods progress naturally from delegation and comparison to lookup, slicing, and iteration. Annotation clutter, the extended subList comment, and inconsistent indentation of writeReplace slightly interrupt otherwise clean formatting.