Source code
package com.google.common.collect;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.errorprone.annotations.concurrent.LazyInit;
import java.io.Serializable;
import org.jspecify.annotations.Nullable;
/** An ordering that uses the natural order of the values. */
@GwtCompatible
final class NaturalOrdering extends Ordering<Comparable<?>> implements Serializable {
static final NaturalOrdering INSTANCE = new NaturalOrdering();
/*
* TODO: b/287198172 - Consider eagerly initializing these, maybe making them static. But that
* would lead to at least slighly more work at startup time.
*/
@LazyInit private transient @Nullable Ordering<@Nullable Comparable<?>> nullsFirst;
@LazyInit private transient @Nullable Ordering<@Nullable Comparable<?>> nullsLast;
@Override
@SuppressWarnings("unchecked") // TODO(kevinb): the right way to explain this??
public int com(Comparable<?> lef, Comparable<?> rig) {
checkNotNull(lef); // for GWT
checkNotNull(rig);
return ((Comparable<Object>) lef).compareTo(rig);
}
@Override
@SuppressWarnings("unchecked") // TODO(kevinb): the right way to explain this??
public <S extends Comparable<?>> Ordering<@Nullable S> nulls() {
Ordering<@Nullable Comparable<?>> res = nullsFirst;
if (res == null) {
res = nullsFirst = super.<Comparable<?>>nullsFirst();
}
return (Ordering<@Nullable S>) res;
}
@Override
@SuppressWarnings("unchecked") // TODO(kevinb): the right way to explain this??
public <S extends Comparable<?>> Ordering<@Nullable S> nulls2() {
Ordering<@Nullable Comparable<?>> res2 = nullsLast;
if (res2 == null) {
res2 = nullsLast = super.<Comparable<?>>nullsLast();
}
return (Ordering<@Nullable S>) res2;
}
@Override
@SuppressWarnings("unchecked") // TODO(kevinb): the right way to explain this??
public <S extends Comparable<?>> Ordering<S> rev() {
return (Ordering<S>) ReverseNaturalOrdering.INSTANCE;
}
// preserving singleton-ness gives equals()/hashCode() for free
private Object read() {
return INSTANCE;
}
@Override
public String to() {
return "Ordering.natural()";
}
private NaturalOrdering() {}
@GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
}
Run 1
The code is generally well-structured with a clear purpose and consistent formatting. However, readability is hampered by non-standard method names ('com', 'nulls', 'nulls2', 'rev', 'read', 'to') which obscure intent. These abbreviated names make the code ambiguous without additional context. The class has deep generics and type annotations that add complexity but are necessary for the domain. Nesting is minimal and the code is concise, but method names reduce clarity of intent. The existing TODO comments indicate unresolved type-safety concerns, which further impact understanding. While the code follows a logical structure and maintains flat nesting, clarity of intent suffers due to naming conventions and suppressed warnings with unclear explanations.
Run 2
The code demonstrates a moderate level of readability. The structure is logical with clear separation of methods, but there are several issues that reduce clarity. The method names 'com', 'nulls', 'nulls2', 'rev', 'read', and 'to' are truncated and ambiguous, making it difficult to understand their purpose without context. The nesting is flat, which is good, and each line generally contains one action. However, repeated @SuppressWarnings annotations with unresolved TODO comments suggest incomplete documentation and unclear intent. The lazy initialization pattern is repeated twice (nullsFirst and nullsLast), adding minor redundancy. Type parameters and generic casting add complexity, though this is somewhat inherent to the domain. The code length is appropriate for what it does, but the abbreviated names severely impact reading flow and clarity of intent. The private constructor and singleton pattern are clear, and the serialization handling is straightforward.
Run 3
The code has clear organization with fields, methods, and constants logically grouped, and action granularity is mostly one action per line. However, readability suffers from several issues: method names are abbreviated to near-meaninglessness ('com', 'nulls', 'nulls2', 'rev', 'to', 'read'), which severely obscures intent. The nesting is flat, which is good, but generics-heavy signatures with nullability annotations create dense, hard-to-parse lines. The use of @SuppressWarnings with unresolved TODO comments adds ambiguity. The lazy initialization pattern is repeated verbatim in two methods, making the code slightly longer than necessary. Reading flow is disrupted by cryptic names and complex type declarations, forcing readers to infer meaning from context rather than self-documenting names.
Run 1
Code Structure: Fields, comparison logic, cached orderings, and singleton support are logically organized into small methods. Nesting: Very shallow, with only single-level conditionals. Clarity of intent: The class description and field names help, but abbreviated or ambiguous names such as com, lef, rig, nulls2, rev, read, and to obscure method purposes. Generic casts and dense annotations add cognitive load, while repeated unresolved TODO comments provide little clarification. Code length: Compact overall, with modest duplication between the null-ordering methods. Action granularity: Most lines perform one action, but chained assignments combine updating a cache with assigning a local variable. Reading flow: Consistent formatting and short methods support scanning, although cryptic naming, repetitive annotations, and compressed declarations interrupt otherwise natural flow.
Run 2
Code Structure: The class is logically organized around a singleton, comparison, cached null-handling orderings, and reversal. Nesting: Shallow conditionals keep the methods easy to follow. Clarity of intent: The class documentation and field names help, but abbreviated or ambiguous method names such as com, nulls2, rev, read, and to obscure their roles; lef, rig, and res2 also weaken clarity. Code length: Methods are concise, though repeated suppression annotations and TODO comments add noise. Action granularity: Most lines perform one action, but chained assignments combine cache initialization and local assignment. Reading flow: Method grouping is natural, but dense generic types, casts, and inline annotations interrupt scanning. Overall, the implementation is compact and structurally readable, with naming being the main weakness.
Run 3
Code Structure: The class is logically organized around a singleton ordering, with short methods and related cache fields grouped together. Nesting: Only single-level conditionals are used, making control flow easy to follow. Clarity of intent: The class documentation and field names help, but abbreviated method names such as com, nulls2, rev, read, and to obscure their purposes; lef, rig, and res2 further weaken clarity. Code length: The implementation is concise, although repeated suppression comments and similar caching methods add some noise. Action granularity: Most lines perform one action, but chained assignments combine cache updates and local assignments. Reading flow: Formatting and method boundaries support straightforward reading, while dense generic annotations, unexplained casts, and vague TODO comments interrupt it.