import javax.annotation.Nullable;
import java.io.Serializable;

public class DefaultWorkResult implements WorkResult, Serializable {
    public static final DefaultWorkResult SUCCESS = new DefaultWorkResult(true, null);

    private final boolean didWork;
    private final Throwable exception;

    public DefaultWorkResult(boolean didWork, @Nullable Throwable exception) {
        this.didWork = didWork;

            if (workResult instanceof DefaultWorkResult) {
                this.workResult = (DefaultWorkResult) workResult;
            } else {
                this.workResult = new DefaultWorkResult(workResult.getDidWork(), null);
            }
        }

        @Override
        public DefaultWorkResult getWorkResult() {
            return workResult;
        }
    }

        return buildOperationRunner.call(new CallableBuildOperation<DefaultWorkResult>() {
            @Override
            public DefaultWorkResult call(BuildOperationContext context) {
                DefaultWorkResult result = work.execute(spec);
                context.setResult(RESULT);
                context.failed(result.getException());
                return result;
            }

            @Override

package org.gradle.api.internal.tasks.compile.incremental.recomp;

import org.gradle.api.tasks.WorkResult;
import org.gradle.workers.internal.DefaultWorkResult;

/**
 * Marks compilation as beeing performed incrementally.
 */
public class DefaultIncrementalCompileResult extends DefaultWorkResult implements IncrementalCompilationResult {
    private final PreviousCompilationData previousCompilationData;

        return new AbstractWorker(buildOperationRunner) {
            @Override
            public DefaultWorkResult execute(IsolatedParametersActionExecutionSpec<?> spec, BuildOperationRef parentBuildOperation) {
                return executeWrappedInBuildOperation(spec, parentBuildOperation, workSpec -> {
                    DefaultWorkResult result;
                    try {

@ThreadSafe
public class WorkerExecutionQueueFactory implements Factory<ConditionalExecutionQueue<DefaultWorkResult>>, Stoppable {
    public static final String QUEUE_DISPLAY_NAME = "WorkerExecutor Queue";
    private final ConditionalExecutionQueueFactory conditionalExecutionQueueFactory;
    private ConditionalExecutionQueue<DefaultWorkResult> queue;

                return ((ProvidesWorkResult) execution).getWorkResult();
            } else {
                return DefaultWorkResult.SUCCESS;
            }
        } catch (Throwable t) {
            return new DefaultWorkResult(true, t);
        }
    }

    @Override
    public String toString() {
        return "DefaultWorkerServer{}";
    }

            Lists.newArrayList(IsolatedAntBuilder.class));
    }

    public DefaultWorkResult executeInClassLoader(TransportableActionExecutionSpec spec, ClassLoader workerClassLoader) {
        return executeInClassloader(workerClassLoader, new Factory<DefaultWorkResult>() {
            @Nullable
            @Override
            public DefaultWorkResult create() {

 */

package org.gradle.workers.internal;

import org.gradle.internal.operations.BuildOperationRef;

public interface BuildOperationAwareWorker {
    DefaultWorkResult execute(IsolatedParametersActionExecutionSpec<?> spec);

    DefaultWorkResult execute(IsolatedParametersActionExecutionSpec<?> spec, final BuildOperationRef parentBuildOperation);

    private final DaemonForkOptions forkOptions;
    private final MultiRequestClient<TransportableActionExecutionSpec, DefaultWorkResult> workerClient;
    private final WorkerProcess workerProcess;
    private final LogLevel logLevel;
    private final ActionExecutionSpecFactory actionExecutionSpecFactory;
    private int uses;