DSMTP-SC/traffic_light_with_interrupts/src-gen/traffic/light/trafficlightctrl/TrafficLightCtrlStatemachine.java

package traffic.light.trafficlightctrl;
import java.util.LinkedList;
import java.util.List;
import traffic.light.ITimer;

public class TrafficLightCtrlStatemachine implements ITrafficLightCtrlStatemachine {

	protected class SCInterfaceImpl implements SCInterface {
	
		private List<SCInterfaceListener> listeners = new LinkedList<SCInterfaceListener>();
		
		public List<SCInterfaceListener> getListeners() {
			return listeners;
		}
		private boolean police_interrupt;
		
		public void raisePolice_interrupt() {
			police_interrupt = true;
		}
		
		private boolean displayRed;
		
		public boolean isRaisedDisplayRed() {
			return displayRed;
		}
		
		protected void raiseDisplayRed() {
			displayRed = true;
			for (SCInterfaceListener listener : listeners) {
				listener.onDisplayRedRaised();
			}
		}
		
		private boolean displayGreen;
		
		public boolean isRaisedDisplayGreen() {
			return displayGreen;
		}
		
		protected void raiseDisplayGreen() {
			displayGreen = true;
			for (SCInterfaceListener listener : listeners) {
				listener.onDisplayGreenRaised();
			}
		}
		
		private boolean displayYellow;
		
		public boolean isRaisedDisplayYellow() {
			return displayYellow;
		}
		
		protected void raiseDisplayYellow() {
			displayYellow = true;
			for (SCInterfaceListener listener : listeners) {
				listener.onDisplayYellowRaised();
			}
		}
		
		private boolean displayNone;
		
		public boolean isRaisedDisplayNone() {
			return displayNone;
		}
		
		protected void raiseDisplayNone() {
			displayNone = true;
			for (SCInterfaceListener listener : listeners) {
				listener.onDisplayNoneRaised();
			}
		}
		
		protected void clearEvents() {
			police_interrupt = false;
		}
		protected void clearOutEvents() {
		
		displayRed = false;
		displayGreen = false;
		displayYellow = false;
		displayNone = false;
		}
		
	}
	
	protected SCInterfaceImpl sCInterface;
	
	private boolean initialized = false;
	
	public enum State {
		main_normal,
		main_normal_normal_Yellow,
		main_normal_normal_Green,
		main_normal_normal_Red,
		main_interrupted,
		main_interrupted_interrupted_Black,
		main_interrupted_interrupted_Yellow,
		$NullState$
	};
	
	private final State[] stateVector = new State[1];
	
	private int nextStateIndex;
	
	private ITimer timer;
	
	private final boolean[] timeEvents = new boolean[5];
	public TrafficLightCtrlStatemachine() {
		sCInterface = new SCInterfaceImpl();
	}
	
	public void init() {
		this.initialized = true;
		if (timer == null) {
			throw new IllegalStateException("timer not set.");
		}
		for (int i = 0; i < 1; i++) {
			stateVector[i] = State.$NullState$;
		}
		clearEvents();
		clearOutEvents();
	}
	
	public void enter() {
		if (!initialized) {
			throw new IllegalStateException(
					"The state machine needs to be initialized first by calling the init() function.");
		}
		if (timer == null) {
			throw new IllegalStateException("timer not set.");
		}
		enterSequence_main_default();
	}
	
	public void exit() {
		exitSequence_main();
	}
	
	/**
	 * @see IStatemachine#isActive()
	 */
	public boolean isActive() {
		return stateVector[0] != State.$NullState$;
	}
	
	/** 
	* Always returns 'false' since this state machine can never become final.
	*
	* @see IStatemachine#isFinal()
	*/
	public boolean isFinal() {
		return false;
	}
	/**
	* This method resets the incoming events (time events included).
	*/
	protected void clearEvents() {
		sCInterface.clearEvents();
		for (int i=0; i<timeEvents.length; i++) {
			timeEvents[i] = false;
		}
	}
	
	/**
	* This method resets the outgoing events.
	*/
	protected void clearOutEvents() {
		sCInterface.clearOutEvents();
	}
	
