X-Git-Url: http://git.nikiroo.be/?a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Futils%2FProgress.java;h=5af7b30d83b357654d2b34e3bff3faa3eb8de9d6;hb=0924c45dd84be115c6c622b075445855b13951e5;hp=8b6e10e5fc97ca6e5b2748aeb58c4829d80a3287;hpb=b3aad1f93ce78c9806361ca1659defcf99b45bdc;p=nikiroo-utils.git diff --git a/src/be/nikiroo/utils/Progress.java b/src/be/nikiroo/utils/Progress.java index 8b6e10e..5af7b30 100644 --- a/src/be/nikiroo/utils/Progress.java +++ b/src/be/nikiroo/utils/Progress.java @@ -6,6 +6,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; +import java.util.Set; /** * Progress reporting system, possibly nested. @@ -18,7 +19,10 @@ public class Progress { * 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 @@ -26,6 +30,8 @@ public class Progress { public void progress(Progress progress, String name); } + private Progress parent = null; + private Object lock = new Object(); private String name; private Map children; private List listeners; @@ -92,6 +98,18 @@ public class Progress { 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. * @@ -106,18 +124,24 @@ public class Progress { * * @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; + } } /** @@ -134,14 +158,20 @@ public class Progress { * * @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; + } } /** @@ -151,6 +181,9 @@ public class Progress { * 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) { @@ -162,8 +195,10 @@ public class Progress { "The minimum progress value must be <= the maximum progress value"); } - this.min = min; - this.max = max; + synchronized (getLock()) { + this.min = min; + this.max = max; + } } /** @@ -186,9 +221,11 @@ public class Progress { * 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); + } } /** @@ -211,27 +248,45 @@ public class Progress { 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 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. + *

+ * 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 @@ -240,6 +295,18 @@ public class Progress { 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. * @@ -249,31 +316,60 @@ public class Progress { * 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 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 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) (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; + } + } }