Tabnine Logo
FileChangeObserver
Code IndexAdd Tabnine to your IDE (free)

How to use
FileChangeObserver
in
leap.lang.io

Best Java code snippets using leap.lang.io.FileChangeObserver (Showing top 12 results out of 315)

origin: org.leapframework/jmms-engine

private FileChangeObserver createObserver(File dir, FileChangeListener listener) {
  FileChangeObserver observer = new FileChangeObserver(dir);
  observer.addListener(listener);
  return observer;
}
origin: org.leapframework/leap-lang

for (FileInfo entry : previous) {
  while (c < files.length && comparator.compare(entry.getFile(), files[c]) > 0) {
    current[c] = createFileEntry(parent, files[c]);
    doCreate(current[c]);
    c++;
    doMatch(entry, files[c]);
    checkAndNotify(entry, entry.getChildren(), listFiles(files[c]));
    current[c] = entry;
    c++;
  } else {
    checkAndNotify(entry, entry.getChildren(), Files.EMPTY_FILE_ARRAY);
    doDelete(entry);
  current[c] = createFileEntry(parent, files[c]);
  doCreate(current[c]);
origin: org.leapframework/leap-lang

/**
 * Stop monitoring.
 *
 * @param stopInterval the amount of time in milliseconds to wait for the thread to finish.
 * A value of zero will wait until the thread is finished (see {@link Thread#join(long)}).
 * @throws Exception if an error occurs initializing the observer
 * @since 2.1
 */
public synchronized void stop(long stopInterval) throws Exception {
  if (running == false) {
    throw new IllegalStateException("Monitor is not running");
  }
  running = false;
  try {
    thread.join(stopInterval);
  } catch (InterruptedException e) {
    Thread.currentThread().interrupt();
  }
  for (FileChangeObserver observer : observers) {
    observer.destroy();
  }
}
origin: org.leapframework/leap-lang

public FileChangeObserver(File directory, FileChangeListener listener) {
  this(directory, (FileFilter)null);
  this.addListener(listener);
}
origin: org.leapframework/leap-lang

initialize();
  checkAndNotify(rootEntry, rootEntry.getChildren(), listFiles(rootFile));
} else if (rootEntry.isExists()) {
  checkAndNotify(rootEntry, rootEntry.getChildren(), Files.EMPTY_FILE_ARRAY);
} else {
origin: org.leapframework/jmms-plugins-swagger-doc

monitor.addObserver(new FileChangeObserver(dir1, listener));
monitor.addObserver(new FileChangeObserver(dir2, listener));
origin: org.leapframework/leap-lang

/**
 * 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 FileInfo createFileEntry(FileInfo parent, File file) {
  FileInfo entry = parent.newChildInstance(file);
  entry.refresh(file);
  File[] files = listFiles(file);
  FileInfo[] children = files.length > 0 ? new FileInfo[files.length] : FileInfo.EMPTY_FILE_INFOS;
  for (int i = 0; i < files.length; i++) {
    children[i] = createFileEntry(entry, files[i]);
  }
  entry.setChildren(children);
  return entry;
}
origin: org.leapframework/leap-lang

  /**
   * Provide a String representation of this observer.
   *
   * @return a String representation of this observer
   */
  @Override
  public String toString() {
    StringBuilder builder = new StringBuilder();
    builder.append(getClass().getSimpleName());
    builder.append("[file='");
    builder.append(getDirectory().getPath());
    builder.append('\'');
    if (fileFilter != null) {
      builder.append(", ");
      builder.append(fileFilter.toString());
    }
    builder.append(", listeners=");
    builder.append(listeners.size());
    builder.append("]");
    return builder.toString();
  }
}
origin: org.leapframework/leap-lang

try {
  for (FileChangeObserver observer : observers) {
    observer.checkAndNotify();
origin: org.leapframework/leap-lang

/**
 * Fire directory/file created events to the registered listeners.
 *
 * @param entry The file entry
 */
private void doCreate(FileInfo entry) {
  for (FileChangeListener listener : listeners) {
    if (entry.isDirectory()) {
      listener.onDirectoryCreate(this,entry.getFile());
    } else {
      listener.onFileCreate(this,entry.getFile());
    }
  }
  FileInfo[] children = entry.getChildren();
  for (FileInfo aChildren : children) {
    doCreate(aChildren);
  }
}
origin: org.leapframework/leap-lang

/**
 * Initialize the observer.
 *
 * @throws Exception if an error occurs
 */
protected synchronized void initialize() {
  rootEntry.refresh(rootEntry.getFile());
  File[] files = listFiles(rootEntry.getFile());
  FileInfo[] children = files.length > 0 ? new FileInfo[files.length] : FileInfo.EMPTY_FILE_INFOS;
  for (int i = 0; i < files.length; i++) {
    children[i] = createFileEntry(rootEntry, files[i]);
  }
  rootEntry.setChildren(children);
  _initialized = true;
}
origin: org.leapframework/leap-orm

if(file.isFile()) {
  FileFilter fileFilter = FileFilters.nameEquals("sqls.xml");
  FileChangeObserver observer = new FileChangeObserver(file.getFile().getParent(), fileFilter);
  observer.addListener(listener);
  fileMonitor.addObserver(observer);
  FileChangeObserver observer = new FileChangeObserver(dir.getFile());
  observer.addListener(listener);
  fileMonitor.addObserver(observer);
leap.lang.ioFileChangeObserver

Javadoc

FileChangeObserver represents the state of files below a root directory, checking the filesystem and notifying listeners of create, change or delete events.

To use this implementation:

  • Create FileChangeListener implementation(s) that process the file/directory create, change and delete events
  • Register the listener(s) with a FileChangeObserver for the appropriate directory.
  • Either register the observer(s) with a FileChangeMonitor or run manually.

Basic Usage Create a FileChangeObserver for the directory and register the listeners:
 
File directory = new File(new File("."), "src"); 
FileChangeObserver observer = new FileChangeObserver(directory); 
observer.addListener(...); 
observer.addListener(...); 
To manually observe a directory, initialize the observer and invoked the #checkAndNotify() method as required:
 
// intialize 
observer.init(); 
... 
// invoke as required 
observer.checkAndNotify(); 
... 
observer.checkAndNotify(); 
... 
// finished 
observer.finish(); 
Alternatively, register the oberver(s) with a FileChangeMonitor, which creates a new thread, invoking the observer at the specified interval:
 
long interval = ... 
FileChangeMonitor monitor = new FileChangeMonitor(interval); 
monitor.addObserver(observer); 
monitor.start(); 
... 
monitor.stop(); 
File Filters This implementation can monitor portions of the file system by using FileFilters to observe only the files and/or directories that are of interest. This makes it more efficient and reduces the noise from unwanted file system events.

Commons IO has a good range of useful, ready made File Filter implementations for this purpose.

For example, to only observe 1) visible directories and 2) files with a ".java" suffix in a root directory called "src" you could set up a FileChangeObserver in the following way:

 
// Create a FileFilter 
Filter directories = Filters.and( 
Filters.isDirectory(), 
Filters.isVisible()); 
Filter files       = Filters.and( 
Filters.isFile(), 
Filters.endsWith(".java")); 
Filter filter = Filters.or(directories, files); 
// Create the File system observer and register File Listeners 
FileChangeObserver observer = new FileChangeObserver(new File("src"), filter); 
observer.addListener(...); 
observer.addListener(...); 

FileEntry FileInfo represents the state of a file or directory, capturing File attributes at a point in time. Custom implementations of FileInfo can be used to capture additional properties that the basic implementation does not support. The FileInfo#refresh(File)method is used to determine if a file or directory has changed since the last check and stores the current state of the File's properties.

Most used methods

  • <init>
    Construct an observer for the specified directory, file filter and file comparator.
  • addListener
    Add a file system listener.
  • checkAndNotify
    Compare two file lists for files which have been created, modified or deleted.
  • createFileEntry
    Create a new file entry for the specified file.
  • destroy
    Final processing.
  • doCreate
    Fire directory/file created events to the registered listeners.
  • doDelete
    Fire directory/file delete events to the registered listeners.
  • doMatch
    Fire directory/file change events to the registered listeners.
  • getDirectory
    Return the directory being observed.
  • initialize
    Initialize the observer.
  • listFiles
    List the contents of a directory
  • listFiles

Popular in Java

  • Reactive rest calls using spring rest template
  • getResourceAsStream (ClassLoader)
  • scheduleAtFixedRate (ScheduledExecutorService)
  • notifyDataSetChanged (ArrayAdapter)
  • OutputStream (java.io)
    A writable sink for bytes.Most clients will use output streams that write data to the file system (
  • Random (java.util)
    This class provides methods that return pseudo-random values.It is dangerous to seed Random with the
  • Set (java.util)
    A Set is a data structure which does not allow duplicate elements.
  • TreeSet (java.util)
    TreeSet is an implementation of SortedSet. All optional operations (adding and removing) are support
  • Vector (java.util)
    Vector is an implementation of List, backed by an array and synchronized. All optional operations in
  • ExecutorService (java.util.concurrent)
    An Executor that provides methods to manage termination and methods that can produce a Future for tr
  • Best plugins for Eclipse
Tabnine Logo
  • Products

    Search for Java codeSearch for JavaScript code
  • IDE Plugins

    IntelliJ IDEAWebStormVisual StudioAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimGoLandRubyMineEmacsJupyter NotebookJupyter LabRiderDataGripAppCode
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogTabnine AcademyTerms of usePrivacy policyJava Code IndexJavascript Code Index
Get Tabnine for your IDE now