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
This code is highly readable. The structure is logical: a private constructor for a utility class, two focused static methods, and clear JavaDoc explaining each method's intent. Nesting is minimal—only a simple if-else chain and a single null check. The purpose of each method is unambiguous, especially with the documentation. The code is concise without sacrificing clarity; no unnecessary lines are present. Each action is appropriately separated, with one core action per line (e.g., null checks, type checks, return statements). The reading flow is natural: validation first, then type-based branching, then null handling fallback. Type casts and generics are handled cleanly, with a suppression annotation explained by an inline comment. Overall, this is well-structured, maintainable code that balances brevity with clarity.
Run 3
The code is well-structured with clear separation of public utility methods and a private constructor preventing instantiation. Nesting is minimal—only a single if-else chain in hasSameComparator and a null check in comparator. Intent is evident from method names and Javadoc. The code is concise, avoiding unnecessary verbosity. Each line generally performs one action, though the if-else chain and type casts require some attention. Reading flow is natural: validation first, then type checks, then comparison. The static imports and usage of checkNotNull improve readability. Minor deductions: the hasSameComparator method's branching could be slightly clearer, and the type cast in comparator is non-obvious without its explanatory comment. Overall, this is highly readable production-quality code.
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: Descriptive method names, documentation, and the natural-ordering comment clearly explain behavior; comparator2 is slightly generic. Code length: Compact without unnecessary repetition or abstraction. Action granularity: Each statement performs one clear action. Reading flow: Validation, collection-type detection, and comparator comparison follow a natural sequence. Minor formatting issues, such as missing separation between the package declaration and imports, slightly reduce polish.
Run 2
Code Structure: A focused utility class cleanly separates comparator equivalence checking from comparator retrieval. Nesting: Shallow conditional branches and an early return keep complexity low. Clarity of intent: Descriptive method names, Javadoc, and the natural-ordering comment clearly explain behavior; comparator2 is slightly generic. Code length: Concise, with no unnecessary logic or duplication. Action granularity: Each statement performs a single clear action. Reading flow: Preconditions, type checks, comparator selection, and comparison follow a natural sequence. Generic casts and the wrapped method signature add minor reading friction, but overall readability is excellent.
Run 3
Code Structure: A focused utility class with two small, logically separated methods. Nesting: Shallow conditional branches and an early return keep control flow simple. Clarity of intent: Descriptive method names, documentation, and the natural-ordering comment explain behavior clearly; comparator2 is slightly less descriptive. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Each statement performs a single clear action, and null checks are separate. Reading flow: Validation, comparator selection, and comparison follow a natural sequence. Generic types and unchecked casts add minor reading complexity, but their purpose is clear.