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;
/**
* A collection of common removal listeners.
*
* @author Charles Fry
* @since 10.0
*/
@GwtIncompatible
public final class RemovalListeners {
private RemovalListeners() {}
/**
* Returns a {@code RemovalListener} which processes all eviction notifications using {@code
* executor}.
*
* @param listener the backing listener
* @param executor the executor with which removal notifications are asynchronously executed
*/
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 highly readable. Structure is logical with a clear class purpose and concise Javadoc. Nesting is minimal—just a lambda within a lambda, which is acceptable. Intent is unambiguous: wrap a removal listener for asynchronous execution. Code length is minimal and avoids boilerplate. Each meaningful action appears on its own line, and the reading flow is natural, following a clear progression from validation to behavior definition. The only minor deduction is that the nested lambda could slightly obscure the execution flow for some readers, but overall it is clean and idiomatic.
Run 2
The code is very readable: the class structure is logical, with a private constructor and clear Javadoc. The method is concise, uses Preconditions validation, and the lambda expression makes the asynchronous behavior easy to follow. Nesting is minimal and the reading flow is natural.
Run 3
The code is highly readable. It has a clear structure with imports, class-level Javadoc, a private constructor, and a single well-documented static method. The logic is flat with no deep nesting, and the lambda expression is concise, expressing intent clearly. The method checks preconditions and returns a functional interface implementation in a natural, easy-to-follow flow. Variable and method names are descriptive. The only minor deduction is that the lambda on one line combines creation and execution, but it remains perfectly understandable.
Run 1
Code Structure: A well-organized utility class contains a single focused factory method and a private constructor. Nesting: Minimal nesting; the two lambdas clearly express asynchronous delegation. Clarity of intent: Descriptive names, explicit types, and Javadoc make the purpose clear. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Null checks are separate statements; the composed lambda naturally combines task submission with its callback. Reading flow: Documentation, validation, and listener creation follow a logical sequence. Minor drawbacks are the lack of spacing between the package and imports and the modest cognitive overhead of nested lambdas.
Run 2
Code Structure: A focused utility class with a private constructor and one logically organized factory method. Nesting: Minimal; the nested lambdas are shallow and easy to follow. Clarity of intent: Descriptive names, documentation, and explicit null checks clearly communicate asynchronous notification dispatch. Code length: Concise, with no unnecessary implementation details. Action granularity: Each validation occupies its own line, and the return expression cleanly represents listener construction and delegation. Reading flow: Natural progression from documentation and signature to validation and execution. Minor drawbacks are tightly grouped package/import declarations and the small cognitive overhead of nested lambdas.
Run 3
Code Structure: A logically organized utility class with a private constructor and one focused factory method. Nesting: Minimal; the nested lambdas remain short and easy to follow. Clarity of intent: Descriptive names, documentation, and explicit null checks clearly explain asynchronous notification handling. Code length: Concise, with no unnecessary implementation detail. Action granularity: Each validation occupies its own line, and the lambda expression cleanly expresses scheduling the callback. Reading flow: Natural progression from documentation and method signature through validation to listener creation. Minor drawbacks are the lack of spacing between package and import declarations and the modest cognitive overhead of nested lambdas.