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;
@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();
}
@GwtIncompatible
@Override
public int indexOf(@Nullable Object target) {
int index = delegateCollection().indexOf(target);
return (index >= 0 && get(index).equals(target)) ? index : -1;
}
@GwtIncompatible
@Override
public int lastIndexOf(@Nullable Object target) {
return indexOf(target);
}
@Override
public boolean contains(@Nullable Object target) {
return indexOf(target) >= 0;
}
@GwtIncompatible
@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());
}
@SuppressWarnings("RedundantOverride")
@Override
@J2ktIncompatible
@GwtIncompatible
Object writeReplace() {
return super.writeReplace();
}
}
Run 1
The code is generally well-structured with clear class hierarchy, consistent annotations, and logical method organization. However, it has several readability issues: excessive blank lines scattered throughout (some appearing in odd places like before annotations), inconsistent formatting around annotations, and unclear empty comment blocks that suggest incomplete documentation. The method 'indexOf' has multiple blank lines and comment fragments that disrupt flow, and there's inconsistent spacing before method declarations. While the code follows Google's style guide for the most part, these formatting irregularities make it appear messy. The nesting is minimal and action granularity is good, but the disorganized whitespace and empty comments reduce overall clarity. The 'writeReplace' method has odd indentation with annotations and return statement. The mixed use of fully-qualified vs imported annotations is acceptable but adds slight noise. Overall it's readable but could be significantly improved with consistent formatting and removal of empty comments.
Run 2
The code is relatively flat and avoids deep nesting. Individual methods are short, and most actions are one per line. However, there are several readability problems. Multiple annotations are scattered and inconsistently formatted; some have no explanatory comment while others have blank or multi-line comment blocks, creating visual noise. Unused or redundant annotations and comment placeholders make the intent of certain methods less clear. In methods such as indexOf and subListUnchecked, key logic relies on delegation and implicit behavior rather than explicit explanation, reducing clarity of intent. Strange blank lines and inconsistent spacing between annotations and methods disrupt natural reading flow. Although class structure is logical and method names are descriptive, the inconsistent formatting, redundant annotations, and unclear comments make the code harder to scan and understand than necessary.
Run 3
The code is generally readable with clear class purpose and logical organization. Methods are concise and follow a predictable pattern. However, readability suffers from excessive blank lines and whitespace, which disrupts flow, and there are unnecessary annotations like @SuppressWarnings("RedundantOverride") on writeReplace(). Some comments are empty or sparse, and the indexOf method includes confusing blank comment blocks that add noise. Nesting is minimal, and action granularity is mostly one action per line. The reading flow is adequate but could be improved by removing awkward spacing and clarifying the purpose of the commented sections.
Run 1
Code Structure: Well-organized class with small, focused methods and consistent delegation. Nesting: Very flat, with no nested control flow; the single conditional expression is straightforward. Clarity of intent: Descriptive method names and types communicate purpose, although the equality check after delegated lookup and compatibility annotations lack explanatory context. Code length: Implementation is concise, but excessive blank lines add unnecessary visual length. Action granularity: Each statement generally performs one clear action; chained calls and the spliterator flags remain manageable. Reading flow: Methods follow a natural progression from delegation to lookup, slicing, and iteration. Irregular spacing and the misaligned writeReplace declaration interrupt otherwise consistent formatting.
Run 2
Code Structure: Logically organized into short, focused overrides with consistent delegation. Nesting: Almost entirely flat; the conditional expression in indexOf is easy to follow. Clarity of intent: Descriptive method and variable names communicate purpose, though the equality check after sorted-set lookup and compatibility annotations require some library knowledge. Code length: Implementation is concise, but excessive blank lines unnecessarily expand the file. Action granularity: Statements generally perform one clear action per line; chained calls remain understandable. Reading flow: Methods follow a natural progression from delegation to lookup, slicing, iteration, and serialization. However, irregular whitespace, trailing spaces, and misaligned writeReplace indentation interrupt the otherwise clean presentation.
Run 3
Code Structure: Logically organized into small overridden methods, with clear delegation to backing collections. Nesting: Very flat, with no nested control flow. Clarity of intent: Descriptive method names and types convey purpose, though the equality check in indexOf and serialization override would benefit from explanatory comments. Code length: Implementations are concise, but excessive blank lines unnecessarily lengthen the presentation. Action granularity: Statements generally perform one action per line; chained calls remain understandable. Reading flow: Method ordering and consistent delegation support natural reading, but scattered whitespace, trailing spaces, and inconsistent indentation in writeReplace disrupt it. Overall, the code is readable, with formatting issues and a few unexplained subtleties preventing a higher score.