import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-import java.util.Set;
/**
* Progress reporting system, possibly nested.
* @author niki
*/
public class Progress {
+ /**
+ * This event listener is designed to report progress events from
+ * {@link Progress}.
+ *
+ * @author niki
+ */
public interface ProgressListener extends EventListener {
/**
* A progression event.
* the min to set
*
*
- * @throws Error
+ * @throws RuntimeException
* if min < 0 or if min > max
*/
public void setMin(int min) {
if (min < 0) {
- throw new Error("negative values not supported");
+ throw new RuntimeException("negative values not supported");
}
- synchronized (getLock()) {
+ synchronized (lock) {
if (min > max) {
- throw new Error(
+ throw new RuntimeException(
"The minimum progress value must be <= the maximum progress value");
}
* the max to set
*
*
- * @throws Error
+ * @throws RuntimeException
* if max < min
*/
public void setMax(int max) {
- synchronized (getLock()) {
+ synchronized (lock) {
if (max < min) {
throw new Error(
"The maximum progress value must be >= the minimum progress value");
* @param max
* the max
*
- * @throws Error
+ * @throws RuntimeException
* if min < 0 or if min > max
*/
public void setMinMax(int min, int max) {
if (min < 0) {
- throw new Error("negative values not supported");
+ throw new RuntimeException("negative values not supported");
}
if (min > max) {
- throw new Error(
+ throw new RuntimeException(
"The minimum progress value must be <= the maximum progress value");
}
- synchronized (getLock()) {
+ synchronized (lock) {
this.min = min;
this.max = max;
}
* the progress to set
*/
public void setProgress(int progress) {
- synchronized (getLock()) {
+ synchronized (lock) {
double childrenProgress = relativeProgress - relativeLocalProgress;
relativeLocalProgress = ((double) progress) / (max - min);
*/
private void setRelativeProgress(Progress pg, String name,
double relativeProgress) {
- synchronized (getLock()) {
+ synchronized (lock) {
relativeProgress = Math.max(0, relativeProgress);
relativeProgress = Math.min(1, relativeProgress);
this.relativeProgress = relativeProgress;
* the amount to add
*/
public void add(int step) {
- synchronized (getLock()) {
+ synchronized (lock) {
setProgress(getLocalProgress() + step);
}
}
* Mark the {@link Progress} as done by setting its value to max.
*/
public void done() {
- synchronized (getLock()) {
+ synchronized (lock) {
double childrenProgress = relativeProgress - relativeLocalProgress;
relativeLocalProgress = 1 - childrenProgress;
setRelativeProgress(this, name, 1d);
*
* @return the children (Who will think of the children??)
*/
- public Set<Progress> getChildren() {
- return children.keySet();
+ public List<Progress> getChildren() {
+ synchronized (lock) {
+ return new ArrayList<Progress>(children.keySet());
+ }
}
/**
name = this.name;
}
- synchronized (getLock()) {
+ synchronized (lock) {
for (ProgressListener l : listeners) {
l.progress(pg, name);
}
* the listener
*/
public void addProgressListener(ProgressListener l) {
- this.listeners.add(l);
+ synchronized (lock) {
+ this.listeners.add(l);
+ }
}
/**
* @return TRUE if it was found (and removed)
*/
public boolean removeProgressListener(ProgressListener l) {
- return this.listeners.remove(l);
+ synchronized (lock) {
+ return this.listeners.remove(l);
+ }
}
/**
* {@link Progress#getMax()} scale) of this child
* {@link Progress} in relation to its parent
*
- * @throws Error
+ * @throws RuntimeException
* if weight exceed {@link Progress#getMax()} or if progress
* already has a parent
*/
public void addProgress(Progress progress, double weight) {
if (weight < min || weight > max) {
- throw new Error(String.format(
+ throw new RuntimeException(String.format(
"Progress object %s cannot have a weight of %f, "
- + "it is outside of its parent (%s) range (%f)",
+ + "it is outside of its parent (%s) range (%d)",
progress.name, weight, name, max));
}
if (progress.parent != null) {
- throw new Error(String.format(
+ throw new RuntimeException(String.format(
"Progress object %s cannot be added to %s, "
+ "as it already has a parent (%s)", progress.name,
name, progress.parent.name));
}
- progress.addProgressListener(new ProgressListener() {
+ ProgressListener progressListener = new ProgressListener() {
@Override
public void progress(Progress pg, String name) {
- synchronized (getLock()) {
+ synchronized (lock) {
double total = relativeLocalProgress;
for (Entry<Progress, Double> entry : children.entrySet()) {
total += (entry.getValue() / (max - min))
setRelativeProgress(pg, name, total);
}
}
- });
-
- this.children.put(progress, weight);
- }
+ };
- /**
- * The lock object to use (this one or the recursively-parent one).
- *
- * @return the lock object to use
- */
- private Object getLock() {
synchronized (lock) {
- if (parent != null) {
- return parent.getLock();
- }
-
- return lock;
+ progress.parent = this;
+ this.children.put(progress, weight);
+ progress.addProgressListener(progressListener);
}
}
}