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 clear separation of concerns: constructor suppression, two focused utility methods, and an appropriate class-level Javadoc. Nesting is minimal—only a straightforward if-else chain, and action granularity ensures one logical operation per statement. Method names like hasSameComparator and comparator clearly signal intent. The code is concise yet sufficiently documented, with a justified @SuppressWarnings. Minor deductions: the initial null checks, though correct, add a small amount of boilerplate; the cast in comparator() requires careful reading. Overall, the reading flow is natural and the class is highly readable.
Run 3
The code is highly readable. It has a clear, single-purpose utility class with a private constructor preventing instantiation. Methods are short, flat, and easy to follow. `hasSameComparator` uses a simple if-else chain that reads naturally, each branch handling a specific type with clear intent. Null checks are explicit and upfront. The `comparator` method handles the null-comparator case concisely and documents the suppression reasoning. Comments are minimal but meaningful. Overall, the structure is logical, naming is clear, and the flow is natural. Only minor slight complexity comes from generics and the instanceof checks, but these are necessary and well-managed.
Run 1
Code Structure: Two focused utility methods are logically organized within a non-instantiable class. Nesting: Simple conditionals keep nesting shallow, with an early return for unsupported iterables. Clarity of intent: Method names, Javadoc, and the natural-ordering comment clearly explain behavior; comparator2 is slightly less descriptive than an alternative such as elementsComparator. Code length: The implementation is concise without sacrificing clarity. Action granularity: Each statement performs one clear operation, including separate null checks. Reading flow: Execution proceeds naturally from validation to comparator extraction and comparison, while the helper cleanly handles natural ordering. Minor formatting issues, such as missing blank lines between package and imports, slightly reduce polish.
Run 2
Code Structure: A focused utility class cleanly separates comparator matching from comparator normalization. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: Descriptive method names, documentation, and the natural-ordering comment explain the purpose well; comparator2 is less descriptive than an alternative such as elementsComparator. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Each statement performs one clear action, making validation and comparator selection easy to follow. Reading flow: Methods progress naturally from input checks to comparator retrieval and comparison. Generic bounds, wildcard types, and unchecked casts add minor reading complexity, while the tightly grouped package and imports slightly reduce visual separation.
Run 3
Code Structure: A focused utility class with two logically separated methods and a private constructor. Nesting: Shallow conditional branches and an early return keep complexity low. Clarity of intent: Method names, documentation, and the natural-ordering comment explain behavior clearly; comparator2 is less descriptive than elementsComparator, and generic casts require some attention. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Each statement performs a single clear action. Reading flow: Input validation, comparator discovery, and comparison follow a natural sequence; the helper similarly retrieves, normalizes, and returns the comparator. Minor formatting issues, such as missing spacing between the package declaration and imports, slightly reduce polish.