	/**
	* Returns true if the given state is currently active otherwise false.
	*/
	public boolean isStateActive(State state) {
	
		switch (state) {
		case main_normal:
			return stateVector[0].ordinal() >= State.
					main_normal.ordinal()&& stateVector[0].ordinal() <= State.main_normal_normal_Red.ordinal();
		case main_normal_normal_Yellow:
			return stateVector[0] == State.main_normal_normal_Yellow;
		case main_normal_normal_Green:
			return stateVector[0] == State.main_normal_normal_Green;
		case main_normal_normal_Red:
			return stateVector[0] == State.main_normal_normal_Red;
		case main_interrupted:
			return stateVector[0].ordinal() >= State.
					main_interrupted.ordinal()&& stateVector[0].ordinal() <= State.main_interrupted_interrupted_Yellow.ordinal();
		case main_interrupted_interrupted_Black:
			return stateVector[0] == State.main_interrupted_interrupted_Black;
		case main_interrupted_interrupted_Yellow:
			return stateVector[0] == State.main_interrupted_interrupted_Yellow;
		default:
			return false;
		}
	}
	
	/**
	* Set the {@link ITimer} for the state machine. It must be set
	* externally on a timed state machine before a run cycle can be correct
	* executed.
	* 
	* @param timer
	*/
	public void setTimer(ITimer timer) {
		this.timer = timer;
	}
	
	/**
	* Returns the currently used timer.
	* 
	* @return {@link ITimer}
	*/
	public ITimer getTimer() {
		return timer;
	}
	
	public void timeElapsed(int eventID) {
		timeEvents[eventID] = true;
	}
	
	public SCInterface getSCInterface() {
		return sCInterface;
	}
	
	public void raisePolice_interrupt() {
		sCInterface.raisePolice_interrupt();
	}
	
	public boolean isRaisedDisplayRed() {
		return sCInterface.isRaisedDisplayRed();
	}
	
	public boolean isRaisedDisplayGreen() {
		return sCInterface.isRaisedDisplayGreen();
	}
	
	public boolean isRaisedDisplayYellow() {
		return sCInterface.isRaisedDisplayYellow();
	}
	
	public boolean isRaisedDisplayNone() {
		return sCInterface.isRaisedDisplayNone();
	}
	
	private boolean check_main_normal_tr0_tr0() {
		return sCInterface.police_interrupt;
	}
	
	private boolean check_main_normal_normal_Yellow_tr0_tr0() {
		return timeEvents[0];
	}
	
	private boolean check_main_normal_normal_Green_tr0_tr0() {
		return timeEvents[1];
	}
	
	private boolean check_main_normal_normal_Red_tr0_tr0() {
		return timeEvents[2];
	}
	
	private boolean check_main_interrupted_tr0_tr0() {
		return sCInterface.police_interrupt;
	}
	
	private boolean check_main_interrupted_interrupted_Black_tr0_tr0() {
		return timeEvents[3];
	}
	
	private boolean check_main_interrupted_interrupted_Yellow_tr0_tr0() {
		return timeEvents[4];
	}
	
	private void effect_main_normal_tr0() {
		exitSequence_main_normal();
		enterSequence_main_interrupted_default();
	}
	
	private void effect_main_normal_normal_Yellow_tr0() {
		exitSequence_main_normal_normal_Yellow();
		enterSequence_main_normal_normal_Red_default();
	}
	
	private void effect_main_normal_normal_Green_tr0() {
		exitSequence_main_normal_normal_Green();
		enterSequence_main_normal_normal_Yellow_default();
	}
	
	private void effect_main_normal_normal_Red_tr0() {
		exitSequence_main_normal_normal_Red();
		enterSequence_main_normal_normal_Green_default();
	}
	
	private void effect_main_interrupted_tr0() {
		exitSequence_main_interrupted();
		enterSequence_main_normal_default();
	}
	
	private void effect_main_interrupted_interrupted_Black_tr0() {
		exitSequence_main_interrupted_interrupted_Black();
		enterSequence_main_interrupted_interrupted_Yellow_default();
	}
	
	private void effect_main_interrupted_interrupted_Yellow_tr0() {
		exitSequence_main_interrupted_interrupted_Yellow();
		enterSequence_main_interrupted_interrupted_Black_default();
	}
	
	/* Entry action for state 'Yellow'. */
	private void entryAction_main_normal_normal_Yellow() {
		timer.setTimer(this, 0, 5 * 1000, false);
		
		sCInterface.raiseDisplayYellow();
	}
	
	/* Entry action for state 'Green'. */
	private void entryAction_main_normal_normal_Green() {
		timer.setTimer(this, 1, 55 * 1000, false);
		
		sCInterface.raiseDisplayGreen();
	}
	
	/* Entry action for state 'Red'. */
	private void entryAction_main_normal_normal_Red() {
		timer.setTimer(this, 2, 60 * 1000, false);
		
		sCInterface.raiseDisplayRed();
	}
	
	/* Entry action for state 'Black'. */
	private void entryAction_main_interrupted_interrupted_Black() {
		timer.setTimer(this, 3, 1 * 1000, false);
		
		sCInterface.raiseDisplayNone();
	}
	
