/**
     * Called before visiting the contents of a directory.
     */
    default void enterDirectory(DirectorySnapshot directorySnapshot) {}

    /**
     * Called for each regular file/directory/missing/unavailable file.
     *
     * @return how to continue visiting the rest of the snapshot hierarchy.
     */
    SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot);

    /**

[!GOOS:windows] env GOTMPDIR=$WORK/my-favorite-tmpdir
[GOOS:windows] env GOTMPDIR=$WORK\my-favorite-tmpdir
mkdir $GOTMPDIR
go build -x hello.go
stderr ^WORK=.*my-favorite-tmpdir

# Make GOTMPDIR a regular file. This prevents the creation of work directories,
# so we can check that certain commands don't create them.
# This simulates running on a full disk or a read-only volume.
rm $GOTMPDIR
cp hello.go $GOTMPDIR # any file will do

     * If {@code true}, each locked dependency is added as a strict constraint,
     * and the resolution result must exactly match the set of locked dependencies.
     *
     * If {@code false}, each locked dependency is added a regular (lenient) constraint,
     * and the resolution result is not verified against the set of locked dependencies.
     *
     * @return {@code true} if lock state was found, {@code false} otherwise
     */

  `ECDHE-ECDSA-AES256-GCM-SHA384`, `ECDHE-RSA-AES256-GCM-SHA384`, and ECDH
  curves to `P-256`. These restrictions apply on the following data paths:

  * mTLS communication between Envoy proxies;
  * regular TLS on the downstream and the upstream of Envoy proxies (e.g. gateway);
  * Google gRPC side requests from Envoy proxies (e.g. Stackdriver extensions);
  * Istiod xDS server;
  * Istiod injection and validation webhook servers.

    /**
     * Called before visiting the contents of a directory.
     */
    default void enterDirectory(DirectorySnapshot directorySnapshot, RelativePathSupplier relativePath) {}

    /**
     * Called for each regular file/directory/missing/unavailable file.
     *
     * @return how to continue visiting the rest of the snapshot hierarchy.
     */

import org.gradle.internal.hash.Hasher;
import org.gradle.internal.hash.Hashing;

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

/**
 * Caches the result of hashing regular files with a {@link ResourceHasher}.
 * It does not cache the result of hashing {@link ZipEntry}s.
 * It also caches the absence of a hash.
 */
public class CachingResourceHasher implements ResourceHasher {

 */
@FunctionalInterface
public interface IoSupplier<T> {
    @Nullable
    T get() throws IOException;

    /**
     * Wraps an {@link IOException}-throwing {@link IoSupplier} into a regular {@link Supplier}.
     *
     * Any {@code IOException}s are rethrown as {@link UncheckedIOException}.
     */
    static <T> Supplier<T> wrap(IoSupplier<T> supplier) {
        return () -> {
            try {

import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.internal.file.FileCollectionInternal;

import javax.annotation.Nullable;

/**
 * Represents a local file dependency. Should be modelled as a regular dependency, but is treated separately as a migration step.
 */
public interface LocalFileDependencyMetadata {
    /**

	MOVQ z+0(FP), R10

	MOVQ $0, CX		// c = 0
	MOVQ $0, SI		// i = 0

	// s/JL/JMP/ below to disable the unrolled loop
	SUBQ $4, DI		// n -= 4
	JL V1			// if n < 0 goto V1

U1:	// n >= 0
	// regular loop body unrolled 4x
	ADDQ CX, CX		// restore CF
	MOVQ 0(R8)(SI*8), R11
	MOVQ 8(R8)(SI*8), R12
	MOVQ 16(R8)(SI*8), R13
	MOVQ 24(R8)(SI*8), R14
	ADCQ 0(R9)(SI*8), R11
	ADCQ 8(R9)(SI*8), R12
	ADCQ 16(R9)(SI*8), R13

//
// This interface is being experimented with as an easier way to write controllers
// with a bit less boilerplate.
//
// Informer/Lister classes are thin wrappers providing a type-safe interface
// over regular interface{}-based Informers/Listers
//
// Controller[T] provides a reusable way to reconcile objects out of an informer
// using the tried and true controller design pattern found all over k8s