1 /*

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

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package jdk.internal.jrtfs;

    27 

    28 import java.io.*;

    29 import java.net.URI;

    30 import java.net.URISyntaxException;

    31 import java.nio.channels.*;

    32 import java.nio.file.*;

    33 import java.nio.file.DirectoryStream.Filter;

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

    35 import java.util.*;

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

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

    38 

    39 final class JrtPath implements Path {

    40 

    41     private final JrtFileSystem jrtfs;

    42     private final byte[] path;

    43     private volatile int[] offsets;

    44     private int hashcode = 0;  // cached hashcode (created lazily)

    45 

    46     JrtPath(JrtFileSystem jrtfs, byte[] path) {

    47         this(jrtfs, path, false);

    48     }

    49 

    50     JrtPath(JrtFileSystem jrtfs, byte[] path, boolean normalized) {

    51         this.jrtfs = jrtfs;

    52         if (normalized)

    53             this.path = path;

    54         else

    55             this.path = normalize(path);

    56     }

    57 

    58     @Override

    59     public JrtPath getRoot() {

    60         if (this.isAbsolute())

    61             return jrtfs.getRootPath();

    62         else

    63             return null;

    64     }

    65 

    66     @Override

    67     public Path getFileName() {

    68         initOffsets();

    69         int count = offsets.length;

    70         if (count == 0)

    71             return null;  // no elements so no name

    72         if (count == 1 && path[0] != '/')

    73             return this;

    74         int lastOffset = offsets[count-1];

    75         int len = path.length - lastOffset;

    76         byte[] result = new byte[len];

    77         System.arraycopy(path, lastOffset, result, 0, len);

    78         return new JrtPath(jrtfs, result);

    79     }

    80 

    81     @Override

    82     public JrtPath getParent() {

    83         initOffsets();

    84         int count = offsets.length;

    85         if (count == 0)    // no elements so no parent

    86             return null;

    87         int len = offsets[count-1] - 1;

    88         if (len <= 0)      // parent is root only (may be null)

    89             return getRoot();

    90         byte[] result = new byte[len];

    91         System.arraycopy(path, 0, result, 0, len);

    92         return new JrtPath(jrtfs, result);

    93     }

    94 

    95     @Override

    96     public int getNameCount() {

    97         initOffsets();

    98         return offsets.length;

    99     }

   100 

   101     @Override

   102     public JrtPath getName(int index) {

   103         initOffsets();

   104         if (index < 0 || index >= offsets.length)

   105             throw new IllegalArgumentException();

   106         int begin = offsets[index];

   107         int len;

   108         if (index == (offsets.length-1))

   109             len = path.length - begin;

   110         else

   111             len = offsets[index+1] - begin - 1;

   112         // construct result

   113         byte[] result = new byte[len];

   114         System.arraycopy(path, begin, result, 0, len);

   115         return new JrtPath(jrtfs, result);

   116     }

   117 

   118     @Override

   119     public JrtPath subpath(int beginIndex, int endIndex) {

   120         initOffsets();

   121         if (beginIndex < 0 ||

   122             beginIndex >=  offsets.length ||

   123             endIndex > offsets.length ||

   124             beginIndex >= endIndex)

   125             throw new IllegalArgumentException();

   126 

   127         // starting offset and length

   128         int begin = offsets[beginIndex];

   129         int len;

   130         if (endIndex == offsets.length)

   131             len = path.length - begin;

   132         else

   133             len = offsets[endIndex] - begin - 1;

   134         // construct result

   135         byte[] result = new byte[len];

   136         System.arraycopy(path, begin, result, 0, len);

   137         return new JrtPath(jrtfs, result);

   138     }

   139 

   140     @Override

   141     public JrtPath toRealPath(LinkOption... options) throws IOException {

   142         JrtPath realPath = new JrtPath(jrtfs, getResolvedPath()).toAbsolutePath();

   143         realPath.checkAccess();

   144         return realPath;

   145     }

   146 

   147     boolean isHidden() {

   148         return false;

   149     }

   150 

   151     @Override

   152     public JrtPath toAbsolutePath() {

   153         if (isAbsolute()) {

   154             return this;

   155         } else {

   156             //add / bofore the existing path

   157             byte[] tmp = new byte[path.length + 1];

   158             tmp[0] = '/';

   159             System.arraycopy(path, 0, tmp, 1, path.length);

   160             return (JrtPath) new JrtPath(jrtfs, tmp).normalize();

   161         }

   162     }

   163 

   164     @Override

   165     public URI toUri() {

   166         try {

   167             return new URI("jrt",

   168                            JrtFileSystem.getString(toAbsolutePath().path),

   169                            null);

   170         } catch (URISyntaxException ex) {

   171             throw new AssertionError(ex);

   172         }

   173     }

   174 

   175     private boolean equalsNameAt(JrtPath other, int index) {

   176         int mbegin = offsets[index];

   177         int mlen;

   178         if (index == (offsets.length-1))

   179             mlen = path.length - mbegin;

   180         else

   181             mlen = offsets[index + 1] - mbegin - 1;

   182         int obegin = other.offsets[index];

   183         int olen;

   184         if (index == (other.offsets.length - 1))

   185             olen = other.path.length - obegin;

   186         else

   187             olen = other.offsets[index + 1] - obegin - 1;

   188         if (mlen != olen)

   189             return false;

   190         int n = 0;

   191         while(n < mlen) {

   192             if (path[mbegin + n] != other.path[obegin + n])

   193                 return false;

   194             n++;

   195         }

   196         return true;

   197     }

   198 

   199     @Override

   200     public Path relativize(Path other) {

   201         final JrtPath o = checkPath(other);

   202         if (o.equals(this))

   203             return new JrtPath(getFileSystem(), new byte[0], true);

   204         if (/* this.getFileSystem() != o.getFileSystem() || */

   205             this.isAbsolute() != o.isAbsolute()) {

   206             throw new IllegalArgumentException();

   207         }

   208         int mc = this.getNameCount();

   209         int oc = o.getNameCount();

   210         int n = Math.min(mc, oc);

   211         int i = 0;

   212         while (i < n) {

   213             if (!equalsNameAt(o, i))

   214                 break;

   215             i++;

   216         }

   217         int dotdots = mc - i;

   218         int len = dotdots * 3 - 1;

   219         if (i < oc)

   220             len += (o.path.length - o.offsets[i] + 1);

   221         byte[] result = new byte[len];

   222 

   223         int pos = 0;

   224         while (dotdots > 0) {

   225             result[pos++] = (byte)'.';

   226             result[pos++] = (byte)'.';

   227             if (pos < len)       // no tailing slash at the end

   228                 result[pos++] = (byte)'/';

   229             dotdots--;

   230         }

   231         if (i < oc)

   232             System.arraycopy(o.path, o.offsets[i],

   233                              result, pos,

   234                              o.path.length - o.offsets[i]);

   235         return new JrtPath(getFileSystem(), result);

   236     }

   237 

   238     @Override

   239     public JrtFileSystem getFileSystem() {

   240         return jrtfs;

   241     }

   242 

   243     @Override

   244     public boolean isAbsolute() {

   245         return (this.path.length > 0 && path[0] == '/');

   246     }

   247 

   248     @Override

   249     public JrtPath resolve(Path other) {

   250         final JrtPath o = checkPath(other);

   251         if (o.isAbsolute())

   252             return o;

   253         byte[] res;

   254         if (this.path[path.length - 1] == '/') {

   255             res = new byte[path.length + o.path.length];

   256             System.arraycopy(path, 0, res, 0, path.length);

   257             System.arraycopy(o.path, 0, res, path.length, o.path.length);

   258         } else {

   259             res = new byte[path.length + 1 + o.path.length];

   260             System.arraycopy(path, 0, res, 0, path.length);

   261             res[path.length] = '/';

   262             System.arraycopy(o.path, 0, res, path.length + 1, o.path.length);

   263         }

   264         return new JrtPath(jrtfs, res);

   265     }

   266 

   267     @Override

   268     public Path resolveSibling(Path other) {

   269         if (other == null)

   270             throw new NullPointerException();

   271         Path parent = getParent();

   272         return (parent == null) ? other : parent.resolve(other);

   273     }

   274 

   275     @Override

   276     public boolean startsWith(Path other) {

   277         final JrtPath o = checkPath(other);

   278         if (o.isAbsolute() != this.isAbsolute() ||

   279             o.path.length > this.path.length)

   280             return false;

   281         int olast = o.path.length;

   282         for (int i = 0; i < olast; i++) {

   283             if (o.path[i] != this.path[i])

   284                 return false;

   285         }

   286         olast--;

   287         return o.path.length == this.path.length ||

   288                o.path[olast] == '/' ||

   289                this.path[olast + 1] == '/';

   290     }

   291 

   292     @Override

   293     public boolean endsWith(Path other) {

   294         final JrtPath o = checkPath(other);

   295         int olast = o.path.length - 1;

   296         if (olast > 0 && o.path[olast] == '/')

   297             olast--;

   298         int last = this.path.length - 1;

   299         if (last > 0 && this.path[last] == '/')

   300             last--;

   301         if (olast == -1)    // o.path.length == 0

   302             return last == -1;

   303         if ((o.isAbsolute() &&(!this.isAbsolute() || olast != last)) ||

   304             (last < olast))

   305             return false;

   306         for (; olast >= 0; olast--, last--) {

   307             if (o.path[olast] != this.path[last])

   308                 return false;

   309         }

   310         return o.path[olast + 1] == '/' ||

   311                last == -1 || this.path[last] == '/';

   312     }

   313 

   314     @Override

   315     public JrtPath resolve(String other) {

   316         return resolve(getFileSystem().getPath(other));

   317     }

   318 

   319     @Override

   320     public final Path resolveSibling(String other) {

   321         return resolveSibling(getFileSystem().getPath(other));

   322     }

   323 

   324     @Override

   325     public final boolean startsWith(String other) {

   326         return startsWith(getFileSystem().getPath(other));

   327     }

   328 

   329     @Override

   330     public final boolean endsWith(String other) {

   331         return endsWith(getFileSystem().getPath(other));

   332     }

   333 

   334     @Override

   335     public Path normalize() {

   336         byte[] res = getResolved();

   337         if (res == path)    // no change

   338             return this;

   339         return new JrtPath(jrtfs, res, true);

   340     }

   341 

   342     private JrtPath checkPath(Path path) {

   343         if (path == null)

   344             throw new NullPointerException();

   345         if (!(path instanceof JrtPath))

   346             throw new ProviderMismatchException();

   347         return (JrtPath) path;

   348     }

   349 

   350     // create offset list if not already created

   351     private void initOffsets() {

   352         if (offsets == null) {

   353             int count, index;

   354             // count names

   355             count = 0;

   356             index = 0;

   357             while (index < path.length) {

   358                 byte c = path[index++];

   359                 if (c != '/') {

   360                     count++;

   361                     while (index < path.length && path[index] != '/')

   362                         index++;

   363                 }

   364             }

   365             // populate offsets

   366             int[] result = new int[count];

   367             count = 0;

   368             index = 0;

   369             while (index < path.length) {

   370                 byte c = path[index];

   371                 if (c == '/') {

   372                     index++;

   373                 } else {

   374                     result[count++] = index++;

   375                     while (index < path.length && path[index] != '/')

   376                         index++;

   377                 }

   378             }

   379             synchronized (this) {

   380                 if (offsets == null)

   381                     offsets = result;

   382             }

   383         }

   384     }

   385 

   386     // resolved path for locating jrt entry inside the jrt file,

   387     // the result path does not contain ./ and .. components

   388     // resolved bytes will always start with '/'

   389     private volatile byte[] resolved = null;

   390     byte[] getResolvedPath() {

   391         byte[] r = resolved;

   392         if (r == null) {

   393             if (isAbsolute())

   394                 r = getResolved();

   395             else

   396                 r = toAbsolutePath().getResolvedPath();

   397             resolved = r;

   398         }

   399         return resolved;

   400     }

   401 

   402     // removes redundant slashs, replace "\" to separator "/"

   403     // and check for invalid characters

   404     private static byte[] normalize(byte[] path) {

   405         if (path.length == 0)

   406             return path;

   407         byte prevC = 0;

   408         for (int i = 0; i < path.length; i++) {

   409             byte c = path[i];

   410             if (c == '\\')

   411                 return normalize(path, i);

   412             if (c == (byte)'/' && prevC == '/')

   413                 return normalize(path, i - 1);

   414             if (c == '\u0000')

   415                 throw new InvalidPathException(JrtFileSystem.getString(path),

   416                                                "Path: nul character not allowed");

   417             prevC = c;

   418         }

   419 

   420         if (path.length > 1 && path[path.length - 1] == '/') {

   421             return Arrays.copyOf(path, path.length - 1);

   422         }

   423 

   424         return path;

   425     }

   426 

   427     private static byte[] normalize(byte[] path, int off) {

   428         byte[] to = new byte[path.length];

   429         int n = 0;

   430         while (n < off) {

   431             to[n] = path[n];

   432             n++;

   433         }

   434         int m = n;

   435         byte prevC = 0;

   436         while (n < path.length) {

   437             byte c = path[n++];

   438             if (c == (byte)'\\')

   439                 c = (byte)'/';

   440             if (c == (byte)'/' && prevC == (byte)'/')

   441                 continue;

   442             if (c == '\u0000')

   443                 throw new InvalidPathException(JrtFileSystem.getString(path),

   444                                                "Path: nul character not allowed");

   445             to[m++] = c;

   446             prevC = c;

   447         }

   448         if (m > 1 && to[m - 1] == '/')

   449             m--;

   450         return (m == to.length)? to : Arrays.copyOf(to, m);

   451     }

   452 

   453     // Remove DotSlash(./) and resolve DotDot (..) components

   454     private byte[] getResolved() {

   455         if (path.length == 0)

   456             return path;

   457         for (int i = 0; i < path.length; i++) {

   458             byte c = path[i];

   459             if (c == (byte)'.')

   460                 return resolve0();

   461         }

   462 

   463         return path;

   464     }

   465 

   466     // TBD: performance, avoid initOffsets

   467     private byte[] resolve0() {

   468         byte[] to = new byte[path.length];

   469         int nc = getNameCount();

   470         int[] lastM = new int[nc];

   471         int lastMOff = -1;

   472         int m = 0;

   473         for (int i = 0; i < nc; i++) {

   474             int n = offsets[i];

   475             int len = (i == offsets.length - 1)?

   476                       (path.length - n):(offsets[i + 1] - n - 1);

   477             if (len == 1 && path[n] == (byte)'.') {

   478                 if (m == 0 && path[0] == '/')   // absolute path

   479                     to[m++] = '/';

   480                 continue;

   481             }

   482             if (len == 2 && path[n] == '.' && path[n + 1] == '.') {

   483                 if (lastMOff >= 0) {

   484                     m = lastM[lastMOff--];  // retreat

   485                     continue;

   486                 }

   487                 if (path[0] == '/') {  // "/../xyz" skip

   488                     if (m == 0)

   489                         to[m++] = '/';

   490                 } else {               // "../xyz" -> "../xyz"

   491                     if (m != 0 && to[m-1] != '/')

   492                         to[m++] = '/';

   493                     while (len-- > 0)

   494                         to[m++] = path[n++];

   495                 }

   496                 continue;

   497             }

   498             if (m == 0 && path[0] == '/' ||   // absolute path

   499                 m != 0 && to[m-1] != '/') {   // not the first name

   500                 to[m++] = '/';

   501             }

   502             lastM[++lastMOff] = m;

   503             while (len-- > 0)

   504                 to[m++] = path[n++];

   505         }

   506         if (m > 1 && to[m - 1] == '/')

   507             m--;

   508         return (m == to.length)? to : Arrays.copyOf(to, m);

   509     }

   510 

   511     @Override

   512     public String toString() {

   513         return JrtFileSystem.getString(path);

   514     }

   515 

   516     @Override

   517     public int hashCode() {

   518         int h = hashcode;

   519         if (h == 0)

   520             hashcode = h = Arrays.hashCode(path);

   521         return h;

   522     }

   523 

   524     @Override

   525     public boolean equals(Object obj) {

   526         return obj != null &&

   527                obj instanceof JrtPath &&

   528                this.jrtfs == ((JrtPath)obj).jrtfs &&

   529                compareTo((Path) obj) == 0;

   530     }

   531 

   532     @Override

   533     public int compareTo(Path other) {

   534         final JrtPath o = checkPath(other);

   535         int len1 = this.path.length;

   536         int len2 = o.path.length;

   537 

   538         int n = Math.min(len1, len2);

   539         byte v1[] = this.path;

   540         byte v2[] = o.path;

   541 

   542         int k = 0;

   543         while (k < n) {

   544             int c1 = v1[k] & 0xff;

   545             int c2 = v2[k] & 0xff;

   546             if (c1 != c2)

   547                 return c1 - c2;

   548             k++;

   549         }

   550         return len1 - len2;

   551     }

   552 

   553     @Override

   554     public WatchKey register(

   555             WatchService watcher,

   556             WatchEvent.Kind<?>[] events,

   557             WatchEvent.Modifier... modifiers) {

   558         if (watcher == null || events == null || modifiers == null) {

   559             throw new NullPointerException();

   560         }

   561         throw new UnsupportedOperationException();

   562     }

   563 

   564     @Override

   565     public WatchKey register(WatchService watcher, WatchEvent.Kind<?>... events) {

   566         return register(watcher, events, new WatchEvent.Modifier[0]);

   567     }

   568 

   569     @Override

   570     public final File toFile() {

   571         throw new UnsupportedOperationException();

   572     }

   573 

   574     @Override

   575     public Iterator<Path> iterator() {

   576         return new Iterator<Path>() {

   577             private int i = 0;

   578 

   579             @Override

   580             public boolean hasNext() {

   581                 return (i < getNameCount());

   582             }

   583 

   584             @Override

   585             public Path next() {

   586                 if (i < getNameCount()) {

   587                     Path result = getName(i);

   588                     i++;

   589                     return result;

   590                 } else {

   591                     throw new NoSuchElementException();

   592                 }

   593             }

   594 

   595             @Override

   596             public void remove() {

   597                 throw new ReadOnlyFileSystemException();

   598             }

   599         };

   600     }

   601 

   602     /////////////////////////////////////////////////////////////////////

   603     // Helpers for JrtFileSystemProvider and JrtFileSystem

   604 

   605     int getPathLength() {

   606         return path.length;

   607     }

   608 

   609 

   610     void createDirectory(FileAttribute<?>... attrs)

   611         throws IOException

   612     {

   613         jrtfs.createDirectory(getResolvedPath(), attrs);

   614     }

   615 

   616     InputStream newInputStream(OpenOption... options) throws IOException

   617     {

   618         if (options.length > 0) {

   619             for (OpenOption opt : options) {

   620                 if (opt != READ)

   621                     throw new UnsupportedOperationException("'" + opt + "' not allowed");

   622             }

   623         }

   624         return jrtfs.newInputStream(getResolvedPath());

   625     }

   626 

   627     DirectoryStream<Path> newDirectoryStream(Filter<? super Path> filter)

   628         throws IOException

   629     {

   630         return new JrtDirectoryStream(this, filter);

   631     }

   632 

   633     void delete() throws IOException {

   634         jrtfs.deleteFile(getResolvedPath(), true);

   635     }

   636 

   637     void deleteIfExists() throws IOException {

   638         jrtfs.deleteFile(getResolvedPath(), false);

   639     }

   640 

   641     JrtFileAttributes getAttributes() throws IOException

   642     {

   643         JrtFileAttributes zfas = jrtfs.getFileAttributes(getResolvedPath());

   644         if (zfas == null)

   645             throw new NoSuchFileException(toString());

   646         return zfas;

   647     }

   648 

   649     void setAttribute(String attribute, Object value, LinkOption... options)

   650         throws IOException

   651     {

   652         String type;

   653         String attr;

   654         int colonPos = attribute.indexOf(':');

   655         if (colonPos == -1) {

   656             type = "basic";

   657             attr = attribute;

   658         } else {

   659             type = attribute.substring(0, colonPos++);

   660             attr = attribute.substring(colonPos);

   661         }

   662         JrtFileAttributeView view = JrtFileAttributeView.get(this, type);

   663         if (view == null)

   664             throw new UnsupportedOperationException("view <" + view + "> is not supported");

   665         view.setAttribute(attr, value);

   666     }

   667 

   668     void setTimes(FileTime mtime, FileTime atime, FileTime ctime)

   669         throws IOException

   670     {

   671         jrtfs.setTimes(getResolvedPath(), mtime, atime, ctime);

   672     }

   673 

   674     Map<String, Object> readAttributes(String attributes, LinkOption... options)

   675         throws IOException

   676 

   677     {

   678         String view;

   679         String attrs;

   680         int colonPos = attributes.indexOf(':');

   681         if (colonPos == -1) {

   682             view = "basic";

   683             attrs = attributes;

   684         } else {

   685             view = attributes.substring(0, colonPos++);

   686             attrs = attributes.substring(colonPos);

   687         }

   688         JrtFileAttributeView jrtfv = JrtFileAttributeView.get(this, view);

   689         if (jrtfv == null) {

   690             throw new UnsupportedOperationException("view not supported");

   691         }

   692         return jrtfv.readAttributes(attrs);

   693     }

   694 

   695     FileStore getFileStore() throws IOException {

   696         // each JrtFileSystem only has one root (as requested for now)

   697         if (exists())

   698             return jrtfs.getFileStore(this);

   699         throw new NoSuchFileException(JrtFileSystem.getString(path));

   700     }

   701 

   702     boolean isSameFile(Path other) throws IOException {

   703         if (this.equals(other))

   704             return true;

   705         if (other == null ||

   706             this.getFileSystem() != other.getFileSystem())

   707             return false;

   708         this.checkAccess();

   709         ((JrtPath)other).checkAccess();

   710         return Arrays.equals(this.getResolvedPath(),

   711                              ((JrtPath)other).getResolvedPath());

   712     }

   713 

   714     SeekableByteChannel newByteChannel(Set<? extends OpenOption> options,

   715                                        FileAttribute<?>... attrs)

   716         throws IOException

   717     {

   718         return jrtfs.newByteChannel(getResolvedPath(), options, attrs);

   719     }

   720 

   721 

   722     FileChannel newFileChannel(Set<? extends OpenOption> options,

   723                                FileAttribute<?>... attrs)

   724         throws IOException

   725     {

   726         return jrtfs.newFileChannel(getResolvedPath(), options, attrs);

   727     }

   728 

   729     void checkAccess(AccessMode... modes) throws IOException {

   730         boolean w = false;

   731         boolean x = false;

   732         for (AccessMode mode : modes) {

   733             switch (mode) {

   734                 case READ:

   735                     break;

   736                 case WRITE:

   737                     w = true;

   738                     break;

   739                 case EXECUTE:

   740                     x = true;

   741                     break;

   742                 default:

   743                     throw new UnsupportedOperationException();

   744             }

   745         }

   746         JrtFileAttributes attrs = jrtfs.getFileAttributes(getResolvedPath());

   747         if (attrs == null && (path.length != 1 || path[0] != '/'))

   748             throw new NoSuchFileException(toString());

   749         if (w) {

   750             if (jrtfs.isReadOnly())

   751                 throw new AccessDeniedException(toString());

   752         }

   753         if (x)

   754             throw new AccessDeniedException(toString());

   755     }

   756 

   757     boolean exists() {

   758         if (isAbsolute())

   759             return true;

   760         try {

   761             return jrtfs.exists(getResolvedPath());

   762         } catch (IOException x) {}

   763         return false;

   764     }

   765 

   766     OutputStream newOutputStream(OpenOption... options) throws IOException

   767     {

   768         if (options.length == 0)

   769             return jrtfs.newOutputStream(getResolvedPath(),

   770                                        CREATE_NEW, WRITE);

   771         return jrtfs.newOutputStream(getResolvedPath(), options);

   772     }

   773 

   774     void move(JrtPath target, CopyOption... options)

   775         throws IOException

   776     {

   777         if (this.jrtfs == target.jrtfs)

   778         {

   779             jrtfs.copyFile(true,

   780                          getResolvedPath(), target.getResolvedPath(),

   781                          options);

   782         } else {

   783             copyToTarget(target, options);

   784             delete();

   785         }

   786     }

   787 

   788     void copy(JrtPath target, CopyOption... options)

   789         throws IOException

   790     {

   791         if (this.jrtfs == target.jrtfs)

   792             jrtfs.copyFile(false,

   793                          getResolvedPath(), target.getResolvedPath(),

   794                          options);

   795         else

   796             copyToTarget(target, options);

   797     }

   798 

   799     private void copyToTarget(JrtPath target, CopyOption... options)

   800         throws IOException

   801     {

   802         boolean replaceExisting = false;

   803         boolean copyAttrs = false;

   804         for (CopyOption opt : options) {

   805             if (opt == REPLACE_EXISTING)

   806                 replaceExisting = true;

   807             else if (opt == COPY_ATTRIBUTES)

   808                 copyAttrs = true;

   809         }

   810         // attributes of source file

   811         JrtFileAttributes jrtfas = getAttributes();

   812         // check if target exists

   813         boolean exists;

   814         if (replaceExisting) {

   815             try {

   816                 target.deleteIfExists();

   817                 exists = false;

   818             } catch (DirectoryNotEmptyException x) {

   819                 exists = true;

   820             }

   821         } else {

   822             exists = target.exists();

   823         }

   824         if (exists)

   825             throw new FileAlreadyExistsException(target.toString());

   826 

   827         if (jrtfas.isDirectory()) {

   828             // create directory or file

   829             target.createDirectory();

   830         } else {

   831             try (InputStream is = jrtfs.newInputStream(getResolvedPath()); OutputStream os = target.newOutputStream()) {

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

   833                 int n;

   834                 while ((n = is.read(buf)) != -1) {

   835                     os.write(buf, 0, n);

   836                 }

   837             }

   838         }

   839         if (copyAttrs) {

   840             BasicFileAttributeView view =

   841                 JrtFileAttributeView.get(target, BasicFileAttributeView.class);

   842             try {

   843                 view.setTimes(jrtfas.lastModifiedTime(),

   844                               jrtfas.lastAccessTime(),

   845                               jrtfas.creationTime());

   846             } catch (IOException x) {

   847                 // rollback?

   848                 try {

   849                     target.delete();

   850                 } catch (IOException ignore) { }

   851                 throw x;

   852             }

   853         }

   854     }

   855 }