Just reminds me, we had a java class that did that for QAlign 2 Panta Rei source code distribution.

Yeah, there it is, May 21, 2005 written in Michas old apartment in Barcelona while working on QAlign2.

The QAlign2 crew

And – do never ever trust Micha when he says that he never copied a “Start Wars – Episode I” script into a static final String variable in one of the source code files

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.Buffer;
import java.nio.CharBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

/*
 * Created on May 21, 2005
 */

/**
 * Class scans given directory for sourcefiles and appends a disclaimer
 *
 * This is a quick hack version of a good appending methods and it is NOT memory efficient. Thats
 * why "Start Wars - Episode I" will not work as disclaimer. The disclaimer itself should NOT be inlined
 * in sourcecode comment tags, this is done by {@see #readDiscalimer()} (Let it be the pure disclaimer, without any \/* *\/).
 * Also the size of source files is limited to the heap size of the vm. If one uses this with large source
 * or disclaimer files extend the VM max heap size (e.g. -Xmx512m).
 *
 * Remember, the scanFile() method automatically appends "\r\n" to each line while writing the files.
 *
 * parameters
 * -d  The source directory
 * -f  The disclaimer
 * -v <0..2> verbose output
 * @author Thasso
 */
public class AppendDisclaimer {
    /**
     * the input directory
     */
    public static String inputDir = ".";
    /**
     * Filename of the disclaimer
     */
    public static String disclaimerFile = null;
    /**
     * String representation of the disclaimer
     */
    public static String disclaimer;

    /**
     * verbose level
     */
    public static int verbose = 0;

    public static void main(String[] args) {
        if(args.length < 1){
            printUsage();
        }
        // Parse arguments
        for (int i = 0; i < args.length; i++) {
            if(args[i].equalsIgnoreCase("-d")){
                inputDir = args[i+1];
            }
            if(args[i].equalsIgnoreCase("-v")){
                verbose = args[i+1] != null ? Integer.parseInt(args[i+1]):2;
            }
            if(args[i].equalsIgnoreCase("-f")){
                disclaimerFile = args[i+1];
            }
        }
        if(disclaimerFile == null)
            printUsage("Discalimer file not set ! Use -f to define a disclaimer");

        readDiscalimer();        

        // read filelist from directory
        File input = new File(inputDir);
        if(!input.isDirectory() ||!input.canRead()){
            printUsage("Can not read from directory " + input.getAbsolutePath());
        }
        if(verbose > 0)
            System.out.println("Scanning Directory :\n\t"+input.getAbsolutePath());

        List javaFiles = readDirectory(input, ".java");
        //Scan files and append disclaimer
        for (Iterator it = javaFiles.iterator(); it.hasNext();) {
            File f = (File) it.next();
            scanFile(f);
        }
    }

    /**
     * read the disclaimer from file
     */
    private static void readDiscalimer() {
        File f = new File(disclaimerFile);
        StringBuffer d = new StringBuffer();
        if(!f.exists())
            printUsage("Disclaimer " + disclaimerFile + " not found");
        if(!f.canRead())
            printUsage("Disclaimer " + disclaimerFile + " not readable");

        try {
            BufferedReader in = new BufferedReader(new FileReader(f));
            d.append("/*\r\n");
            String l = in.readLine();
            while(l != null){
                d.append(" * "+l+"\r\n");
                l = in.readLine();
            }
            d.append("*/\r\n");
            disclaimer = d.toString();
            in.close();
        } catch (FileNotFoundException e) {
            printUsage("Disclaimer " + disclaimerFile + " not found");
        } catch (IOException e) {
            printUsage("Error while reading from file " + disclaimerFile);
        }
    }

    /**
     * Memory consuming scna file method.
     * Creates a buffer and appends the disclaimer. Than reads the file and appends it to
     * the buffer, line by line, adding \\r\\n to each line.
     * When done, writes out the file with a simple and absolute inefficent buffer.toString() call.
     *
     * @param f
     */
    private static void scanFile(File f){
        BufferedReader in = null;
        StringBuffer content = new StringBuffer();
        content.append(disclaimer+"\r\n"+"\r\n");
        if(verbose > 1)
            System.out.println("Reading file " + f.getName());

        try {
            in = new BufferedReader(new FileReader(f));
            String line = in.readLine();
            while(line != null){
                content.append(line+"\r\n");
                line = in.readLine();
            }
            in.close();
        } catch (FileNotFoundException e) {
            printUsage("File  not found " + f.getName());
        } catch (IOException e) {
            printUsage("Could not read file " + f.getName());
        }finally{
            try {
                in.close();
            } catch (IOException e1) {}
        }
        if(verbose > 1)
            System.out.println("Writing file " + f.getName());

        BufferedWriter w = null;
        try {
            w = new BufferedWriter(new FileWriter(f));
            w.write(content.toString());
            w.close();
        } catch (IOException e) {
            printUsage("Could not write file " + f.getName());
        }finally{
            try {
                w.close();
            } catch (IOException e) {}
        }
    }

