Renamed to Isa88StateMachine

Author: aljoshakoecher

src/main/java/statemachine/Isa88StateMachine.java

@@ -5,18 +5,18 @@
 import states.State;
 import states.TransitionName;
 
-public class StateMachine {
+public class Isa88StateMachine {
 
 	private State currentState;
 	private StateActionManager stateActionManager = new StateActionManager();
 	private ArrayList<IStateChangeObserver> stateChangeObservers = new ArrayList<>();
 
 	/**
-	 * Instantiates a new {@link StateMachine} with the a given initial state
+	 * Instantiates a new {@link Isa88StateMachine} with the a given initial state
 	 * 
 	 * @param initialState State that the state machine is in upon starting
 	 */
-	StateMachine(State initialState) {
+	Isa88StateMachine(State initialState) {
 		this.currentState = initialState;
 	}
 
@@ -137,7 +137,7 @@ public State getState() {
 	 * 
 	 * @param state The new state that will be set as the current state
 	 */
-	protected void setState(State state) {
+	protected synchronized void setState(State state) {
 		this.currentState = state;
 	}
 
@@ -146,7 +146,7 @@ protected void setState(State state) {
 	 * 
 	 * @param state The new state that will be set as the current state
 	 */
-	public void setStateAndRunAction(State state) {
+	public synchronized void setStateAndRunAction(State state) {
 		this.currentState = state;
 
 		for (IStateChangeObserver observer : stateChangeObservers) {

src/main/java/statemachine/StateMachineBuilder.java

@@ -6,14 +6,14 @@
 import states.impl.*;
 
 /**
- * Builder class that is in charge of constructing a properly set up {@link StateMachine}
+ * Builder class that is in charge of constructing a properly set up {@link Isa88StateMachine}
  */
 public class StateMachineBuilder {
 
-	private StateMachine stateMachine;
+	private Isa88StateMachine stateMachine;
 
 	public StateMachineBuilder() {
-		this.stateMachine = new StateMachine(new IdleState());
+		this.stateMachine = new Isa88StateMachine(new IdleState());
 	}
 
 	/**
@@ -198,11 +198,11 @@ public StateMachineBuilder withActionInClearing(IStateAction action) {
 	}
 
 	/**
-	 * Finishes building the {@link StateMachine} and returns a fresh instance with the given attributes
+	 * Finishes building the {@link Isa88StateMachine} and returns a fresh instance with the given attributes
 	 * 
-	 * @return Fresh instance of {@link StateMachine}
+	 * @return Fresh instance of {@link Isa88StateMachine}
 	 */
-	public StateMachine build() {
+	public Isa88StateMachine build() {
 		return this.stateMachine;
 	}
 }

src/main/java/states/AbortableState.java

@@ -1,6 +1,6 @@
 package states;
 
-import statemachine.StateMachine;
+import statemachine.Isa88StateMachine;
 import states.impl.AbortingState;
 
 /**
@@ -9,11 +9,11 @@
 public abstract class AbortableState extends State {
 
 	@Override
-	public void abort(StateMachine stateMachine) {
+	public void abort(Isa88StateMachine stateMachine) {
 		stateMachine.setStateAndRunAction(new AbortingState());
 	}
 
 	@Override
-	public void stop(StateMachine stateMachine) {
+	public void stop(Isa88StateMachine stateMachine) {
 	}
 }

src/main/java/states/IState.java

@@ -1,6 +1,6 @@
 package states;
 
-import statemachine.StateMachine;
+import statemachine.Isa88StateMachine;
 import states.impl.AbortedState;
 import states.impl.AbortingState;
 import states.impl.ClearingState;
@@ -23,66 +23,66 @@ public interface IState {
 
 	/**
 	 * The start command does only have an effect in {@link IdleState}. With this command, the state machine will change to the {@link ExecuteState}
-	 * @param stateMachine A reference to the current {@link StateMachine} instance 
+	 * @param stateMachine A reference to the current {@link Isa88StateMachine} instance 
 	 */
-	public void start(StateMachine stateMachine);
+	public void start(Isa88StateMachine stateMachine);
 
 	/**
 	 * The hold command is used when interal reasons of a machine should bring it to an halt. Such reasons could be e.g. necessary refill of material.
 	 * With this command, the state machine will transition to a {@link HoldingState} and eventually come to a full {@link HeldState}.
-	 * @param stateMachine A reference to the current {@link StateMachine} instance 
+	 * @param stateMachine A reference to the current {@link Isa88StateMachine} instance 
 	 */
-	public void hold(StateMachine stateMachine);
+	public void hold(Isa88StateMachine stateMachine);
 
 	/**
 	 * The unhold command brings the machine into an {@link UnholdingState} that eventually leads back to the {@link ExecuteState}. The hold command
 	 * should be used when the internal reasons that brought a machine into a {@link HeldState} have been cleared.
-	 * @param stateMachine A reference to the current {@link StateMachine} instance 
+	 * @param stateMachine A reference to the current {@link Isa88StateMachine} instance 
 	 */
-	public void unhold(StateMachine stateMachine);
+	public void unhold(Isa88StateMachine stateMachine);
 
 	/**
 	 * The suspend command is used when extenal reasons of a machine should bring it to an halt. Such reasons could be e.g. waiting for following
 	 * machines to accept a workpiece. With this command, the state machine will transition to a {@link SuspendingState} and eventually come to a full
 	 * {@link SuspendedState}.
-	 * @param stateMachine A reference to the current {@link StateMachine} instance 
+	 * @param stateMachine A reference to the current {@link Isa88StateMachine} instance 
 	 */
-	public void suspend(StateMachine stateMachine);
+	public void suspend(Isa88StateMachine stateMachine);
 
 	/**
 	 * The unsuspend command brings the machine into an {@link UnsuspendingState} that eventually leads back to the {@link ExecuteState}. The
 	 * unsuspend command should be used when the external reasons that brought a machine into a {@link SuspendedState} have been cleared.
-	 * @param stateMachine A reference to the current {@link StateMachine} instance 
+	 * @param stateMachine A reference to the current {@link Isa88StateMachine} instance 
 	 */
-	public void unsuspend(StateMachine stateMachine);
+	public void unsuspend(Isa88StateMachine stateMachine);
 
 	/**
 	 * The reset command brings the machine into a {@link ResettingState} that eventually leads back to the {@link IdleState}. The reset command can
 	 * be used when the machine has been brought to a sudden halt (e.g. with stop or abort command)
-	 * @param stateMachine A reference to the current {@link StateMachine} instance 
+	 * @param stateMachine A reference to the current {@link Isa88StateMachine} instance 
 	 */
-	public void reset(StateMachine stateMachine);
+	public void reset(Isa88StateMachine stateMachine);
 
 	/**
 	 * The stop command can be triggered by an external system such as an MES. Stop brings the state machine to a {@link StoppingState} and from there
 	 * to a {@link StoppedState}. The currently produced product should not be destroyed and production can continue after the machine has been reset.
-	  * @param stateMachine A reference to the current {@link StateMachine} instance 
+	  * @param stateMachine A reference to the current {@link Isa88StateMachine} instance 
 	 */
-	public void stop(StateMachine stateMachine);
+	public void stop(Isa88StateMachine stateMachine);
 
 	/**
 	 * The abort command can be triggered by an external system such as an MES. Abort brings the state machine to a sudden stop by transitioning to
 	 * the {@link AbortingState} and eventually to the {@link AbortedState}. The machine is switched off, the currently produced product might have to
 	 * be destroyed and production of it can not be continued.
-	  * @param stateMachine A reference to the current {@link StateMachine} instance 
+	  * @param stateMachine A reference to the current {@link Isa88StateMachine} instance 
 	 */
-	public void abort(StateMachine stateMachine);
+	public void abort(Isa88StateMachine stateMachine);
 
 	/**
 	 * After a machine has been brought to the {@link AbortedState}, a clear command can be used to bring it to a {@link ClearingState} to e.g. remove
 	 * destroyed products. From the {@link ClearingState}, the machine will come to the {@link StoppedState} from which it then can be reset.
-	  * @param stateMachine A reference to the current {@link StateMachine} instance 
+	  * @param stateMachine A reference to the current {@link Isa88StateMachine} instance 
 	 */
-	public void clear(StateMachine stateMachine);
+	public void clear(Isa88StateMachine stateMachine);
 
 }

src/main/java/states/State.java

@@ -1,14 +1,14 @@
 package states;
 
-import statemachine.StateMachine;
+import statemachine.Isa88StateMachine;
 
 public abstract class State implements IState {
 
 	/**
 	 * Execute an action, complete this state and transition to the next state 
 	 * @param stateMachine The current state machine instance
 	 */
-	public void executeActionAndComplete(StateMachine stateMachine) {
+	public void executeActionAndComplete(Isa88StateMachine stateMachine) {
 		// Default implementation: Do nothing
 	}
 

src/main/java/states/StoppableState.java

@@ -1,6 +1,6 @@
 package states;
 
-import statemachine.StateMachine;
+import statemachine.Isa88StateMachine;
 import states.impl.StoppedState;
 
 /**
@@ -10,7 +10,7 @@ public abstract class StoppableState extends AbortableState {
 
 
 	@Override
-	public void stop(StateMachine stateMachine) {
+	public void stop(Isa88StateMachine stateMachine) {
 		// Execute the stop-method that the developer implemented (has that to be executed in another thread?)
 		// Inside of the thread: Update the state in the ontology to now be "Stopping"
 		// When the thread is done: Update the state in the ontology to now be "Stopped" (might have to be done in the other thread as well)

src/main/java/states/impl/AbortedState.java

@@ -1,6 +1,6 @@
 package states.impl;
 
-import statemachine.StateMachine;
+import statemachine.Isa88StateMachine;
 import states.State;
 
 /**
@@ -10,47 +10,47 @@
 public class AbortedState extends State {
 
 	@Override
-	public void start(StateMachine stateMachine) {
+	public void start(Isa88StateMachine stateMachine) {
 		// Start cannot be fired from Aborted -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void hold(StateMachine stateMachine) {
+	public void hold(Isa88StateMachine stateMachine) {
 		// Hold cannot be fired from Aborted -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void unhold(StateMachine stateMachine) {
+	public void unhold(Isa88StateMachine stateMachine) {
 		// Unhold cannot be fired from Aborted -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void suspend(StateMachine stateMachine) {
+	public void suspend(Isa88StateMachine stateMachine) {
 		// Suspend cannot be fired from Aborted -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void unsuspend(StateMachine stateMachine) {
+	public void unsuspend(Isa88StateMachine stateMachine) {
 		// Unsuspend cannot be fired from Aborted -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void reset(StateMachine stateMachine) {
+	public void reset(Isa88StateMachine stateMachine) {
 		// Reset cannot be fired from Aborted -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void stop(StateMachine stateMachine) {
+	public void stop(Isa88StateMachine stateMachine) {
 		// Stop cannot be fired from Aborted -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void abort(StateMachine stateMachine) {
+	public void abort(Isa88StateMachine stateMachine) {
 		// Abort cannot be fired from Aborted -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void clear(StateMachine stateMachine) {
+	public void clear(Isa88StateMachine stateMachine) {
 		stateMachine.setStateAndRunAction(new ClearingState());
 	}
 

src/main/java/states/impl/AbortingState.java

@@ -1,6 +1,6 @@
 package states.impl;
 
-import statemachine.StateMachine;
+import statemachine.Isa88StateMachine;
 import states.ActiveStateName;
 import states.IStateAction;
 import states.State;
@@ -12,52 +12,52 @@
 public class AbortingState extends State {
 
 	@Override
-	public void start(StateMachine stateMachine) {
+	public void start(Isa88StateMachine stateMachine) {
 		// Start cannot be fired from Aborting -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void hold(StateMachine stateMachine) {
+	public void hold(Isa88StateMachine stateMachine) {
 		// Hold cannot be fired from Aborting -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void unhold(StateMachine stateMachine) {
+	public void unhold(Isa88StateMachine stateMachine) {
 		// Unhold cannot be fired from Aborting -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void suspend(StateMachine stateMachine) {
+	public void suspend(Isa88StateMachine stateMachine) {
 		// Suspend cannot be fired from Aborting -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void unsuspend(StateMachine stateMachine) {
+	public void unsuspend(Isa88StateMachine stateMachine) {
 		// Unsuspend cannot be fired from Aborting -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void reset(StateMachine stateMachine) {
+	public void reset(Isa88StateMachine stateMachine) {
 		// Reset cannot be fired from Aborting -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void stop(StateMachine stateMachine) {
+	public void stop(Isa88StateMachine stateMachine) {
 		// Stop cannot be fired from Aborting -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void abort(StateMachine stateMachine) {
+	public void abort(Isa88StateMachine stateMachine) {
 		// Abort cannot be fired from Aborting -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void clear(StateMachine stateMachine) {
+	public void clear(Isa88StateMachine stateMachine) {
 		// Clear cannot be fired from Aborting -> Do nothing except maybe giving a warning
 	}
 
 	@Override
-	public void executeActionAndComplete(StateMachine stateMachine) {
+	public void executeActionAndComplete(Isa88StateMachine stateMachine) {
 		IStateAction actionToRun = stateMachine.getStateActionManager().getAction(ActiveStateName.Aborting);
 		super.executeAction(actionToRun);