From b086f57f56bf0eb9dab9cf321a0f69aaaae84347 Mon Sep 17 00:00:00 2001
From: Andrew Branson <andrew.branson@cern.ch>
Date: Wed, 30 May 2012 08:37:45 +0200
Subject: Initial Maven Conversion

---
 .../lifecycle/instance/AdvancementCalculator.java  | 225 +++++++++++++++++++++
 1 file changed, 225 insertions(+)
 create mode 100644 src/main/java/com/c2kernel/lifecycle/instance/AdvancementCalculator.java

(limited to 'src/main/java/com/c2kernel/lifecycle/instance/AdvancementCalculator.java')

diff --git a/src/main/java/com/c2kernel/lifecycle/instance/AdvancementCalculator.java b/src/main/java/com/c2kernel/lifecycle/instance/AdvancementCalculator.java
new file mode 100644
index 0000000..6a3abe7
--- /dev/null
+++ b/src/main/java/com/c2kernel/lifecycle/instance/AdvancementCalculator.java
@@ -0,0 +1,225 @@
+/* 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<Vertex, Serializable> isMarked;
+	private Hashtable<Vertex, Vertex> HasNextMarked;
+	public Hashtable<String, Vertex> 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<Vertex, Serializable>();
+		HasNextMarked = new Hashtable<Vertex, Vertex>();
+		hasprevActive = new Hashtable<String, Vertex>();
+	}
+	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<Vertex, Serializable>();
+		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 (Vertex next : nexts)
+			if (current.isMarked.get(next) != null)
+				current.HasNextMarked.put(v, next);
+			else
+				check(next, current);
+        int j=0;
+		for (Vertex next : nexts)
+			if (current.HasNextMarked.get(next) != 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 hasNobranchFinished = true;
+			boolean hasNoBranchActive = true;
+			for (AdvancementCalculator adv : advs) {
+				if (adv.mIsbranchActive)
+					hasNoBranchActive = false;
+				if (adv.mIsbranchFinished)
+					hasNobranchFinished = false;
+			}
+			for (AdvancementCalculator adv : advs) {
+
+				if (maximuNbActexp < adv.mMaximuNbActexp)
+					maximuNbActexp = adv.mMaximuNbActexp;
+				if (adv.mIsbranchActive || adv.mIsbranchFinished || (hasNoBranchActive && hasNobranchFinished))
+				{
+					if (NbActpassed < adv.mNbActpassed)
+						NbActpassed = adv.mNbActpassed;
+					if (NbActpassedWithCurrent < adv.mNbActpassedWithCurrent)
+						NbActpassedWithCurrent = adv.mNbActpassedWithCurrent;
+					if (NbActLeftWithCurrent < adv.mNbActLeftWithCurrent)
+						NbActLeftWithCurrent = adv.mNbActLeftWithCurrent;
+					if (NbActLeftWithoutCurrent < adv.mNbActLeftWithoutCurrent)
+						NbActLeftWithoutCurrent += adv.mNbActLeftWithoutCurrent;
+					if (currentNbActExp < adv.mCurrentNbActExp)
+						currentNbActExp = adv.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;
+	}
+}
-- 
cgit v1.2.3