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