Java example source code file (GenDocletBeanInfo.java)

This example Java source code file (GenDocletBeanInfo.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

bean, classdoc, debug, debug\=false, debug\=true, docbeaninfo, enumeration, exception, genswingbeaninfo, hashmap, hashtable, javabean, javadoc, string, stringbuffer, stringtokenizer, tag, util

The GenDocletBeanInfo.java Java example source code

/*
 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package build.tools.swingbeaninfo;

import com.sun.javadoc.ClassDoc;
import com.sun.javadoc.MethodDoc;
import com.sun.javadoc.RootDoc;
import com.sun.javadoc.Tag;

import java.beans.Introspector;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.HashMap;
import java.util.StringTokenizer;

/**
 * Properties supported and tag syntax:
 *
 * @beaninfo
 *      bound: flag
 *      constrained: flag
 *      expert: flag
 *      hidden: flag
 *      preferred: flag
 *      description: string
 *      displayname: string
 *      propertyeditorclass: string (with dots: foo.bar.MyPropertyEditor
 *      customizerclass: string (w/dots: foo.bar.MyCustomizer)
 *      attribute: key1 value1
 *      attribute: key2 value2
 *
 * TODO: getValue and genDocletInfo needs some cleaning.
 *
 * @author Hans Muller
 * @author Rich Schiavi
 * @author Mark Davidson
 */
public class GenDocletBeanInfo {

    static String[] ATTRIBUTE_NAMES = { "bound",
                                     "constrained",
                                     "expert",
                                     "hidden",
                                     "preferred",
                                     "displayname",
                                     "propertyeditorclass",
                                     "customizerclass",
                                     "displayname",
                                     "description",
                                     "enum",
                                     "attribute" };
    private static boolean DEBUG = false;

    private static String fileDir = "";
    private static String templateDir = "";

    public static final String TRUE = "true";
    public static final String FALSE = "false";

    /**
     * Method called from the javadoc environment to determint the options length.
     * Doclet options:
     *      -t template location
     *      -d outputdir
     *      -x true Enable debug output.
     */
    public static int optionLength(String option) {
        // remind: this needs to be cleaned up
        if (option.equals("-t"))
            return 2;
        if (option.equals("-d"))
            return 2;
        if (option.equals("-x"))
            return 2;
        return 0;
    }

    /** @beaninfo
     * bound:true
     * constrained:false
     * expert:true
     * hidden:true
     * preferred:false
     * description: the description of this method can
     *              do all sorts of funky things. if it \n
     *              is indented like this, we have to remove
     *              all char spaces greater than 2 and also any hard-coded \n
     *              newline characters and all newlines
     * displayname: theString
     * propertyeditorclass: foo.bar.MyPropertyEditorClass
     * customizerclass: foo.bar.MyCustomizerClass
     * attribute:key1 value1
     * attribute: key2  value2
     *
     */
    public static boolean start(RootDoc doc) {
        readOptions(doc.options());

        if (templateDir.length() == 0) {
            System.err.println("-t option not specified");
            return false;
        }
        if (fileDir.length() == 0) {
            System.err.println("-d option not specified");
            return false;
        }

        GenSwingBeanInfo generator = new GenSwingBeanInfo(fileDir, templateDir, DEBUG);
        Hashtable dochash = new Hashtable();
        DocBeanInfo dbi;

        /* "javadoc Foo.java Bar.java" will return:
        *         "Foo Foo.I1 Foo.I2 Bar Bar.I1 Bar.I2"
        * i.e., with all the innerclasses of classes specified in the command
        * line.  We don't want to generate BeanInfo for any of these inner
        * classes, so we ignore these by remembering what the last outer
        * class was.  A hack, I admit, but makes the build faster.
        */
        String previousClass = null;

        ClassDoc[] classes = doc.classes();

        for (int cnt = 0; cnt < classes.length; cnt++) {
            String className = classes[cnt].qualifiedName();
            if (previousClass != null &&
                className.startsWith(previousClass) &&
                className.charAt(previousClass.length()) == '.') {
                continue;
            }
            previousClass = className;

            // XXX - debug
            System.out.println("\n>>> Generating beaninfo for " + className + "...");

            // Examine the javadoc tags and look for the the @beaninfo tag
            // This first block looks at the javadoc for the class
            Tag[] tags = classes[cnt].tags();
            for (int i = 0; i < tags.length; i++) {
                if (tags[i].kind().equalsIgnoreCase("@beaninfo")) {
                    if (DEBUG)
                       System.out.println("GenDocletBeanInfo: found @beaninfo tagged Class: " + tags[i].text());
                    dbi = genDocletInfo(tags[i].text(), classes[cnt].name());
                    dochash.put(dbi.name, dbi);
                    break;
                }
            }

            // This block looks at the javadoc for the class methods.
            int startPos = -1;
            MethodDoc[] methods = classes[cnt].methods();
            for (int j = 0; j < methods.length; j++) {
                // actually don't "introspect" - look for all
                // methods with a @beaninfo tag
                tags = methods[j].tags();
                for (int x = 0; x < tags.length; x++){
                    if (tags[x].kind().equalsIgnoreCase("@beaninfo")){
                        if ((methods[j].name().startsWith("get")) ||
                            (methods[j].name().startsWith("set")))
                            startPos = 3;
                        else if (methods[j].name().startsWith("is"))
                            startPos = 2;
                        else
                            startPos = 0;
                        String propDesc =
                            Introspector.decapitalize((methods[j].name()).substring(startPos));
                        if (DEBUG)
                            System.out.println("GenDocletBeanInfo: found @beaninfo tagged Method: " + tags[x].text());
                        dbi = genDocletInfo(tags[x].text(), propDesc);
                        dochash.put(dbi.name, dbi);
                        break;
                    }
                }
            }
            if (DEBUG) {
                // dump our classes doc beaninfo
                System.out.println(">>>>DocletBeanInfo for class: " + classes[cnt].name());
                Enumeration e = dochash.elements();
                while (e.hasMoreElements()) {
                    DocBeanInfo db = (DocBeanInfo)e.nextElement();
                    System.out.println(db.toString());
                }
            }

            // Use the generator to create the beaninfo code for the class.
            generator.genBeanInfo(classes[cnt].containingPackage().name(),
                                        classes[cnt].name(), dochash);
            // reset the values!
            dochash.clear();
        } // end for loop
        return true;
    }

    /**
     * Reads the command line options.
     * Side Effect, sets class variables templateDir, fileDir and DEBUG
     */
    private static void readOptions(String[][] options)  {
        // Parse the command line args
        for (int i = 0; i < options.length; i++){
            if (options[i][0].equals("-t")) {
                templateDir = options[i][1];
            } else if (options[i][0].equals("-d")) {
                fileDir = options[i][1];
            } else if (options[i][0].equals("-x")){
                if (options[i][1].equals("true"))
                    DEBUG=true;
                else
                    DEBUG=false;
            }
        }
    }

    /**
     * Create a "BeanInfo" data structure from the tag. This is a data structure
     * which contains all beaninfo data for a method or a class.
     *
     * @param text All the text after the @beaninfo tag.
     * @param name Name of the property i.e., mnemonic for setMnemonic
     */
    private static DocBeanInfo genDocletInfo(String text, String name) {
        int beanflags = 0;
        String desc = "null";
        String displayname = "null";
        String propertyeditorclass = "null";
        String customizerclass = "null";
        String value = "null";
        HashMap attribs = null;
        HashMap enums = null;

        int index;

        for (int j = 0; j < ATTRIBUTE_NAMES.length; j++){
            index = 0;
            if ((index = text.indexOf(ATTRIBUTE_NAMES[j])) != -1){
                value = getValue((text).substring(index),ATTRIBUTE_NAMES[j]);

                if (ATTRIBUTE_NAMES[j].equalsIgnoreCase("attribute")) {
                    attribs = getAttributeMap(value, " ");
                }
                if (ATTRIBUTE_NAMES[j].equalsIgnoreCase("enum")) {
                    enums = getAttributeMap(value, " \n");
                }
                else if (ATTRIBUTE_NAMES[j].equals("displayname")){
                    displayname = value;
                }
                else if (ATTRIBUTE_NAMES[j].equalsIgnoreCase("propertyeditorclass")) {
                    propertyeditorclass = value;
                }
                else if (ATTRIBUTE_NAMES[j].equalsIgnoreCase("customizerclass")){
                    customizerclass = value;
                }
                else if ((ATTRIBUTE_NAMES[j].equalsIgnoreCase("bound"))
                         && (value.equalsIgnoreCase(TRUE)))
                    beanflags = beanflags | DocBeanInfo.BOUND;
                else if ((ATTRIBUTE_NAMES[j].equalsIgnoreCase("expert"))
                         && (value.equalsIgnoreCase(TRUE)))
                    beanflags = beanflags | DocBeanInfo.EXPERT;
                else if ((ATTRIBUTE_NAMES[j].equalsIgnoreCase("constrained"))
                         && (value.equalsIgnoreCase(TRUE)))
                    beanflags = beanflags | DocBeanInfo.CONSTRAINED;
                else if ((ATTRIBUTE_NAMES[j].equalsIgnoreCase("hidden"))
                         && (value.equalsIgnoreCase(TRUE)))
                    beanflags = beanflags | DocBeanInfo.HIDDEN;
                else if ((ATTRIBUTE_NAMES[j].equalsIgnoreCase("preferred"))
                         && (value.equalsIgnoreCase(TRUE)))
                    beanflags = beanflags | DocBeanInfo.PREFERRED;
                else if (ATTRIBUTE_NAMES[j].equalsIgnoreCase("description")){
                    desc = value;
                }
            }
        }
        /** here we create our doclet-beaninfo data structure, which we read in
         *  later if it has anything worthwhile
         */

        // Construct a new Descriptor class
        return new DocBeanInfo(name, beanflags, desc,displayname,
                                         propertyeditorclass, customizerclass,
                                         attribs, enums);
    }

    /**
     * Parses the substring and returns the cleaned up value for the attribute.
     * @param substring Full String of the attrib tag.
     *       i.e., "attribute: visualUpdate true" will return "visualUpdate true";
     */
    private static String getValue(String substring, String prop) {
        StringTokenizer t;
        String value = "null";

        try {
            /** if the ATTRIBUTE_NAMES is NOT the description, then we
             *  parse until newline
             *  if it is the description we read until the next token
             *  and then look for a match in the last MAXMATCH index
             *  and truncate the description
             *  if it is the attribute we wead until no more
             */
            if (prop.equalsIgnoreCase("attribute")){
                StringBuffer tmp = new StringBuffer();
                try {
                    t = new StringTokenizer(substring, " :\n");
                    t.nextToken().trim();//the prop
                    // we want to return : key1 value1 key2 value2
                    while (t.hasMoreTokens()){
                        tmp.append(t.nextToken().trim()).append(" ");
                        tmp.append(t.nextToken().trim()).append(" ");
                        String test = t.nextToken().trim();
                        if (!(test.equalsIgnoreCase("attribute")))
                            break;
                    }
                } catch (Exception e){
                }
                value = tmp.toString();
            }
            else if (prop.equalsIgnoreCase("enum")){
                t = new StringTokenizer(substring, ":");
                t.nextToken().trim(); // the prop we already know
                StringBuffer tmp = new StringBuffer(t.nextToken().trim());
                for (int i = 0; i < ATTRIBUTE_NAMES.length; i++){
                    if (tmp.toString().endsWith(ATTRIBUTE_NAMES[i])){
                        int len = ATTRIBUTE_NAMES[i].length();
                        // trim off that
                        tmp.setLength(tmp.length() - len);
                        break;
                    }
                }
                value = tmp.toString();
            }
            else if (prop.equalsIgnoreCase("description")){
                t = new StringTokenizer(substring, ":");
                t.nextToken().trim(); // the prop we already know
                StringBuffer tmp = new StringBuffer(t.nextToken().trim());
                for (int i = 0; i < ATTRIBUTE_NAMES.length; i++){
                    if (tmp.toString().endsWith(ATTRIBUTE_NAMES[i])){
                        int len = ATTRIBUTE_NAMES[i].length();
                        // trim off that
                        tmp.setLength(tmp.length() - len);
                        break;
                    }
                }
                value = hansalizeIt(tmp.toString());
            }
            else {
                // Single value properties like bound: true
                t = new StringTokenizer(substring, ":\n");
                t.nextToken().trim(); // the prop we already know
                value = t.nextToken().trim();
            }

            // now we need to look for a match of any of the
            // property

            return value;
        }
        catch (Exception e){
            return "invalidValue";
        }
    }

    /**
     * Creates a HashMap containing the key value pair for the parsed values
     * of the "attributes" and "enum" tags.
     * ie. For attribute value: visualUpdate true
     *     The HashMap will have key: visualUpdate, value: true
     */
    private static HashMap getAttributeMap(String str, String delim)  {
        StringTokenizer t = new StringTokenizer(str, delim);
        HashMap map = null;
        String key;
        String value;

        int num = t.countTokens()/2;
        if (num > 0)  {
            map = new HashMap();
            for (int i = 0; i < num; i++) {
                key = t.nextToken().trim();
                value = t.nextToken().trim();
                map.put(key, value);
            }
        }
        return map;
    }

    // looks for extra spaces, \n hard-coded and invisible,etc
    private static String hansalizeIt(String from){
        char [] chars = from.toCharArray();
        int len = chars.length;
        int toss = 0;

        // remove double spaces
        for (int i = 0; i < len; i++){
            if ((chars[i] == ' ')) {
                if (i+1 < len) {
                    if ((chars[i+1] == ' ' ) || (chars[i+1] == '\n'))
                        {
                            --len;
                            System.arraycopy(chars,i+1,chars,i,len-i);
                            --i;
                        }
                }
            }

            if (chars[i] == '\n'){
                chars[i] = ' ';
                i -= 2;
            }

            if (chars[i] == '\\') {
                if (i+1 < len) {
                    if (chars[i+1] == 'n'){
                        chars[i+1] = ' ';
                        --len;
                        System.arraycopy(chars,i+1, chars,i, len-i);
                        --i;
                    }
                }
            }
        }
        return new String(chars,0,len);
    }

}