rename AlgorithmStep to AlgorithmStage

src/Algorithms/Animated/AlgorithmStep.java → src/Algorithms/Animated/AlgorithmStage.java

@@ -9,13 +9,13 @@ import Algorithms.Animated.BK.BlockCalc;
  * @author kolja
  *
  */
-public interface AlgorithmStep {
+public interface AlgorithmStage {
     /**
      * Indicates whether the whole stage is finished.
      * @author kolja
      *
      */
-	public static enum StepStatus
+	public static enum StageStatus
 	{
 		UNFINISHED,
 		FINISHED
@@ -24,13 +24,14 @@ public interface AlgorithmStep {
 	/**
 	 * perform one atomic step of the algorithm
 	 * @return whether the whole stage is finished.
+     * For example if all steps are reverted, then {@code FINISHED} is returned.
 	 */
-	public StepStatus forwardStep();
+	public StageStatus forwardStep();
     
     /**
      * undo one atomic step of the algorithm
      * @return whether the whole stage is finished in backwards direction. 
      * For example if all steps are reverted, then {@code FINISHED} is returned.
      */
-	public StepStatus backwardStep();
+	public StageStatus backwardStep();
 }

src/Algorithms/Animated/AnimatedAlgorithm.java

@@ -2,7 +2,7 @@ package Algorithms.Animated;
 
 import Model.LayeredGraphNode;
 
-public abstract class AnimatedAlgorithm extends Thread implements AlgorithmStep {
+public abstract class AnimatedAlgorithm extends Thread implements AlgorithmStage {
 
 	protected AnimationController ac;
 	protected LayeredGraphNode graph;

src/Algorithms/Animated/BK/BKNodePlacement.java

@@ -1,6 +1,6 @@
 package Algorithms.Animated.BK;
 
-import Algorithms.Animated.AlgorithmStep;
+import Algorithms.Animated.AlgorithmStage;
 import Algorithms.Animated.AnimatedAlgorithm;
 import Algorithms.Animated.AnimationController;
 import Model.LayeredGraphNode;
@@ -36,54 +36,54 @@ public class BKNodePlacement extends AnimatedAlgorithm {
 	}
 
 	@Override
-	public StepStatus forwardStep() {
+	public StageStatus forwardStep() {
 		switch( state )
 		{
 		case LAYOUT1:
-			if( layouts[ 0 ].forwardStep() == AlgorithmStep.StepStatus.FINISHED )
+			if( layouts[ 0 ].forwardStep() == AlgorithmStage.StageStatus.FINISHED )
 				state = State.LAYOUT2;
 			break;
 		case LAYOUT2:
-			if( layouts[ 1 ].forwardStep() == AlgorithmStep.StepStatus.FINISHED )
+			if( layouts[ 1 ].forwardStep() == AlgorithmStage.StageStatus.FINISHED )
 				state = State.LAYOUT3;
 			break;
 		case LAYOUT3:
-			if( layouts[ 2 ].forwardStep() == AlgorithmStep.StepStatus.FINISHED )
+			if( layouts[ 2 ].forwardStep() == AlgorithmStage.StageStatus.FINISHED )
 				state = State.LAYOUT4;
 			break;
 		case LAYOUT4:
-			if( layouts[ 3 ].forwardStep() == AlgorithmStep.StepStatus.FINISHED )
+			if( layouts[ 3 ].forwardStep() == AlgorithmStage.StageStatus.FINISHED )
 				state = State.COMBINE;
 			break;
 		case COMBINE:
 			return combine.forwardStep();
 		}
-		return StepStatus.UNFINISHED;
+		return StageStatus.UNFINISHED;
 	}
 
 	@Override
-	public StepStatus backwardStep() {
+	public StageStatus backwardStep() {
 		switch( state )
 		{
 		case LAYOUT1:
 			return layouts[ 0 ].backwardStep();
 		case LAYOUT2:
-			if( layouts[ 1 ].backwardStep() == AlgorithmStep.StepStatus.FINISHED )
+			if( layouts[ 1 ].backwardStep() == AlgorithmStage.StageStatus.FINISHED )
 				state = State.LAYOUT1;
 			break;
 		case LAYOUT3:
-			if( layouts[ 2 ].backwardStep() == AlgorithmStep.StepStatus.FINISHED )
+			if( layouts[ 2 ].backwardStep() == AlgorithmStage.StageStatus.FINISHED )
 				state = State.LAYOUT2;
 			break;
 		case LAYOUT4:
-			if( layouts[ 3 ].backwardStep() == AlgorithmStep.StepStatus.FINISHED )
+			if( layouts[ 3 ].backwardStep() == AlgorithmStage.StageStatus.FINISHED )
 				state = State.LAYOUT3;
 			break;
 		case COMBINE:
-			if( combine.backwardStep() == AlgorithmStep.StepStatus.FINISHED )
+			if( combine.backwardStep() == AlgorithmStage.StageStatus.FINISHED )
 				state = State.LAYOUT4;
 			break;
 		}
-		return StepStatus.UNFINISHED;
+		return StageStatus.UNFINISHED;
 	}
 }

src/Algorithms/Animated/BK/BlockCalc.java

@@ -3,12 +3,12 @@ package Algorithms.Animated.BK;
 import java.awt.Color;
 import java.util.ArrayList;
 
-import Algorithms.Animated.AlgorithmStep;
+import Algorithms.Animated.AlgorithmStage;
 import Algorithms.Animated.BackwardAction;
 import Model.LayeredGraphEdge;
 import Model.LayeredGraphNode;
 
-public class BlockCalc implements AlgorithmStep {
+public class BlockCalc implements AlgorithmStage {
 
 	private int layerIndex;
 	private int nodeIndex;
@@ -37,7 +37,7 @@ public class BlockCalc implements AlgorithmStep {
 	}
 	
 	@Override
-	public StepStatus forwardStep() {
+	public StageStatus forwardStep() {
 		System.out.println( "test" );
 		LayeredGraphNode current = graph.getContainedLayers().get( layerIndex ).get( nodeIndex );
 		current.setSelected();
@@ -45,8 +45,8 @@ public class BlockCalc implements AlgorithmStep {
 		{
 			if( subgraphAlgs.get( layerIndex ).get( nodeIndex ) == null )
 				subgraphAlgs.get( layerIndex ).set( nodeIndex, new BKNodePlacement( null, current ) );
-			if( subgraphAlgs.get( layerIndex ).get( nodeIndex ).forwardStep() == StepStatus.UNFINISHED )
-				return StepStatus.UNFINISHED;
+			if( subgraphAlgs.get( layerIndex ).get( nodeIndex ).forwardStep() == StageStatus.UNFINISHED )
+				return StageStatus.UNFINISHED;
 		}
 		ArrayList< LayeredGraphEdge > incommingEdges = current.getIncomingEdges();
 		if( incommingEdges.size() == 0 )
@@ -108,12 +108,12 @@ public class BlockCalc implements AlgorithmStep {
 		return calcNextState();
 	}
 	
-	private StepStatus calcNextState()
+	private StageStatus calcNextState()
 	{
 		if( layerIndex >= graph.getContainedLayers().size() - 1 )
 		{
 			if( nodeIndex >= graph.getContainedLayers().get( layerIndex ).size() -1 )
-				return StepStatus.FINISHED;
+				return StageStatus.FINISHED;
 		}
 		nodeIndex++;
 		if( nodeIndex >= graph.getContainedLayers().get( layerIndex ).size() )
@@ -126,23 +126,23 @@ public class BlockCalc implements AlgorithmStep {
 			   this.r = oldR;
 			});
 		}
-		return StepStatus.UNFINISHED;
+		return StageStatus.UNFINISHED;
 	}
 
 	@Override
-	public StepStatus backwardStep() {
+	public StageStatus backwardStep() {
 		if( subgraphAlgs.get( layerIndex ).get( nodeIndex ) != null )
 		{
-			if( subgraphAlgs.get( layerIndex ).get( nodeIndex ).backwardStep() == StepStatus.UNFINISHED )
+			if( subgraphAlgs.get( layerIndex ).get( nodeIndex ).backwardStep() == StageStatus.UNFINISHED )
 			{
 				LayeredGraphNode current = graph.getContainedLayers().get( layerIndex ).get( nodeIndex );
 				current.setSelected();
 				//current.update();
-				return StepStatus.UNFINISHED;
+				return StageStatus.UNFINISHED;
 			}
 		}
-		StepStatus status = calcBeforeState();
-		if( status == StepStatus.FINISHED )
+		StageStatus status = calcBeforeState();
+		if( status == StageStatus.FINISHED )
 			return status;
 		LayeredGraphNode current = graph.getContainedLayers().get( layerIndex ).get( nodeIndex );
 		current.setSelected();
@@ -155,12 +155,12 @@ public class BlockCalc implements AlgorithmStep {
 		return status;
 	}
 	
-	private StepStatus calcBeforeState()
+	private StageStatus calcBeforeState()
 	{
 		if( layerIndex == 0 )
 		{
 			if( nodeIndex == 0 )
-				return StepStatus.FINISHED;
+				return StageStatus.FINISHED;
 		}
 		nodeIndex--;
 		if( nodeIndex < 0 )
@@ -170,6 +170,6 @@ public class BlockCalc implements AlgorithmStep {
 	        backwards.remove( 0 );
 			nodeIndex = graph.getContainedLayers().get( layerIndex ).size() - 1;
 		}
-		return StepStatus.UNFINISHED;
+		return StageStatus.UNFINISHED;
 	}
 }

src/Algorithms/Animated/BK/Combine.java

@@ -1,9 +1,9 @@
 package Algorithms.Animated.BK;
 
-import Algorithms.Animated.AlgorithmStep;
+import Algorithms.Animated.AlgorithmStage;
 import Model.LayeredGraphNode;
 
-public class Combine implements AlgorithmStep {
+public class Combine implements AlgorithmStage {
 
 	public Combine( LayeredGraphNode graph )
 	{
@@ -11,13 +11,13 @@ public class Combine implements AlgorithmStep {
 	}
 	
 	@Override
-	public StepStatus forwardStep() {
+	public StageStatus forwardStep() {
 		// TODO Auto-generated method stub
 		return null;
 	}
 
 	@Override
-	public StepStatus backwardStep() {
+	public StageStatus backwardStep() {
 		// TODO Auto-generated method stub
 		return null;
 	}

src/Algorithms/Animated/BK/Compaction.java

@@ -2,11 +2,11 @@ package Algorithms.Animated.BK;
 
 import java.util.ArrayList;
 
-import Algorithms.Animated.AlgorithmStep;
+import Algorithms.Animated.AlgorithmStage;
 import Algorithms.Animated.BackwardAction;
 import Model.LayeredGraphNode;
 
-public class Compaction implements AlgorithmStep{
+public class Compaction implements AlgorithmStage{
 
 	private enum CompactionState
 	{
@@ -46,7 +46,7 @@ public class Compaction implements AlgorithmStep{
 	}
 	
 	@Override
-	public StepStatus forwardStep() {
+	public StageStatus forwardStep() {
 		int acSize = actions.size();
 		if( state == CompactionState.PLACE_BLOCKS )
 		{
@@ -202,20 +202,20 @@ public class Compaction implements AlgorithmStep{
 			} );
 			vIndex++;
 			if( vIndex >= graph.getContainedNodes().size() )
-				return StepStatus.FINISHED;
+				return StageStatus.FINISHED;
 		}
 		if( actions.size() != acSize + 1 )
 			System.out.println( "ERROR" );
-		return StepStatus.UNFINISHED;
+		return StageStatus.UNFINISHED;
 	}
 
 	@Override
-	public StepStatus backwardStep() {
+	public StageStatus backwardStep() {
 		if( actions.size() == 0 )
-			return StepStatus.FINISHED;
+			return StageStatus.FINISHED;
 		actions.get( 0 ).reverse();
 		actions.remove( 0 );
-		return StepStatus.UNFINISHED;
+		return StageStatus.UNFINISHED;
 	}
 
 }

src/Algorithms/Animated/BK/Layout.java

@@ -1,9 +1,9 @@
 package Algorithms.Animated.BK;
 
-import Algorithms.Animated.AlgorithmStep;
+import Algorithms.Animated.AlgorithmStage;
 import Model.LayeredGraphNode;
 
-public class Layout implements AlgorithmStep {
+public class Layout implements AlgorithmStage {
 
 	public enum LayoutType{
 		TOP_BOTTOM_LEFT,
@@ -33,30 +33,30 @@ public class Layout implements AlgorithmStep {
 	}
 	
 	@Override
-	public StepStatus forwardStep() {
+	public StageStatus forwardStep() {
 		if( status == LayoutState.BLOCK_CALCULATION )
 		{
-			if( bc.forwardStep() == StepStatus.FINISHED )
+			if( bc.forwardStep() == StageStatus.FINISHED )
 			{
 				status = LayoutState.COMPACTION;
 			}
-			return StepStatus.UNFINISHED;
+			return StageStatus.UNFINISHED;
 		}
 		if( status == LayoutState.COMPACTION )
 			return cp.forwardStep();
-		return StepStatus.UNFINISHED;
+		return StageStatus.UNFINISHED;
 	}
 
 	@Override
-	public StepStatus backwardStep() {
+	public StageStatus backwardStep() {
 		if( status == LayoutState.BLOCK_CALCULATION )
 			return bc.backwardStep();
 		if( status == LayoutState.COMPACTION )
 		{
-			if( cp.backwardStep() == StepStatus.FINISHED )
+			if( cp.backwardStep() == StageStatus.FINISHED )
 				status = LayoutState.BLOCK_CALCULATION;
 		}
-		return StepStatus.UNFINISHED;
+		return StageStatus.UNFINISHED;
 	}
 
 }