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;
/**
* Utilities for dealing with sorted collections of all types.
*
* @author Louis Wasserman
*/
@GwtCompatible
final class SortedIterables {
private SortedIterables() {}
/**
* Returns {@code true} if {@code elements} is a sorted collection using an ordering equivalent to
* {@code comparator}.
*/
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")
// if sortedSet.comparator() is null, the set must be naturally ordered
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, flat nesting, and concise methods. The class has a well-defined single purpose: utilities for sorted collections. Each method performs one logical action per line, and the reading flow is natural. The `hasSameComparator` method uses a clear if-else chain to check different collection types before comparing comparators. Javadoc documentation explains intent precisely. The code is appropriately concise without unnecessary verbosity. Minor deductions could be made for the type cast and null-handling in the comparator method requiring a comment for clarity, but overall the code exemplifies strong readability practices.
Run 2
The code is well-structured with a clear separation of methods and a logical private constructor for a utility class. Nesting is minimal, with only single-level conditionals. Intent is explicit through concise Javadoc and descriptive method names. Code length is appropriate, avoiding unnecessary verbosity. Each line generally performs one action, enhancing granularity. Reading flow is natural, progressing logically through type checks and fallback paths. Minor deductions: the null-check followed by instanceof checks could be slightly more streamlined, and the @SuppressWarnings on the comparator method adds mild noise, but overall the code is highly readable.
Run 3
The code is highly readable with clear structure and purpose. It follows a logical organization: a private constructor, a public utility method, and a helper method. Nesting is minimal, with a straightforward if-else chain that avoids deep indentation. Intent is immediately clear from method names and Javadoc comments, which explain the purpose of both methods. Code length is concise—no unnecessary verbosity. Action granularity is appropriate, with each line performing a distinct operation without cramming multiple actions. Reading flow is natural, progressing from validation through type checks to the final comparison. The use of static imports like checkNotNull and annotations like @GwtCompatible adds clarity without clutter. The suppression of warnings is justified with an explanatory comment, preserving readability. Minor potential improvement could be extracted variable names like 'comparator2', but overall the code is exemplary in terms of readability.
Run 1
Code Structure: A focused utility class separates comparator matching from comparator normalization. Nesting: Both methods use shallow conditionals, and an early return avoids unnecessary nesting. Clarity of intent: Method names, documentation, and the natural-ordering comment make the purpose clear; comparator2 is slightly generic, and the unchecked cast requires familiarity with Java generics. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Each statement performs one clear action. Reading flow: Validation, collection-type detection, and comparison follow a natural sequence. Minor formatting issues, such as missing blank lines between the package and imports, slightly reduce visual readability.
Run 2
Code Structure: A focused utility class with two small, logically separated methods. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: Method names, documentation, and the natural-ordering comment clearly explain behavior; comparator2 is less descriptive than an alternative such as elementsComparator. Code length: Concise, with no unnecessary logic or duplication. Action granularity: Statements generally perform one action per line, making validation and comparator selection easy to follow. Reading flow: Imports, class documentation, and methods follow a natural sequence. Generic bounds and unchecked casts add minor cognitive overhead, but their purpose is understandable.
Run 3
Code Structure: Well-organized utility class with two focused methods and a private constructor. Nesting: Shallow conditional branches keep control flow easy to follow. Clarity of intent: Method names, documentation, and the natural-ordering comment clearly explain behavior; comparator2 is slightly less descriptive than an alternative such as elementsComparator. Code length: Concise without unnecessary logic or repetition. Action granularity: Each statement performs a single clear action, with validation and comparator selection separated. Reading flow: Imports, class documentation, validation, type checks, and comparison follow a natural sequence. Minor readability drawbacks include the lack of spacing between the package declaration and imports, explicit casts, and the unchecked generic cast, though the latter is explained and locally suppressed.