001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017
018package org.apache.commons.io.file;
019
020import java.io.BufferedReader;
021import java.io.BufferedWriter;
022import java.io.IOException;
023import java.io.InputStream;
024import java.io.OutputStream;
025import java.io.Reader;
026import java.io.UncheckedIOException;
027import java.nio.channels.SeekableByteChannel;
028import java.nio.charset.Charset;
029import java.nio.file.CopyOption;
030import java.nio.file.DirectoryStream;
031import java.nio.file.FileStore;
032import java.nio.file.FileVisitOption;
033import java.nio.file.FileVisitor;
034import java.nio.file.Files;
035import java.nio.file.LinkOption;
036import java.nio.file.OpenOption;
037import java.nio.file.Path;
038import java.nio.file.attribute.BasicFileAttributes;
039import java.nio.file.attribute.FileAttribute;
040import java.nio.file.attribute.FileTime;
041import java.nio.file.attribute.PosixFilePermission;
042import java.nio.file.attribute.UserPrincipal;
043import java.util.List;
044import java.util.Map;
045import java.util.Set;
046import java.util.function.BiPredicate;
047import java.util.stream.Stream;
048
049import org.apache.commons.io.function.Uncheck;
050
051/**
052 * Delegates to {@link Files} to uncheck calls by throwing {@link UncheckedIOException} instead of {@link IOException}.
053 *
054 * @see Files
055 * @see IOException
056 * @see UncheckedIOException
057 * @since 2.12.0
058 */
059public final class FilesUncheck {
060
061    /**
062     * Delegates to {@link Files#copy(InputStream, Path, CopyOption...)} throwing {@link UncheckedIOException} instead of
063     * {@link IOException}.
064     *
065     * @param in See delegate.
066     * @param target See delegate.
067     * @param options See delegate.
068     * @return See delegate.
069     * @throws UncheckedIOException Wraps an {@link IOException}.
070     * @see Files#copy(InputStream, Path,CopyOption...)
071     */
072    public static long copy(final InputStream in, final Path target, final CopyOption... options) {
073        return Uncheck.apply(Files::copy, in, target, options);
074    }
075
076    /**
077     * Delegates to {@link Files#copy(Path, OutputStream)} throwing {@link UncheckedIOException} instead of
078     * {@link IOException}.
079     *
080     * @param source See delegate. See delegate.
081     * @param out See delegate. See delegate.
082     * @return See delegate. See delegate.
083     * @throws UncheckedIOException Wraps an {@link IOException}.
084     */
085    public static long copy(final Path source, final OutputStream out) {
086        return Uncheck.apply(Files::copy, source, out);
087    }
088
089    /**
090     * Delegates to {@link Files#copy(Path, Path, CopyOption...)} throwing {@link UncheckedIOException} instead of
091     * {@link IOException}.
092     *
093     * @param source See delegate.
094     * @param target See delegate.
095     * @param options See delegate.
096     * @return See delegate.
097     * @throws UncheckedIOException Wraps an {@link IOException}.
098     */
099    public static Path copy(final Path source, final Path target, final CopyOption... options) {
100        return Uncheck.apply(Files::copy, source, target, options);
101    }
102
103    /**
104     * Delegates to {@link Files#createDirectories(Path, FileAttribute...)} throwing {@link UncheckedIOException} instead of
105     * {@link IOException}.
106     *
107     * @param dir See delegate.
108     * @param attrs See delegate.
109     * @return See delegate.
110     * @throws UncheckedIOException Wraps an {@link IOException}.
111     */
112    public static Path createDirectories(final Path dir, final FileAttribute<?>... attrs) {
113        return Uncheck.apply(Files::createDirectories, dir, attrs);
114    }
115
116    /**
117     * Delegates to {@link Files#createDirectory(Path, FileAttribute...)} throwing {@link UncheckedIOException} instead of
118     * {@link IOException}.
119     *
120     * @param dir See delegate.
121     * @param attrs See delegate.
122     * @return See delegate.
123     * @throws UncheckedIOException Wraps an {@link IOException}.
124     */
125    public static Path createDirectory(final Path dir, final FileAttribute<?>... attrs) {
126        return Uncheck.apply(Files::createDirectory, dir, attrs);
127    }
128
129    /**
130     * Delegates to {@link Files#createFile(Path, FileAttribute...)} throwing {@link UncheckedIOException} instead of
131     * {@link IOException}.
132     *
133     * @param path See delegate.
134     * @param attrs See delegate.
135     * @return See delegate.
136     * @throws UncheckedIOException Wraps an {@link IOException}.
137     */
138    public static Path createFile(final Path path, final FileAttribute<?>... attrs) {
139        return Uncheck.apply(Files::createFile, path, attrs);
140    }
141
142    /**
143     * Delegates to {@link Files#createLink(Path, Path)} throwing {@link UncheckedIOException} instead of
144     * {@link IOException}.
145     *
146     * @param link See delegate.
147     * @param existing See delegate.
148     * @return See delegate.
149     * @throws UncheckedIOException Wraps an {@link IOException}.
150     */
151    public static Path createLink(final Path link, final Path existing) {
152        return Uncheck.apply(Files::createLink, link, existing);
153    }
154
155    /**
156     * Delegates to {@link Files#createSymbolicLink(Path, Path, FileAttribute...)} throwing {@link UncheckedIOException}
157     * instead of {@link IOException}.
158     *
159     * @param link See delegate.
160     * @param target See delegate.
161     * @param attrs See delegate.
162     * @return See delegate.
163     * @throws UncheckedIOException Wraps an {@link IOException}.
164     */
165    public static Path createSymbolicLink(final Path link, final Path target, final FileAttribute<?>... attrs) {
166        return Uncheck.apply(Files::createSymbolicLink, link, target, attrs);
167    }
168
169    /**
170     * Delegates to {@link Files#createTempDirectory(Path, String, FileAttribute...)} throwing {@link UncheckedIOException}
171     * instead of {@link IOException}.
172     *
173     * @param dir See delegate.
174     * @param prefix See delegate.
175     * @param attrs See delegate.
176     * @return See delegate.
177     * @throws UncheckedIOException Wraps an {@link IOException}.
178     */
179    public static Path createTempDirectory(final Path dir, final String prefix, final FileAttribute<?>... attrs) {
180        return Uncheck.apply(Files::createTempDirectory, dir, prefix, attrs);
181    }
182
183    /**
184     * Delegates to {@link Files#createTempDirectory(String, FileAttribute...)} throwing {@link UncheckedIOException}
185     * instead of {@link IOException}.
186     *
187     * @param prefix See delegate.
188     * @param attrs See delegate.
189     * @return See delegate.
190     * @throws UncheckedIOException Wraps an {@link IOException}.
191     */
192    public static Path createTempDirectory(final String prefix, final FileAttribute<?>... attrs) {
193        return Uncheck.apply(Files::createTempDirectory, prefix, attrs);
194    }
195
196    /**
197     * Delegates to {@link Files#createTempFile(Path, String, String, FileAttribute...)} throwing
198     * {@link UncheckedIOException} instead of {@link IOException}.
199     *
200     * @param dir See delegate.
201     * @param prefix See delegate.
202     * @param suffix See delegate.
203     * @param attrs See delegate.
204     * @return See delegate.
205     * @throws UncheckedIOException Wraps an {@link IOException}.
206     */
207    public static Path createTempFile(final Path dir, final String prefix, final String suffix, final FileAttribute<?>... attrs) {
208        return Uncheck.apply(Files::createTempFile, dir, prefix, suffix, attrs);
209    }
210
211    /**
212     * Delegates to {@link Files#createTempFile(String, String, FileAttribute...)} throwing {@link UncheckedIOException}
213     * instead of {@link IOException}.
214     *
215     * @param prefix See delegate.
216     * @param suffix See delegate.
217     * @param attrs See delegate.
218     * @return See delegate.
219     * @throws UncheckedIOException Wraps an {@link IOException}.
220     */
221    public static Path createTempFile(final String prefix, final String suffix, final FileAttribute<?>... attrs) {
222        return Uncheck.apply(Files::createTempFile, prefix, suffix, attrs);
223    }
224
225    /**
226     * Delegates to {@link Files#delete(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
227     *
228     * @param path See delegate.
229     * @throws UncheckedIOException Wraps an {@link IOException}.
230     */
231    public static void delete(final Path path) {
232        Uncheck.accept(Files::delete, path);
233    }
234
235    /**
236     * Delegates to {@link Files#deleteIfExists(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
237     *
238     * @param path See delegate.
239     * @return See delegate.
240     * @throws UncheckedIOException Wraps an {@link IOException}.
241     */
242    public static boolean deleteIfExists(final Path path) {
243        return Uncheck.apply(Files::deleteIfExists, path);
244    }
245
246    /**
247     * Delegates to {@link Files#find(Path, int, BiPredicate, FileVisitOption...)} throwing {@link UncheckedIOException} instead of {@link IOException}.
248     * <p>
249     * The returned {@link Stream} wraps a {@link DirectoryStream}. When you require timely disposal of file system resources, use a {@code try}-with-resources
250     * block to ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed.
251     * </p>
252     *
253     * @param start    See delegate.
254     * @param maxDepth See delegate.
255     * @param matcher  See delegate.
256     * @param options  See delegate.
257     * @return See delegate.
258     * @throws UncheckedIOException Wraps an {@link IOException}.
259     * @since 2.14.0
260     */
261    public static Stream<Path> find(final Path start, final int maxDepth, final BiPredicate<Path, BasicFileAttributes> matcher,
262            final FileVisitOption... options) {
263        return Uncheck.apply(Files::find, start, maxDepth, matcher, options);
264    }
265
266    /**
267     * Delegates to {@link Files#getAttribute(Path, String, LinkOption...)} throwing {@link UncheckedIOException} instead of
268     * {@link IOException}.
269     *
270     * @param path See delegate.
271     * @param attribute See delegate.
272     * @param options See delegate.
273     * @return See delegate.
274     * @throws UncheckedIOException Wraps an {@link IOException}.
275     */
276    public static Object getAttribute(final Path path, final String attribute, final LinkOption... options) {
277        return Uncheck.apply(Files::getAttribute, path, attribute, options);
278    }
279
280    /**
281     * Delegates to {@link Files#getFileStore(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
282     *
283     * @param path See delegate.
284     * @return See delegate.
285     * @throws UncheckedIOException Wraps an {@link IOException}.
286     */
287    public static FileStore getFileStore(final Path path) {
288        return Uncheck.apply(Files::getFileStore, path);
289    }
290
291    /**
292     * Delegates to {@link Files#getLastModifiedTime(Path, LinkOption...)} throwing {@link UncheckedIOException} instead of
293     * {@link IOException}.
294     *
295     * @param path See delegate.
296     * @param options See delegate.
297     * @return See delegate.
298     * @throws UncheckedIOException Wraps an {@link IOException}.
299     */
300    public static FileTime getLastModifiedTime(final Path path, final LinkOption... options) {
301        return Uncheck.apply(Files::getLastModifiedTime, path, options);
302    }
303
304    /**
305     * Delegates to {@link Files#getOwner(Path, LinkOption...)} throwing {@link UncheckedIOException} instead of
306     * {@link IOException}.
307     *
308     * @param path See delegate.
309     * @param options See delegate.
310     * @return See delegate.
311     * @throws UncheckedIOException Wraps an {@link IOException}.
312     */
313    public static UserPrincipal getOwner(final Path path, final LinkOption... options) {
314        return Uncheck.apply(Files::getOwner, path, options);
315    }
316
317    /**
318     * Delegates to {@link Files#getPosixFilePermissions(Path, LinkOption...)} throwing {@link UncheckedIOException} instead
319     * of {@link IOException}.
320     *
321     * @param path See delegate.
322     * @param options See delegate.
323     * @return See delegate.
324     * @throws UncheckedIOException Wraps an {@link IOException}.
325     */
326    public static Set<PosixFilePermission> getPosixFilePermissions(final Path path, final LinkOption... options) {
327        return Uncheck.apply(Files::getPosixFilePermissions, path, options);
328    }
329
330    /**
331     * Delegates to {@link Files#isHidden(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
332     *
333     * @param path See delegate.
334     * @return See delegate.
335     * @throws UncheckedIOException Wraps an {@link IOException}.
336     */
337    public static boolean isHidden(final Path path) {
338        return Uncheck.apply(Files::isHidden, path);
339    }
340
341    /**
342     * Delegates to {@link Files#isSameFile(Path, Path)} throwing {@link UncheckedIOException} instead of
343     * {@link IOException}.
344     *
345     * @param path See delegate.
346     * @param path2 See delegate.
347     * @return See delegate.
348     * @throws UncheckedIOException Wraps an {@link IOException}.
349     */
350    public static boolean isSameFile(final Path path, final Path path2) {
351        return Uncheck.apply(Files::isSameFile, path, path2);
352    }
353
354    /**
355     * Delegates to {@link Files#lines(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
356     * <p>
357     * The returned {@link Stream} wraps a {@link Reader}. When you require timely disposal of file system resources, use a {@code try}-with-resources block to
358     * ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed.
359     * </p>
360     *
361     * @param path See delegate.
362     * @return See delegate.
363     * @throws UncheckedIOException Wraps an {@link IOException}.
364     */
365    public static Stream<String> lines(final Path path) {
366        return Uncheck.apply(Files::lines, path);
367    }
368
369    /**
370     * Delegates to {@link Files#lines(Path, Charset)} throwing {@link UncheckedIOException} instead of {@link IOException}.
371     * <p>
372     * The returned {@link Stream} wraps a {@link Reader}. When you require timely disposal of file system resources, use a {@code try}-with-resources block to
373     * ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed.
374     * </p>
375     *
376     * @param path See delegate.
377     * @param cs See delegate.
378     * @return See delegate.
379     * @throws UncheckedIOException Wraps an {@link IOException}.
380     */
381    public static Stream<String> lines(final Path path, final Charset cs) {
382        return Uncheck.apply(Files::lines, path, cs);
383    }
384
385    /**
386     * Delegates to {@link Files#list(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
387     * <p>
388     * The returned {@link Stream} wraps a {@link DirectoryStream}. When you require timely disposal of file system resources, use a {@code try}-with-resources
389     * block to ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed.
390     * </p>
391     *
392     * @param dir See delegate.
393     * @return See delegate.
394     * @throws UncheckedIOException Wraps an {@link IOException}.
395     */
396    public static Stream<Path> list(final Path dir) {
397        return Uncheck.apply(Files::list, dir);
398    }
399
400    /**
401     * Delegates to {@link Files#move(Path, Path, CopyOption...)} throwing {@link UncheckedIOException} instead of
402     * {@link IOException}.
403     *
404     * @param source See delegate.
405     * @param target See delegate.
406     * @param options See delegate.
407     * @return See delegate.
408     * @throws UncheckedIOException Wraps an {@link IOException}.
409     */
410    public static Path move(final Path source, final Path target, final CopyOption... options) {
411        return Uncheck.apply(Files::move, source, target, options);
412    }
413
414    /**
415     * Delegates to {@link Files#newBufferedReader(Path)} throwing {@link UncheckedIOException} instead of
416     * {@link IOException}.
417     *
418     * @param path See delegate.
419     * @return See delegate.
420     * @throws UncheckedIOException Wraps an {@link IOException}.
421     */
422    public static BufferedReader newBufferedReader(final Path path) {
423        return Uncheck.apply(Files::newBufferedReader, path);
424    }
425
426    /**
427     * Delegates to {@link Files#newBufferedReader(Path, Charset)} throwing {@link UncheckedIOException} instead of
428     * {@link IOException}.
429     *
430     * @param path See delegate.
431     * @param cs See delegate.
432     * @return See delegate.
433     * @throws UncheckedIOException Wraps an {@link IOException}.
434     */
435    public static BufferedReader newBufferedReader(final Path path, final Charset cs) {
436        return Uncheck.apply(Files::newBufferedReader, path, cs);
437    }
438
439    /**
440     * Delegates to {@link Files#newBufferedWriter(Path, Charset, OpenOption...)} throwing {@link UncheckedIOException}
441     * instead of {@link IOException}.
442     *
443     * @param path See delegate.
444     * @param cs See delegate.
445     * @param options See delegate.
446     * @return See delegate.
447     * @throws UncheckedIOException Wraps an {@link IOException}.
448     */
449    public static BufferedWriter newBufferedWriter(final Path path, final Charset cs, final OpenOption... options) {
450        return Uncheck.apply(Files::newBufferedWriter, path, cs, options);
451    }
452
453    /**
454     * Delegates to {@link Files#newBufferedWriter(Path, OpenOption...)} throwing {@link UncheckedIOException} instead of
455     * {@link IOException}.
456     *
457     * @param path See delegate.
458     * @param options See delegate.
459     * @return See delegate.
460     * @throws UncheckedIOException Wraps an {@link IOException}.
461     */
462    public static BufferedWriter newBufferedWriter(final Path path, final OpenOption... options) {
463        return Uncheck.apply(Files::newBufferedWriter, path, options);
464    }
465
466    /**
467     * Delegates to {@link Files#newByteChannel(Path, OpenOption...)} throwing {@link UncheckedIOException} instead of
468     * {@link IOException}.
469     *
470     * @param path See delegate.
471     * @param options See delegate.
472     * @return See delegate.
473     * @throws UncheckedIOException Wraps an {@link IOException}.
474     */
475    public static SeekableByteChannel newByteChannel(final Path path, final OpenOption... options) {
476        return Uncheck.apply(Files::newByteChannel, path, options);
477    }
478
479    /**
480     * Delegates to {@link Files#newByteChannel(Path, Set, FileAttribute...)} throwing {@link UncheckedIOException} instead
481     * of {@link IOException}.
482     *
483     * @param path See delegate.
484     * @param options See delegate.
485     * @param attrs See delegate.
486     * @return See delegate.
487     * @throws UncheckedIOException Wraps an {@link IOException}.
488     */
489    public static SeekableByteChannel newByteChannel(final Path path, final Set<? extends OpenOption> options, final FileAttribute<?>... attrs) {
490        return Uncheck.apply(Files::newByteChannel, path, options, attrs);
491    }
492
493    /**
494     * Delegates to {@link Files#newDirectoryStream(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
495     * <p>
496     * If you don't use the try-with-resources construct, then you must call the stream's {@link Stream#close()} method after iteration is complete to free any
497     * resources held for the open directory.
498     * </p>
499     *
500     * @param dir See delegate.
501     * @return See delegate.
502     */
503    public static DirectoryStream<Path> newDirectoryStream(final Path dir) {
504        return Uncheck.apply(Files::newDirectoryStream, dir);
505    }
506
507    /**
508     * Delegates to {@link Files#newDirectoryStream(Path, java.nio.file.DirectoryStream.Filter)} throwing {@link UncheckedIOException} instead of
509     * {@link IOException}.
510     * <p>
511     * If you don't use the try-with-resources construct, then you must call the stream's {@link Stream#close()} method after iteration is complete to free any
512     * resources held for the open directory.
513     * </p>
514     *
515     * @param dir    See delegate.
516     * @param filter See delegate.
517     * @return See delegate.
518     */
519    public static DirectoryStream<Path> newDirectoryStream(final Path dir, final DirectoryStream.Filter<? super Path> filter) {
520        return Uncheck.apply(Files::newDirectoryStream, dir, filter);
521    }
522
523    /**
524     * Delegates to {@link Files#newDirectoryStream(Path, String)} throwing {@link UncheckedIOException} instead of
525     * {@link IOException}.
526     * <p>
527     * The returned {@link Stream} wraps a {@link DirectoryStream}. When you require timely disposal of file system resources, use a {@code try}-with-resources
528     * block to ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed.
529     * </p>
530     *
531     * @param dir See delegate.
532     * @param glob See delegate.
533     * @return See delegate.
534     */
535    public static DirectoryStream<Path> newDirectoryStream(final Path dir, final String glob) {
536        return Uncheck.apply(Files::newDirectoryStream, dir, glob);
537    }
538
539    /**
540     * Delegates to {@link Files#newInputStream(Path, OpenOption...)} throwing {@link UncheckedIOException} instead of
541     * {@link IOException}.
542     *
543     * @param path See delegate.
544     * @param options See delegate.
545     * @return See delegate.
546     */
547    public static InputStream newInputStream(final Path path, final OpenOption... options) {
548        return Uncheck.apply(Files::newInputStream, path, options);
549    }
550
551    /**
552     * Delegates to {@link Files#newOutputStream(Path, OpenOption...)} throwing {@link UncheckedIOException} instead of
553     * {@link IOException}.
554     *
555     * @param path See delegate.
556     * @param options See delegate.
557     * @return See delegate.
558     */
559    public static OutputStream newOutputStream(final Path path, final OpenOption... options) {
560        return Uncheck.apply(Files::newOutputStream, path, options);
561    }
562
563    /**
564     * Delegates to {@link Files#probeContentType(Path)} throwing {@link UncheckedIOException} instead of
565     * {@link IOException}.
566     *
567     * @param path See delegate.
568     * @return See delegate.
569     */
570    public static String probeContentType(final Path path) {
571        return Uncheck.apply(Files::probeContentType, path);
572    }
573
574    /**
575     * Delegates to {@link Files#readAllBytes(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
576     *
577     * @param path See delegate.
578     * @return See delegate.
579     */
580    public static byte[] readAllBytes(final Path path) {
581        return Uncheck.apply(Files::readAllBytes, path);
582    }
583
584    /**
585     * Delegates to {@link Files#readAllLines(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
586     *
587     * @param path See delegate.
588     * @return See delegate.
589     */
590    public static List<String> readAllLines(final Path path) {
591        return Uncheck.apply(Files::readAllLines, path);
592    }
593
594    /**
595     * Delegates to {@link Files#readAllLines(Path, Charset)} throwing {@link UncheckedIOException} instead of
596     * {@link IOException}.
597     *
598     * @param path See delegate.
599     * @param cs See delegate.
600     * @return See delegate.
601     */
602    public static List<String> readAllLines(final Path path, final Charset cs) {
603        return Uncheck.apply(Files::readAllLines, path, cs);
604    }
605
606    /**
607     * Delegates to {@link Files#readAttributes(Path, Class, LinkOption...)} throwing {@link UncheckedIOException} instead
608     * of {@link IOException}.
609     *
610     * @param <A> See delegate.
611     * @param path See delegate.
612     * @param type See delegate.
613     * @param options See delegate.
614     * @return See delegate.
615     */
616    public static <A extends BasicFileAttributes> A readAttributes(final Path path, final Class<A> type, final LinkOption... options) {
617        return Uncheck.apply(Files::readAttributes, path, type, options);
618    }
619
620    /**
621     * Delegates to {@link Files#readAttributes(Path, String, LinkOption...)} throwing {@link UncheckedIOException} instead
622     * of {@link IOException}.
623     *
624     * @param path See delegate.
625     * @param attributes See delegate.
626     * @param options See delegate.
627     * @return See delegate.
628     */
629    public static Map<String, Object> readAttributes(final Path path, final String attributes, final LinkOption... options) {
630        return Uncheck.apply(Files::readAttributes, path, attributes, options);
631    }
632
633    /**
634     * Delegates to {@link Files#readSymbolicLink(Path)} throwing {@link UncheckedIOException} instead of
635     * {@link IOException}.
636     *
637     * @param link See delegate.
638     * @return See delegate.
639     */
640    public static Path readSymbolicLink(final Path link) {
641        return Uncheck.apply(Files::readSymbolicLink, link);
642    }
643
644    /**
645     * Delegates to {@link Files#setAttribute(Path, String, Object, LinkOption...)} throwing {@link UncheckedIOException}
646     * instead of {@link IOException}.
647     *
648     * @param path See delegate.
649     * @param attribute See delegate.
650     * @param value See delegate.
651     * @param options See delegate.
652     * @return See delegate.
653     */
654    public static Path setAttribute(final Path path, final String attribute, final Object value, final LinkOption... options) {
655        return Uncheck.apply(Files::setAttribute, path, attribute, value, options);
656    }
657
658    /**
659     * Delegates to {@link Files#setLastModifiedTime(Path, FileTime)} throwing {@link UncheckedIOException} instead of
660     * {@link IOException}.
661     *
662     * @param path See delegate.
663     * @param time See delegate.
664     * @return See delegate.
665     */
666    public static Path setLastModifiedTime(final Path path, final FileTime time) {
667        return Uncheck.apply(Files::setLastModifiedTime, path, time);
668    }
669
670    /**
671     * Delegates to {@link Files#setOwner(Path, UserPrincipal)} throwing {@link UncheckedIOException} instead of
672     * {@link IOException}.
673     *
674     * @param path See delegate.
675     * @param owner See delegate.
676     * @return See delegate.
677     */
678    public static Path setOwner(final Path path, final UserPrincipal owner) {
679        return Uncheck.apply(Files::setOwner, path, owner);
680    }
681
682    /**
683     * Delegates to {@link Files#setPosixFilePermissions(Path, Set)} throwing {@link UncheckedIOException} instead of
684     * {@link IOException}.
685     *
686     * @param path See delegate.
687     * @param perms See delegate.
688     * @return See delegate.
689     */
690    public static Path setPosixFilePermissions(final Path path, final Set<PosixFilePermission> perms) {
691        return Uncheck.apply(Files::setPosixFilePermissions, path, perms);
692    }
693
694    /**
695     * Delegates to {@link Files#size(Path)} throwing {@link UncheckedIOException} instead of {@link IOException}.
696     *
697     * @param path See delegate.
698     * @return See delegate.
699     */
700    public static long size(final Path path) {
701        return Uncheck.apply(Files::size, path);
702    }
703
704    /**
705     * Delegates to {@link Files#walk(Path, FileVisitOption...)} throwing {@link UncheckedIOException} instead of {@link IOException}.
706     * <p>
707     * The returned {@link Stream} may wrap one or more {@link DirectoryStream}s. When you require timely disposal of file system resources, use a
708     * {@code try}-with-resources block to ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed. Calling a
709     * closed stream causes a {@link IllegalStateException}.
710     * </p>
711     *
712     * @param start   See delegate.
713     * @param options See delegate.
714     * @return See delegate.
715     */
716    public static Stream<Path> walk(final Path start, final FileVisitOption... options) {
717        return Uncheck.apply(Files::walk, start, options);
718    }
719
720    /**
721     * Delegates to {@link Files#walk(Path, int, FileVisitOption...)} throwing {@link UncheckedIOException} instead of {@link IOException}.
722     * <p>
723     * The returned {@link Stream} may wrap one or more {@link DirectoryStream}s. When you require timely disposal of file system resources, use a
724     * {@code try}-with-resources block to ensure invocation of the stream's {@link Stream#close()} method after the stream operations are completed. Calling a
725     * closed stream causes a {@link IllegalStateException}.
726     * </p>
727     *
728     * @param start    See delegate.
729     * @param maxDepth See delegate.
730     * @param options  See delegate.
731     * @return See delegate.
732     */
733    public static Stream<Path> walk(final Path start, final int maxDepth, final FileVisitOption... options) {
734        return Uncheck.apply(Files::walk, start, maxDepth, options);
735    }
736
737    /**
738     * Delegates to {@link Files#walkFileTree(Path, FileVisitor)} throwing {@link UncheckedIOException} instead of
739     * {@link IOException}.
740     *
741     * @param start See delegate.
742     * @param visitor See delegate.
743     * @return See delegate.
744     */
745    public static Path walkFileTree(final Path start, final FileVisitor<? super Path> visitor) {
746        return Uncheck.apply(Files::walkFileTree, start, visitor);
747    }
748
749    /**
750     * Delegates to {@link Files#walkFileTree(Path, Set, int, FileVisitor)} throwing {@link UncheckedIOException} instead of
751     * {@link IOException}.
752     *
753     * @param start See delegate.
754     * @param options See delegate.
755     * @param maxDepth See delegate.
756     * @param visitor See delegate.
757     * @return See delegate.
758     */
759    public static Path walkFileTree(final Path start, final Set<FileVisitOption> options, final int maxDepth, final FileVisitor<? super Path> visitor) {
760        return Uncheck.apply(Files::walkFileTree, start, options, maxDepth, visitor);
761    }
762
763    /**
764     * Delegates to {@link Files#write(Path, byte[], OpenOption...)} throwing {@link UncheckedIOException} instead of
765     * {@link IOException}.
766     *
767     * @param path See delegate.
768     * @param bytes See delegate.
769     * @param options See delegate.
770     * @return See delegate.
771     */
772    public static Path write(final Path path, final byte[] bytes, final OpenOption... options) {
773        return Uncheck.apply(Files::write, path, bytes, options);
774    }
775
776    /**
777     * Delegates to {@link Files#write(Path, Iterable, Charset, OpenOption...)} throwing {@link UncheckedIOException}
778     * instead of {@link IOException}.
779     *
780     * @param path See delegate.
781     * @param lines See delegate.
782     * @param cs See delegate.
783     * @param options See delegate.
784     * @return See delegate.
785     */
786    public static Path write(final Path path, final Iterable<? extends CharSequence> lines, final Charset cs, final OpenOption... options) {
787        return Uncheck.apply(Files::write, path, lines, cs, options);
788    }
789
790    /**
791     * Delegates to {@link Files#write(Path, Iterable, OpenOption...)} throwing {@link UncheckedIOException} instead of
792     * {@link IOException}.
793     *
794     * @param path See delegate.
795     * @param lines See delegate.
796     * @param options See delegate.
797     * @return See delegate.
798     */
799    public static Path write(final Path path, final Iterable<? extends CharSequence> lines, final OpenOption... options) {
800        return Uncheck.apply(Files::write, path, lines, options);
801    }
802
803    /**
804     * No instances.
805     */
806    private FilesUncheck() {
807        // No instances
808    }
809}