final Enumeration<? extends FileObject> existingFileObjects(AbstractFolder fo) { class OnlyValidAndDeep implements org.openide.util.Enumerations.Processor<Reference<AbstractFolder>,FileObject> { public FileObject process(Reference<AbstractFolder> obj, Collection<Reference<AbstractFolder>> toAdd) { AbstractFolder file = obj.get(); if (file != null) { AbstractFolder[] arr = file.subfiles(); // make the array weak for (int i = 0; i < arr.length; i++) { toAdd.add(new WeakReference<AbstractFolder>(arr[i])); } return file.isValid() ? file : null; } return null; } } Reference<AbstractFolder> ref = new WeakReference<AbstractFolder>(fo); Enumeration<Reference<AbstractFolder>> singleEn = org.openide.util.Enumerations.<Reference<AbstractFolder>>singleton(ref); return org.openide.util.Enumerations.removeNulls( org.openide.util.Enumerations.queue(singleEn, new OnlyValidAndDeep()) ); }
/** Creates enumeration of existing subfiles in all tree * of files. * * @param rec should it be recursive or not * @return enumeration of AbstractFolders */ final Enumeration<AbstractFolder> existingSubFiles(boolean rec) { if (!rec) { return Enumerations.array(subfiles()); } else { class P implements org.openide.util.Enumerations.Processor<AbstractFolder, AbstractFolder> { public AbstractFolder process(AbstractFolder af, Collection<AbstractFolder> toAdd) { toAdd.addAll(Arrays.asList(af.subfiles())); return af; } } return Enumerations.queue(Enumerations.singleton(this), new P()); } }
return Enumerations.queue(Enumerations.array(getChildren()), new WithChildren());
/** * For the FileObject specified as parameter, returns the recursive enumeration * of existing children fileobjects (both folders and data). It doesn't create * any new FileObject instances. Direct children are at the begining of the enumeration. * @param fo the starting point for the recursive fileobject search * @return enumeration of currently existing fileobjects. */ protected final Enumeration existingFileObjects (FileObject fo) { class OnlyValidAndDeep implements org.openide.util.Enumerations.Processor { public Object process (Object obj, Collection toAdd) { if (obj instanceof Reference) { obj = ((Reference) obj).get(); } AbstractFileObject file = (AbstractFileObject)obj; if (file != null) { FileObject[] arr = file.subfiles (); // make the array weak for (int i = 0; i < arr.length; i++) { toAdd.add (new WeakReference (arr[i])); } return file.isValid () ? file : null; } return null; } } return org.openide.util.Enumerations.removeNulls (org.openide.util.Enumerations.queue ( org.openide.util.Enumerations.singleton (fo), new OnlyValidAndDeep () )); }
/** * For the FileObject specified as parameter, returns the recursive enumeration * of existing children fileobjects (both folders and data). It doesn't create * any new FileObject instances. Direct children are at the begining of the enumeration. * @param fo the starting point for the recursive fileobject search * @return enumeration of currently existing fileobjects. */ protected final Enumeration existingFileObjects (FileObject fo) { class OnlyValidAndDeep implements org.openide.util.Enumerations.Processor { public Object process (Object obj, Collection toAdd) { if (obj instanceof Reference) { obj = ((Reference) obj).get(); } AbstractFileObject file = (AbstractFileObject)obj; if (file != null) { FileObject[] arr = file.subfiles (); // make the array weak for (int i = 0; i < arr.length; i++) { toAdd.add (new WeakReference (arr[i])); } return file.isValid () ? file : null; } return null; } } return org.openide.util.Enumerations.removeNulls (org.openide.util.Enumerations.queue ( org.openide.util.Enumerations.singleton (fo), new OnlyValidAndDeep () )); }
/** Creates enumeration of existing subfiles in all tree * of files. * * @param rec should it be recursive or not * @return enumeration of AbstractFolders */ final Enumeration existingSubFiles (boolean rec) { if (!rec) { return Enumerations.array (subfiles ()); } else { class P implements org.openide.util.Enumerations.Processor { public Object process(Object o, Collection toAdd) { AbstractFolder af = (AbstractFolder)o; toAdd.addAll (Arrays.asList (af.subfiles ())); return o; } } return Enumerations.queue ( Enumerations.singleton (this), new P () ); } }
/** Creates enumeration of existing subfiles in all tree * of files. * * @param rec should it be recursive or not * @return enumeration of AbstractFolders */ final Enumeration existingSubFiles (boolean rec) { if (!rec) { return Enumerations.array (subfiles ()); } else { class P implements org.openide.util.Enumerations.Processor { public Object process(Object o, Collection toAdd) { AbstractFolder af = (AbstractFolder)o; toAdd.addAll (Arrays.asList (af.subfiles ())); return o; } } return Enumerations.queue ( Enumerations.singleton (this), new P () ); } }
/** Enumerate all children of this folder. If the children should be enumerated * recursively, first all direct children are listed; then children of direct subfolders; and so on. * * @param rec whether to enumerate recursively * @return enumeration of type <code>DataObject</code> */ public Enumeration children (final boolean rec) { if (!rec) { return children(); } class Processor implements org.openide.util.Enumerations.Processor { /** @param o processes object by adding its children to the queue */ public Object process (Object o, Collection toAdd) { DataObject dataObj = (DataObject)o; if (rec && dataObj instanceof DataFolder) { toAdd.addAll (Arrays.asList (((DataFolder)dataObj).getChildren())); } return o; } } Enumeration en = org.openide.util.Enumerations.queue ( org.openide.util.Enumerations.array (getChildren ()), new Processor () ); return en; }
/** Recursively enumerate all children of this folder to some specified depth. * All direct children are listed; then children of direct subfolders; and so on. * * @param root the starting directory * @param depth the search limit * @param onlyWritables only recurse into wriable directories * @return enumeration of type <code>FileObject</code> */ public static Enumeration<FileObject> getChildrenToDepth(final FileObject root, final int depth, final boolean onlyWritables) { class WithChildren implements Enumerations.Processor<FileObject, FileObject> { private int rootDepth; public WithChildren(final int rootDepth) { this.rootDepth = rootDepth; } public FileObject process(FileObject fo, Collection<FileObject> toAdd) { if (!onlyWritables || (onlyWritables && fo.canWrite())) { if (fo.isFolder() && (getDepth(fo) - rootDepth) < depth) { toAdd.addAll(Arrays.asList(fo.getChildren())); } } return fo; } } return Enumerations.queue( Enumerations.array(root.getChildren()), new WithChildren(getDepth(root)) ); }
Enumeration en = org.openide.util.Enumerations.queue (
Enumeration en = org.openide.util.Enumerations.queue (
Enumeration<Enumeration<Pair>> en = Enumerations.queue(
return Enumerations.queue( Enumerations.array(getChildren()), new WithChildren ()
return Enumerations.queue( Enumerations.array(getChildren()), new WithChildren ()