diff options
Diffstat (limited to 'source/com/c2kernel/lifecycle/instance/AdvancementCalculator.java')
| -rwxr-xr-x | source/com/c2kernel/lifecycle/instance/AdvancementCalculator.java | 228 |
1 files changed, 228 insertions, 0 deletions
diff --git a/source/com/c2kernel/lifecycle/instance/AdvancementCalculator.java b/source/com/c2kernel/lifecycle/instance/AdvancementCalculator.java new file mode 100755 index 0000000..ea47721 --- /dev/null +++ b/source/com/c2kernel/lifecycle/instance/AdvancementCalculator.java @@ -0,0 +1,228 @@ +/* Created on 11 mars 2004 */
+package com.c2kernel.lifecycle.instance;
+import java.io.Serializable;
+import java.util.Hashtable;
+
+import com.c2kernel.graph.model.Vertex;
+import com.c2kernel.lifecycle.instance.stateMachine.States;
+//import com.c2kernel.utils.Logger;
+/** @author XSeb74 */
+public class AdvancementCalculator implements Serializable
+{
+ private CompositeActivity activity;
+ private Hashtable isMarked;
+ private Hashtable HasNextMarked;
+ public Hashtable hasprevActive;
+ private long mCurrentNbActExp = 0;
+ private long mMaximuNbActexp = 0;
+ private long mNbActpassed = 0;
+ private long mNbActpassedWithCurrent = 0;
+ private long mNbActLeftWithCurrent = 0;
+ private long mNbActLeftWithoutCurrent = 0;
+ private boolean mIsbranchActive = false;
+ private boolean mIsbranchFinished = true;
+ private boolean mHasPrevActive = false;
+ public AdvancementCalculator()
+ {
+ isMarked = new Hashtable();
+ HasNextMarked = new Hashtable();
+ hasprevActive = new Hashtable();
+ }
+ public void calculate(CompositeActivity act)
+ {
+// Logger.debug(0, act.getName()+" >>>>>>>>>");
+ if (act instanceof Workflow)
+ {
+ calculate((CompositeActivity) act.search("workflow/domain"));
+ return;
+ }
+ activity = act;
+ Vertex v = activity.getChildGraphModel().getStartVertex();
+ check(v, this);
+ isMarked = new Hashtable();
+ calc(v, this);
+// Logger.debug(0, act.getName()+" <<<<<<<<<");
+ }
+ private void check(Vertex v, AdvancementCalculator current)
+ {
+ current.isMarked.put(v, "");
+ Vertex[] nexts = current.activity.getChildGraphModel().getOutVertices(v);
+ for (int i = 0; i < nexts.length; i++)
+ if (current.isMarked.get(nexts[i]) != null)
+ current.HasNextMarked.put(v, nexts[i]);
+ else
+ check(nexts[i], current);
+ int j=0;
+ for (int i = 0; i < nexts.length; i++)
+ if (current.HasNextMarked.get(nexts[i]) != null)
+ j++;
+ if (j != 0 && j==nexts.length) current.HasNextMarked.put(v, nexts[0]);
+ }
+ private void calc(Vertex v, AdvancementCalculator current)
+ {
+ if (current.isMarked.get(v) != null && !(v instanceof Join))
+ return;
+ if (v instanceof Activity)
+ {
+ current.isMarked.put(v, current);
+ Activity act = (Activity) v;
+ if (v instanceof CompositeActivity)
+ {
+ CompositeActivity cact = (CompositeActivity) v;
+ AdvancementCalculator adv = new AdvancementCalculator();
+ adv.isMarked = current.isMarked;
+ adv.HasNextMarked = current.HasNextMarked;
+ adv.calculate(cact);
+ current.mCurrentNbActExp += adv.mCurrentNbActExp;
+ current.mMaximuNbActexp += adv.mMaximuNbActexp;
+ current.mNbActpassed += adv.mNbActpassed;
+ current.mNbActpassedWithCurrent += adv.mNbActpassedWithCurrent;
+ current.mIsbranchActive = current.mIsbranchActive || adv.mIsbranchActive||act.getActive();
+ current.mNbActLeftWithCurrent += adv.mNbActLeftWithCurrent;
+ current.mNbActLeftWithoutCurrent += adv.mNbActLeftWithoutCurrent;
+ current.mHasPrevActive = adv.mHasPrevActive||act.getActive();
+ if (adv.hasprevActive.size()!=0) current.mHasPrevActive=true;
+ }
+ else
+ {
+ current.mCurrentNbActExp += 1;
+ current.mMaximuNbActexp += 1;
+ if (act.getCurrentState() == States.FINISHED)
+ {
+ current.mNbActpassed += 1;
+ current.mNbActpassedWithCurrent += 1;
+ }
+ else if (act.getActive()&&act.getState()<States.REPEATSTATESTART)
+ {
+ current.mIsbranchActive = true;
+ current.mIsbranchFinished = false;
+ current.mHasPrevActive = true;
+// Logger.debug(0, "set HasprevActive to true " + act.getName());
+ current.mNbActpassedWithCurrent += 1;
+ current.mNbActLeftWithCurrent += 1;
+ }
+ else
+ {
+ current.mIsbranchFinished = false;
+ current.mNbActLeftWithCurrent += 1;
+ current.mNbActLeftWithoutCurrent += 1;
+ }
+ }
+ }
+ Vertex[] nexts = current.activity.getChildGraphModel().getOutVertices(v);
+ if (v instanceof Split)
+ {
+ current.isMarked.put(v, current);
+ AdvancementCalculator[] advs = new AdvancementCalculator[nexts.length];
+ for (int i = 0; i < nexts.length; i++)
+ {
+ advs[i] = new AdvancementCalculator();
+ advs[i].mHasPrevActive = current.mHasPrevActive;
+ advs[i].isMarked = current.isMarked;
+ advs[i].HasNextMarked = current.HasNextMarked;
+ advs[i].activity = current.activity;
+ if ((v instanceof Loop) && (current.HasNextMarked.get(nexts[i]) != null))
+// Logger.debug(0, v.getID() + " " + nexts[i].getID() + " HasNextMarked")
+ ;
+ else
+ calc(nexts[i], advs[i]);
+ }
+ long maximuNbActexp = 0;
+ long currentNbActExp = 0;
+ long NbActpassed = 0;
+ long NbActpassedWithCurrent = 0;
+ long NbActLeftWithCurrent = 0;
+ long NbActLeftWithoutCurrent = 0;
+ boolean isbranchFinished = true;
+ boolean hasNobranchFinished = true;
+ boolean hasNoBranchActive = true;
+ for (int i = 0; i < advs.length; i++)
+ {
+ if (advs[i].mIsbranchActive)
+ hasNoBranchActive = false;
+ if (advs[i].mIsbranchFinished)
+ hasNobranchFinished = false;
+ }
+ for (int i = 0; i < advs.length; i++)
+ {
+
+ if (maximuNbActexp < advs[i].mMaximuNbActexp)
+ maximuNbActexp = advs[i].mMaximuNbActexp;
+ if (advs[i].mIsbranchActive || advs[i].mIsbranchFinished || (hasNoBranchActive && hasNobranchFinished))
+ {
+ if (NbActpassed < advs[i].mNbActpassed)
+ NbActpassed = advs[i].mNbActpassed;
+ if (NbActpassedWithCurrent < advs[i].mNbActpassedWithCurrent)
+ NbActpassedWithCurrent = advs[i].mNbActpassedWithCurrent;
+ if (NbActLeftWithCurrent < advs[i].mNbActLeftWithCurrent)
+ NbActLeftWithCurrent = advs[i].mNbActLeftWithCurrent;
+ if (NbActLeftWithoutCurrent < advs[i].mNbActLeftWithoutCurrent)
+ NbActLeftWithoutCurrent += advs[i].mNbActLeftWithoutCurrent;
+ if (currentNbActExp < advs[i].mCurrentNbActExp)
+ currentNbActExp = advs[i].mCurrentNbActExp;
+ }
+ }
+ current.mCurrentNbActExp += currentNbActExp;
+ current.mNbActpassedWithCurrent += NbActpassedWithCurrent;
+ current.mMaximuNbActexp += maximuNbActexp;
+ current.mNbActpassed += NbActpassed;
+ current.mIsbranchActive = current.mIsbranchActive || !hasNoBranchActive;
+ current.mNbActLeftWithCurrent += NbActLeftWithCurrent;
+ current.mNbActLeftWithoutCurrent += NbActLeftWithoutCurrent;
+ return;
+ }
+ if (v instanceof Join)
+ {
+ AdvancementCalculator adv;
+ if (current.isMarked.get(v) == null)
+ {
+ adv = new AdvancementCalculator();
+ adv.isMarked = current.isMarked;
+ adv.HasNextMarked = current.HasNextMarked;
+ adv.activity = current.activity;
+ adv.mHasPrevActive = current.mHasPrevActive;
+ current.isMarked.put(v, adv);
+ if (nexts.length == 1)
+ calc(nexts[0], adv);
+ }
+ else
+ adv = (AdvancementCalculator) current.isMarked.get(v);
+ current.mCurrentNbActExp += adv.mCurrentNbActExp;
+ current.mMaximuNbActexp += adv.mMaximuNbActexp;
+ current.mNbActpassed += adv.mNbActpassed;
+ current.mNbActpassedWithCurrent += adv.mNbActpassedWithCurrent;
+ current.mIsbranchActive = current.mIsbranchActive || (current.mMaximuNbActexp == 0 && adv.mIsbranchActive);
+ if (current.mHasPrevActive)
+ hasprevActive.put(String.valueOf(v.getID()), v);
+ current.mNbActLeftWithCurrent += adv.mNbActLeftWithCurrent;
+ current.mNbActLeftWithoutCurrent += adv.mNbActLeftWithoutCurrent;
+ return;
+ }
+ if (nexts.length != 0)
+ calc(nexts[0], current);
+ }
+ public long getLongestWayInAct()
+ {
+ return mMaximuNbActexp;
+ }
+ public long getCurrentLongestWayInAct()
+ {
+ return mCurrentNbActExp;
+ }
+ public long getNbActLeftWithActive()
+ {
+ return mNbActLeftWithCurrent;
+ }
+ public long getNbActLeftWithoutActive()
+ {
+ return mNbActLeftWithoutCurrent;
+ }
+ public long getNbActPassedWithoutActive()
+ {
+ return mNbActpassed;
+ }
+ public long getNbActPassedWithActive()
+ {
+ return mNbActpassedWithCurrent;
+ }
+}
|