private Files() { }

/**

private static FileSystemProvider provider(Path path) {

return path.getFileSystem().provider();

}

/**

private static Runnable asUncheckedRunnable(Closeable c) {

return () -> {

try {

c.close();

} catch (IOException e) {

throw new UncheckedIOException(e);

}

};

}

// -- File contents --

/**

public static InputStream newInputStream(Path path, OpenOption... options)

throws IOException

{

return provider(path).newInputStream(path, options);

}

/**

public static OutputStream newOutputStream(Path path, OpenOption... options)

throws IOException

{

return provider(path).newOutputStream(path, options);

}

/**

public static SeekableByteChannel newByteChannel(Path path,

Set<? extends OpenOption> options,

FileAttribute<?>... attrs)

throws IOException

{

return provider(path).newByteChannel(path, options, attrs);

}

/**

public static SeekableByteChannel newByteChannel(Path path, OpenOption... options)

throws IOException

{

Set<OpenOption> set = new HashSet<OpenOption>(options.length);

Collections.addAll(set, options);

return newByteChannel(path, set);

}

// -- Directories --

private static class AcceptAllFilter

implements DirectoryStream.Filter<Path>

{

private AcceptAllFilter() { }

@Override

public boolean accept(Path entry) { return true; }

static final AcceptAllFilter FILTER = new AcceptAllFilter();

}

/**

public static DirectoryStream<Path> newDirectoryStream(Path dir)

throws IOException

{

return provider(dir).newDirectoryStream(dir, AcceptAllFilter.FILTER);

}

/**

public static DirectoryStream<Path> newDirectoryStream(Path dir, String glob)

throws IOException

{

// avoid creating a matcher if all entries are required.

if (glob.equals("*"))

return newDirectoryStream(dir);

// create a matcher and return a filter that uses it.

FileSystem fs = dir.getFileSystem();

final PathMatcher matcher = fs.getPathMatcher("glob:" + glob);

DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<Path>() {

@Override

public boolean accept(Path entry) {

return matcher.matches(entry.getFileName());

}

};

return fs.provider().newDirectoryStream(dir, filter);

}

/**

public static DirectoryStream<Path> newDirectoryStream(Path dir,

DirectoryStream.Filter<? super Path> filter)

throws IOException

{

return provider(dir).newDirectoryStream(dir, filter);

}

// -- Creation and deletion --

/**

public static Path createFile(Path path, FileAttribute<?>... attrs)

throws IOException

{

EnumSet<StandardOpenOption> options =

EnumSet.<StandardOpenOption>of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE);

newByteChannel(path, options, attrs).close();

return path;

}

/**

public static Path createDirectory(Path dir, FileAttribute<?>... attrs)

throws IOException

{

provider(dir).createDirectory(dir, attrs);

return dir;

}

/**

public static Path createDirectories(Path dir, FileAttribute<?>... attrs)

throws IOException

{

// attempt to create the directory

try {

createAndCheckIsDirectory(dir, attrs);

return dir;

} catch (FileAlreadyExistsException x) {

// file exists and is not a directory

throw x;

} catch (IOException x) {

// parent may not exist or other reason

}

SecurityException se = null;

try {

dir = dir.toAbsolutePath();

} catch (SecurityException x) {

// don't have permission to get absolute path

se = x;

}

// find a decendent that exists

Path parent = dir.getParent();

while (parent != null) {

try {

provider(parent).checkAccess(parent);

break;

} catch (NoSuchFileException x) {

// does not exist

}

parent = parent.getParent();

}

if (parent == null) {

// unable to find existing parent

if (se != null)

throw se;

throw new IOException("Root directory does not exist");

}

// create directories

Path child = parent;

for (Path name: parent.relativize(dir)) {

child = child.resolve(name);

createAndCheckIsDirectory(child, attrs);

}

return dir;

}

/**

private static void createAndCheckIsDirectory(Path dir,

FileAttribute<?>... attrs)

throws IOException

{

try {

createDirectory(dir, attrs);

} catch (FileAlreadyExistsException x) {

if (!isDirectory(dir, LinkOption.NOFOLLOW_LINKS))

throw x;

}

}

/**

public static Path createTempFile(Path dir,

String prefix,

String suffix,

FileAttribute<?>... attrs)

throws IOException

{

return TempFileHelper.createTempFile(Objects.requireNonNull(dir),

prefix, suffix, attrs);

}

/**

public static Path createTempFile(String prefix,

String suffix,

FileAttribute<?>... attrs)

throws IOException

{

return TempFileHelper.createTempFile(null, prefix, suffix, attrs);

}

/**

public static Path createTempDirectory(Path dir,

String prefix,

FileAttribute<?>... attrs)

throws IOException

{

return TempFileHelper.createTempDirectory(Objects.requireNonNull(dir),

prefix, attrs);

}

/**

public static Path createTempDirectory(String prefix,

FileAttribute<?>... attrs)

throws IOException

{

return TempFileHelper.createTempDirectory(null, prefix, attrs);

}

/**