	/* Entry action for state 'Yellow'. */
	private void entryAction_main_interrupted_interrupted_Yellow() {
		timer.setTimer(this, 4, 1 * 1000, false);
		
		sCInterface.raiseDisplayYellow();
	}
	
	/* Exit action for state 'Yellow'. */
	private void exitAction_main_normal_normal_Yellow() {
		timer.unsetTimer(this, 0);
	}
	
	/* Exit action for state 'Green'. */
	private void exitAction_main_normal_normal_Green() {
		timer.unsetTimer(this, 1);
	}
	
	/* Exit action for state 'Red'. */
	private void exitAction_main_normal_normal_Red() {
		timer.unsetTimer(this, 2);
	}
	
	/* Exit action for state 'Black'. */
	private void exitAction_main_interrupted_interrupted_Black() {
		timer.unsetTimer(this, 3);
	}
	
	/* Exit action for state 'Yellow'. */
	private void exitAction_main_interrupted_interrupted_Yellow() {
		timer.unsetTimer(this, 4);
	}
	
	/* 'default' enter sequence for state normal */
	private void enterSequence_main_normal_default() {
		enterSequence_main_normal_normal_default();
	}
	
	/* 'default' enter sequence for state Yellow */
	private void enterSequence_main_normal_normal_Yellow_default() {
		entryAction_main_normal_normal_Yellow();
		nextStateIndex = 0;
		stateVector[0] = State.main_normal_normal_Yellow;
	}
	
	/* 'default' enter sequence for state Green */
	private void enterSequence_main_normal_normal_Green_default() {
		entryAction_main_normal_normal_Green();
		nextStateIndex = 0;
		stateVector[0] = State.main_normal_normal_Green;
	}
	
	/* 'default' enter sequence for state Red */
	private void enterSequence_main_normal_normal_Red_default() {
		entryAction_main_normal_normal_Red();
		nextStateIndex = 0;
		stateVector[0] = State.main_normal_normal_Red;
	}
	
	/* 'default' enter sequence for state interrupted */
	private void enterSequence_main_interrupted_default() {
		enterSequence_main_interrupted_interrupted_default();
	}
	
	/* 'default' enter sequence for state Black */
	private void enterSequence_main_interrupted_interrupted_Black_default() {
		entryAction_main_interrupted_interrupted_Black();
		nextStateIndex = 0;
		stateVector[0] = State.main_interrupted_interrupted_Black;
	}
	
	/* 'default' enter sequence for state Yellow */
	private void enterSequence_main_interrupted_interrupted_Yellow_default() {
		entryAction_main_interrupted_interrupted_Yellow();
		nextStateIndex = 0;
		stateVector[0] = State.main_interrupted_interrupted_Yellow;
	}
	
	/* 'default' enter sequence for region main */
	private void enterSequence_main_default() {
		react_main__entry_Default();
	}
	
	/* 'default' enter sequence for region normal */
	private void enterSequence_main_normal_normal_default() {
		react_main_normal_normal__entry_Default();
	}
	
	/* 'default' enter sequence for region interrupted */
	private void enterSequence_main_interrupted_interrupted_default() {
		react_main_interrupted_interrupted__entry_Default();
	}
	
	/* Default exit sequence for state normal */
	private void exitSequence_main_normal() {
		exitSequence_main_normal_normal();
	}
	
	/* Default exit sequence for state Yellow */
	private void exitSequence_main_normal_normal_Yellow() {
		nextStateIndex = 0;
		stateVector[0] = State.$NullState$;
		
		exitAction_main_normal_normal_Yellow();
	}
	
	/* Default exit sequence for state Green */
	private void exitSequence_main_normal_normal_Green() {
		nextStateIndex = 0;
		stateVector[0] = State.$NullState$;
		
		exitAction_main_normal_normal_Green();
	}
	
	/* Default exit sequence for state Red */
	private void exitSequence_main_normal_normal_Red() {
		nextStateIndex = 0;
		stateVector[0] = State.$NullState$;
		
		exitAction_main_normal_normal_Red();
	}
	
	/* Default exit sequence for state interrupted */
	private void exitSequence_main_interrupted() {
		exitSequence_main_interrupted_interrupted();
	}
	
	/* Default exit sequence for state Black */
	private void exitSequence_main_interrupted_interrupted_Black() {
		nextStateIndex = 0;
		stateVector[0] = State.$NullState$;
		
		exitAction_main_interrupted_interrupted_Black();
	}
	
	/* Default exit sequence for state Yellow */
	private void exitSequence_main_interrupted_interrupted_Yellow() {
		nextStateIndex = 0;
		stateVector[0] = State.$NullState$;
		
		exitAction_main_interrupted_interrupted_Yellow();
	}
	
