001/**
002 *
003 * Copyright (c) 2014, the Railo Company Ltd. All rights reserved.
004 *
005 * This library is free software; you can redistribute it and/or
006 * modify it under the terms of the GNU Lesser General Public
007 * License as published by the Free Software Foundation; either 
008 * version 2.1 of the License, or (at your option) any later version.
009 * 
010 * This library is distributed in the hope that it will be useful,
011 * but WITHOUT ANY WARRANTY; without even the implied warranty of
012 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
013 * Lesser General Public License for more details.
014 * 
015 * You should have received a copy of the GNU Lesser General Public 
016 * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
017 * 
018 **/
019package lucee.commons.io.res.util;
020
021import java.io.File;
022import java.io.FileFilter;
023import java.io.FilenameFilter;
024import java.io.IOException;
025import java.io.InputStream;
026import java.io.OutputStream;
027import java.net.MalformedURLException;
028import java.net.URI;
029import java.net.URL;
030
031import lucee.commons.io.res.Resource;
032import lucee.commons.io.res.ResourceProvider;
033import lucee.commons.io.res.filter.ResourceFilter;
034import lucee.commons.io.res.filter.ResourceNameFilter;
035
036public final class FileWrapper extends File implements Resource {
037
038        private final Resource res;
039
040        /**
041         * Constructor of the class
042         * @param res
043         */
044        private FileWrapper(Resource res) {
045                super(res.getPath());
046                this.res=res;
047        }
048        
049        @Override
050        public boolean canRead() {
051                return res.canRead();
052        }
053
054
055        @Override
056        public boolean canWrite() {
057                return res.canWrite();
058        }
059
060
061        @Override
062        public int compareTo(File pathname) {
063                if(res instanceof File) ((File)res).compareTo(pathname);
064                return res.getPath().compareTo(pathname.getPath());
065        }
066
067
068
069        @Override
070        public boolean createNewFile() {
071                return res.createNewFile();
072        }
073
074
075        @Override
076        public boolean delete() {
077                return res.delete();
078        }
079
080
081        @Override
082        public void deleteOnExit() {
083                if(res instanceof File) ((File)res).deleteOnExit();
084        }
085
086
087        @Override
088        public boolean equals(Object obj) {
089                return res.equals(obj);
090        }
091
092
093        @Override
094        public boolean exists() {
095                return res.exists();
096        }
097
098
099        @Override
100        public File getAbsoluteFile() {
101                if(res.isAbsolute()) return this;
102                return new FileWrapper(res.getAbsoluteResource());
103        }
104
105
106        @Override
107        public String getAbsolutePath() {
108                return res.getAbsolutePath();
109        }
110
111
112        @Override
113        public File getCanonicalFile() throws IOException {
114                return new FileWrapper(res.getCanonicalResource());
115        }
116
117
118        @Override
119        public String getCanonicalPath() throws IOException {
120                return res.getCanonicalPath();
121        }
122
123
124        @Override
125        public String getName() {
126                return res.getName();
127        }
128
129
130        @Override
131        public String getParent() {
132                return res.getParent();
133        }
134
135
136        @Override
137        public File getParentFile() {
138                return new FileWrapper(this.getParentResource());
139        }
140
141
142        @Override
143        public String getPath() {
144                return res.getPath();
145        }
146
147
148        @Override
149        public int hashCode() {
150                return res.hashCode();
151        }
152
153
154        @Override
155        public boolean isAbsolute() {
156                return res.isAbsolute();
157        }
158
159
160        @Override
161        public boolean isDirectory() {
162                return res.isDirectory();
163        }
164
165
166        @Override
167        public boolean isFile() {
168                return res.isFile();
169        }
170
171
172        @Override
173        public boolean isHidden() {
174                return res.isHidden();
175        }
176
177
178        @Override
179        public long lastModified() {
180                return res.lastModified();
181        }
182
183
184        @Override
185        public long length() {
186                return res.length();
187        }
188
189
190        @Override
191        public String[] list() {
192                return res.list();
193        }
194
195
196        @Override
197        public String[] list(FilenameFilter filter) {
198                if(res instanceof File) ((File)res).list(filter);
199                return list((ResourceNameFilter)new FileNameFilterWrapper(filter));
200        }
201
202
203        @Override
204        public File[] listFiles() {
205                //if(res instanceof File) return ((File)res).listFiles();
206                return toFiles(listResources());
207        }
208        
209        private File[] toFiles(Resource[] resources) {
210                File[] files = new File[resources.length];
211                for(int i=0;i<resources.length;i++) {
212                        files[i]=new FileWrapper(resources[i]);
213                }
214                return files;
215        }
216
217
218        @Override
219        public File[] listFiles(FileFilter filter) {
220                //if(res instanceof File) return ((File)res).listFiles(filter);
221                return toFiles(listResources(new FileFilterWrapper(filter)));
222        }
223
224
225        @Override
226        public File[] listFiles(FilenameFilter filter) {
227                //if(res instanceof File) return ((File)res).listFiles(filter);
228                return toFiles(listResources(new FileNameFilterWrapper(filter)));
229        }
230
231
232        @Override
233        public boolean mkdir() {
234                return res.mkdir();
235        }
236
237
238        @Override
239        public boolean mkdirs() {
240                return res.mkdirs();
241        }
242
243
244        @Override
245        public boolean renameTo(File dest) {
246                try {
247                        if(res instanceof File) return ((File)res).renameTo(dest);
248                        if(dest instanceof Resource) return res.renameTo((Resource)dest);
249                        ResourceUtil.moveTo(this, ResourceUtil.toResource(dest),true);
250                        return true;
251                }
252                catch(IOException ioe) {
253                        return false;
254                }
255        }
256
257
258        @Override
259        public boolean setLastModified(long time) {
260                return res.setLastModified(time);
261        }
262
263
264        @Override
265        public boolean setReadOnly() {
266                return res.setReadOnly();
267        }
268
269
270        @Override
271        public String toString() {
272                return res.toString();
273        }
274
275
276        @Override
277        public URI toURI() {
278                if(res instanceof File) return ((File)res).toURI();
279                return null;
280        }
281
282
283        @Override
284        public URL toURL() throws MalformedURLException {
285                if(res instanceof File) return ((File)res).toURL();
286                return null;
287        }
288
289        @Override
290        public void createDirectory(boolean createParentWhenNotExists) throws IOException {
291                res.createDirectory(createParentWhenNotExists);
292        }
293
294        @Override
295        public void createFile(boolean createParentWhenNotExists) throws IOException {
296                res.createFile(createParentWhenNotExists);
297        }
298
299        @Override
300        public Resource getAbsoluteResource() {
301                return res.getAbsoluteResource();
302        }
303
304        @Override
305        public Resource getCanonicalResource() throws IOException {
306                return res.getCanonicalResource();
307        }
308
309        @Override
310        public InputStream getInputStream() throws IOException {
311                return res.getInputStream();
312        }
313
314        @Override
315        public int getMode() {
316                return res.getMode();
317        }
318
319        @Override
320        public OutputStream getOutputStream() throws IOException {
321                return res.getOutputStream();
322        }
323
324        @Override
325        public OutputStream getOutputStream(boolean append) throws IOException {
326                return res.getOutputStream(append);
327        }
328
329        @Override
330        public Resource getParentResource() {
331                return res.getParentResource();
332        }
333
334        @Override
335        public String getReal(String relpath) {
336                return res.getReal(relpath);
337        }
338
339        @Override
340        public Resource getRealResource(String relpath) {
341                return res.getRealResource(relpath);
342        }
343
344        @Override
345        public ResourceProvider getResourceProvider() {
346                return res.getResourceProvider();
347        }
348
349        @Override
350        public boolean isArchive() {
351                return res.isArchive();
352        }
353
354        @Override
355        public boolean isReadable() {
356                return res.isReadable();
357        }
358
359        @Override
360        public boolean isSystem() {
361                return res.isSystem();
362        }
363
364        @Override
365        public boolean isWriteable() {
366                return res.isWriteable();
367        }
368
369        @Override
370        public String[] list(ResourceNameFilter filter) {
371                return res.list(filter);
372        }
373
374        @Override
375        public String[] list(ResourceFilter filter) {
376                return res.list(filter);
377        }
378
379        @Override
380        public Resource[] listResources() {
381                return res.listResources();
382        }
383
384        @Override
385        public Resource[] listResources(ResourceFilter filter) {
386                return res.listResources(filter);
387        }
388
389        @Override
390        public Resource[] listResources(ResourceNameFilter filter) {
391                return res.listResources(filter);
392        }
393
394        @Override
395        public void moveTo(Resource dest) throws IOException {
396                res.moveTo(dest);
397        }
398
399        @Override
400        public void remove(boolean force) throws IOException {
401                res.remove(force);
402        }
403
404        @Override
405        public boolean renameTo(Resource dest) {
406                return res.renameTo(dest);
407        }
408
409        @Override
410        public void setMode(int mode) throws IOException {
411                res.setMode(mode);
412        }
413
414
415        /**
416         * @param res
417         * @return
418         */
419        public static File toFile(Resource res) {
420                if(res instanceof File) return (File)res;
421                return new FileWrapper(res);
422        }
423
424
425        @Override
426        public void setArchive(boolean value) throws IOException {
427                res.setArchive(value);
428        }
429
430        @Override
431        public void setHidden(boolean value) throws IOException {
432                res.setHidden(value);
433        }
434
435        @Override
436        public void setSystem(boolean value) throws IOException {
437                res.setSystem(value);
438        }
439
440
441        @Override
442        public boolean getAttribute(short attribute) {
443                return res.getAttribute(attribute);
444        }
445
446
447        @Override
448        public void setAttribute(short attribute, boolean value) throws IOException {
449                res.setAttribute(attribute, value);
450        }
451
452
453        @Override
454        public boolean setReadable(boolean value) {
455                return res.setReadable(value);
456        }
457
458
459        @Override
460        public boolean setWritable(boolean value) {
461                return res.setWritable(value);
462        }
463
464        public void copyFrom(Resource res, boolean append) throws IOException {
465                res.copyFrom(res, append);
466        }
467
468        public void copyTo(Resource res, boolean append) throws IOException {
469                res.copyTo(res, append);
470        }
471
472}