net.sf.nakeduml.feature.SequenceCalculator Maven / Gradle / Ivy

Go to download
package net.sf.nakeduml.feature;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public abstract class SequenceCalculator {
	public class BeforeAndAfter {
		T executableUnit;
		Set predecessors = new HashSet();
		Class[] before;
		Class[] after;

		public BeforeAndAfter(T phase, Class[] before, Class[] after) {
			super();
			this.executableUnit = phase;
			this.before = before;
			this.after = after;
		}

		public BeforeAndAfter(T phase) {
			super();
		}

		public T getExecutableUnit() {
			return this.executableUnit;
		}

		public Set getPredecessors() {
			return this.predecessors;
		}

		public void addPredecessor(BeforeAndAfter p) {
			this.predecessors.add(p);
		}

		public Class[] before() {
			return before;
		}

		public Class[] after() {
			return after;
		}
	}

	Map, BeforeAndAfter> classMap = new HashMap, BeforeAndAfter>();
	List executionUnits = new ArrayList();

	protected abstract BeforeAndAfter createStepAndPredecessor(T step);

	public void initializeFromClasses(Set> selectedExecutionUnits) {
		populateClassToBeforeAndAfterMap(selectedExecutionUnits);
		resolvePredecessors();
		sort();
	}

	public void populateClassToBeforeAndAfterMap(Set> selectedExecutionUnits) {
		for (Class t : selectedExecutionUnits) {
			BeforeAndAfter beforeAndAfter;
			try {
				beforeAndAfter = createStepAndPredecessor(t.newInstance());
				classMap.put(t, beforeAndAfter);
			} catch (InstantiationException e) {
				throw new RuntimeException(e);
			} catch (IllegalAccessException e) {
				throw new RuntimeException(e);
			}
		}
	}

	private void resolvePredecessors() {
		for (BeforeAndAfter me : classMap.values()) {
			addMyPredecessors(me);
			addMeToMySuccessors(me);
		}
	}

	private void addMeToMySuccessors(BeforeAndAfter me) {
		for (Class c : me.before()) {
			if (classMap.containsKey(c)) {
				classMap.get(c).addPredecessor(me);
			}
		}
	}

	private void addMyPredecessors(BeforeAndAfter me) {
		for (Class c : me.after()) {
			if (classMap.containsKey(c)) {
				me.addPredecessor(classMap.get(c));
			}
		}
	}

	private void sort() throws CircularPrecessionException {
		List traversalPath = new ArrayList();
		for (BeforeAndAfter tp : classMap.values()) {
			addPredecessorsThenMyself(traversalPath, tp);
		}
	}

	private void addPredecessorsThenMyself(List traversalPath, BeforeAndAfter tp) throws CircularPrecessionException {
		if (!executionUnits.contains(tp.getExecutableUnit())) {
			traversalPath.add(tp.getExecutableUnit());
			for (BeforeAndAfter pf : tp.getPredecessors()) {
				if (traversalPath.contains(pf.getExecutableUnit())) {
					throw new CircularPrecessionException(traversalPath, pf.getExecutableUnit());
				} else {
					addPredecessorsThenMyself(traversalPath, pf);
				}
			}
			traversalPath.remove(tp.getExecutableUnit());
			executionUnits.add(tp.getExecutableUnit());
		}
	}

	public List getExecutionUnits() {
		return this.executionUnits;
	}
}