<change id="getSymbols">

             <api name="general"/>

             <summary>Added several methods to support Java 8 features.</summary>

             <version major="0" minor="114"/>

             <date day="25" month="2" year="2013"/>

             <author login="jlahoda"/>

            <compatibility addition="yes" binary="compatible" deletion="no" deprecation="no" modification="no" semantic="compatible" source="compatible"/>

             <description>

                 Added <code>ClassIndex.getDeclaredSymbols</code>.

             </description>

             <class package="org.netbeans.api.java.source" name="ClassIndex"/>

             <issue number="227607"/>

        </change>

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

     * Returns descriptions of symbols found on the given classpath and matching the additional criteria.

     * @param name case sensitive prefix, case insensitive prefix, exact simple name,

     * camel case or regular expression depending on the kind parameter.

     * @param kind of the name {@see NameKind}

     * @param scope to search in {@see SearchScope}

     * @return iterable of {@link Symbols} describing found symbols matching the specified criteria.

     * It may return null when the caller is a CancellableTask<CompilationInfo> and is cancelled

     * inside call of this method.

     * @since 0.114

     */

    public @NullUnknown Iterable<Symbols> getDeclaredSymbols(

            final @NonNull String name,

            final @NonNull NameKind kind,

            final @NonNull Set<? extends SearchScopeType> scope) {

        Parameters.notNull("name", name);

        Parameters.notNull("kind", kind);

        final Map<ElementHandle<TypeElement>,Set<String>> result = new HashMap<ElementHandle<TypeElement>,Set<String>>();

        final Iterable<? extends ClassIndexImpl> queries = this.getQueries (scope);        

        final Convertor<Document, ElementHandle<TypeElement>> thConvertor = DocumentUtil.elementHandleConvertor();

        try {

            for (ClassIndexImpl query : queries) {

                try {

                    query.getDeclaredElements(

                        name,

                        kind,

                        thConvertor,

                        result);

                } catch (Index.IndexClosedException e) {

                    logClosedIndex (query);

                } catch (IOException e) {

                    Exceptions.printStackTrace(e);

                }

            }

            if (LOGGER.isLoggable(Level.FINE)) {

                LOGGER.log(

                        Level.FINE,

                        "ClassIndex.getDeclaredTypes returned {0} elements\n",  //NOI18N

                        result.size());

            }

            List<Symbols> finalResult = new ArrayList<Symbols>();

            for (Entry<ElementHandle<TypeElement>, Set<String>> e : result.entrySet()) {

                finalResult.add(new Symbols(e.getKey(), e.getValue()));

            }

            return Collections.unmodifiableList(finalResult);

        } catch (InterruptedException e) {

            return null;

        }

    }

    /**Description of found symbols (methods, constructors, fields) for one enclosing type.

     * Returned from {@link #getDeclaredSymbols(java.lang.String, org.netbeans.api.java.source.ClassIndex.NameKind, java.util.Set) }.

     * 

     * @since 0.114

     */

    public static final class Symbols {

        private final ElementHandle<TypeElement> enclosingType;

        private final Set<String> symbols;

        Symbols(ElementHandle<TypeElement> enclosingType, Set<String> symbols) {

            this.enclosingType = enclosingType;

            this.symbols = symbols;

        }

        /**The type that contains some symbols matching the required criterie.

         * 

         * @return enclosing type

         */

        public ElementHandle<TypeElement> getEnclosingType() {

            return enclosingType;

        }

        /**The simple names of all symbols matching the criteria inside the given enclosing type.

         * 

         * @return simple names of matching symbols

         */

        public Set<String> getSymbols() {

            return symbols;

        }

    }

    /**

import org.netbeans.api.java.source.ClassIndex.NameKind;

import org.netbeans.api.java.source.ClassIndex.Symbols;

    public void testFindSymbols() throws Exception {

        final FileObject wd = FileUtil.toFileObject(getWorkDir());

        final FileObject root = FileUtil.createFolder(wd,"src");    //NOI18N

        sourcePath = ClassPathSupport.createClassPath(root);

        compilePath = ClassPathSupport.createClassPath(new URL[0]);

        bootPath = JavaPlatformManager.getDefault().getDefaultPlatform().getBootstrapLibraries();

        final FileObject t1 = createJavaFile(

                root,

                "test",                                          //NOI18N

                "Test",                                          //NOI18N

                "package test;\n"+                               //NOI18N

                "public class Test { private void foo() { } }"); //NOI18N

        final FileObject t2 = createJavaFile(

                root,

                "test",                                          //NOI18N

                "foo",                                           //NOI18N

                "package test;\n"+                               //NOI18N

                "public class foo {\n"+                          //NOI18N

                "}");                                            //NOI18N

        IndexingManager.getDefault().refreshIndexAndWait(root.toURL(), null);

        final ClassIndex ci = ClasspathInfo.create(bootPath, compilePath, sourcePath).getClassIndex();

        assertNotNull(ci);

        Iterable<Symbols> result = ci.getDeclaredSymbols("foo", NameKind.SIMPLE_NAME,

            EnumSet.<ClassIndex.SearchScope>of(ClassIndex.SearchScope.SOURCE));

        Set<String> actualResult = new HashSet<String>();

        for (Symbols s : result) {

            actualResult.add(s.getEnclosingType().getQualifiedName() + ":" + s.getSymbols().toString());

        }

        assertEquals(new HashSet<String>(Arrays.asList("test.foo:[foo]", "test.Test:[foo]")), actualResult);

    }