Java Code Examples for org.openide.util.Enumerations#array()

/** 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());
    }
}
 

/** Computes a list of FileObjects in the right order
* that can represent this instance.
*
* @param name of resource to find
* @return enumeration of FileObject
*/
Enumeration<FileObject> delegates(final String name) {
    Enumeration<FileSystem> en = Enumerations.array(systems);

    // XXX order (stably) by weight
    class Resources implements Enumerations.Processor<FileSystem, FileObject> {
        public @Override FileObject process(FileSystem fs, Collection<FileSystem> ignore) {
            if (fs == null) {
                return null;
            } else {
                return findResourceOn(fs, name);
            }
        }
    }

    return Enumerations.filter(en, new Resources());
}
 

private Enumeration<FileChangeListener> getListeners() {
    synchronized (EVENT_SUPPORT_LOCK) {
        if (eventSupport == null) {
            return Enumerations.empty();
        }
        return Enumerations.array(eventSupport.getListeners(FileChangeListener.class));
    }
}
 

private void startLoading() {
    LOG.fine("start loading doc"); //NOI18N
    Directive[] dirs = Directive.values();
    directives = Enumerations.array(dirs);
    progress = ProgressHandleFactory.createHandle(Bundle.doc_building());
    progress.start(dirs.length);

    buildDoc();
}
 

@NonNull
@Override
public Iterable<JavaFileObject> getFiles(
        @NonNull final String folderName,
        @NullAllowed final ClassPath.Entry entry,
        @NullAllowed final Set<JavaFileObject.Kind> kinds,
        @NullAllowed final JavaFileFilterImplementation filter,
        final boolean recursive) throws IOException {
    final FileObject folder = root.getFileObject(folderName);
    if (folder == null || !(entry == null || entry.includes(folder))) {
        return Collections.<JavaFileObject>emptySet();
    }
    final Enumeration<? extends FileObject> children;
    final List<JavaFileObject> result;
    if (recursive) {
        children = Enumerations.filter(
                folder.getChildren(recursive),
                (p,x)->{
                    return  !p.isFolder() && isInJavaPackage(folder,p) ?
                            p :
                            null;
                });
        result = new ArrayList<>(/*unknown size*/);
    } else {
        final FileObject[] chlds = folder.getChildren();
        children = Enumerations.array(chlds);
        result = new ArrayList<>(chlds.length);
    }
    while (children.hasMoreElements()) {
        final FileObject fo = children.nextElement();
        if (fo.isData() && (entry == null || entry.includes(fo))) {
            final Kind kind = FileObjects.getKind(fo.getExt());
            if (kinds == null || kinds.contains (kind)) {
                JavaFileObject file;
                if (kind == Kind.CLASS) {
                    file = FileObjects.fileObjectFileObject(fo, root, filter, null);
                } else {
                    file = FileObjects.sourceFileObject(fo, root, filter,false);
                }
                result.add(file);
            }
        }
    }
    return result;
}
 

protected Enumeration<DataLoader> loaders() {
    return Enumerations.<DataLoader>array(new DataLoader[] { 
        SimpleLoader.getLoader(SimpleLoader.class),
        TwoPartLoader.getLoader(TwoPartLoader.class),
    });
}
 

protected Enumeration<DataLoader> loaders() {
    return Enumerations.<DataLoader>array(new DataLoader[] { 
        SimpleLoader.getLoader(SimpleLoader.class),
    });
}
 

protected Enumeration<DataLoader> loaders() {
    return Enumerations.<DataLoader>array(new DataLoader[] { 
        SimpleLoader.getLoader(SimpleLoader.class),
    });
}
 

protected Enumeration<DataLoader> loaders() {
    return Enumerations.<DataLoader>array(new DataLoader[] { 
        TwoPartLoader.getLoader(TwoPartLoader.class),
        SimpleLoader.getLoader(SimpleLoader.class),
    });
}
 

protected Enumeration<DataLoader> loaders() {
    return Enumerations.<DataLoader>array(new DataLoader[] { 
        TwoPartLoader.getLoader(TwoPartLoader.class),
        SimpleLoader.getLoader(SimpleLoader.class),
    });
}
 

protected Enumeration<DataLoader> loaders() {
    return Enumerations.<DataLoader>array(new DataLoader[] { 
        SimpleLoader.getLoader(SimpleLoader.class),
        TwoPartLoader.getLoader(TwoPartLoader.class),
    });
}
 

protected Enumeration loaders() {
    return Enumerations.array(ARR);
}
 

@Override
protected Enumeration loaders() {
    return Enumerations.array(ARR);
}
 

/** Get the nodes as an enumeration.
* @return enumeration of nodes
*/
public final Enumeration<Node> nodes() {
    return Enumerations.array(getNodes());
}
 

protected <T> Enumeration<T> array(T[] arr) {
    return Enumerations.array(arr);
}
 

protected Enumeration<DataLoader> loaders() {
    return Enumerations.<DataLoader>array(new DataLoader[] { 
        TwoPartLoader.getLoader(TwoPartLoader.class),
        SimpleLoader.getLoader(SimpleLoader.class),
    });
}