* limitations under the License.
 */
package org.gradle.internal.nativeintegration.services;

import org.gradle.internal.nativeintegration.filesystem.FileSystem;

public abstract class FileSystems {
    public static FileSystem getDefault() {
        return NativeServices.getInstance().get(FileSystem.class);
    }

        "vboxsf"
    );

    private final FileSystems fileSystems;

    public DefaultWatchableFileSystemDetector(FileSystems fileSystems) {
        this.fileSystems = fileSystems;
    }

    @Override
    public Stream<File> detectUnsupportedFileSystems() {
        return fileSystems.getFileSystems().stream()
            .filter(fileSystem -> {
                LOGGER.debug("Detected {}: {} from {} (remote: {})",

import net.rubygrapefruit.platform.file.FileSystems
import net.rubygrapefruit.platform.internal.DefaultFileSystemInfo
import spock.lang.Specification

import java.nio.file.Paths
import java.util.stream.Collectors

class DefaultWatchableFileSystemDetectorTest extends Specification {
    def fileSystemsService = Stub(FileSystems)
    def detector = new DefaultWatchableFileSystemDetector(fileSystemsService)

# logic even on case-insensitive filesystems.
cp b/file.go b/FILE.go  # no-op on case-insensitive filesystems
! go list b/file.go b/FILE.go
stderr 'case-insensitive file name collision'

mkdir a/Pkg  # no-op on case-insensitive filesystems
cp a/pkg/pkg.go a/Pkg/pkg.go  # no-op on case-insensitive filesystems
! go list example/a/pkg example/a/Pkg

# Experimental filesystem C APIs for TensorFlow.
# Will be moved in proper place once all filesystems are converted to the
# modular framework.
load("//tensorflow:tensorflow.bzl", "tf_cc_test")
load("//tensorflow/core/platform:rules_cc.bzl", "cc_library")

package(
    # copybara:uncomment default_applicable_licenses = ["//tensorflow:license"],
    licenses = ["notice"],
)

# This is only for plugins
cc_library(
    name = "filesystem_interface",

                return new PatternSet();
            }
        };
        this.fileSystem = FileSystems.getDefault();
    }

    public DefaultDirectoryFileTreeFactory(Factory<PatternSet> patternSetFactory, FileSystem fileSystem) {
        this.patternSetFactory = patternSetFactory;
        this.fileSystem = fileSystem;
    }

    @Override
    public DirectoryFileTree create(File directory) {

import org.gradle.internal.nativeintegration.services.FileSystems;

import java.io.File;

public class FileBackedDirectoryFileTree extends DirectoryFileTree {
    private final File file;

    public FileBackedDirectoryFileTree(File file) {
        super(file.getParentFile(), new PatternSet().include(file.getName()), FileSystems.getDefault());
        this.file = file;
    }

    public File getFile() {

    }

    private static Predicate<Artifact> toPredicate(Exclusion exclusion) {
        PathMatcher groupId = FileSystems.getDefault().getPathMatcher("glob:" + exclusion.getGroupId());
        PathMatcher artifactId = FileSystems.getDefault().getPathMatcher("glob:" + exclusion.getArtifactId());
        Predicate<Artifact> predGroupId = a -> groupId.matches(createPathProxy(a.getGroupId()));

        this(dir, patternSet, fileSystem, false);
    }

    @VisibleForTesting
    public DirectoryFileTree(File dir, PatternSet patternSet, FileSystem fileSystem, boolean postfix) {
        this.patternSet = patternSet;
        this.dir = dir;
        this.fileSystem = fileSystem;
        this.postfix = postfix;
    }

    @Override
    public String getDisplayName() {

            populateFilesList(jdkFiles, jdkHomeDirectory)

            def fileSystem = FileSystems.getDefault()

            for (File file : jdkFiles) {
                def path = RelativePathUtil.relativePath(jdkHomeParentDirectory, file)
                ZipArchiveEntry entry = (ZipArchiveEntry) aos.createArchiveEntry(file, path)
                entry.setUnixMode(fileSystem.getUnixMode(file))
                aos.putArchiveEntry(entry)