com.github.fge.filesystem

Class MorePaths

java.lang.Object

com.github.fge.filesystem.MorePaths

@ParametersAreNonnullByDefault
public final class MorePaths
extends Object

Path utility methods

Unless otherwise noted, all methods in this class do not accept null arguments and will throw a NullPointerException if a null argument is passed to them.

Method Summary

Methods

Modifier and Type	Method and Description
static Path	normalize(Path path) Normalizes the given path
static Path	resolve(Path path1, Path path2) Resolve a path against another path with a potentially different FileSystem or FileSystemProvider

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

resolve

@Nonnull
public static Path resolve(Path path1,
                   Path path2)

Resolve a path against another path with a potentially different FileSystem or FileSystemProvider

Path.resolve(Path) will refuse to operate if its argument is issued from a different provider (with a ProviderMismatchException); moreover, if the argument is issued from the same provider but is on a different filesystem, the result of the resolution may be on the argument's filesystem, not the caller's.

This method will attempt to resolve the second path against the first so that the result is always associated to the filesystem (and therefore provider) of the first argument. For the resolution to operate, the following conditions must be met for path2:

• if it is not absolute, it must not have a root;
• if it is absolute, it must have a root, and the string representation of this root must match a string representation of one possible root of the first path's filesystem.

If the conditions above are not satisfied, this method throws an UnresolvablePathException (unchecked).

If both paths are issued from the same filesystem, this method will delegate to path1's .resolve(); if they are from different filesystems but share the same provider, this method returns:

     path1.resolve(path1.getFileSystem().getPath(path2.toString()))
 

This means that for instance it is possible to resolve a Unix path against a Windows path, or the reverse, as long as the second path is not absolute (the root paths of both filesystems are incompatible):

• resolving foo/bar/baz against c: will return c:\foo\bar\baz;
• resolving baz\quux against /foo/bar will return /foo/bar/baz/quux.

Parameters:

path1 - the first path

path2 - the second path

Returns:

the resolved path

Throws:

UnresolvablePathException - see description

InvalidPathException - path2 is from a different provider, and one of its name elements is invalid according to path1's filesystem

See Also:

FileSystem.getPath(String, String...), FileSystem.getRootDirectories()

normalize

@Nonnull
public static Path normalize(Path path)

Normalizes the given path

On Unix systems and at least up to Oracle JDK 7u51 and 8u15, Paths.get("").normalize() will throw an ArrayIndexOutOfBoundsException. See this bug entry.

This method works around the problem by testing that the path is empty (its string representation is empty); if this is the case, it is returned as is. Otherwise, normalization is performed normally.

Parameters:

path - the path

Returns:

the normalized path