import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Set;
/**
* Progress reporting system, possibly nested.
* A progression event.
*
* @param progress
- * the {@link Progress} object that generated it, or a parent
+ * the {@link Progress} object that generated it, not
+ * necessarily the same as the one where the listener was
+ * attached (it could be a child {@link Progress} of this
+ * {@link Progress}).
* @param name
* the first non-null name of the {@link Progress} step that
* generated this event
public void progress(Progress progress, String name);
}
+ private Progress parent = null;
+ private Object lock = new Object();
private String name;
private Map<Progress, Double> children;
private List<ProgressListener> listeners;
return name;
}
+ /**
+ * The name of this {@link Progress} step.
+ *
+ * @param name
+ * the new name
+ */
+ public void setName(String name) {
+ this.name = name;
+ // will fire an action event:
+ setProgress(this.localProgress);
+ }
+
/**
* The minimum progress value.
*
*
* @param min
* the min to set
+ *
+ *
+ * @throws Error
+ * if min < 0 or if min > max
*/
public void setMin(int min) {
if (min < 0) {
throw new Error("negative values not supported");
}
- if (min > max) {
- throw new Error(
- "The minimum progress value must be <= the maximum progress value");
- }
+ synchronized (getLock()) {
+ if (min > max) {
+ throw new Error(
+ "The minimum progress value must be <= the maximum progress value");
+ }
- this.min = min;
+ this.min = min;
+ }
}
/**
*
* @param max
* the max to set
+ *
+ *
+ * @throws Error
+ * if max < min
*/
public void setMax(int max) {
- if (max < min) {
- throw new Error(
- "The maximum progress value must be >= the minimum progress value");
- }
+ synchronized (getLock()) {
+ if (max < min) {
+ throw new Error(
+ "The maximum progress value must be >= the minimum progress value");
+ }
- this.max = max;
+ this.max = max;
+ }
}
/**
* the min
* @param max
* the max
+ *
+ * @throws Error
+ * if min < 0 or if min > max
*/
public void setMinMax(int min, int max) {
if (min < 0) {
"The minimum progress value must be <= the maximum progress value");
}
- this.min = min;
- this.max = max;
+ synchronized (getLock()) {
+ this.min = min;
+ this.max = max;
+ }
}
/**
* the progress to set
*/
public void setProgress(int progress) {
- int diff = this.progress - this.localProgress;
- this.localProgress = progress;
- setTotalProgress(name, progress + diff);
+ synchronized (getLock()) {
+ int diff = this.progress - this.localProgress;
+ this.localProgress = progress;
+ setTotalProgress(this, name, progress + diff);
+ }
}
/**
return (((double) progress) / (max - min));
}
+ /**
+ * Return the list of direct children of this {@link Progress}.
+ *
+ * @return the children (who will think of them??)
+ */
+ public Set<Progress> getChildren() {
+ return children.keySet();
+ }
+
/**
* Set the total progress value (including the optional children
* {@link Progress}), on a {@link Progress#getMin()} to
* {@link Progress#getMax()} scale.
*
+ * @param pg
+ * the {@link Progress} to report as the progression emitter
* @param name
* the current name (if it is NULL, the first non-null name in
- * the hierarchy will overwrite it)
+ * the hierarchy will overwrite it) of the {@link Progress} who
+ * emitted this change
* @param progress
* the progress to set
*/
- private void setTotalProgress(String name, int progress) {
- this.progress = progress;
+ private void setTotalProgress(Progress pg, String name, int progress) {
+ synchronized (getLock()) {
+ this.progress = progress;
- for (ProgressListener l : listeners) {
- l.progress(this, name);
+ for (ProgressListener l : listeners) {
+ l.progress(pg, name);
+ }
}
}
/**
* Add a {@link ProgressListener} that will trigger on progress changes.
+ * <p>
+ * Note: the {@link Progress} that will be reported will be the active
+ * progress, not necessarily the same as the current one (it could be a
+ * child {@link Progress} of this {@link Progress}).
*
* @param l
* the listener
this.listeners.add(l);
}
+ /**
+ * Remove a {@link ProgressListener} that would trigger on progress changes.
+ *
+ * @param l
+ * the listener
+ *
+ * @return TRUE if it was found (and removed)
+ */
+ public boolean removeProgressListener(ProgressListener l) {
+ return this.listeners.remove(l);
+ }
+
/**
* Add a child {@link Progress} of the given weight.
*
* the weight (on a {@link Progress#getMin()} to
* {@link Progress#getMax()} scale) of this child
* {@link Progress} in relation to its parent
+ *
+ * @throws Error
+ * 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(
- "A Progress object cannot have a weight outside its parent range");
+ throw new Error(String.format(
+ "Progress object %s cannot have a weight of %f, "
+ + "it is outside of its parent (%s) range (%f)",
+ progress.name, weight, name, max));
+ }
+
+ if (progress.parent != null) {
+ throw new Error(String.format(
+ "Progress object %s cannot be added to %s, "
+ + "as it already has a parent (%s)", progress.name,
+ name, progress.parent.name));
}
- // Note: this is quite inefficient, especially with many children
- // TODO: improve it?
progress.addProgressListener(new ProgressListener() {
- public void progress(Progress progress, String name) {
- double total = ((double) localProgress) / (max - min);
- for (Entry<Progress, Double> entry : children.entrySet()) {
- total += (entry.getValue() / (max - min))
- * entry.getKey().getRelativeProgress();
- }
+ public void progress(Progress pg, String name) {
+ synchronized (getLock()) {
+ double total = ((double) localProgress) / (max - min);
+ for (Entry<Progress, Double> entry : children.entrySet()) {
+ total += (entry.getValue() / (max - min))
+ * entry.getKey().getRelativeProgress();
+ }
- if (name == null) {
- name = Progress.this.name;
- }
+ if (name == null) {
+ name = Progress.this.name;
+ }
- setTotalProgress(name, (int) Math.round(total * (max - min)));
+ setTotalProgress(pg, name,
+ (int) Math.round(total * (max - min)));
+ }
}
});
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;
+ }
+ }
}
git://git.nikiroo.be / nikiroo-utils.git / blobdiff