001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.kernel.nio;
016    
017    import java.io.File;
018    import java.io.IOException;
019    
020    import java.net.URI;
021    
022    import java.nio.file.FileSystem;
023    import java.nio.file.LinkOption;
024    import java.nio.file.Path;
025    import java.nio.file.WatchEvent;
026    import java.nio.file.WatchKey;
027    import java.nio.file.WatchService;
028    
029    import java.util.Iterator;
030    
031    /**
032     * @author Shuyang Zhou
033     */
034    public class PathWrapper implements Path {
035    
036            public PathWrapper(Path path, FileSystem fileSystem) {
037                    _path = path;
038                    _fileSystem = fileSystem;
039            }
040    
041            @Override
042            public int compareTo(Path path) {
043                    return _path.compareTo(unwrapPath(path));
044            }
045    
046            @Override
047            public boolean endsWith(Path path) {
048                    return _path.endsWith(unwrapPath(path));
049            }
050    
051            @Override
052            public boolean endsWith(String path) {
053                    return _path.endsWith(path);
054            }
055    
056            @Override
057            public boolean equals(Object path) {
058                    if (path instanceof PathWrapper) {
059                            PathWrapper pathWrapper = (PathWrapper)path;
060    
061                            path = pathWrapper._path;
062                    }
063    
064                    return _path.equals(path);
065            }
066    
067            @Override
068            public Path getFileName() {
069                    return wrapPath(_path.getFileName(), _fileSystem);
070            }
071    
072            @Override
073            public FileSystem getFileSystem() {
074                    return _fileSystem;
075            }
076    
077            @Override
078            public Path getName(int index) {
079                    return wrapPath(_path.getName(index), _fileSystem);
080            }
081    
082            @Override
083            public int getNameCount() {
084                    return _path.getNameCount();
085            }
086    
087            @Override
088            public Path getParent() {
089                    return wrapPath(_path.getParent(), _fileSystem);
090            }
091    
092            @Override
093            public Path getRoot() {
094                    return wrapPath(_path.getRoot(), _fileSystem);
095            }
096    
097            @Override
098            public int hashCode() {
099                    return _path.hashCode();
100            }
101    
102            @Override
103            public boolean isAbsolute() {
104                    return _path.isAbsolute();
105            }
106    
107            @Override
108            public Iterator<Path> iterator() {
109                    final Iterator<Path> iterator = _path.iterator();
110    
111                    return new Iterator<Path>() {
112    
113                            @Override
114                            public boolean hasNext() {
115                                    return iterator.hasNext();
116                            }
117    
118                            @Override
119                            public Path next() {
120                                    return wrapPath(iterator.next(), _fileSystem);
121                            }
122    
123                            @Override
124                            public void remove() {
125                                    iterator.remove();
126                            }
127    
128                    };
129            }
130    
131            @Override
132            public Path normalize() {
133                    return wrapPath(_path.normalize(), _fileSystem);
134            }
135    
136            @Override
137            public WatchKey register(
138                            WatchService watcherService, WatchEvent.Kind<?>... kinds)
139                    throws IOException {
140    
141                    return _path.register(watcherService, kinds);
142            }
143    
144            @Override
145            public WatchKey register(
146                            WatchService watcherService, WatchEvent.Kind<?>[] kinds,
147                            WatchEvent.Modifier... modifiers)
148                    throws IOException {
149    
150                    return _path.register(watcherService, kinds, modifiers);
151            }
152    
153            @Override
154            public Path relativize(Path path) {
155                    return wrapPath(_path.relativize(unwrapPath(path)), _fileSystem);
156            }
157    
158            @Override
159            public Path resolve(Path path) {
160                    return wrapPath(_path.resolve(unwrapPath(path)), _fileSystem);
161            }
162    
163            @Override
164            public Path resolve(String path) {
165                    return wrapPath(_path.resolve(path), _fileSystem);
166            }
167    
168            @Override
169            public Path resolveSibling(Path path) {
170                    return wrapPath(_path.resolveSibling(unwrapPath(path)), _fileSystem);
171            }
172    
173            @Override
174            public Path resolveSibling(String path) {
175                    return wrapPath(_path.resolveSibling(path), _fileSystem);
176            }
177    
178            @Override
179            public boolean startsWith(Path path) {
180                    return _path.startsWith(unwrapPath(path));
181            }
182    
183            @Override
184            public boolean startsWith(String path) {
185                    return _path.startsWith(path);
186            }
187    
188            @Override
189            public Path subpath(int beginIndex, int endIndex) {
190                    return wrapPath(_path.subpath(beginIndex, endIndex), _fileSystem);
191            }
192    
193            @Override
194            public Path toAbsolutePath() {
195                    return wrapPath(_path.toAbsolutePath(), _fileSystem);
196            }
197    
198            @Override
199            public File toFile() {
200                    return _path.toFile();
201            }
202    
203            @Override
204            public Path toRealPath(LinkOption... linkOptions) throws IOException {
205                    return wrapPath(_path.toRealPath(linkOptions), _fileSystem);
206            }
207    
208            @Override
209            public String toString() {
210                    return _path.toString();
211            }
212    
213            @Override
214            public URI toUri() {
215                    return _path.toUri();
216            }
217    
218            protected static Path unwrapPath(Path path) {
219                    if (path instanceof PathWrapper) {
220                            PathWrapper pathWrapper = (PathWrapper)path;
221    
222                            path = pathWrapper._path;
223                    }
224    
225                    return path;
226            }
227    
228            protected static Path wrapPath(Path path, FileSystem fileSystem) {
229                    if (path == null) {
230                            return null;
231                    }
232    
233                    return new PathWrapper(path, fileSystem);
234            }
235    
236            private final FileSystem _fileSystem;
237            private final Path _path;
238    
239    }