Source code
package com.google.common.collect;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.GwtCompatible;
import java.util.Comparator;
import java.util.SortedSet;
import org.jspecify.annotations.Nullable;
@GwtCompatible
final class SortedIterables {
private SortedIterables() {}
public static boolean hasSameComparator(Comparator<?> comparator, Iterable<?> elements) {
checkNotNull(comparator);
checkNotNull(elements);
Comparator<?> comparator2;
if (elements instanceof SortedSet) {
comparator2 = comparator((SortedSet<?>) elements);
} else if (elements instanceof SortedIterable) {
comparator2 = ((SortedIterable<?>) elements).comparator();
} else {
return false;
}
return comparator.equals(comparator2);
}
@SuppressWarnings("unchecked")
public static <E extends @Nullable Object> Comparator<? super E> comparator(
SortedSet<E> sortedSet) {
Comparator<? super E> result = sortedSet.comparator();
if (result == null) {
result = (Comparator<? super E>) Ordering.natural();
}
return result;
}
}
Run 1
The code is highly readable with clear structure and intent. The class is focused on sorted collection utilities, with a private constructor indicating utility-only usage. The hasSameComparator method is logically structured but has moderate nesting with two instance checks and an early return. The comparator method is flat and clean, though the wildcard generics slightly increase mental overhead. Code length is appropriate, and most lines perform a single action. The reading flow is natural: validation checks occur first, followed by type checking and comparison logic. The use of static imports and proper annotations maintains clarity. Minor deductions are for the moderate branching in hasSameComparator and the potential ambiguity around the purpose of the SortedIterable interface check, which may require developer familiarity with Guava internals.
Run 2
The code is well-structured and highly readable. It has a clear logical organization, with two static utility methods separated by a private constructor. Nesting is minimal, using flat if-else branching rather than deeply nested logic. The intent is clear: determine if a comparator matches a sorted collection's comparator and obtain a default comparator when needed. Code length is concise and appropriate, without redundant code. Action granularity is good, with one meaningful operation per line. The reading flow is natural, progressing from null checks to type checks to comparison. The use of blank lines and package-private access is idiomatic. Minor issues include a stray blank line and the @SuppressWarnings annotation, but these are negligible.
Run 3
The code is highly readable with clear structure, minimal nesting, and explicit intent. The class is well-organized with a private constructor and two static utility methods. Nesting is shallow (max one level of if-else). Each method has a single responsibility: checking comparator consistency and retrieving a comparator with natural ordering as fallback. Variable names are descriptive ('comparator2', 'result', 'sortedSet'). The use of 'instanceof' checks with distinct branches is clean. Minor deductions: several blank lines and an empty comment block create slight visual noise, and the null-annotation generic syntax adds a bit of complexity, but overall clarity and flow are excellent.
Run 1
Code Structure: Two focused utility methods are logically organized within a non-instantiable class. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: Method names clearly convey comparator comparison and retrieval, although comparator2 is a generic variable name and the natural-order fallback could benefit from a brief explanation. Code length: The implementation is concise, but excessive blank lines add unnecessary visual space. Action granularity: Each statement performs a single action, making operations easy to follow. Reading flow: Validation, comparator selection, and comparison proceed naturally; inconsistent whitespace and the unchecked generic cast slightly interrupt readability.
Run 2
Code Structure: Two small, focused utility methods provide logical organization. Nesting: Shallow conditional branches make control flow easy to follow. Clarity of intent: Method names clearly describe comparator comparison and retrieval, though comparator2 is a generic name and the natural-order fallback could benefit from a brief comment. Code length: The implementation is concise, but excessive blank lines add visual noise. Action granularity: Each statement performs one clear action. Reading flow: Null checks, type-based comparator selection, and equality comparison follow a natural sequence; inconsistent whitespace slightly disrupts presentation.
Run 3
Code Structure: Two small, focused utility methods are logically organized. Nesting: Shallow conditional branches keep control flow easy to follow. Clarity of intent: Method names clearly describe comparator retrieval and comparison, although comparator2 is a generic variable name and the unchecked natural-order cast requires some Java knowledge. Code length: Implementation is concise, but excessive blank lines add visual clutter. Action granularity: Each statement performs one clear action, with validation and assignments on separate lines. Reading flow: Input checks, comparator selection, and equality comparison follow a natural sequence; inconsistent whitespace around imports and annotations slightly disrupts scanning.