public JavaDocBuilder() 
{
        this(new DefaultDocletTagFactory());
}

 public JavaDocBuilder(DocletTagFactory docletTagFactory) 
{
        this.docletTagFactory = docletTagFactory;
        classLibrary = new ClassLibrary(this);
        classLibrary.addDefaultLoader();
}

 public JavaSource addSource(Reader reader) 
{
        return addSource(reader, "UNKNOWN SOURCE");
}

 public JavaSource addSource(File file) throws IOException, FileNotFoundException 
{
        return addSource(file.toURL());
}

 public JavaSource addSource(URL url) throws IOException, FileNotFoundException 
{
        JavaSource source = addSource(new InputStreamReader(url.openStream(),encoding), url.toExternalForm());
        source.setURL(url);
        return source;
}

 public JavaSource addSource(Reader reader,
    String sourceInfo) 
{
        ModelBuilder builder = new ModelBuilder(classLibrary, docletTagFactory);
        Lexer lexer = new JFlexLexer(reader);
        Parser parser = new Parser(lexer, builder);
        parser.setDebugLexer(debugLexer);
        parser.setDebugParser(debugParser);
        try {
            parser.parse();
        } catch (ParseException e) {
            e.setSourceInfo(sourceInfo);
            throw e;
        }
        JavaSource source = builder.getSource();
        sources.add(source);
        addClasses(source);
        return source;
}

 public  void addSourceTree(File file) 
{
        DirectoryScanner scanner = new DirectoryScanner(file);
        scanner.addFilter(new SuffixFilter(".java"));
        scanner.scan(new FileVisitor() {
            public void visitFile(File currentFile) {
                try {
                    addSource(currentFile);
                } catch (UnsupportedEncodingException e) {
					throw new RuntimeException("Unsupported encoding : " + encoding);
                } catch (IOException e) {
                    throw new RuntimeException("Cannot read file : " + currentFile.getName());
                }
            }
        });
}

 public JavaClass getClassByName(String name) 
{
        if (name == null) {
            return null;
        }
        JavaClass result = (JavaClass) classes.get(name);
        if (result == null) {
            // Try to make a binary class out of it
            result = createBinaryClass(name);
            if (result != null) {
                addClass(result);
            } else {
                result = createUnknownClass(name);
            }
        }
        return result;
}

 public ClassLibrary getClassLibrary() 
{
        return classLibrary;
}

 public JavaClass[] getClasses() 
{
        Set resultSet = new HashSet();
        JavaSource[] javaSources = getSources();
        for (int i = 0; i <  javaSources.length; i++) {
            JavaSource javaSource = javaSources[i];
            addClassesRecursive(javaSource, resultSet);
        }
        JavaClass[] result = (JavaClass[]) resultSet.toArray(new JavaClass[resultSet.size()]);
        return result;
}

Returns all the classes found in all the sources, including inner classes and "extra" classes (multiple outer classes defined in the same source file).

 public JavaSource[] getSources() 
{
        return (JavaSource[]) sources.toArray(new JavaSource[sources.size()]);
}

 public static JavaDocBuilder load(File file) throws IOException 
{
        FileInputStream fis = new FileInputStream(file);
        ObjectInputStream in = new ObjectInputStream(fis);
        JavaDocBuilder builder = null;
        try {
            builder = (JavaDocBuilder) in.readObject();
        } catch (ClassNotFoundException e) {
            throw new Error("Couldn't load class : " + e.getMessage());
        } finally {
            in.close();
            fis.close();
        }
        return builder;
}

Note that after loading JavaDocBuilder classloaders need to be re-added.

 public  void save(File file) throws IOException 
{
        FileOutputStream fos = new FileOutputStream(file);
        ObjectOutputStream out = new ObjectOutputStream(fos);
        try {
            out.writeObject(this);
        } finally {
            out.close();
            fos.close();
        }
}

 public List search(Searcher searcher) 
{
        List results = new LinkedList();
        for (Iterator iterator = classLibrary.all().iterator(); iterator.hasNext();) {
            String clsName = (String) iterator.next();
            JavaClass cls = getClassByName(clsName);
            if (searcher.eval(cls)) {
                results.add(cls);
            }
        }
        return results;
}

 public  void setDebugLexer(boolean debugLexer) 
{
        this.debugLexer = debugLexer;
}

Forces QDox to dump tokens returned from lexer to System.err.

 public  void setDebugParser(boolean debugParser) 
{
        this.debugParser = debugParser;
}

Forces QDox to dump parser states to System.out.

 public  void setEncoding(String encoding) 
{
        this.encoding = encoding;
}