import org.gradle.internal.service.scopes.ServiceScope;

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

@ServiceScope(Scope.Global.class)
public interface StreamHasher {
    /**
     * Returns the hash of the given input stream. The stream will not be closed by the method.
     */
    HashCode hash(InputStream inputStream);

    /**

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

public class DefaultFileHasher implements FileHasher {
    private final StreamHasher streamHasher;

    public DefaultFileHasher(StreamHasher streamHasher) {
        this.streamHasher = streamHasher;
    }

    @Override
    public HashCode hash(File file) {
        InputStream inputStream;
        try {

    private final StreamHasher streamHasher;
    private final Lazy<Map<String, Set<String>>> instrumentedSuperTypes;
    private final Lazy<Optional<HashCode>> instrumentedHashCode;
    private final Lazy<Optional<HashCode>> upgradedPropertiesHashCode;

    public GradleCoreInstrumentationTypeRegistry(StreamHasher streamHasher) {
        this.streamHasher = streamHasher;

                                                       FileOperations fileOperations, FileSystemAccess fileSystemAccess, GeneralCompileCaches cache) {
            return new CachingClassSetAnalyzer(
                new DefaultClassSetAnalyzer(fileHasher, streamHasher, classAnalyzer, fileOperations),
                fileSystemAccess,

    private final StreamHasher hasher;
    private final ClassDependenciesAnalyzer analyzer;
    private final FileOperations fileOperations;

    public DefaultClassSetAnalyzer(FileHasher fileHasher, StreamHasher streamHasher, ClassDependenciesAnalyzer analyzer, FileOperations fileOperations) {
        this.fileHasher = fileHasher;
        this.hasher = streamHasher;
        this.analyzer = analyzer;

    def deleter = createDeleter()
    def fileSystemSupport = new DefaultTarPackerFileSystemSupport(deleter)
    def streamHasher = new DefaultStreamHasher()
    def stringInterner = new StringInterner()
    def packer = new TarBuildCacheEntryPacker(fileSystemSupport, filePermissionAccess, streamHasher, stringInterner, Stub(BufferProvider) {
        getBuffer() >> new byte[4096]
    })

import org.gradle.internal.file.BufferProvider;
import org.gradle.internal.file.Deleter;
import org.gradle.internal.file.FileException;
import org.gradle.internal.file.ThreadLocalBufferProvider;
import org.gradle.internal.hash.StreamHasher;
import org.gradle.internal.instantiation.InstanceGenerator;
import org.gradle.internal.instantiation.InstantiatorFactory;
import org.gradle.internal.nativeintegration.filesystem.FileSystem;

import org.gradle.internal.event.ListenerManager;
import org.gradle.internal.file.Deleter;
import org.gradle.internal.file.impl.DefaultDeleter;
import org.gradle.internal.hash.DefaultStreamHasher;
import org.gradle.internal.hash.StreamHasher;
import org.gradle.internal.installation.CurrentGradleInstallation;
import org.gradle.internal.instantiation.InstantiatorFactory;
import org.gradle.internal.logging.events.OutputEventListener;

import java.io.InputStream;
import java.io.OutputStream;
import java.io.UncheckedIOException;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;

public class DefaultStreamHasher implements StreamHasher {
    private static final HashCode SIGNATURE = Hashing.signature(DefaultStreamHasher.class);

    private final Queue<byte[]> buffers = new ArrayBlockingQueue<byte[]>(16);

    @Override