1 /*

     2  * Copyright (c) 2010 Oracle and/or its affiliates. All rights reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  *

     8  *   - Redistributions of source code must retain the above copyright

     9  *     notice, this list of conditions and the following disclaimer.

    10  *

    11  *   - Redistributions in binary form must reproduce the above copyright

    12  *     notice, this list of conditions and the following disclaimer in the

    13  *     documentation and/or other materials provided with the distribution.

    14  *

    15  *   - Neither the name of Oracle nor the names of its

    16  *     contributors may be used to endorse or promote products derived

    17  *     from this software without specific prior written permission.

    18  *

    19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

    20  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

    21  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR

    23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

    27  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

    28  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

    29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    30  */

    31 

    32 /*

    33  * This source code is provided to illustrate the usage of a given feature

    34  * or technique and has been deliberately simplified. Additional steps

    35  * required for a production-quality application, such as security checks,

    36  * input validation and proper error handling, might not be present in

    37  * this sample code.

    38  */

    39 

    40 

    41 import java.io.*;

    42 import java.nio.*;

    43 import java.nio.channels.*;

    44 import java.nio.file.*;

    45 import java.nio.file.spi.*;

    46 import java.nio.file.attribute.*;

    47 import java.net.*;

    48 import java.text.DateFormat;

    49 import java.text.SimpleDateFormat;

    50 import java.util.*;

    51 

    52 import static java.nio.file.StandardOpenOption.*;

    53 import static java.nio.file.StandardCopyOption.*;

    54 /*

    55  * ZipFileSystem usage demo

    56  *

    57  * java Demo action ZipfileName [...]

    58  *

    59  * @author Xueming Shen

    60  */

    61 

    62 public class Demo {

    63 

    64     static enum Action {

    65         rename,          // <java Demo rename zipfile src dst>

    66                          // rename entry src to dst inside zipfile

    67 

    68         movein,          // <java Demo movein zipfile src dst>

    69                          // move an external src file into zipfile

    70                          // as entry dst

    71 

    72         moveout,         // <java Demo moveout zipfile src dst>

    73                          // move a zipfile entry src out to dst

    74 

    75         copy,            // <java Demo copy zipfile src dst>

    76                          // copy entry src to dst inside zipfile

    77 

    78         copyin,          // <java Demo copyin zipfile src dst>

    79                          // copy an external src file into zipfile

    80                          // as entry dst

    81 

    82         copyin_attrs,    // <java Demo copyin_attrs zipfile src dst>

    83                          // copy an external src file into zipfile

    84                          // as entry dst, with attributes (timestamp)

    85 

    86         copyout,         // <java Demo copyout zipfile src dst>

    87                          // copy zipfile entry src" out to file dst

    88 

    89         copyout_attrs,   // <java Demo copyout_attrs zipfile src dst>

    90 

    91         zzmove,          // <java Demo zzmove zfsrc zfdst path>

    92                          // move entry path/dir from zfsrc to zfdst

    93 

    94         zzcopy,          // <java Demo zzcopy zfsrc zfdst path>

    95                          // copy path from zipfile zfsrc to zipfile

    96                          // zfdst

    97 

    98         attrs,           // <java Demo attrs zipfile path>

    99                          // printout the attributes of entry path

   100 

   101         attrsspace,      // <java Demo attrsspace zipfile path>

   102                          // printout the storespace attrs of entry path

   103 

   104         setmtime,        // <java Demo setmtime zipfile "MM/dd/yy-HH:mm:ss" path...>

   105                          // set the lastModifiedTime of entry path

   106 

   107         setatime,        // <java Demo setatime zipfile "MM/dd/yy-HH:mm:ss" path...>

   108         setctime,        // <java Demo setctime zipfile "MM/dd/yy-HH:mm:ss" path...>

   109 

   110         lsdir,           // <java Demo lsdir zipfile dir>

   111                          // list dir's direct child files/dirs

   112 

   113         mkdir,           // <java Demo mkdir zipfile dir>

   114 

   115         mkdirs,          // <java Demo mkdirs zipfile dir>

   116 

   117         rmdirs,          // <java Demo rmdirs zipfile dir>

   118 

   119         list,            // <java Demo list zipfile [dir]>

   120                          // recursively list all entries of dir

   121                          // via DirectoryStream

   122 

   123         tlist,           // <java Demo tlist zipfile [dir]>

   124                          // list with buildDirTree=true

   125 

   126         vlist,           // <java Demo vlist zipfile [dir]>

   127                          // recursively verbose list all entries of

   128                          // dir via DirectoryStream

   129 

   130         walk,            // <java Demo walk zipfile [dir]>

   131                          // recursively walk all entries of dir

   132                          // via Files.walkFileTree

   133 

   134         twalk,           // <java Demo twalk zipfile [dir]>

   135                          // walk with buildDirTree=true

   136 

   137         extract,         // <java Demo extract zipfile file [...]>

   138 

   139         update,          // <java Demo extract zipfile file [...]>

   140 

   141         delete,          // <java Demo delete zipfile file [...]>

   142 

   143         add,             // <java Demo add zipfile file [...]>

   144 

   145         create,          // <java Demo create zipfile file [...]>

   146                          // create a new zipfile if it doesn't exit

   147                          // and then add the file(s) into it.

   148 

   149         attrs2,          // <java Demo attrs2 zipfile file [...]>

   150                          // test different ways to print attrs

   151 

   152         prof,

   153     }

   154 

   155     public static void main(String[] args) throws Throwable {

   156         FileSystemProvider provider = getZipFSProvider();

   157         if (provider == null) {

   158             System.err.println("ZIP filesystem provider is not installed");

   159             System.exit(1);

   160         }

   161 

   162         Action action = Action.valueOf(args[0]);

   163         Map<String, Object> env = env = new HashMap<>();

   164         if (action == Action.create)

   165             env.put("create", "true");

   166         try (FileSystem fs = provider.newFileSystem(Paths.get(args[1]), env)) {

   167             Path path, src, dst;

   168             switch (action) {

   169             case rename:

   170                 src = fs.getPath(args[2]);

   171                 dst = fs.getPath(args[3]);

   172                 Files.move(src, dst);

   173                 break;

   174             case moveout:

   175                 src = fs.getPath(args[2]);

   176                 dst = Paths.get(args[3]);

   177                 Files.move(src, dst);

   178                 break;

   179             case movein:

   180                 src = Paths.get(args[2]);

   181                 dst = fs.getPath(args[3]);

   182                 Files.move(src, dst);

   183                 break;

   184             case copy:

   185                 src = fs.getPath(args[2]);

   186                 dst = fs.getPath(args[3]);

   187                 Files.copy(src, dst);

   188                 break;

   189             case copyout:

   190                 src = fs.getPath(args[2]);

   191                 dst = Paths.get(args[3]);

   192                 Files.copy(src, dst);

   193                 break;

   194             case copyin:

   195                 src = Paths.get(args[2]);

   196                 dst = fs.getPath(args[3]);

   197                 Files.copy(src, dst);

   198                 break;

   199             case copyin_attrs:

   200                 src = Paths.get(args[2]);

   201                 dst = fs.getPath(args[3]);

   202                 Files.copy(src, dst, COPY_ATTRIBUTES);

   203                 break;

   204             case copyout_attrs:

   205                 src = fs.getPath(args[2]);

   206                 dst = Paths.get(args[3]);

   207                 Files.copy(src, dst, COPY_ATTRIBUTES);

   208                 break;

   209             case zzmove:

   210                 try (FileSystem fs2 = provider.newFileSystem(Paths.get(args[2]), env)) {

   211                     z2zmove(fs, fs2, args[3]);

   212                 }

   213                 break;

   214             case zzcopy:

   215                 try (FileSystem fs2 = provider.newFileSystem(Paths.get(args[2]), env)) {

   216                     z2zcopy(fs, fs2, args[3]);

   217                 }

   218                 break;

   219             case attrs:

   220                 for (int i = 2; i < args.length; i++) {

   221                     path = fs.getPath(args[i]);

   222                     System.out.println(path);

   223                     System.out.println(

   224                         Files.readAttributes(path, BasicFileAttributes.class).toString());

   225                 }

   226                 break;

   227             case setmtime:

   228                 DateFormat df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");

   229                 Date newDatetime = df.parse(args[2]);

   230                 for (int i = 3; i < args.length; i++) {

   231                     path = fs.getPath(args[i]);

   232                     Files.setAttribute(path, "lastModifiedTime",

   233                                        FileTime.fromMillis(newDatetime.getTime()));

   234                     System.out.println(

   235                         Files.readAttributes(path, BasicFileAttributes.class).toString());

   236                 }

   237                 break;

   238             case setctime:

   239                 df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");

   240                 newDatetime = df.parse(args[2]);

   241                 for (int i = 3; i < args.length; i++) {

   242                     path = fs.getPath(args[i]);

   243                     Files.setAttribute(path, "creationTime",

   244                                        FileTime.fromMillis(newDatetime.getTime()));

   245                     System.out.println(

   246                         Files.readAttributes(path, BasicFileAttributes.class).toString());

   247                 }

   248                 break;

   249             case setatime:

   250                 df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");

   251                 newDatetime = df.parse(args[2]);

   252                 for (int i = 3; i < args.length; i++) {

   253                     path = fs.getPath(args[i]);

   254                     Files.setAttribute(path, "lastAccessTime",

   255                                        FileTime.fromMillis(newDatetime.getTime()));

   256                     System.out.println(

   257                         Files.readAttributes(path, BasicFileAttributes.class).toString());

   258                 }

   259                 break;

   260             case attrsspace:

   261                 path = fs.getPath("/");

   262                 FileStore fstore = Files.getFileStore(path);

   263                 System.out.printf("filestore[%s]%n", fstore.name());

   264                 System.out.printf("    totalSpace: %d%n",

   265                                   (Long)fstore.getAttribute("totalSpace"));

   266                 System.out.printf("   usableSpace: %d%n",

   267                                   (Long)fstore.getAttribute("usableSpace"));

   268                 System.out.printf("  unallocSpace: %d%n",

   269                                   (Long)fstore.getAttribute("unallocatedSpace"));

   270                 break;

   271             case list:

   272             case tlist:

   273                 if (args.length < 3)

   274                     list(fs.getPath("/"), false);

   275                 else

   276                     list(fs.getPath(args[2]), false);

   277                 break;

   278             case vlist:

   279                 if (args.length < 3)

   280                     list(fs.getPath("/"), true);

   281                 else

   282                     list(fs.getPath(args[2]), true);

   283                 break;

   284             case twalk:

   285             case walk:

   286                 walk(fs.getPath((args.length > 2)? args[2] : "/"));

   287                 break;

   288             case extract:

   289                 if (args.length == 2) {

   290                      extract(fs, "/");

   291                 } else {

   292                     for (int i = 2; i < args.length; i++) {

   293                         extract(fs, args[i]);

   294                     }

   295                 }

   296                 break;

   297             case delete:

   298                 for (int i = 2; i < args.length; i++)

   299                     Files.delete(fs.getPath(args[i]));

   300                 break;

   301             case create:

   302             case add:

   303             case update:

   304                 for (int i = 2; i < args.length; i++) {

   305                     update(fs, args[i]);

   306                 }

   307                 break;

   308             case lsdir:

   309                 path = fs.getPath(args[2]);

   310                 final String fStr = (args.length > 3)?args[3]:"";

   311                 try (DirectoryStream<Path> ds = Files.newDirectoryStream(path,

   312                     new DirectoryStream.Filter<Path>() {

   313                         @Override

   314                         public boolean accept(Path path) {

   315                             return path.toString().contains(fStr);

   316                         }

   317                     }))

   318                 {

   319                     for (Path p : ds)

   320                         System.out.println(p);

   321                 }

   322                 break;

   323             case mkdir:

   324                 Files.createDirectory(fs.getPath(args[2]));

   325                 break;

   326             case mkdirs:

   327                 mkdirs(fs.getPath(args[2]));

   328                 break;

   329             case attrs2:

   330                 for (int i = 2; i < args.length; i++) {

   331                     path = fs.getPath(args[i]);

   332                     System.out.printf("%n%s%n", path);

   333                     System.out.println("-------(1)---------");

   334                     System.out.println(

   335                         Files.readAttributes(path, BasicFileAttributes.class).toString());

   336                     System.out.println("-------(2)---------");

   337                     Map<String, Object> map = Files.readAttributes(path, "zip:*");

   338                     for (Map.Entry<String, Object> e : map.entrySet()) {

   339                         System.out.printf("    %s : %s%n", e.getKey(), e.getValue());

   340                     }

   341                     System.out.println("-------(3)---------");

   342                     map = Files.readAttributes(path, "size,lastModifiedTime,isDirectory");

   343                     for (Map.Entry<String, ?> e : map.entrySet()) {

   344                         System.out.printf("    %s : %s%n", e.getKey(), e.getValue());

   345                     }

   346                 }

   347                 break;

   348             case prof:

   349                 list(fs.getPath("/"), false);

   350                 while (true) {

   351                     Thread.sleep(10000);

   352                     //list(fs.getPath("/"), true);

   353                     System.out.println("sleeping...");

   354                 }

   355             }

   356         } catch (Exception x) {

   357             x.printStackTrace();

   358         }

   359     }

   360 

   361     private static FileSystemProvider getZipFSProvider() {

   362         for (FileSystemProvider provider : FileSystemProvider.installedProviders()) {

   363             if ("jar".equals(provider.getScheme()))

   364                 return provider;

   365         }

   366         return null;

   367     }

   368 

   369     @SuppressWarnings("unused")

   370     /**

   371      * Not used in demo, but included for demonstrational purposes.

   372      */

   373     private static byte[] getBytes(String name) {

   374         return name.getBytes();

   375     }

   376 

   377     @SuppressWarnings("unused")

   378     /**

   379      * Not used in demo, but included for demonstrational purposes.

   380      */

   381     private static String getString(byte[] name) {

   382         return new String(name);

   383     }

   384 

   385     private static void walk(Path path) throws IOException

   386     {

   387         Files.walkFileTree(

   388             path,

   389             new SimpleFileVisitor<Path>() {

   390                 private int indent = 0;

   391                 private void indent() {

   392                     int n = 0;

   393                     while (n++ < indent)

   394                         System.out.printf(" ");

   395                 }

   396 

   397                 @Override

   398                 public FileVisitResult visitFile(Path file,

   399                                                  BasicFileAttributes attrs)

   400                 {

   401                     indent();

   402                     System.out.printf("%s%n", file.getFileName().toString());

   403                     return FileVisitResult.CONTINUE;

   404                 }

   405 

   406                 @Override

   407                 public FileVisitResult preVisitDirectory(Path dir,

   408                                                          BasicFileAttributes attrs)

   409                 {

   410                     indent();

   411                     System.out.printf("[%s]%n", dir.toString());

   412                     indent += 2;

   413                     return FileVisitResult.CONTINUE;

   414                 }

   415 

   416                 @Override

   417                 public FileVisitResult postVisitDirectory(Path dir,

   418                                                           IOException ioe)

   419                 {

   420                     indent -= 2;

   421                     return FileVisitResult.CONTINUE;

   422                 }

   423         });

   424     }

   425 

   426     private static void update(FileSystem fs, String path) throws Throwable{

   427         Path src = FileSystems.getDefault().getPath(path);

   428         if (Files.isDirectory(src)) {

   429             try (DirectoryStream<Path> ds = Files.newDirectoryStream(src)) {

   430                 for (Path child : ds)

   431                     update(fs, child.toString());

   432             }

   433         } else {

   434             Path dst = fs.getPath(path);

   435             Path parent = dst.getParent();

   436             if (parent != null && Files.notExists(parent))

   437                 mkdirs(parent);

   438             Files.copy(src, dst, REPLACE_EXISTING);

   439         }

   440     }

   441 

   442     private static void extract(FileSystem fs, String path) throws Throwable{

   443         Path src = fs.getPath(path);

   444         if (Files.isDirectory(src)) {

   445             try (DirectoryStream<Path> ds = Files.newDirectoryStream(src)) {

   446                 for (Path child : ds)

   447                     extract(fs, child.toString());

   448             }

   449         } else {

   450             if (path.startsWith("/"))

   451                 path = path.substring(1);

   452             Path dst = FileSystems.getDefault().getPath(path);

   453             Path parent = dst.getParent();

   454             if (Files.notExists(parent))

   455                 mkdirs(parent);

   456             Files.copy(src, dst, REPLACE_EXISTING);

   457         }

   458     }

   459 

   460     // use DirectoryStream

   461     private static void z2zcopy(FileSystem src, FileSystem dst, String path)

   462         throws IOException

   463     {

   464         Path srcPath = src.getPath(path);

   465         Path dstPath = dst.getPath(path);

   466 

   467         if (Files.isDirectory(srcPath)) {

   468             if (!Files.exists(dstPath)) {

   469                 try {

   470                     mkdirs(dstPath);

   471                 } catch (FileAlreadyExistsException x) {}

   472             }

   473             try (DirectoryStream<Path> ds = Files.newDirectoryStream(srcPath)) {

   474                 for (Path child : ds) {

   475                     z2zcopy(src, dst,

   476                             path + (path.endsWith("/")?"":"/") + child.getFileName());

   477                 }

   478             }

   479         } else {

   480             //System.out.println("copying..." + path);

   481             Files.copy(srcPath, dstPath);

   482         }

   483     }

   484 

   485     // use TreeWalk to move

   486     private static void z2zmove(FileSystem src, FileSystem dst, String path)

   487         throws IOException

   488     {

   489         final Path srcPath = src.getPath(path).toAbsolutePath();

   490         final Path dstPath = dst.getPath(path).toAbsolutePath();

   491 

   492         Files.walkFileTree(srcPath, new SimpleFileVisitor<Path>() {

   493 

   494             @Override

   495             public FileVisitResult visitFile(Path file,

   496                                             BasicFileAttributes attrs)

   497             {

   498                 Path dst = srcPath.relativize(file);

   499                 dst = dstPath.resolve(dst);

   500                 try {

   501                     Path parent = dstPath.getParent();

   502                     if (parent != null && Files.notExists(parent))

   503                         mkdirs(parent);

   504                     Files.move(file, dst);

   505                 } catch (IOException x) {

   506                     x.printStackTrace();

   507                 }

   508                 return FileVisitResult.CONTINUE;

   509             }

   510 

   511             @Override

   512             public FileVisitResult preVisitDirectory(Path dir,

   513                                                      BasicFileAttributes attrs)

   514             {

   515                 Path dst = srcPath.relativize(dir);

   516                 dst = dstPath.resolve(dst);

   517                 try {

   518 

   519                     if (Files.notExists(dst))

   520                         mkdirs(dst);

   521                 } catch (IOException x) {

   522                     x.printStackTrace();

   523                 }

   524                 return FileVisitResult.CONTINUE;

   525             }

   526 

   527             @Override

   528             public FileVisitResult postVisitDirectory(Path dir,

   529                                                       IOException ioe)

   530                 throws IOException

   531             {

   532                 try {

   533                     Files.delete(dir);

   534                 } catch (IOException x) {

   535                     //x.printStackTrace();

   536                 }

   537                 return FileVisitResult.CONTINUE;

   538             }

   539         });

   540 

   541     }

   542 

   543     private static void mkdirs(Path path) throws IOException {

   544         path = path.toAbsolutePath();

   545         Path parent = path.getParent();

   546         if (parent != null) {

   547             if (Files.notExists(parent))

   548                 mkdirs(parent);

   549         }

   550         Files.createDirectory(path);

   551     }

   552 

   553     @SuppressWarnings("unused")

   554     /**

   555      * Not used in demo, but included for demonstrational purposes.

   556      */

   557     private static void rmdirs(Path path) throws IOException {

   558         while (path != null && path.getNameCount() != 0) {

   559             Files.delete(path);

   560             path = path.getParent();

   561         }

   562     }

   563 

   564     private static void list(Path path, boolean verbose ) throws IOException {

   565         if (!"/".equals(path.toString())) {

   566            System.out.printf("  %s%n", path.toString());

   567            if (verbose)

   568                 System.out.println(Files.readAttributes(path, BasicFileAttributes.class).toString());

   569         }

   570         if (Files.notExists(path))

   571             return;

   572         if (Files.isDirectory(path)) {

   573             try (DirectoryStream<Path> ds = Files.newDirectoryStream(path)) {

   574                 for (Path child : ds)

   575                     list(child, verbose);

   576             }

   577         }

   578     }

   579 

   580     @SuppressWarnings("unused")

   581     /**

   582      * Checks that the content of two paths are equal.

   583      * Not used in demo, but included for demonstrational purposes.

   584      */

   585     private static void checkEqual(Path src, Path dst) throws IOException

   586     {

   587         //System.out.printf("checking <%s> vs <%s>...%n",

   588         //                  src.toString(), dst.toString());

   589 

   590         //streams

   591         byte[] bufSrc = new byte[8192];

   592         byte[] bufDst = new byte[8192];

   593         try (InputStream isSrc = Files.newInputStream(src);

   594              InputStream isDst = Files.newInputStream(dst))

   595         {

   596             int nSrc = 0;

   597             while ((nSrc = isSrc.read(bufSrc)) != -1) {

   598                 int nDst = 0;

   599                 while (nDst < nSrc) {

   600                     int n = isDst.read(bufDst, nDst, nSrc - nDst);

   601                     if (n == -1) {

   602                         System.out.printf("checking <%s> vs <%s>...%n",

   603                                           src.toString(), dst.toString());

   604                         throw new RuntimeException("CHECK FAILED!");

   605                     }

   606                     nDst += n;

   607                 }

   608                 while (--nSrc >= 0) {

   609                     if (bufSrc[nSrc] != bufDst[nSrc]) {

   610                         System.out.printf("checking <%s> vs <%s>...%n",

   611                                           src.toString(), dst.toString());

   612                         throw new RuntimeException("CHECK FAILED!");

   613                     }

   614                     nSrc--;

   615                 }

   616             }

   617         }

   618 

   619         // channels

   620 

   621         try (SeekableByteChannel chSrc = Files.newByteChannel(src);

   622              SeekableByteChannel chDst = Files.newByteChannel(dst))

   623         {

   624             if (chSrc.size() != chDst.size()) {

   625                 System.out.printf("src[%s].size=%d, dst[%s].size=%d%n",

   626                                   chSrc.toString(), chSrc.size(),

   627                                   chDst.toString(), chDst.size());

   628                 throw new RuntimeException("CHECK FAILED!");

   629             }

   630             ByteBuffer bbSrc = ByteBuffer.allocate(8192);

   631             ByteBuffer bbDst = ByteBuffer.allocate(8192);

   632 

   633             int nSrc = 0;

   634             while ((nSrc = chSrc.read(bbSrc)) != -1) {

   635                 int nDst = chDst.read(bbDst);

   636                 if (nSrc != nDst) {

   637                     System.out.printf("checking <%s> vs <%s>...%n",

   638                                       src.toString(), dst.toString());

   639                     throw new RuntimeException("CHECK FAILED!");

   640                 }

   641                 while (--nSrc >= 0) {

   642                     if (bbSrc.get(nSrc) != bbDst.get(nSrc)) {

   643                         System.out.printf("checking <%s> vs <%s>...%n",

   644                                           src.toString(), dst.toString());

   645                         throw new RuntimeException("CHECK FAILED!");

   646                     }

   647                     nSrc--;

   648                 }

   649                 bbSrc.flip();

   650                 bbDst.flip();

   651             }

   652         } catch (IOException x) {

   653             x.printStackTrace();

   654         }

   655     }

   656 

   657     private static void fchCopy(Path src, Path dst) throws IOException

   658     {

   659         Set<OpenOption> read = new HashSet<>();

   660         read.add(READ);

   661         Set<OpenOption> openwrite = new HashSet<>();

   662         openwrite.add(CREATE_NEW);

   663         openwrite.add(WRITE);

   664 

   665         try (FileChannel srcFc = src.getFileSystem().provider().newFileChannel(src, read);

   666              FileChannel dstFc = dst.getFileSystem().provider().newFileChannel(dst, openwrite))

   667         {

   668             ByteBuffer bb = ByteBuffer.allocate(8192);

   669             while (srcFc.read(bb) >= 0) {

   670                 bb.flip();

   671                 dstFc.write(bb);

   672                 bb.clear();

   673             }

   674         }

   675     }

   676 

   677     private static void chCopy(Path src, Path dst) throws IOException

   678     {

   679         Set<OpenOption> read = new HashSet<>();

   680         read.add(READ);

   681         Set<OpenOption> openwrite = new HashSet<>();

   682         openwrite.add(CREATE_NEW);

   683         openwrite.add(WRITE);

   684 

   685         try (SeekableByteChannel srcCh = Files.newByteChannel(src, read);

   686              SeekableByteChannel dstCh = Files.newByteChannel(dst, openwrite))

   687         {

   688             ByteBuffer bb = ByteBuffer.allocate(8192);

   689             while (srcCh.read(bb) >= 0) {

   690                 bb.flip();

   691                 dstCh.write(bb);

   692                 bb.clear();

   693             }

   694         }

   695     }

   696 

   697     private static void streamCopy(Path src, Path dst) throws IOException

   698     {

   699         byte[] buf = new byte[8192];

   700         try (InputStream isSrc = Files.newInputStream(src);

   701              OutputStream osDst = Files.newOutputStream(dst))

   702         {

   703             int n = 0;

   704             while ((n = isSrc.read(buf)) != -1) {

   705                 osDst.write(buf, 0, n);

   706             }

   707         }

   708     }

   709 }