Java FileUtil.addFileChangeListener方法代码示例

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
public CachingArchive(
        @NonNull final File archiveFile,
        @NullAllowed final String pathToRootInArchive,
        final boolean keepOpened) {
    Parameters.notNull("archiveFile", archiveFile); //NOI18N
    if (pathToRootInArchive != null) {
        if (!keepOpened) {
            throw new UnsupportedOperationException(String.format(
                "FastJar not supported for relocated root of archive %s, relocation %s",    //NOI18N
                archiveFile.getAbsolutePath(),
                pathToRootInArchive));
        }
        if (pathToRootInArchive.charAt(pathToRootInArchive.length()-1) != FileObjects.NBFS_SEPARATOR_CHAR) {
            throw new IllegalArgumentException(String.format(
                "Path to root: %s has to end with /",   //NOI18N
                pathToRootInArchive));
        }
    }
    this.archiveFile = archiveFile;
    this.pathToRootInArchive = pathToRootInArchive;
    this.keepOpened = keepOpened;

    FileUtil.addFileChangeListener(this, FileUtil.normalizeFile(archiveFile));
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
private List<Coordinates> getJarMetadataCoordinatesIntern(File binaryFile) {        
    if (binaryFile == null || !binaryFile.exists() || !binaryFile.isFile()) {
        return null;
    }        
    synchronized (coorCache) {
        List<Coordinates> toRet = coorCache.get(binaryFile);
        if(toRet == null) {
            toRet = getJarMetadataCoordinates(binaryFile);         
            if(toRet != null) {
                FileUtil.addFileChangeListener(binaryChangeListener, binaryFile);
                coorCache.put(binaryFile, toRet);
            }                
        } 
        return toRet;
    }
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
DualLayers(FileSystem explicit) {
    this.explicit = explicit;
    NbModuleProvider nbmp = project.getLookup().lookup(NbModuleProvider.class);
    File clazz = nbmp != null ? nbmp.getClassesDirectory() : null;
    if (clazz != null) {
        generated = new File(clazz, ManifestManager.GENERATED_LAYER_PATH);
        FileUtil.addFileChangeListener(this, generated);
    } else {
        generated = null;
    }
    configure();
    setPropagateMasks(true);
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
@CheckForNull
private String computeModuleIfAbsent(
        @NonNull FileObject root,
        @NonNull final Function<FileObject,String> provider) {
    final Pair<Pair<Reference<FileObject>,File>,String> entry = modNameCache.get();
    FileObject owner;
    String modName;
    if (entry == null ||
            (owner = entry.first().first().get()) == null ||
            !owner.equals(root)) {
        modName = provider.apply(root);
        final File modInfo = Optional.ofNullable(FileUtil.toFile(root))
                .map((rf) -> new File(rf, String.format("%s.%s", FileObjects.MODULE_INFO, FileObjects.JAVA)))   //NOI18N
                .orElse(null);
        final Pair<Pair<Reference<FileObject>,File>,String> newEntry = Pair.of(
                Pair.of(new WeakReference<>(root), modInfo),
                modName);
        if (modNameCache.compareAndSet(entry, newEntry)) {
            if (entry != null && entry.first().second() != null) {
                FileUtil.removeFileChangeListener(this, entry.first().second());
            }
            if (newEntry.first().second() != null) {
                FileUtil.addFileChangeListener(this, newEntry.first().second());
            }
        }
        LOG.log(Level.FINE, "modNameCache updated: {0}", modName);  //NOI18N
    } else {
        modName = entry.second();
    }
    return modName;
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
/**
 * Call this method in order to change the persistence scope returned by the
 * <code>PersistenceScopes</code> instance returned by {@link #getPersistenceScopes}
 * or the corresponding persistence.xml file.
 *
 * @param  newPersistenceScope the new persistence scope; can be null, but in this case
 *         the <code>newPersistenceXml</code> parameter must be null too.
 * @param  newPersistenceXml the new persistence.xml file; can be null.
 *
 * @throws IllegalArgumentException if <code>newPersistenceScope</code> is null
 *         and <code>newPersistenceXml</code> is not.
 */
public void changePersistenceScope(PersistenceScope newPersistenceScope, File newPersistenceXml) {
    if (newPersistenceScope == null && newPersistenceXml != null) {
        throw new IllegalArgumentException("The persistenceScope parameter cannot be null when newPersistenceXml is non-null"); // NOI18N
    }

    boolean oldPersistenceExists, newPersistenceExists;
    PersistenceScope oldPersistenceScope;

    synchronized (this) {
        oldPersistenceExists = persistenceExists;
        oldPersistenceScope = persistenceScope;

        LOG.fine("changePersistenceScope: newPersistenceXml=" + newPersistenceXml); // NOI18N

        if (persistenceXml != null) {
            FileUtil.removeFileChangeListener(fileChangeListener, persistenceXml);
        }
        if (newPersistenceXml != null) {
            persistenceXml = newPersistenceXml;
            FileUtil.addFileChangeListener(fileChangeListener, persistenceXml);
        } else {
            persistenceXml = null;
        }

        persistenceScope = newPersistenceScope;
        persistenceXml = newPersistenceXml;

        change();

        newPersistenceExists = persistenceExists;

        LOG.fine("changePersistenceScope: oldPersistenceExists=" + oldPersistenceExists + ", newPersistenceExists=" + newPersistenceExists); // NOI18N
    }

    if (oldPersistenceExists != newPersistenceExists || (oldPersistenceScope != newPersistenceScope && newPersistenceExists)) {
        LOG.fine("changePersistenceScope: firing PROP_PERSISTENCE_SCOPES change"); // NOI18N
        propChangeSupport.firePropertyChange(PersistenceScopes.PROP_PERSISTENCE_SCOPES, null, null);
    }
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
public ModuleInfoSupport(NbMavenProjectImpl project, DependencyType type) {
    this.project = project;
    this.type = type;        
    
    Collection<String> roots = getRoots(project.getOriginalMavenProject(), type);
    for (String root : roots) {
        FileUtil.addFileChangeListener(moduleInfoListener, new File(root));
    }        
    moduleInfo = getModuleInfo(roots);
    if(moduleInfo != null) {
        populateDeclaredModules(moduleInfo);
    }
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
/**
 * Note an artifact whose absence in the local repository is implicated among the problems.
 * Note that some problems are not caused by missing artifacts,
 * and some problems encapsulate several missing artifacts.
 * @param a an artifact (scope permitted but ignored)
 */
void addMissingArtifact(Artifact a) {
    synchronized (reports) {
        a = EmbedderFactory.getProjectEmbedder().getLocalRepository().find(a);
        //a.getFile should be already normalized but the find() method can pull tricks on us.
        //#225008
        File f = FileUtil.normalizeFile(a.getFile());
        if (missingArtifacts.add(f)) {                
            LOG.log(Level.FINE, "listening to {0} from {1}", new Object[] {f, projectPOMFile});                
            FileUtil.addFileChangeListener(fcl, f);
        }
    }
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
LP(ProjectLibraryArea area) {
    this.area = area;
    libraries = calculate(area);
    Definitions defs = new Definitions(area.mainPropertiesFile);
    FileUtil.addFileChangeListener(this, defs.mainPropertiesFile);
    FileUtil.addFileChangeListener(this, defs.privatePropertiesFile);
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
private void safeAddFileChangeListener(@NonNull final File file) {
    try {
        FileUtil.addFileChangeListener(this, file);
    } catch (IllegalArgumentException iae) {
        LOG.log(Level.FINE, iae.getMessage());
    }
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
private void initListeners() {
    if (listens.compareAndSet(false, true)) {
        final JavaPlatformManager jpm = JavaPlatformManager.getDefault();
        jpm.addPropertyChangeListener(WeakListeners.propertyChange(
            this,
            jpm));
        J2SEProject j2sePrj = project.getLookup().lookup(J2SEProject.class);
        if (j2sePrj != null) {
            j2sePrj.evaluator().addPropertyChangeListener(this);
        } else {
            LOG.log(
               Level.WARNING,
               "No property evaluator provider in project {0}({1})", //NOI18N
               new Object[]{
                   ProjectUtils.getInformation(project).getDisplayName(),
                   FileUtil.getFileDisplayName(project.getProjectDirectory())
               });
        }

        final FileObject projectFolder = project.getProjectDirectory();
        if (projectFolder != null) {
            final File projectDir = FileUtil.toFile(projectFolder);
            if (projectDir != null) {
                final File cfgDir = new File(projectDir, CFG_PATH);   //NOI18N
                FileUtil.addFileChangeListener(this, cfgDir);
            }
        }
    }
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
public void addPropertyChangeListener(@NonNull final PropertyChangeListener listener) {
    Parameters.notNull("listener", listener);   //NOI18N
    if (!state.compareAndSet(0, 1)) {
        throw new IllegalStateException("Already in state: " + state.get());    //NOI18N
    }
    support.addPropertyChangeListener(listener);
    for (File f : listensOn) {
        FileUtil.addFileChangeListener(this, f);
    }
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
public void add(File f, boolean moduleRoot) {
    if (moduleRoot) {
        if (!moduleRoots.contains(f)) {
            moduleRoots.add(f);
            FileUtil.addFileChangeListener(this, f);
        }
    } else {
        if (!files.contains(f)) {
            files.add(f);
            FileUtil.addFileChangeListener(this, f);
        }
    }
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
private static void safeAddFileListener(
        @NonNull final File file,
        @NonNull final FileChangeListener listener) {
    try {
        FileUtil.addFileChangeListener(listener, file);
    } catch (IllegalArgumentException e) {
        LOG.log(
                Level.WARNING,
                "Cannot add listener to: {0}",      //NOI18N
                file);
    }
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
private boolean isModular(final FileObject javaFile) {
    //Module-info always modular
    if (MODULE_INFO.equals(javaFile.getName())) {
        return true;
    }
    //Try to find module-info
    final Pair<Reference<FileObject>,Reference<FileObject>> entry = rootCache.get();
    FileObject file, root;
    if (entry == null ||
            (file = entry.first().get()) == null || !file.equals(javaFile) ||
            (root = entry.second().get()) == null) {
        root = Optional.ofNullable(ClassPath.getClassPath(javaFile, ClassPath.SOURCE))
                .map((scp) -> scp.findOwnerRoot(javaFile))
                .orElseGet(() -> {
                    final String pkg = parsePackage(javaFile);
                    final String[] pkgElements = pkg.isEmpty() ?
                            new String[0] :
                            pkg.split("\\.");   //NOI18N
                    FileObject owner = javaFile.getParent();
                    for (int i = 0; owner != null && i < pkgElements.length; i++) {
                        owner = owner.getParent();
                    }
                    return owner;
                });
        rootCache.set(Pair.of(
                new WeakReference<>(javaFile),
                new WeakReference<>(root)));
        LOG.log(Level.FINE, "rootCache updated: {0}", root);  //NOI18N
    }
    if (root == null) {
        return false;
    }
    final Pair<Pair<Reference<FileObject>,File>,Boolean> modEntry = modCache.get();
    FileObject meKye;
    if (modEntry == null ||
            (meKye = modEntry.first().first().get()) == null || !meKye.equals(root)) {
        final FileObject modInfo = root.getFileObject(MODULE_INFO, JAVA_EXT);
        final boolean res =  modInfo != null && modInfo.isData();
        final Pair<Pair<Reference<FileObject>,File>,Boolean> newModEntry = Pair.of(
                Pair.of(new WeakReference<>(root), FileUtil.toFile(root)),
                res);
        if (modCache.compareAndSet(modEntry, newModEntry)) {
            if (modEntry != null && modEntry.first().second() != null) {
                FileUtil.removeFileChangeListener(this, modEntry.first().second());
            }
            if (newModEntry != null && newModEntry.first().second() != null) {
                FileUtil.addFileChangeListener(this, newModEntry.first().second());
            }
            LOG.log(Level.FINE, "modCache updated: {0}", res);  //NOI18N
        }
        return res;
    } else {
        return modEntry.second();
    }
}
 

import org.openide.filesystems.FileUtil; //导入方法依赖的package包/类
/** Tests FileChangeListener on folder. As declared in
 * {@link FileUtil#addFileChangeListener(org.openide.filesystems.FileChangeListener, java.io.File) }
 * - fileFolderCreated event is fired when the folder is created or a child folder created
 * - fileDataCreated event is fired when a child file is created
 * - fileDeleted event is fired when the folder is deleted or a child file/folder removed
 * - fileChanged event is fired when a child file is modified
 * - fileRenamed event is fired when the folder is renamed or a child file/folder is renamed
 * - fileAttributeChanged is fired when FileObject's attribute is changed
 */
public void testAddFileChangeListenerFolder() throws IOException {
    clearWorkDir();
    // test files: dir/file1, dir/subdir/subfile
    File rootF = getWorkDir();
    File dirF = new File(rootF, "dir");
    TestFileChangeListener fcl = new TestFileChangeListener();
    FileUtil.addFileChangeListener(fcl, dirF);
    // create dir
    FileObject dirFO = FileUtil.createFolder(dirF);
    assertEquals("Event not fired when folder created.", 1, fcl.check(EventType.FOLDER_CREATED));
    FileObject subdirFO = dirFO.createFolder("subdir");
    assertEquals("Event not fired when sub folder created.", 1, fcl.check(EventType.FOLDER_CREATED));

    // create file
    FileObject file1FO = dirFO.createData("file1");
    assertEquals("Event not fired when data created.", 1, fcl.check(EventType.DATA_CREATED));
    FileObject subfileFO = subdirFO.createData("subfile");
    assertEquals("Event fired when data in sub folder created.", 0, fcl.checkAll());

    // modify
    file1FO.getOutputStream().close();
    assertEquals("fileChanged event not fired.", 1, fcl.check(EventType.CHANGED));
    subfileFO.getOutputStream().close();
    assertEquals("Event fired when file sub folder modified.", 0, fcl.checkAll());

    // delete
    file1FO.delete();
    assertEquals("Event not fired when child file deleted.", 1, fcl.check(EventType.DELETED));
    subfileFO.delete();
    assertEquals("Event fired when child file in sub folder deleted.", 0, fcl.checkAll());
    subdirFO.delete();
    assertEquals("Event not fired when sub folder deleted.", 1, fcl.check(EventType.DELETED));
    dirFO.delete();
    assertEquals("Event not fired when folder deleted.", 1, fcl.check(EventType.DELETED));

    // rename
    dirFO = FileUtil.createFolder(dirF);
    file1FO = dirFO.createData("file1");
    subdirFO = dirFO.createFolder("subdir");
    subfileFO = subdirFO.createData("subfile");
    fcl.checkAll();
    FileLock lock = file1FO.lock();
    file1FO.rename(lock, "file1Renamed", null);
    lock.releaseLock();
    assertEquals("Event not fired when child file renamed.", 1, fcl.check(EventType.RENAMED));
    lock = subfileFO.lock();
    subfileFO.rename(lock, "subfileRenamed", null);
    lock.releaseLock();
    assertEquals("Event fired when child file in sub folder renamed.", 0, fcl.check(EventType.RENAMED));
    lock = subdirFO.lock();
    subdirFO.rename(lock, "subdirRenamed", null);
    lock.releaseLock();
    assertEquals("Event not fired when sub folder renamed.", 1, fcl.check(EventType.RENAMED));
    lock = dirFO.lock();
    dirFO.rename(lock, "dirRenamed", null);
    lock.releaseLock();
    assertEquals("Event not fired when sub folder renamed.", 1, fcl.check(EventType.RENAMED));
    fcl.printAll();
    assertEquals("No other events should be fired.", 0, fcl.checkAll());
}