    /**
     * Recurcive scan directory for files with given suffix
     *
     * @param dir directory to scan
     * @param suffix files suffix
     */
    protected static List readDirectory(File dir, String suffix) {
        ArrayList files = new ArrayList();
        if(dir.isFile())
            return null;

        if(verbose > 1)
            System.out.println("Scanning Directory :\n\t"+dir.getAbsolutePath());

        File[] all = dir.listFiles();
        ArrayList dirs = new ArrayList();
        for (int i = 0; i < all.length; i++) {
            if(all[i].isFile()){
                if(all[i].getName().endsWith(suffix)){
                    files.add(all[i]);
                }
            }else if(all[i].isDirectory()){
                dirs.add(all[i]);
            }
        }
        for (Iterator it = dirs.iterator(); it.hasNext();) {
            File d = (File) it.next();
            List l = readDirectory(d, suffix);
            files.addAll(l);
        }
        return files;
    }

    /**
     * print string and the usage
     * @param string
     */
    private static void printUsage(String string) {
        System.err.println(string + "\n\n");
        printUsage();
    }

    /**
     * print the usage
     */
    private static void printUsage() {
        System.err.println(""
                +" This is a quick hack version of a good appending methods and it is NOT memory efficient. \r\n"
                + " Thats why "Start Wars - Episode I" will not work as disclaimer.\r\n"
                + " The disclaimer itself should NOT be inlined\r\n"
                + " in sourcecode comment tags, this is done automaticaly (Let it be the pure disclaimer, without any /* */) \r\n"
                + " Also the size of source files is limited to the heap size of the vm. If one uses this with large source\r\n"
                + " or disclaimer files extend the VM max heap size (e.g. -Xmx512m).\r\n"
                + " \r\n"
                + " Remember, the scanFile() method automatically appends "\\r\\n" to each line while writing the files.\r\n"
                + " \r\n"
                + " parameters\r\n"
                + " -d  The source directory\r\n"
                + " -f  The disclaimer\r\n"
                + " -v <0..2> verbose output\r\n"

        );
        System.exit(1);
    }

}

public abstract class AbstractBean {
    /**
     * Create a new change support
     */
    protected PropertyChangeSupport change = new EDTSafePropertyChangeSupport(this);

    /**
     * @param listener
     * @see java.beans.PropertyChangeSupport#addPropertyChangeListener(java.beans.PropertyChangeListener)
     */
    public void addPropertyChangeListener(PropertyChangeListener listener) {
        change.addPropertyChangeListener(listener);
    }

    /**
     * @param propertyName
     * @param listener
     * @see java.beans.PropertyChangeSupport#addPropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
     */
    public void addPropertyChangeListener(String propertyName,
            PropertyChangeListener listener) {
        change.addPropertyChangeListener(propertyName, listener);
    }

    /**
     * @param propertyName
     * @param oldValue
     * @param newValue
     * @see java.beans.PropertyChangeSupport#firePropertyChange(java.lang.String, java.lang.Object, java.lang.Object)
     */
    public void firePropertyChange(String propertyName, Object oldValue,
            Object newValue) {
        change.firePropertyChange(propertyName, oldValue, newValue);
    }

    /**
     * @return
     * @see java.beans.PropertyChangeSupport#getPropertyChangeListeners()
     */
    public PropertyChangeListener[] getPropertyChangeListeners() {
        return change.getPropertyChangeListeners();
    }

    /**
     * @param propertyName
     * @return
     * @see java.beans.PropertyChangeSupport#getPropertyChangeListeners(java.lang.String)
     */
    public PropertyChangeListener[] getPropertyChangeListeners(
            String propertyName) {
        return change.getPropertyChangeListeners(propertyName);
    }

    /**
     * @param propertyName
     * @return
     * @see java.beans.PropertyChangeSupport#hasListeners(java.lang.String)
     */
    public boolean hasListeners(String propertyName) {
        return change.hasListeners(propertyName);
    }

