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 and readable. It has a clear class purpose, logical method organization, minimal nesting (max 2 levels), and good action granularity. Method names and variable names clearly express intent. The `hasSameComparator` method uses a straightforward if-else chain for type checking, which is easy to follow. The `comparator` method is concise with a single null check. The only minor readability deduction is for the @SuppressWarnings annotation with a slightly cryptic comment about null comparators, but this is standard Guava style and necessary for generic type safety.
Run 3
The code is well-structured with clear separation of concerns and a logical organization. It has minimal nesting (only one level of if-else and a null check), making it easy to follow. Intent is immediately obvious from method names and documentation. The code is concise—no unnecessary verbosity—and each line performs a single coherent action. Reading flow is natural, with helper methods and clear return points. The only minor deduction is the unchecked cast and suppressed warning, which slightly obscures flow and requires the explanatory comment.
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, documentation, and the natural-ordering comment clearly explain behavior; comparator2 is slightly less descriptive than ideal. Code length: The implementation is concise without sacrificing validation or clarity. Action granularity: Each statement performs a single action, making the logic easy to follow. Reading flow: Validation, comparator extraction, and comparison proceed naturally; the helper cleanly handles the null-comparator convention. Minor formatting issues, such as the lack of spacing between the package and imports, slightly reduce polish.
Run 2
Code Structure: A focused utility class cleanly separates comparator equivalence checking from comparator retrieval. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: Method names, documentation, and the natural-ordering comment explain behavior 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 a single clear action. Reading flow: Null checks, type inspection, comparator extraction, and comparison follow a natural sequence. Generic bounds and unchecked casts introduce minor reading overhead, and spacing between the package declaration and imports could improve visual organization.
Run 3
Code Structure: A focused utility class cleanly separates comparator matching from comparator retrieval. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: Descriptive methods, documentation, and the natural-ordering comment explain behavior well; comparator2 is less informative, and the generic cast requires some Java knowledge. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Each statement performs one clear action. Reading flow: Validation, type checks, comparator extraction, and comparison follow a natural sequence. Minor formatting issues, such as missing blank lines between package and import groups, slightly reduce readability.