org.jdesktop.swingworker.AccumulativeRunnable Maven / Gradle / Ivy
/*
* $Id: AccumulativeRunnable.java,v 1.2 2006/09/28 20:20:28 idk Exp $
*
* Copyright ? 2005 Sun Microsystems, Inc. All rights
* reserved. Use is subject to license terms.
*/
package org.jdesktop.swingworker;
import java.util.*;
import javax.swing.SwingUtilities;
/**
* An abstract class to be used in the cases where we need {@code Runnable}
* to perform some actions on an appendable set of data.
* The set of data might be appended after the {@code Runnable} is
* sent for the execution. Usually such {@code Runnables} are sent to
* the EDT.
*
*
* Usage example:
*
*
* Say we want to implement JLabel.setText(String text) which sends
* {@code text} string to the JLabel.setTextImpl(String text) on the EDT.
* In the event JLabel.setText is called rapidly many times off the EDT
* we will get many updates on the EDT but only the last one is important.
* (Every next updates overrides the previous one.)
* We might want to implement this {@code setText} in a way that only
* the last update is delivered.
*
* Here is how one can do this using {@code AccumulativeRunnable}:
*
* AccumulativeRunnable doSetTextImpl =
* new AccumulativeRunnable() {
* @Override
* protected void run(List<String> args) {
* //set to the last string being passed
* setTextImpl(args.get(args.size() - 1);
* }
* }
* void setText(String text) {
* //add text and send for the execution if needed.
* doSetTextImpl.add(text);
* }
*
*
*
* Say we want want to implement addDirtyRegion(Rectangle rect)
* which sends this region to the
* handleDirtyRegions(List regions) on the EDT.
* addDirtyRegions better be accumulated before handling on the EDT.
*
*
* Here is how it can be implemented using AccumulativeRunnable:
*
* AccumulativeRunnable doHandleDirtyRegions =
* new AccumulativeRunnable() {
* @Override
* protected void run(List<Rectangle> args) {
* handleDirtyRegions(args);
* }
* };
* void addDirtyRegion(Rectangle rect) {
* doHandleDirtyRegions.add(rect);
* }
*
*
* @author Igor Kushnirskiy
* @version $Revision: 1.2 $ $Date: 2006/09/28 20:20:28 $
*
* @param the type this {@code Runnable} accumulates
*
*/
abstract class AccumulativeRunnable implements Runnable {
private List arguments = null;
/**
* Equivalent to {@code Runnable.run} method with the
* accumulated arguments to process.
*
* @param args accumulated arguments to process.
*/
protected abstract void run(List args);
/**
* {@inheritDoc}
*
*
* This implementation calls {@code run(List args)} method
* with the list of accumulated arguments.
*/
public final void run() {
run(flush());
}
/**
* appends arguments and sends this {@code Runnable} for the
* execution if needed.
*
* This implementation uses {@see #submit} to send this
* {@code Runnable} for execution.
* @param args the arguments to accumulate
*/
public final synchronized void add(T... args) {
boolean isSubmitted = true;
if (arguments == null) {
isSubmitted = false;
arguments = new ArrayList();
}
Collections.addAll(arguments, args);
if (!isSubmitted) {
submit();
}
}
/**
* Sends this {@code Runnable} for the execution
*
*
* This method is to be executed only from {@code add} method.
*
*
* This implementation uses {@code SwingWorker.invokeLater}.
*/
protected void submit() {
SwingUtilities.invokeLater(this);
}
/**
* Returns accumulated arguments and flashes the arguments storage.
*
* @return accumulated arguments
*/
private final synchronized List flush() {
List list = arguments;
arguments = null;
return list;
}
}