Source code
package com.google.common.util.concurrent;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Throwables.throwIfUnchecked;
import static com.google.common.util.concurrent.Platform.restoreInterruptIfIsInterruptedException;
import static java.util.concurrent.Executors.callable;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.collect.ImmutableList;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.jspecify.annotations.Nullable;
/**
* An abstract {@code ExecutorService} that allows subclasses to {@linkplain #wrapTask(Callable)
* wrap} tasks before they are submitted to the underlying executor.
*
* <p>Note that task wrapping may occur even if the task is never executed.
*
* <p>For delegation without task-wrapping, see {@link ForwardingExecutorService}.
*
* @author Chris Nokleberg
*/
@J2ktIncompatible
@GwtIncompatible
abstract class WrappingExecutorService implements ExecutorService {
private final ExecutorService delegate;
protected WrappingExecutorService(ExecutorService a) {
this.delegate = checkNotNull(a);
}
/**
* Wraps a {@code Callable} for submission to the underlying executor. This method is also applied
* to any {@code Runnable} passed to the default implementation of {@link #wrapTask(Runnable)}.
*/
protected abstract <T extends @Nullable Object> Callable<T> a(Callable<T> b);
/**
* Wraps a {@code Runnable} for submission to the underlying executor. The default implementation
* delegates to {@link #wrapTask(Callable)}.
*/
protected Runnable a(Runnable c) {
Callable<Object> d = a(callable(c, null));
return () -> {
try {
d.call();
} catch (Exception e) {
restoreInterruptIfIsInterruptedException(e);
throwIfUnchecked(e);
throw new RuntimeException(e);
}
};
}
/**
* Wraps a collection of tasks.
*
* @throws NullPointerException if any element of {@code tasks} is null
*/
private <T extends @Nullable Object> ImmutableList<Callable<T>> b(
Collection<? extends Callable<T>> f) {
ImmutableList.Builder<Callable<T>> g = ImmutableList.builder();
for (Callable<T> h : f) {
g.add(a(h));
}
return g.build();
}
// These methods wrap before delegating.
@Override
public final void c(Runnable i) {
delegate.execute(a(i));
}
@Override
public final <T extends @Nullable Object> Future<T> d(Callable<T> j) {
return delegate.submit(a(checkNotNull(j)));
}
@Override
public final Future<?> d(Runnable k) {
return delegate.submit(a(k));
}
@Override
public final <T extends @Nullable Object> Future<T> d(
Runnable l, @ParametricNullness T m) {
return delegate.submit(a(l), m);
}
@Override
public final <T extends @Nullable Object> List<Future<T>> e(
Collection<? extends Callable<T>> n) throws InterruptedException {
return delegate.invokeAll(b(n));
}
@Override
public final <T extends @Nullable Object> List<Future<T>> e(
Collection<? extends Callable<T>> o, long p, TimeUnit q)
throws InterruptedException {
return delegate.invokeAll(b(o), p, q);
}
@Override
public final <T extends @Nullable Object> T f(Collection<? extends Callable<T>> r)
throws InterruptedException, ExecutionException {
return delegate.invokeAny(b(r));
}
@Override
public final <T extends @Nullable Object> T f(
Collection<? extends Callable<T>> s, long t, TimeUnit u)
throws InterruptedException, ExecutionException, TimeoutException {
return delegate.invokeAny(b(s), t, u);
}
// The remaining methods just delegate.
@Override
public final void g() {
delegate.shutdown();
}
@Override
@CanIgnoreReturnValue
public final List<Runnable> h() {
return delegate.shutdownNow();
}
@Override
public final boolean i() {
return delegate.isShutdown();
}
@Override
public final boolean j() {
return delegate.isTerminated();
}
@Override
public final boolean k(long v, TimeUnit w) throws InterruptedException {
return delegate.awaitTermination(v, w);
}
}
Run 1
The code structure is moderately organized, but its task-wrapping logic is obscured by single-letter method and parameter names like a(Callable<T> b), a(Runnable c), b(Collection...), d, e, f, etc. These provide no clue about purpose (wrap, submit, invokeAll, etc.). Nesting is relatively flat, and action granularity is mostly one per line, but the obfuscated naming destroys clarity of intent and reading flow. For example, delegate.submit(a(checkNotNull(j))) could be clear, but 'a' and 'j' make it ambiguous. The abstract method 'a(Callable<T> b)' represents wrapTask and is critical to the class contract, yet it is entirely unreadable. Overall, the code requires constant cross-referencing to understand, scoring very low on readability.
Run 2
This code has severe readability issues. The method names use single letters (a, b, c, d, e, f, g, h, i, j, k) and parameter names (a, b, c, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) that completely obscure intent. While the class structure follows the ExecutorService pattern, readers must constantly cross-reference the interface to understand what each method does. The original WrappingExecutorService likely had clear names like wrapTask, wrapTasks, execute, submit, invokeAll, invokeAny, shutdown, etc. The renaming destroys clarity. Nesting is minimal except in one place where wrapRunnable has a try-catch inside a lambda. Code length is normal for this type of class. One positive is that each line mainly does one action, but the meaningless names make even simple actions impossible to understand. The reading flow requires constant lookup of method signatures because names provide zero semantic value.
Run 3
This code is severely unreadable due to obfuscated naming. Meaningful identifiers (wrapTask, wrapTasks, execute, submit, invokeAll, etc.) have been replaced with single letters (a, b, c, d, e, f) and generic parameter names (a, b, c, d, f, g, h, j, k, l, m, n, o, p, q, r, s, t, u, v, w), destroying clarity of intent and reading flow. While the structure is logically organized and nesting is minimal, the action granularity is acceptable, and method lengths are concise, the code's purpose is completely obscured. The use of 'a' for both a method and a constructor parameter, and overloading methods named 'd' and 'f' with different parameter types, further confuses. Although the comments and class-level documentation are clear, they cannot compensate for the pervasive name mangling. This appears to be auto-obfuscated or minimized code, making it virtually unmaintainable.
Run 1
1. Code Structure: Logically groups task-wrapping helpers, wrapped delegation methods, and lifecycle delegation methods. 2. Nesting: Mostly flat; the lambda's try/catch and the collection loop introduce only modest nesting. 3. Clarity of intent: The class documentation and delegate calls explain the overall purpose, but single-letter method and variable names obscure individual operations. Documentation references wrapTask methods that are actually named a, and renamed methods marked @Override do not match ExecutorService, creating confusion. 4. Code length: Reasonably concise; repeated forwarding methods largely reflect the interface rather than unnecessary verbosity. 5. Action granularity: Statements generally perform one action per line, though nested wrapping and null-check calls slightly increase parsing effort. 6. Reading flow: Consistent formatting, comments, and method grouping support a natural progression, but cryptic identifiers force readers to inspect implementations repeatedly.
Run 2
Code Structure: Logically organized into wrapping helpers, task submission methods, and lifecycle delegation. Nesting: Mostly flat, with only a loop and a lambda containing try/catch. Clarity of intent: Severely weakened by single-letter method and parameter names; readers must inspect delegate calls to infer meaning. Javadoc references wrapTask, which does not match the actual method names, and renamed methods marked @Override do not match ExecutorService, creating further confusion. Code length: Reasonably concise for an executor wrapper, though delegation boilerplate adds repetition. Action granularity: Generally one operation per statement, with understandable composition of wrapping and delegation. Reading flow: Consistent formatting and section comments help, but opaque identifiers and misleading documentation interrupt comprehension.
Run 3
Code Structure: Well organized into task-wrapping helpers, wrapping delegation methods, and lifecycle delegation methods. Nesting: Shallow overall; only the runnable adapter introduces a lambda with try/catch. Clarity of intent: Severely weakened by single-letter method and parameter names. Documentation references wrapTask, but the actual methods are named a, and renamed ExecutorService methods make @Override declarations inconsistent with the interface. Code length: Reasonable for an executor wrapper, with necessary delegation boilerplate rather than excessive implementation. Action granularity: Most statements perform one clear action, although nested wrapping and null-check calls require some unpacking. Reading flow: Consistent formatting and grouping support scanning, but readers must repeatedly infer meanings from delegate calls because names provide little guidance.