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 and well-structured. It has a clear logical organization, with each method having a single purpose and a concise Javadoc explaining intent. The nesting depth is minimal, with only simple if-else branches. The code is concise without sacrificing clarity—there are no redundant variables or dead code. Each line performs one meaningful action, and the reading flow follows a natural top-down path. The use of `checkNotNull` immediately validates inputs, demonstrating clear intent. The only slight deduction is due to the cast and specialization in the `comparator` method, which is justified by the semantics of SortedSet but still requires a brief pause for comprehension.
Run 2
The code is well-structured with clear class and method boundaries. Nesting is minimal, with only a single if-else chain and no deep blocks. Intent is clear: verify comparator compatibility and safely retrieve a comparator. Names are descriptive and Javadoc explains the public method. Length is concise—no unnecessary code. Action granularity is appropriate, with each line performing a focused operation. Reading flow is natural, progressing from validation to type checks and final comparison. Minor deductions: the suppressed unchecked cast in `comparator` adds slight cognitive overhead, and the null-handling comment is terse. Overall, it is highly readable for experienced Java developers but may be less approachable for beginners due to generics and type checks.
Run 3
The code is well-structured and readable. It has a clear single-purpose class with private constructor, logical method ordering, and flat nesting with only one else-if chain. Each line performs one action, and variable names are descriptive. The use of @Nullable annotation and JavaDoc comments clarify intent. The only minor issues are the suppressed warning and generic casting in the comparator method, which slightly reduce clarity. Overall, this is concise, maintainable utility code typical of Guava's style.
Run 1
Code Structure: Two focused utility methods are logically organized in a non-instantiable class. Nesting: Shallow conditionals and an early return keep complexity low. Clarity of intent: Descriptive method names, documentation, and the natural-ordering comment explain behavior clearly; comparator2 is slightly generic, and the unchecked cast requires some type-system knowledge. Code length: Compact without unnecessary logic or repetition. Action granularity: Each statement performs one clear action. Reading flow: Validation, collection-type detection, and comparator comparison follow a natural sequence, with fallback handling isolated in a helper. Minor formatting issues, such as the lack of spacing between package and imports, slightly reduce polish.
Run 2
Code Structure: A focused utility class with two logically separated methods and a private constructor. 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 a less descriptive variable name, and generic casts require some familiarity with Java. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Each statement performs a single clear action. Reading flow: Validation, comparator extraction, and comparison proceed naturally; the helper follows a straightforward retrieve-and-default pattern. Minor formatting issues, such as missing separation between package and imports, slightly reduce polish.
Run 3
Code Structure: A focused utility class with two logically separated methods and a private constructor. Nesting: Shallow conditionals and an early return keep control flow simple. Clarity of intent: Method names, documentation, and the natural-ordering comment explain behavior clearly; comparator2 is slightly generic, and the unchecked cast requires familiarity with Java generics. Code length: Concise, with no unnecessary repetition or abstraction. Action granularity: Each statement performs one clear operation. Reading flow: Null checks, type-based comparator extraction, and comparison follow a natural sequence; the helper is easy to follow. Missing spacing between package and imports slightly reduces visual organization.