Java Path.getFileSystem方法代码示例

import java.nio.file.Path; //导入方法依赖的package包/类
protected Path mockPath(Path parent, String name, long size) {
	FileSystem fileSystem = parent.getFileSystem();
	Path subPath = mock(Path.class);
	File subPathToFile = mock(File.class);
	when(subPath.toFile()).thenReturn(subPathToFile);
	when(subPathToFile.length()).thenReturn(size);
	when(subPathToFile.exists()).thenReturn(true);
	when(subPath.getFileSystem()).thenReturn(fileSystem);
	when(subPath.resolve(anyString())).thenAnswer(invoke -> {
		String childName = (String) invoke.getArguments()[0];
		return mockPath(subPath, childName);
	});
	when(subPath.getParent()).thenReturn(parent);
	when(fileSystem.getPath(parent.toString(), name)).thenReturn(subPath);
	String fullPath = (parent.toString() + "/" + name).replace("//", "/");
	when(fileSystem.getPath(fullPath)).thenReturn(subPath);
	when(subPath.toString()).thenReturn(fullPath);
	Path subPathFileName = mock(Path.class);
	when(subPathFileName.toString()).thenReturn(name);
	when(subPath.getFileName()).thenReturn(subPathFileName);
	return subPath;
}
 

import java.nio.file.Path; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    FileSystem fs = FileSystems.getDefault();
    if (fs.getClass().getModule() == Object.class.getModule())
        throw new RuntimeException("FileSystemProvider not overridden");

    // exercise the file system
    Path dir = Files.createTempDirectory("tmp");
    if (dir.getFileSystem() != fs)
        throw new RuntimeException("'dir' not in default file system");
    System.out.println("created: " + dir);

    Path foo = Files.createFile(dir.resolve("foo"));
    if (foo.getFileSystem() != fs)
        throw new RuntimeException("'foo' not in default file system");
    System.out.println("created: " + foo);

    // exercise interop with java.io.File
    File file = foo.toFile();
    Path path = file.toPath();
    if (path.getFileSystem() != fs)
        throw new RuntimeException("'path' not in default file system");
    if (!path.equals(foo))
        throw new RuntimeException(path + " not equal to " + foo);
}
 

import java.nio.file.Path; //导入方法依赖的package包/类
@VisibleForTesting
protected MirrorFs(Path mirroredPath, FileChannelCloser fileChannelCloser) {
	super();
	this.mirroredRoot = mirroredPath.toString();
	this.fileSystem = mirroredPath.getFileSystem();
	this.fileChannelCloser = fileChannelCloser;
}
 

import java.nio.file.Path; //导入方法依赖的package包/类
FaultyFileSystem(Path root) throws IOException {
    if (root == null) {
        root = Files.createTempDirectory("faultyFS");
        removeRootAfterClose = true;
    } else {
        if (! Files.isDirectory(root)) {
            throw new IllegalArgumentException("must be a directory.");
        }
        removeRootAfterClose = false;
    }
    this.root = root;
    delegate = root.getFileSystem();
    isOpen = true;
}
 

import java.nio.file.Path; //导入方法依赖的package包/类
protected boolean isPathNameCompatible(Path p, String simpleName, Kind kind) {
    Objects.requireNonNull(simpleName);
    Objects.requireNonNull(kind);

    if (kind == Kind.OTHER && BaseFileManager.getKind(p) != kind) {
        return false;
    }

    String sn = simpleName + kind.extension;
    String pn = p.getFileName().toString();
    if (pn.equals(sn)) {
        return true;
    }

    if (p.getFileSystem() == defaultFileSystem) {
        if (isMacOS) {
            if (Normalizer.isNormalized(pn, Normalizer.Form.NFD)
                    && Normalizer.isNormalized(sn, Normalizer.Form.NFC)) {
                // On Mac OS X it is quite possible to have the file name and the
                // given simple name normalized in different ways.
                // In that case we have to normalize file name to the
                // Normal Form Composed (NFC).
                String normName = Normalizer.normalize(pn, Normalizer.Form.NFC);
                if (normName.equals(sn)) {
                    return true;
                }
            }
        }

        if (pn.equalsIgnoreCase(sn)) {
            try {
                // allow for Windows
                return p.toRealPath(LinkOption.NOFOLLOW_LINKS).getFileName().toString().equals(sn);
            } catch (IOException e) {
            }
        }
    }

    return false;
}
 

