Source code
package com.google.common.cache;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.GwtIncompatible;
import java.util.concurrent.Executor;
@GwtIncompatible
public final class RemovalListeners {
private RemovalListeners() {}
public static <K, V> RemovalListener<K, V> asynchronous(
RemovalListener<K, V> listener, Executor executor) {
checkNotNull(listener);
checkNotNull(executor);
return (RemovalNotification<K, V> notification) ->
executor.execute(() -> listener.onRemoval(notification));
}
}
Run 1
The code is a well-structured utility class with a single static factory method. It follows clean code principles: the private constructor prevents instantiation, null checks are explicit and self-documenting, and the method has a clear purpose. Nesting is minimal (lambdas only), and the action granularity is excellent with one logical step per line. Reading flow is natural — from validation to return of the wrapped listener. The code is concise, uses static imports appropriately, and clearly documents GWT incompatibility. Only minor deduction due to unnecessary blank lines, but overall this is near-ideal readability.
Run 2
The code is highly readable due to its clean structure, minimal nesting, and clear intent. The package and imports are well-organized, and the class is appropriately final with a private constructor. The asynchronous method is concise, uses proper null checks, and the lambda expression clearly delegates removal notifications to the executor. Action granularity is good, with each logical step on its own line. The only minor drawbacks are several blank lines and a stray empty comment block, which slightly disrupt the reading flow but do not affect functionality.
Run 3
The code is exceptionally readable, with a clear and focused single-purpose class. The structure is logical: private constructor to prevent instantiation, followed by a single static factory method. There is minimal nesting — only a lambda inside a lambda — and the flat hierarchy aids comprehension. Intent is explicit through descriptive naming and immediate null checks using Preconditions. The code is concise, with no unnecessary boilerplate or comments, and each line performs a distinct logical action. The reading flow is natural: validation first, then the construction of a lambda that defers execution to the provided Executor. The only minor detractor is the slight indirection of the lambda returning another lambda, but this pattern is idiomatic and transparent in context. Overall, it demonstrates excellent readability and maintainability.
Run 1
Code Structure: A well-organized utility class with a private constructor and one focused factory method. Nesting: Minimal; the nested lambdas remain easy to follow. Clarity of intent: The asynchronous method name, descriptive parameters, and executor delegation clearly communicate its purpose. Code length: The implementation is concise, although excessive blank lines add unnecessary visual length. Action granularity: Each null check occupies its own line, and the callback dispatch forms a single coherent expression. Reading flow: The progression from validation to listener creation is natural, but inconsistent whitespace and the lack of separation between package and import declarations slightly reduce readability.
Run 2
Code Structure: A logically organized utility class with a private constructor and one focused factory method. Nesting: Minimal nesting; the two lambdas are compact and easy to follow. Clarity of intent: Descriptive class, method, and parameter names clearly communicate asynchronous removal notification, though a brief API comment could clarify executor behavior. Code length: The implementation is concise, but excessive blank lines add unnecessary visual length. Action granularity: Each null check occupies its own line, and the returned expression represents one cohesive operation. Reading flow: Validation naturally precedes listener construction, and formatting makes execution delegation clear; excessive whitespace and tightly grouped package/import declarations slightly disrupt presentation.
Run 3
Code Structure: A small, logically organized utility class with a private constructor and one public factory method; excessive blank lines slightly weaken presentation. Nesting: Minimal nesting, with two compact lambdas expressing asynchronous delegation. Clarity of intent: Descriptive names and explicit null checks make the purpose clear. Code length: The implementation is concise, although whitespace unnecessarily lengthens the snippet. Action granularity: Each validation occupies its own line, and the return expression represents one cohesive operation. Reading flow: Imports, class declaration, constructor, and method follow a natural order, but inconsistent spacing and large blank gaps interrupt scanning.