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: package, imports, Javadoc, class definition, single static factory method. Nesting is minimal—only a lambda within a lambda, but both are simple. Clarity of intent is strong due to clear naming ('asynchronous', 'listener', 'executor') and comprehensive Javadoc. Code length is concise and appropriate, with no redundant boilerplate. Action granularity is mostly one action per line; the lambda bodies are compact but still understandable. Reading flow is natural: validation first, then return of the composed listener. Minor deductions: the static import is used correctly, and the inner lambda could arguably be extracted for absolute clarity, but current form is acceptable. Overall, this is exemplary Java library code.
Run 2
The code is highly readable. It uses a clear class-level Javadoc and a private constructor for a utility class. The asynchronous method is concise, with minimal nesting and clear intent: validate inputs, then return a lambda that delegates to the executor. Each action is on its own line, and reading flow follows a natural progression from validation to behavior. The only minor drawbacks are the slightly long generic method signature and the inline lambda, but these are idiomatic for Java and do not harm comprehension.
Run 3
The code is highly readable. It has a clear, logical structure with a single well-named final class and a private constructor preventing instantiation. The asynchronous method is concise, with no unnecessary nesting. The intent is immediately apparent: it wraps a removal listener to execute asynchronously via an executor. Null checks are performed flatly using static imports, and the lambda expressions are brief and perform one logical action per line. The reading flow is natural, moving from validation through construction to behavior. The Javadoc is clear but not excessive. Overall, the code is exemplary in brevity and clarity.
Run 1
Code Structure: The utility class is logically organized, with a private constructor and one focused factory method. Nesting: Minimal nesting; the nested lambdas are compact and easy to follow. Clarity of intent: Descriptive names and Javadoc clearly explain the asynchronous listener wrapper, although the documentation refers to eviction rather than all removal notifications. Code length: Concise, with no unnecessary implementation detail. Action granularity: Each null check occupies its own line, and the return expression cleanly expresses task submission and callback invocation. Reading flow: Documentation, validation, and construction appear in a natural sequence. Minor drawbacks are the lack of spacing between package and import declarations and the small cognitive overhead of nested lambdas.
Run 2
Code Structure: A well-organized utility class with a private constructor and one focused 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 delivery. Code length: Concise, with no unnecessary implementation steps. Action granularity: Each validation occupies its own line, and the return expression cleanly represents task submission and callback execution. Reading flow: Naturally progresses from documentation and method signature to validation and listener construction. Minor drawbacks are cramped spacing around package/import declarations and the slight mental overhead of nested lambdas.
Run 3
Code Structure: A well-organized utility class with a private constructor and one focused factory method. Nesting: Minimal; the nested lambdas are shallow and easy to follow. Clarity of intent: Descriptive names, documentation, and explicit null checks clearly convey asynchronous notification delivery. Code length: Concise, with no unnecessary logic or boilerplate. Action granularity: Each validation occupies its own line, and the returned expression cleanly expresses task submission and callback execution. Reading flow: Natural progression from documentation and method signature through validation to listener creation. Minor drawbacks are the lack of spacing between package and imports and the modest cognitive overhead of nested lambdas.