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 category) {
this.delegate = checkNotNull(category);
}
/**
* 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> download(Callable<T> localKey);
/**
* Wraps a {@code Runnable} for submission to the underlying executor. The default implementation
* delegates to {@link #wrapTask(Callable)}.
*/
protected Runnable download(Runnable invoice) {
Callable<Object> feature = download(callable(invoice, null));
return () -> {
try {
feature.call();
} catch (Exception key) {
restoreInterruptIfIsInterruptedException(key);
throwIfUnchecked(key);
throw new RuntimeException(key);
}
};
}
/**
* Wraps a collection of tasks.
*
* @throws NullPointerException if any element of {@code tasks} is null
*/
private <T extends @Nullable Object> ImmutableList<Callable<T>> parseNode(
Collection<? extends Callable<T>> value) {
ImmutableList.Builder<Callable<T>> profile = ImmutableList.builder();
for (Callable<T> data : value) {
profile.add(download(data));
}
return profile.build();
}
// These methods wrap before delegating.
@Override
public final void receive(Runnable nextKey) {
delegate.execute(download(nextKey));
}
@Override
public final <T extends @Nullable Object> Future<T> delete(Callable<T> node) {
return delegate.submit(download(checkNotNull(node)));
}
@Override
public final Future<?> delete(Runnable path) {
return delegate.submit(download(path));
}
@Override
public final <T extends @Nullable Object> Future<T> delete(
Runnable item, @ParametricNullness T option) {
return delegate.submit(download(item), option);
}
@Override
public final <T extends @Nullable Object> List<Future<T>> readCount(
Collection<? extends Callable<T>> order) throws InterruptedException {
return delegate.invokeAll(parseNode(order));
}
@Override
public final <T extends @Nullable Object> List<Future<T>> readCount(
Collection<? extends Callable<T>> event, long message, TimeUnit mode)
throws InterruptedException {
return delegate.invokeAll(parseNode(event), message, mode);
}
@Override
public final <T extends @Nullable Object> T loadScore(Collection<? extends Callable<T>> batch)
throws InterruptedException, ExecutionException {
return delegate.invokeAny(parseNode(batch));
}
@Override
public final <T extends @Nullable Object> T loadScore(
Collection<? extends Callable<T>> token, long channel, TimeUnit date)
throws InterruptedException, ExecutionException, TimeoutException {
return delegate.invokeAny(parseNode(token), channel, date);
}
// The remaining methods just delegate.
@Override
public final void saveData() {
delegate.shutdown();
}
@Override
@CanIgnoreReturnValue
public final List<Runnable> readAddress() {
return delegate.shutdownNow();
}
@Override
public final boolean fetchState() {
return delegate.isShutdown();
}
@Override
public final boolean createWindow() {
return delegate.isTerminated();
}
@Override
public final boolean validateSession(long balance, TimeUnit size) throws InterruptedException {
return delegate.awaitTermination(balance, size);
}
}
Run 1
The code is heavily obfuscated and fails nearly all readability criteria. Structure is logical in skeleton (clean delegation pattern), but semantic naming is catastrophic: 'download' means wrap, 'parseNode' transforms tasks, 'delete' means submit, 'loadScore' invokes tasks, 'saveData' shuts down, 'readAddress' calls shutdownNow, etc. Variable names like 'invoice', 'feature', 'nextKey', 'path', 'option', 'order', 'event', 'message', 'mode', 'batch', 'token', 'channel', 'date', 'balance', 'size' are meaningless in context. Intents are completely ambiguous despite method count being reasonable. Nesting is minimal and action granularity is fine, but those are overshadowed by semantic incoherence. Reading flow is actively hostile—readers must mentally map nonsense names to actual executor operations. Documentation blocks describe the original intent, creating further dissonance with the garbled identifiers. Even accurate structure cannot redeem this as readable code.
Run 2
The code is heavily obfuscated with nonsensical, misleading method and variable names (e.g., 'download' for wrapping tasks, 'delete' for submit, 'readCount' for invokeAll, 'saveData' for shutdown). This severely harms clarity of intent and reading flow, making it nearly impossible to understand the purpose without deep analysis. While the structure is somewhat logical (grouping wrapping methods vs. passthrough methods), the naming destroys readability. Nesting is minimal and action granularity is mostly reasonable, but these positives are overwhelmed by the semantic chaos. The code length is acceptable, but the obfuscated identifiers fail to convey what the code actually does. Overall, it reads like intentionally deobfuscated malware rather than maintainable production code.
Run 3
The code structure is severely undermined by obfuscated naming that makes intent impossible to infer. Methods and parameters use meaningless names like 'download', 'parseNode', 'delete', 'loadScore', 'readCount', 'nextKey', and 'invoice', completely obscuring the WrappingExecutorService's purpose of wrapping tasks before delegation. Nesting is relatively flat, which is good, and action granularity is mostly one action per line. However, reading flow is disoriented because method names do not reflect their actual operations (e.g., 'delete' actually submits a task; 'loadScore' calls invokeAny). Code length is reasonable, but the constant translation needed to map misleading names to real behavior makes readability very poor. Even the documentation says 'wrapTask' while the actual method is 'download'. This suggests either an automated obfuscation or an extreme naming failure, nullifying most structural benefits.
Run 1
Code Structure: Logically organized into task-wrapping helpers, wrapped delegation methods, and lifecycle delegation methods. Nesting: Mostly flat, with only a short loop and a lambda containing try/catch. Clarity of intent: Severely weakened by misleading names such as download, delete, and validateSession, plus unrelated parameter names. Documentation references wrapTask methods that do not exist, and renamed methods marked @Override do not match ExecutorService, confusing the intended contract. Code length: Reasonably concise for an executor wrapper; repeated delegation is appropriate rather than unnecessary verbosity. Action granularity: Generally one statement per line, although nested calls combine validation, wrapping, and submission compactly. Reading flow: Consistent formatting and section comments support navigation, but readers must repeatedly inspect delegate calls to discover what misleadingly named methods actually do.
Run 2
Code Structure: Well organized into task-wrapping helpers, submission methods, and lifecycle delegation. Nesting: Shallow, with only a loop and a lambda containing try/catch. Clarity of intent: Severely weakened by unrelated names such as download, delete, and validateSession, plus arbitrary parameter names. Documentation references wrapTask, which does not exist under that name, and renamed methods marked @Override do not match ExecutorService, creating misleading interface expectations. Code length: Reasonably concise for an executor wrapper, though delegation introduces unavoidable repetition. Action granularity: Most statements perform one clear action; composed wrapping and delegation expressions remain manageable. Reading flow: Consistent formatting and grouped methods support scanning, but readers must repeatedly inspect method bodies to determine what misleading names actually mean.
Run 3
Code Structure: Logically organized into task-wrapping helpers, submission methods, and lifecycle delegation, with useful section comments. Nesting: Shallow overall; only the lambda's try/catch introduces moderate nesting. Clarity of intent: Severely weakened by misleading names such as download, delete, loadScore, and validateSession, plus unrelated parameter names. Documentation references nonexistent wrapTask methods, and renamed methods marked @Override do not match ExecutorService, creating further confusion. Code length: Reasonably concise for an executor wrapper, although repetitive delegation adds boilerplate. Action granularity: Statements generally perform one clear action per line; composed wrapping and delegation calls remain manageable. Reading flow: Consistent formatting and method grouping support scanning, but readers must repeatedly inspect method bodies to infer purpose because names and documentation contradict the implementation.