// the directory itself, if the dirPath doesn't exist this function doesn't return
// an error.
func readDirFn(dirPath string, filter func(name string, typ os.FileMode) error) error {
	// Ensure we don't pick up files as directories.
	globAll := filepath.Clean(dirPath) + `\*`
	globAllP, err := syscall.UTF16PtrFromString(globAll)
	if err != nil {
		return errInvalidArgument
	}
	data := &syscall.Win32finddata{}

/**
 * The metadata of a file.
 */
public interface FileMetadata {
    FileType getType();

    /**
     * Note: always 0 for directories and missing files.
     */
    long getLastModified();

    /**
     * Note: always 0 for directories and missing files.
     */
    long getLength();

    /**
     * How the file with the metadata was accessed.
     */
    AccessType getAccessType();

     */
    WorkResult copy(Action<? super CopySpec> action);

    /**
     * Synchronizes the contents of a destination directory with some source directories and files.
     * The given action is used to configure a {@link CopySpec}, which is then used to synchronize the files.
     *
     * @param action action Action to configure the CopySpec.

	}
}

// readDataDirectories accepts an io.ReadSeeker pointing to data directories in the PE file,
// its size and number of data directories as seen in optional header.
// It parses the given size of bytes and returns given number of data directories.
func readDataDirectories(r io.ReadSeeker, sz uint16, n uint32) ([]DataDirectory, error) {
	ddSz := uint64(binary.Size(DataDirectory{}))

thing that go work use does.

The -r flag searches recursively for modules in the argument
directories, and the use command operates as if each of the directories
were specified as arguments: namely, use directives will be added for
directories that exist, and removed for directories that do not exist.



See the workspaces reference at https://go.dev/ref/mod#workspaces
for more information.
`,
}

// meta-data file. Pods are intended to simplify processing of
// coverage output files in the case where we have several coverage
// output directories containing output files derived from more
// than one instrumented executable. In the case where the files that
// make up a pod are spread out across multiple directories, each
// element of the "Origins" field below will be populated with the
// index of the originating directory for the corresponding counter

// parsed contents of the first file. There must be at least one file.
// If an error occurs, parsing stops and the returned *Template is nil.
//
// When parsing multiple files with the same name in different directories,
// the last one mentioned will be the one that results.
// For instance, ParseFiles("a/foo", "b/foo") stores "b/foo" as the template
// named "foo", while "a/foo" is unavailable.

	scannerBucketScansStartedMD = NewCounterMD(scannerBucketScansStarted,
		"Total number of bucket scans started since server start")
	scannerDirectoriesScannedMD = NewCounterMD(scannerDirectoriesScanned,
		"Total number of directories scanned since server start")
	scannerObjectsScannedMD = NewCounterMD(scannerObjectsScanned,
		"Total number of unique objects scanned since server start")
	scannerVersionsScannedMD = NewCounterMD(scannerVersionsScanned,

    private static class FixedIncludePath extends IncludePath {
        private final List<DirectoryContents> directories;
        private final Map<String, CachedIncludeFile> cachedLookups = new HashMap<String, CachedIncludeFile>();

        FixedIncludePath(List<DirectoryContents> directories) {
            this.directories = directories;
        }

        @Nullable
        @Override

 * <p>
 * Within a process, only one thread is allowed write access to a given expanded directory. This is to avoid concurrent writes
 * to the same expanded directory.
 *
 * Multiple threads are allowed to extract into different expanded directories concurrently.
 * <p>