/** * Initialize the observer. * * @throws Exception if an error occurs */ public void initialize() throws Exception { rootEntry.refresh(rootEntry.getFile()); final FileEntry[] children = doListFiles(rootEntry.getFile(), rootEntry); rootEntry.setChildren(children); }
/** * Create a new file entry for the specified file. * * @param parent The parent file entry * @param file The file to create an entry for * @return A new file entry */ private FileEntry createFileEntry(final FileEntry parent, final File file) { final FileEntry entry = parent.newChildInstance(file); entry.refresh(file); final FileEntry[] children = doListFiles(file, entry); entry.setChildren(children); return entry; }
/** * Stop monitoring. * * @throws Exception if an error occurs initializing the observer */ public synchronized void stop() throws Exception { stop(interval); }
/** * Create a {@link FileAlterationObserver}. * * @param file The directory to observe * @param fileFilter The file filter to apply */ protected void createObserver(final File file, final FileFilter fileFilter) { observer = new FileAlterationObserver(file, fileFilter); observer.addListener(listener); observer.addListener(new FileAlterationListenerAdaptor()); try { observer.initialize(); } catch (final Exception e) { fail("Observer init() threw " + e); } }
/** * Check whether the file and its children have been created, modified or deleted. */ public void checkAndNotify() { /* fire onStart() */ for (final FileAlterationListener listener : listeners) { listener.onStart(this); } /* fire directory/file events */ final File rootFile = rootEntry.getFile(); if (rootFile.exists()) { checkAndNotify(rootEntry, rootEntry.getChildren(), listFiles(rootFile)); } else if (rootEntry.isExists()) { checkAndNotify(rootEntry, rootEntry.getChildren(), FileUtils.EMPTY_FILE_ARRAY); } else { // Didn't exist and still doesn't } /* fire onStop() */ for (final FileAlterationListener listener : listeners) { listener.onStop(this); } }
/** * Fire directory/file created events to the registered listeners. * * @param entry The file entry */ private void doCreate(final FileEntry entry) { for (final FileAlterationListener listener : listeners) { if (entry.isDirectory()) { listener.onDirectoryCreate(entry.getFile()); } else { listener.onFileCreate(entry.getFile()); } } final FileEntry[] children = entry.getChildren(); for (final FileEntry aChildren : children) { doCreate(aChildren); } }
/** * Construct a monitor with the specified interval and set of observers. * * @param interval The amount of time in milliseconds to wait between * checks of the file system * @param observers The set of observers to add to the monitor. */ public FileAlterationMonitor(final long interval, final FileAlterationObserver... observers) { this(interval); if (observers != null) { for (final FileAlterationObserver observer : observers) { addObserver(observer); } } }
/** * Fire directory/file delete events to the registered listeners. * * @param entry The file entry */ private void doDelete(final FileEntry entry) { for (final FileAlterationListener listener : listeners) { if (entry.isDirectory()) { listener.onDirectoryDelete(entry.getFile()); } else { listener.onFileDelete(entry.getFile()); } } }
/** * Test default constructor. */ @Test public void testDefaultConstructor() { final FileAlterationMonitor monitor = new FileAlterationMonitor(); assertEquals("Interval", 10000, monitor.getInterval()); }
/** * Fire directory/file change events to the registered listeners. * * @param entry The previous file system entry * @param file The current file */ private void doMatch(final FileEntry entry, final File file) { if (entry.refresh(file)) { for (final FileAlterationListener listener : listeners) { if (entry.isDirectory()) { listener.onDirectoryChange(file); } else { listener.onFileChange(file); } } } }
/** * List the files * @param file The file to list files for * @param entry the parent entry * @return The child files */ private FileEntry[] doListFiles(final File file, final FileEntry entry) { final File[] files = listFiles(file); final FileEntry[] children = files.length > 0 ? new FileEntry[files.length] : FileEntry.EMPTY_ENTRIES; for (int i = 0; i < files.length; i++) { children[i] = createFileEntry(entry, files[i]); } return children; }
/** * Call {@link FileAlterationObserver#checkAndNotify()}. * * @throws Exception if an error occurs */ protected void checkAndNotify() throws Exception { observer.checkAndNotify(); } }
/** * Construct an observer for the specified directory, file filter and * file comparator. * * @param directory the directory to observe * @param fileFilter The file filter or null if none * @param caseSensitivity what case sensitivity to use comparing file names, null means system sensitive */ public FileAlterationObserver(final File directory, final FileFilter fileFilter, final IOCase caseSensitivity) { this(new FileEntry(directory), fileFilter, caseSensitivity); }
/** * Return the directory being observed. * * @return the directory being observed */ public File getDirectory() { return rootEntry.getFile(); }
/** * Return the level * * @return the level */ public int getLevel() { return parent == null ? 0 : parent.getLevel() + 1; }
/** * Construct a new test case. * */ public FileAlterationObserverTestCase() { listener = new CollectionFileListener(true); }
/** * Check all the Collections are empty * * @param label the label to use for this check */ protected void checkCollectionsEmpty(final String label) { checkCollectionSizes("EMPTY-" + label, 0, 0, 0, 0, 0, 0); }
/** * File system observer started checking event. * * @param observer The file system observer */ @Override public void onStart(final FileAlterationObserver observer) { if (clearOnStart) { clear(); } }
/** * Create a new child instance. * <p> * Custom implementations should override this method to return * a new instance of the appropriate type. * * @param file The child file * @return a new child instance */ public FileEntry newChildInstance(final File file) { return new FileEntry(this, file); }
/** * Construct a new test case. * */ public FileAlterationMonitorTestCase() { listener = new CollectionFileListener(false); }