import java.nio.file.Path; //导入方法依赖的package包/类
private boolean contains(Collection<Path> searchPath, Path file) throws IOException {

        if (searchPath == null) {
            return false;
        }

        Path enclosingJar = null;
        if (file.getFileSystem().provider() == fsInfo.getJarFSProvider()) {
            URI uri = file.toUri();
            if (uri.getScheme().equals("jar")) {
                String ssp = uri.getSchemeSpecificPart();
                int sep = ssp.lastIndexOf("!");
                if (ssp.startsWith("file:") && sep > 0) {
                    enclosingJar = Paths.get(URI.create(ssp.substring(0, sep)));
                }
            }
        }

        Path nf = normalize(file);
        for (Path p : searchPath) {
            Path np = normalize(p);
            if (np.getFileSystem() == nf.getFileSystem()
                    && Files.isDirectory(np)
                    && nf.startsWith(np)) {
                return true;
            }
            if (enclosingJar != null
                    && Files.isSameFile(enclosingJar, np)) {
                return true;
            }
        }

        return false;
    }
 

import java.nio.file.Path; //导入方法依赖的package包/类
public boolean isInJRT(FileObject fo) {
    if (fo instanceof PathFileObject) {
        Path path = ((PathFileObject) fo).getPath();
        return (path.getFileSystem() == jrtfs);
    } else {
        return false;
    }
}
 

import java.nio.file.Path; //导入方法依赖的package包/类
public ConversionFileWriterWrapper(Path inFile) {
	this.source = new PathSource(inFile);

	fileSystem = inFile.getFileSystem();
}
 

import java.nio.file.Path; //导入方法依赖的package包/类
private static Path resolve(Path base, String relativePath) {
    FileSystem fs = base.getFileSystem();
    Path rp = fs.getPath(relativePath.replace("/", fs.getSeparator()));
    return base.resolve(rp);
}
 

import java.nio.file.Path; //导入方法依赖的package包/类
private static Observable<Event> createAppSkeleton(final Path projectDirectory, final Project project) {

        Preconditions.checkNotNull(projectDirectory);
        Preconditions.checkNotNull(project);

        final FileSystem fs = projectDirectory.getFileSystem();
        final Identifier projectIdentifier = project.name.map(StringUtils::escapeStringGitHubStyle)
            .flatMap(Identifier::parse)
            .orElseGet(() -> Identifier.of("my-project"));

        return Observable.concat(ImmutableList.of(

            // Write the project file
            CommonTasks.writeFile(
                Serializers.serialize(project),
                fs.getPath("buckaroo.json").toAbsolutePath(),
                false)
                .toObservable()
                .cast(Event.class)
                .onErrorReturnItem(Notification.of("buckaroo.json already exists!")),

            // Touch the .buckconfig
            CommonTasks.touchFile(fs.getPath(projectDirectory.toString(), ".buckconfig"))
                .toObservable(),

            // Generate an empty BUCKAROO_DEPS
            Single.fromCallable(() -> CommonTasks.generateBuckarooDeps(ImmutableList.of()))
                .flatMap(content ->
                    CommonTasks.writeFile(
                        content,
                        fs.getPath(projectDirectory.toString(), "BUCKAROO_DEPS"),
                        false))
                .toObservable()
                .cast(Event.class)
                .onErrorReturnItem(Notification.of("BUCKAROO_DEPS already exists!")),

            // Create the project directories
            CommonTasks.createDirectory(fs.getPath(projectDirectory.toString(), projectIdentifier.name))
                .toObservable(),

            CommonTasks.createDirectory(fs.getPath(projectDirectory.toString(), projectIdentifier.name, "src"))
                .toObservable(),

            CommonTasks.createDirectory(fs.getPath(projectDirectory.toString(), projectIdentifier.name, "include"))
                .toObservable(),

            CommonTasks.createDirectory(fs.getPath(projectDirectory.toString(), projectIdentifier.name, "detail"))
                .toObservable(),

            // Write the Hello World cpp file
            Single.fromCallable(QuickstartTasks::helloWorldCpp).flatMap(content -> CommonTasks.writeFile(
                content,
                fs.getPath(projectDirectory.toString(), projectIdentifier.name, "apps", "main.cpp"),
                false))
                .toObservable()
                .cast(Event.class)
                .onErrorReturnItem(Notification.of("apps/main.cpp already exists!")),

            // Generate the BUCK file
            Single.fromCallable(() -> Either.orThrow(BuckFile.generate(projectIdentifier)))
                .flatMapObservable(content -> Observable.concat(
                    CommonTasks.writeFile(
                        content,
                        fs.getPath(projectDirectory.toString(), "BUCK"),
                        false).toObservable()
                        .cast(Event.class)
                        .onErrorReturnItem(Notification.of("BUCK-file already exists!")),
                    Observable.just(Notification.of("buck run :main"))
                ))
        ));
    }