    /**
     * @param listener
     * @see java.beans.PropertyChangeSupport#removePropertyChangeListener(java.beans.PropertyChangeListener)
     */
    public void removePropertyChangeListener(PropertyChangeListener listener) {
        change.removePropertyChangeListener(listener);
    }

    /**
     * @param propertyName
     * @param listener
     * @see java.beans.PropertyChangeSupport#removePropertyChangeListener(java.lang.String, java.beans.PropertyChangeListener)
     */
    public void removePropertyChangeListener(String propertyName,
            PropertyChangeListener listener) {
        change.removePropertyChangeListener(propertyName, listener);
    }

    /**
     * Simply ensures that events are delivered through the event dispatching thread
     *
     */
    class EDTSafePropertyChangeSupport extends PropertyChangeSupport{
        public EDTSafePropertyChangeSupport(Object sourceBean) {
            super(sourceBean);
        }
        @Override
        public void firePropertyChange(final PropertyChangeEvent evt) {
            if(SwingUtilities.isEventDispatchThread()){
                super.firePropertyChange(evt);
            }else{
                SwingUtilities.invokeLater(new Runnable() {
                    public void run() {
                        firePropertyChange(evt);
                    }
                });
            }
        }
    }
}

This implementation restricts itself to the firePropertyChange(String,Object,Object) method. It also provide a custom extension of PropertyChangeSupport that ensures that events are fired in the EventDispatchingThread.

I searched the net to find an Eclipse plugin that does the job of creating bound properties, but I didn’t find anything. So….I wrote my own plugin. The plugin works with Eclipse Ganymede (>=3.4) and can be installed using this update site:

http://java.randgestalten.de/updatesite

At the moment, the the plugin assumes that your bean provides a firePropertyChange(String, Object, Object) method. Thats one drawback I will try to address in the next version. For the moment, I think a good solution is to provide an AbstractBean class that you extend when you write a JavaBean from scratch ( here is an example of such class).

As long as your class provides a firePropertyChange method, you can use the plugin to generate bounded getter/setter methods. The plugin uses the default template for getter methods and provides a new template for bounded setters. You find the template in the Java->Editor->Templates preferences, where you can change it according to your needs.

Using the plugins mechanism to create getter/setter is straight forward, integrated in the “Source” menu of the context popup in the java editor as well as the package explorer and outline views. Just start writing your bean, right-click in the editor and select Source->Generate bounded getters/setters. This will open the same dialog as the default getter/setter generation except that it uses the boundedsetter template to create the setter method.

Menu integration

Beside the integration into the context menu, the plugin also supports quickfix and quickassist. Move your cursor to a variable definition and hit ctrl-1 (or command-1 if you are on a mac) to open the quickfix menu. The plugin integrates a bounded getter/setter generation quickfix that follows the same rules as the default generation behavior. You will see the same dialog except that you will get a bounded setter when you hit the Ok button.

So, as said before, the plugin integrates nicely into the Eclipse mechanism of generating getter/setter methods. You have a custom template just for the bounded setters and all dialogs are basically the same.

Quickfix Dialog

The thing that is missing currently is the automatic generation of the property change support or some delegation methods. This involves more work, because we have to check for existing methods…create property change support….insert delegation methods etc. I will try to build that in the next version, but for the moment you have to provide that by yourself. Either let your Bean extend an AbstractBean implementation that already supports property changes or integrate it directly into the object using PropertyChangeSupport. Keep in mind that plugin currently expects a firePropertyChange(String,Object,Object) method.

EDIT
The plugins source code is available here.

UPDATE

I just checked, and it seems that the Plugin is also working with Eclipse 3.5 but you have to uncheck the “Group items by category” to get the plugins listed.

Packagesorter in action

While working on EPoS, I found it very confusing that Eclipse does not sort multiple source directories alphabetically. The little PackageSorter plugin helps here and can be used in Eclipse Ganymede (>=3.4). The plugin is available on our update site:

http://java.randgestalten.de/updatesite

Add this site in the Eclipse Software Update dialog and install the Packagesorter plugin. If the plugin is successfully installed, it provides a button in to top toolbar of the java package explorer. If activated, it will sort your source directories in alphabetic order instead of using the build-path order, which seems to be the default.

As long as you only deal with one source directory, you will see no use in this plugin, but when your project consists of multiple source directories, which are all included in the projects build path, this might be helpful.

Source code (Download)

http://java.randgestalten.de/updatesite

and it includes the package sorter plugin and the bounded setter generator – and might include more at some point – we’ll see.