public synchronized Map<FileNaming, Integer> refresh( final FileNaming folderName, Runnable[] task) { Map<FileNaming, Integer> retVal = new HashMap<FileNaming, Integer>(); Set<FileNaming> e = new HashSet<FileNaming>(getExisting(false)); Set<FileNaming> nE = new HashSet<FileNaming>(getNotExisting(false)); if (isStatus(ChildrenSupport.SOME_CHILDREN_CACHED)) { Set<FileNaming> existingToCheck = new HashSet<FileNaming>(e); for (FileNaming fnToCheck : existingToCheck) { FileNaming fnRescanned = rescanChild(folderName, fnToCheck.getName(), true); if (fnRescanned == null) { retVal.put(fnToCheck, ChildrenCache.REMOVED_CHILD); } } Set<FileNaming> notExistingToCheck = new HashSet<FileNaming>(nE); for (FileNaming fnToCheck : notExistingToCheck) { assert fnToCheck != null; FileNaming fnRescanned = rescanChild(folderName, fnToCheck.getName(), true); if (fnRescanned != null) { retVal.put(fnToCheck, ChildrenCache.ADDED_CHILD); } } } else if (isStatus(ChildrenSupport.ALL_CHILDREN_CACHED)) { retVal = rescanChildren(folderName, true, task); } return retVal; }
private synchronized void addChild(final FileNaming folderName, final FileNaming childName) { assert childName != null; assert childName.getParent().equals(folderName) : "childName: " + childName.getFile() + " folderName: " + folderName.getFile(); getExisting().add(childName); getNotExisting().remove(childName); }
private static Set<FileNaming> deepMinus(Set<FileNaming> base, Set<FileNaming> minus) { HashMap<FileNaming, FileNaming> detract = new HashMap<FileNaming, FileNaming>(base.size() * 2); for (FileNaming fn : base) { detract.put(fn, fn); } assert minus != null; for (FileNaming mm : minus) { FileNaming orig = detract.remove(mm); if (orig != null && orig.isFile() != mm.isFile()) { detract.put(orig, orig); } } return detract.keySet(); }
private FileNaming rescanChild( final FileNaming folderName, final String childName, boolean ignoreCache) { final File folder = folderName.getFile(); final File child = new File(folder, childName); final FileInfo fInfo = new FileInfo(child); FileNaming retval = (fInfo.isConvertibleToFileObject()) ? NamingFactory.fromFile(folderName, child, ignoreCache) : null; if (retval != null) { addChild(folderName, retval); } else { FileName fChild = new FileName(folderName, child, null) { @Override public boolean isDirectory() { return false; } @Override public boolean isFile() { return false; } }; removeChild(folderName, fChild); } return retval; }
public synchronized void removeChild(final FileNaming folderName, final FileNaming childName) { assert childName != null; getExisting().remove(childName); if (childName.getParent().equals(folderName)) { getNotExisting().add(childName); } }
private FileNaming lookupChildInCache( final FileNaming folder, final String childName, boolean lookupExisting) { final File f = new File(folder.getFile(), childName); final Integer id = NamingFactory.createID(f); class FakeNaming implements FileNaming { public FileNaming lastEqual; public String getName() { return childName; } public FileNaming getParent() { return folder; } public boolean isRoot() { return false; } public File getFile() { return f; } public Integer getId() { return id; } public FileNaming rename(String name, ProvidedExtensions.IOHandler h) { // not implemented, as it will not be called throw new IllegalStateException(); } @Override public boolean equals(Object obj) { if (hashCode() == obj.hashCode() && getName().equals(((FileNaming) obj).getName())) { assert lastEqual == null : "Just one can be there"; // NOI18N if (obj instanceof FileNaming) { lastEqual = (FileNaming) obj; } return true; } return false; } @Override public int hashCode() { return id.intValue(); } public boolean isFile() { return this.getFile().isFile(); } public boolean isDirectory() { return !isFile(); } } FakeNaming fake = new FakeNaming(); final Set<FileNaming> cache = (lookupExisting) ? getExisting(false) : getNotExisting(false); if (cache.contains(fake)) { assert fake.lastEqual != null : "If cache contains the object, we set lastEqual"; // NOI18N assert fake.lastEqual.getName().equals(childName) : "childName: " + childName + " equals: " + fake.lastEqual; return fake.lastEqual; } else { return null; } }
private Map<FileNaming, Integer> rescanChildren( final FileNaming folderName, final boolean ignoreCache, Runnable[] task) { final Map<FileNaming, Integer> retval = new IdentityHashMap<FileNaming, Integer>(); final File folder = folderName.getFile(); assert folderName.getFile().getAbsolutePath().equals(folderName.toString()); class IOJob implements Runnable { boolean folderExists; Set<FileNaming> newChildren; @Override public void run() { final File[] children = folder.listFiles(); if (children != null) { newChildren = new LinkedHashSet<FileNaming>(); for (int i = 0; i < children.length; i++) { final FileInfo fInfo = new FileInfo(children[i], 1); if (fInfo.isConvertibleToFileObject()) { FileNaming child = NamingFactory.fromFile(folderName, children[i], ignoreCache); newChildren.add(child); } } } else { folderExists = folder.exists(); // #150009 - children == null -> folder does not exists, or an I/O error occurs // folder.listFiles() failed with I/O exception - do not remove children } } } IOJob job; if (task[0] instanceof IOJob) { job = (IOJob) task[0]; } else { task[0] = new IOJob(); return null; } if (job.newChildren == null) { if (job.folderExists) { // #150009 - children == null -> folder does not exists, or an I/O // error occurs // folder.listFiles() failed with I/O exception - do not remove children return retval; } job.newChildren = new LinkedHashSet<FileNaming>(); } Set<FileNaming> deleted = deepMinus(getExisting(false), job.newChildren); for (FileNaming fnRem : deleted) { removeChild(folderName, fnRem); retval.put(fnRem, ChildrenCache.REMOVED_CHILD); } Set<FileNaming> added = deepMinus(job.newChildren, getExisting(false)); for (FileNaming fnAdd : added) { addChild(folderName, fnAdd); retval.put(fnAdd, ChildrenCache.ADDED_CHILD); } return retval; }