	/* Default exit sequence for region main */
	private void exitSequence_main() {
		switch (stateVector[0]) {
		case main_normal_normal_Yellow:
			exitSequence_main_normal_normal_Yellow();
			break;
		case main_normal_normal_Green:
			exitSequence_main_normal_normal_Green();
			break;
		case main_normal_normal_Red:
			exitSequence_main_normal_normal_Red();
			break;
		case main_interrupted_interrupted_Black:
			exitSequence_main_interrupted_interrupted_Black();
			break;
		case main_interrupted_interrupted_Yellow:
			exitSequence_main_interrupted_interrupted_Yellow();
			break;
		default:
			break;
		}
	}
	
	/* Default exit sequence for region normal */
	private void exitSequence_main_normal_normal() {
		switch (stateVector[0]) {
		case main_normal_normal_Yellow:
			exitSequence_main_normal_normal_Yellow();
			break;
		case main_normal_normal_Green:
			exitSequence_main_normal_normal_Green();
			break;
		case main_normal_normal_Red:
			exitSequence_main_normal_normal_Red();
			break;
		default:
			break;
		}
	}
	
	/* Default exit sequence for region interrupted */
	private void exitSequence_main_interrupted_interrupted() {
		switch (stateVector[0]) {
		case main_interrupted_interrupted_Black:
			exitSequence_main_interrupted_interrupted_Black();
			break;
		case main_interrupted_interrupted_Yellow:
			exitSequence_main_interrupted_interrupted_Yellow();
			break;
		default:
			break;
		}
	}
	
	/* The reactions of state Yellow. */
	private void react_main_normal_normal_Yellow() {
		if (check_main_normal_tr0_tr0()) {
			effect_main_normal_tr0();
		} else {
			if (check_main_normal_normal_Yellow_tr0_tr0()) {
				effect_main_normal_normal_Yellow_tr0();
			}
		}
	}
	
	/* The reactions of state Green. */
	private void react_main_normal_normal_Green() {
		if (check_main_normal_tr0_tr0()) {
			effect_main_normal_tr0();
		} else {
			if (check_main_normal_normal_Green_tr0_tr0()) {
				effect_main_normal_normal_Green_tr0();
			}
		}
	}
	
	/* The reactions of state Red. */
	private void react_main_normal_normal_Red() {
		if (check_main_normal_tr0_tr0()) {
			effect_main_normal_tr0();
		} else {
			if (check_main_normal_normal_Red_tr0_tr0()) {
				effect_main_normal_normal_Red_tr0();
			}
		}
	}
	
	/* The reactions of state Black. */
	private void react_main_interrupted_interrupted_Black() {
		if (check_main_interrupted_tr0_tr0()) {
			effect_main_interrupted_tr0();
		} else {
			if (check_main_interrupted_interrupted_Black_tr0_tr0()) {
				effect_main_interrupted_interrupted_Black_tr0();
			}
		}
	}
	
	/* The reactions of state Yellow. */
	private void react_main_interrupted_interrupted_Yellow() {
		if (check_main_interrupted_tr0_tr0()) {
			effect_main_interrupted_tr0();
		} else {
			if (check_main_interrupted_interrupted_Yellow_tr0_tr0()) {
				effect_main_interrupted_interrupted_Yellow_tr0();
			}
		}
	}
	
	/* Default react sequence for initial entry  */
	private void react_main__entry_Default() {
		enterSequence_main_normal_default();
	}
	
	/* Default react sequence for initial entry  */
	private void react_main_normal_normal__entry_Default() {
		enterSequence_main_normal_normal_Red_default();
	}
	
	/* Default react sequence for initial entry  */
	private void react_main_interrupted_interrupted__entry_Default() {
		enterSequence_main_interrupted_interrupted_Yellow_default();
	}
	
	public void runCycle() {
		if (!initialized)
			throw new IllegalStateException(
					"The state machine needs to be initialized first by calling the init() function.");
		clearOutEvents();
		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
			switch (stateVector[nextStateIndex]) {
			case main_normal_normal_Yellow:
				react_main_normal_normal_Yellow();
				break;
			case main_normal_normal_Green:
				react_main_normal_normal_Green();
				break;
			case main_normal_normal_Red:
				react_main_normal_normal_Red();
				break;
			case main_interrupted_interrupted_Black:
				react_main_interrupted_interrupted_Black();
				break;
			case main_interrupted_interrupted_Yellow:
				react_main_interrupted_interrupted_Yellow();
				break;
			default:
				// $NullState$
			}
		}
		clearEvents();
	}
}