*
 * @param <OUT> The type the value is transformed to.
 * @param <IN> The type of the value to be transformed.
 */
public interface InternalTransformer<OUT, IN> {
    /**
     * Transforms the given object, and returns the transformed value.
     *
     * @param in The object to transform.
     * @return The transformed object.
     */
    OUT transform(IN in);

     */
    public static <O, I> InternalTransformer<O, I> cast(Class<O> outputType) {
        return new CastingTransformer<O, I>(outputType);
    }

    //just returns the original object
    public static <T> InternalTransformer<T, T> noOpTransformer() {
        return new InternalTransformer<T, T>() {
            @Override
            public T transform(T original) {

package org.gradle.internal.serialize;

import org.gradle.internal.InternalTransformer;
import org.gradle.internal.UncheckedException;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;

public class ExceptionReplacingObjectOutputStream extends ObjectOutputStream {
    private InternalTransformer<Object, Object> objectTransformer = new InternalTransformer<Object, Object>() {
        @Override

package org.gradle.internal.serialize;

import org.gradle.internal.InternalTransformer;
import org.gradle.internal.UncheckedException;

import java.io.IOException;
import java.io.InputStream;

public class ExceptionReplacingObjectInputStream extends ClassLoaderObjectInputStream {
    private InternalTransformer<Object, Object> objectTransformer = new InternalTransformer<Object, Object>() {
        @Override

     */
    public static InternalTransformer<List<String>, List<String>> argsFileGenerator(final File argsFile, final InternalTransformer<ArgWriter, PrintWriter> argWriterFactory) {
        return new InternalTransformer<List<String>, List<String>>() {
            @Override
            public List<String> transform(List<String> args) {

     */
    boolean withStateLock(InternalTransformer<ResourceLockState.Disposition, ResourceLockState> stateLockAction);

    /**
     * A convenience for using {@link #withStateLock(InternalTransformer)}.
     */
    void withStateLock(Runnable action);

    /**
     * A convenience for using {@link #withStateLock(InternalTransformer)}.
     */
    <T> T withStateLock(Supplier<T> action);

    /**

        super(createProducer(baseDir, pattern), checksumService);
    }

    private static InternalTransformer<Factory<List<File>>, ModuleComponentArtifactMetadata> createProducer(final File baseDir, final ResourcePattern pattern) {
        return new InternalTransformer<Factory<List<File>>, ModuleComponentArtifactMetadata>() {
            @Override

import org.gradle.internal.Factory;
import org.gradle.internal.InternalTransformer;
import org.gradle.internal.hash.ChecksumService;

import java.io.File;
import java.util.List;

public class AbstractLocallyAvailableResourceFinder<C> implements LocallyAvailableResourceFinder<C> {

    private final InternalTransformer<Factory<List<File>>, C> producer;
    private final ChecksumService checksumService;

    public static <R, I> R[] collectArray(I[] list, Class<R> newType, InternalTransformer<? extends R, ? super I> transformer) {
        @SuppressWarnings("unchecked") R[] destination = (R[]) Array.newInstance(newType, list.length);
        return collectArray(list, destination, transformer);
    }

    public static <R, I> R[] collectArray(I[] list, R[] destination, InternalTransformer<? extends R, ? super I> transformer) {

     */
    public static InternalTransformer<ResourceLockState.Disposition, ResourceLockState> lock(Iterable<? extends ResourceLock> resourceLocks) {
        return new AcquireLocks(resourceLocks, true);
    }

    /**
     * Attempts an atomic, blocking lock on the provided resource locks.
     */