*/
public abstract class TransformExecutionResult {

    protected final ImmutableList<Builder.TransformExecutionOutput> executionOutputs;

    protected TransformExecutionResult(ImmutableList<Builder.TransformExecutionOutput> executionOutputs) {
        this.executionOutputs = executionOutputs;
    }

    /**

        });
        unchecked(() -> Files.write(target.toPath(), resultFileContents));
    }

    public TransformExecutionResult readResultsFile(File resultsFile) {
        Path transformerResultsPath = resultsFile.toPath();
        try {
            TransformExecutionResult.Builder builder = TransformExecutionResult.builder();
            List<String> paths = Files.readAllLines(transformerResultsPath, StandardCharsets.UTF_8);

        this.outputDir = outputDir;
        this.resultBuilder = TransformExecutionResult.builderFor(inputArtifact, outputDir);
    }

    @Override
    public TransformExecutionResult getRegisteredOutputs() {
        TransformExecutionResult result = resultBuilder.build();
        result.visitOutputs(new TransformExecutionResult.OutputVisitor() {
            @Override
            public void visitEntireInputArtifact() {

        }
    }

    private WorkOutput executeWithinTransformerListener(ExecutionRequest executionRequest) {
        TransformExecutionResult result = buildOperationRunner.call(new CallableBuildOperation<TransformExecutionResult>() {
            @Override
            public TransformExecutionResult call(BuildOperationContext context) {
                try {
                    File workspace = executionRequest.getWorkspace();

        assert serializer.readResultsFile(resultFile).resolveForWorkspace(outputDir).resolveForInputArtifact(inputArtifact) == resultFiles
    }

    private TransformExecutionResult buildTransformExecutionResult(Collection<File> files) {
        def builder = TransformExecutionResult.builderFor(inputArtifact, outputDir)
        for (File file in files) {
            builder.addOutput(file) {}
        }
        return builder.build()
    }

import org.gradle.api.internal.artifacts.transform.ImmutableTransformWorkspaceServices;
import org.gradle.api.internal.artifacts.transform.ToPlannedTransformStepConverter;
import org.gradle.api.internal.artifacts.transform.TransformExecutionResult;
import org.gradle.api.internal.cache.CacheConfigurationsInternal;
import org.gradle.cache.Cache;
import org.gradle.cache.CacheBuilder;
import org.gradle.cache.UnscopedCacheBuilderFactory;

import java.io.Closeable;

public interface ImmutableTransformWorkspaceServices extends Closeable {
    ImmutableWorkspaceProvider getWorkspaceProvider();

    Cache<UnitOfWork.Identity, ExecutionEngine.IdentityCacheResult<TransformExecutionResult.TransformWorkspaceResult>> getIdentityCache();

public interface MutableTransformWorkspaceServices extends ReservedFileSystemLocation {
    MutableWorkspaceProvider getWorkspaceProvider();

    Cache<UnitOfWork.Identity, ExecutionEngine.IdentityCacheResult<TransformExecutionResult.TransformWorkspaceResult>> getIdentityCache();

 */

package org.gradle.api.internal.artifacts.transform;

import org.gradle.api.artifacts.transform.TransformOutputs;

public interface TransformOutputsInternal extends TransformOutputs {

    TransformExecutionResult getRegisteredOutputs();

     */
    boolean requiresInputChanges();

    /**
     * Whether the transformer is cacheable.
     */
    boolean isCacheable();

    TransformExecutionResult transform(Provider<FileSystemLocation> inputArtifactProvider, File outputDir, TransformDependencies dependencies, @Nullable InputChanges inputChanges);

    /**
     * The hash of the secondary inputs of the transformer.