Coverage Report

 package org.webslinger.commons.vfs;
 
 import java.io.File;
 import java.io.IOException;
 import java.util.Comparator;
 
 import org.apache.commons.vfs.FileObject;
 import org.apache.commons.vfs.FileListener;
 import org.apache.commons.vfs.provider.AbstractFileSystem;
 
 import org.webslinger.io.Monitor;
 
 public interface FileObjectMonitor<F extends FileObject> extends Monitor<F, FileObjectMonitor.FileObjectListener<F>> {
     void add(F item, FileObjectListener<F> listener) throws IOException;
     void remove(F item, FileObjectListener<F> listener) throws IOException;
     interface FileObjectListener<F extends FileObject> extends Monitor.Listener<F> {
     }
 
     abstract class AbstractFileObjectListener<F extends FileObject> implements Comparable<AbstractFileObjectListener<F>> {
         protected final F file;
 
         protected AbstractFileObjectListener(F file) {
             this.file = file;
         }
 
         protected void forwardAbstractEvent(F file, Monitor.Listener.Event event) {
             try {
                 AbstractFileSystem afs = (AbstractFileSystem) file.getFileSystem();
                 switch (event) {
                     case CHANGE:
                         afs.fireFileChanged(file);
                         break;
                     case CREATE:
                         afs.fireFileCreated(file);
                         break;
                     case DELETE:
                         afs.fireFileDeleted(file);
                         break;
                 }
             } catch (RuntimeException e) {
                 throw e;
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
 
         public int compareTo(AbstractFileObjectListener<F> other) {
             return file.getName().compareTo(other.file.getName());
         }
     }
 
     final class FileObjectListenerDispatcher<F extends FileObject> extends AbstractFileObjectListener<F> implements Monitor.Listener<F> {
         public FileObjectListenerDispatcher(F file) {
             super(file);
         }
 
         public void acceptEvent(F file, Monitor.Listener.Event event) {
             assert this.file == file;
             forwardAbstractEvent(file, event);
         }
     }
 
     final class FileObjectListenerProxy<F extends FileObject> extends AbstractFileObjectListener<F> implements Monitor.Listener<File> {
         public FileObjectListenerProxy(F file) {
             super(file);
         }
 
         public void acceptEvent(File item, Monitor.Listener.Event event) {
             forwardAbstractEvent(file, event);
         }
 
         public int hashCode() {
             return FileObjectListenerProxy.class.hashCode() ^ file.hashCode();
         }
 
         public boolean equals(Object o) {
             if (!(o instanceof FileObjectListenerProxy)) return false;
             FileObjectListenerProxy other = (FileObjectListenerProxy) o;
             return file.equals(other.file);
         }
     }
 }

1		package org.webslinger.commons.vfs;
2
3		import java.io.File;
4		import java.io.IOException;
5		import java.util.Comparator;
6
7		import org.apache.commons.vfs.FileObject;
8		import org.apache.commons.vfs.FileListener;
9		import org.apache.commons.vfs.provider.AbstractFileSystem;
10
11		import org.webslinger.io.Monitor;
12
13		public interface FileObjectMonitor<F extends FileObject> extends Monitor<F, FileObjectMonitor.FileObjectListener<F>> {
14		void add(F item, FileObjectListener<F> listener) throws IOException;
15		void remove(F item, FileObjectListener<F> listener) throws IOException;
16		interface FileObjectListener<F extends FileObject> extends Monitor.Listener<F> {
17		}
18
19	0	abstract class AbstractFileObjectListener<F extends FileObject> implements Comparable<AbstractFileObjectListener<F>> {
20		protected final F file;
21
22	0	protected AbstractFileObjectListener(F file) {
23	0	this.file = file;
24	0	}
25
26		protected void forwardAbstractEvent(F file, Monitor.Listener.Event event) {
27		try {
28	0	AbstractFileSystem afs = (AbstractFileSystem) file.getFileSystem();
29	0	switch (event) {
30		case CHANGE:
31	0	afs.fireFileChanged(file);
32	0	break;
33		case CREATE:
34	0	afs.fireFileCreated(file);
35	0	break;
36		case DELETE:
37	0	afs.fireFileDeleted(file);
38		break;
39		}
40	0	} catch (RuntimeException e) {
41	0	throw e;
42	0	} catch (Exception e) {
43	0	e.printStackTrace();
44	0	}
45	0	}
46
47		public int compareTo(AbstractFileObjectListener<F> other) {
48	0	return file.getName().compareTo(other.file.getName());
49		}
50		}
51
52	0	final class FileObjectListenerDispatcher<F extends FileObject> extends AbstractFileObjectListener<F> implements Monitor.Listener<F> {
53		public FileObjectListenerDispatcher(F file) {
54	0	super(file);
55	0	}
56
57		public void acceptEvent(F file, Monitor.Listener.Event event) {
58	0	assert this.file == file;
59	0	forwardAbstractEvent(file, event);
60	0	}
61		}
62
63	0	final class FileObjectListenerProxy<F extends FileObject> extends AbstractFileObjectListener<F> implements Monitor.Listener<File> {
64		public FileObjectListenerProxy(F file) {
65	0	super(file);
66	0	}
67
68		public void acceptEvent(File item, Monitor.Listener.Event event) {
69	0	forwardAbstractEvent(file, event);
70	0	}
71
72		public int hashCode() {
73	0	return FileObjectListenerProxy.class.hashCode() ^ file.hashCode();
74		}
75
76		public boolean equals(Object o) {
77	0	if (!(o instanceof FileObjectListenerProxy)) return false;
78	0	FileObjectListenerProxy other = (FileObjectListenerProxy) o;
79	0	return file.equals(other.file);
80		}
81		}
82		}