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. Structure is clean: a final utility class with a private constructor and a single static factory method. Nesting is minimal, using a lambda and method reference to avoid deep indentation. Intent is clear from the class Javadoc, method Javadoc, and parameter validation. Code length is concise—no unnecessary boilerplate. Action granularity is appropriate, with null checks and the return statement each on separate lines. Reading flow is natural: validation then behavior. The only minor deduction is that the lambda's asynchronous execution could be slightly more explicit, but overall it is very well-written.
Run 3
The code is exceptionally readable. It has a clear, logical structure with a single static factory method, minimal nesting, and concise implementation. The purpose is unambiguous: it creates an asynchronous removal listener. Each action (validation, lambda construction, executor call) is cleanly separated. The reading flow is natural, enhanced by clear Javadoc and meaningful parameter names. The only minor deduction is that the nested lambda could slightly reduce clarity for readers unfamiliar with functional syntax, but overall this is near-exemplary code.
Run 1
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 and Javadoc clearly explain the asynchronous listener wrapper, although 'eviction notifications' is slightly narrower than removal notifications. Code length: Concise, with no unnecessary implementation detail. Action granularity: Each null check occupies its own line, and the return expression performs one coherent wrapping operation. Reading flow: Documentation, argument validation, and listener construction follow a natural sequence. A blank line between the package declaration and imports would slightly improve visual organization.
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 handling. Code length: Concise, with no unnecessary implementation logic. Action granularity: Each validation occupies its own line, while the compact return expression cleanly expresses task submission and callback execution. Reading flow: Natural progression from documentation and signature through validation to listener creation. Minor readability drawbacks are the tightly packed package/import declarations and the modest cognitive overhead of nested lambdas.
Run 3
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 listener delegation. Code length: Concise, with no unnecessary implementation or abstraction. Action granularity: Each validation occupies its own line, while the compact return expression naturally groups task submission and callback execution. Reading flow: Documentation, signature, validation, and return follow a predictable sequence. Minor drawbacks are the lack of spacing between package and imports and the slightly denser nested-lambda expression.