DSMTP-SC/traffic_light_timer/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 boolean police_interrupt;
		
		public void raisePolice_interrupt() {
			police_interrupt = true;
		}
		
		private boolean toggle;
		
		public void raiseToggle() {
			toggle = true;
		}
		
		protected void clearEvents() {
			police_interrupt = false;
			toggle = false;
		}
	}
	
	protected SCInterfaceImpl sCInterface;
	
	protected class SCITrafficLightImpl implements SCITrafficLight {
	
		private List<SCITrafficLightListener> listeners = new LinkedList<SCITrafficLightListener>();
		
		public List<SCITrafficLightListener> getListeners() {
			return listeners;
		}
		private boolean displayRed;
		
		public boolean isRaisedDisplayRed() {
			return displayRed;
		}
		
		protected void raiseDisplayRed() {
			displayRed = true;
			for (SCITrafficLightListener listener : listeners) {
				listener.onDisplayRedRaised();
			}
		}
		
		private boolean displayGreen;
		
		public boolean isRaisedDisplayGreen() {
			return displayGreen;
		}
		
		protected void raiseDisplayGreen() {
			displayGreen = true;
			for (SCITrafficLightListener listener : listeners) {
				listener.onDisplayGreenRaised();
			}
		}
		
		private boolean displayYellow;
		
		public boolean isRaisedDisplayYellow() {
			return displayYellow;
		}
		
		protected void raiseDisplayYellow() {
			displayYellow = true;
			for (SCITrafficLightListener listener : listeners) {
				listener.onDisplayYellowRaised();
			}
		}
		
		private boolean displayNone;
		
		public boolean isRaisedDisplayNone() {
			return displayNone;
		}
		
		protected void raiseDisplayNone() {
			displayNone = true;
			for (SCITrafficLightListener listener : listeners) {
				listener.onDisplayNoneRaised();
			}
		}
		
		protected void clearEvents() {
		}
		protected void clearOutEvents() {
		
		displayRed = false;
		displayGreen = false;
		displayYellow = false;
		displayNone = false;
		}
		
	}
	
	protected SCITrafficLightImpl sCITrafficLight;
	
	protected class SCITimerImpl implements SCITimer {
	
		private List<SCITimerListener> listeners = new LinkedList<SCITimerListener>();
		
		public List<SCITimerListener> getListeners() {
			return listeners;
		}
		private boolean updateTimerColour;
		
		private String updateTimerColourValue;
		
		public boolean isRaisedUpdateTimerColour() {
			return updateTimerColour;
		}
		
		protected void raiseUpdateTimerColour(String value) {
			updateTimerColour = true;
			updateTimerColourValue = value;
			for (SCITimerListener listener : listeners) {
				listener.onUpdateTimerColourRaised(value);
			}
		}
		
		public String getUpdateTimerColourValue() {
			if (! updateTimerColour ) 
				throw new IllegalStateException("Illegal event value access. Event UpdateTimerColour is not raised!");
			return updateTimerColourValue;
		}
		
		private boolean updateTimerValue;
		
		private long updateTimerValueValue;
		
		public boolean isRaisedUpdateTimerValue() {
			return updateTimerValue;
		}
		
		protected void raiseUpdateTimerValue(long value) {
			updateTimerValue = true;
			updateTimerValueValue = value;
			for (SCITimerListener listener : listeners) {
				listener.onUpdateTimerValueRaised(value);
			}
		}
		
		public long getUpdateTimerValueValue() {
			if (! updateTimerValue ) 
				throw new IllegalStateException("Illegal event value access. Event UpdateTimerValue is not raised!");
			return updateTimerValueValue;
		}
		
		protected void clearEvents() {
		}
		protected void clearOutEvents() {
		
		updateTimerColour = false;
		updateTimerValue = false;
		}
		
	}
	
	protected SCITimerImpl sCITimer;
	
	private boolean initialized = false;
	
	public enum State {
		main_main,
		main_main_trafficlight_interrupted,
		main_main_trafficlight_interrupted_blinking_Black,
		main_main_trafficlight_interrupted_blinking_Yellow,
		main_main_trafficlight_normal,
		main_main_trafficlight_normal_normal_Red,
		main_main_trafficlight_normal_normal_Yellow,
		main_main_trafficlight_normal_normal_Green,
		main_main_timer_Disabled,
		main_main_timer_running,
		main_main_timer_running_running_DecidingColor,
		main_main_timer_running_running_Green,
		main_main_timer_running_running_Red,
		main_off,
		$NullState$
	};
	
	private State[] historyVector = new State[1];
	private final State[] stateVector = new State[2];
	
	private int nextStateIndex;
	
	private ITimer timer;
	
	private final boolean[] timeEvents = new boolean[7];
	
	private boolean resetTimer;
	
	private boolean disableTimer;
	
	private boolean enableTimer;
	private long counter;
	
	protected void setCounter(long value) {
		counter = value;
	}
	
	protected long getCounter() {
		return counter;
	}
	
	public TrafficLightCtrlStatemachine() {
		sCInterface = new SCInterfaceImpl();
		sCITrafficLight = new SCITrafficLightImpl();
		sCITimer = new SCITimerImpl();
	}
	
	public void init() {
		this.initialized = true;
		if (timer == null) {
			throw new IllegalStateException("timer not set.");
		}
		for (int i = 0; i < 2; i++) {
			stateVector[i] = State.$NullState$;
		}
		for (int i = 0; i < 1; i++) {
			historyVector[i] = State.$NullState$;
		}
		clearEvents();
		clearOutEvents();
		setCounter(0);
	}
	
	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$||stateVector[1] != 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();
		sCITrafficLight.clearEvents();
		sCITimer.clearEvents();
		resetTimer = false;
		disableTimer = false;
		enableTimer = false;
		for (int i=0; i<timeEvents.length; i++) {
			timeEvents[i] = false;
		}
	}
	
	/**
	* This method resets the outgoing events.
	*/
	protected void clearOutEvents() {
		sCITrafficLight.clearOutEvents();
		sCITimer.clearOutEvents();
	}
	
	/**
	* Returns true if the given state is currently active otherwise false.
	*/
	public boolean isStateActive(State state) {
	
		switch (state) {
		case main_main:
			return stateVector[0].ordinal() >= State.
					main_main.ordinal()&& stateVector[0].ordinal() <= State.main_main_timer_running_running_Red.ordinal();
		case main_main_trafficlight_interrupted:
			return stateVector[0].ordinal() >= State.
					main_main_trafficlight_interrupted.ordinal()&& stateVector[0].ordinal() <= State.main_main_trafficlight_interrupted_blinking_Yellow.ordinal();
		case main_main_trafficlight_interrupted_blinking_Black:
			return stateVector[0] == State.main_main_trafficlight_interrupted_blinking_Black;
		case main_main_trafficlight_interrupted_blinking_Yellow:
			return stateVector[0] == State.main_main_trafficlight_interrupted_blinking_Yellow;
		case main_main_trafficlight_normal:
			return stateVector[0].ordinal() >= State.
					main_main_trafficlight_normal.ordinal()&& stateVector[0].ordinal() <= State.main_main_trafficlight_normal_normal_Green.ordinal();
		case main_main_trafficlight_normal_normal_Red:
			return stateVector[0] == State.main_main_trafficlight_normal_normal_Red;
		case main_main_trafficlight_normal_normal_Yellow:
			return stateVector[0] == State.main_main_trafficlight_normal_normal_Yellow;
		case main_main_trafficlight_normal_normal_Green:
			return stateVector[0] == State.main_main_trafficlight_normal_normal_Green;
		case main_main_timer_Disabled:
			return stateVector[1] == State.main_main_timer_Disabled;
		case main_main_timer_running:
			return stateVector[1].ordinal() >= State.
					main_main_timer_running.ordinal()&& stateVector[1].ordinal() <= State.main_main_timer_running_running_Red.ordinal();
		case main_main_timer_running_running_DecidingColor:
			return stateVector[1] == State.main_main_timer_running_running_DecidingColor;
		case main_main_timer_running_running_Green:
			return stateVector[1] == State.main_main_timer_running_running_Green;
		case main_main_timer_running_running_Red:
			return stateVector[1] == State.main_main_timer_running_running_Red;
		case main_off:
			return stateVector[0] == State.main_off;
		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 SCITrafficLight getSCITrafficLight() {
		return sCITrafficLight;
	}
	
	public SCITimer getSCITimer() {
		return sCITimer;
	}
	
	private void raiseResetTimer() {
		resetTimer = true;
	}
	
	
	private void raiseDisableTimer() {
		disableTimer = true;
	}
	
	
	private void raiseEnableTimer() {
		enableTimer = true;
	}
	
	
	public void raisePolice_interrupt() {
		sCInterface.raisePolice_interrupt();
	}
	
	public void raiseToggle() {
		sCInterface.raiseToggle();
	}
	
	private boolean check_main_main_tr0_tr0() {
		return sCInterface.toggle;
	}
	
	private boolean check_main_main_trafficlight_interrupted_tr0_tr0() {
		return sCInterface.police_interrupt;
	}
	
	private boolean check_main_main_trafficlight_interrupted_blinking_Black_tr0_tr0() {
		return timeEvents[0];
	}
	
	private boolean check_main_main_trafficlight_interrupted_blinking_Yellow_tr0_tr0() {
		return timeEvents[1];
	}
	
	private boolean check_main_main_trafficlight_normal_tr0_tr0() {
		return sCInterface.police_interrupt;
	}
	
	private boolean check_main_main_trafficlight_normal_normal_Red_tr0_tr0() {
		return timeEvents[2];
	}
	
	private boolean check_main_main_trafficlight_normal_normal_Yellow_tr0_tr0() {
		return timeEvents[3];
	}
	
	private boolean check_main_main_trafficlight_normal_normal_Green_tr0_tr0() {
		return timeEvents[4];
	}
	
	private boolean check_main_main_timer_Disabled_tr0_tr0() {
		return enableTimer;
	}
	
	private boolean check_main_main_timer_running_tr0_tr0() {
		return disableTimer;
	}
	
	private boolean check_main_main_timer_running_tr1_tr1() {
		return resetTimer;
	}
	
	private boolean check_main_main_timer_running_running_DecidingColor_tr0_tr0() {
		return isStateActive(State.main_main_trafficlight_normal_normal_Green);
	}
	
	private boolean check_main_main_timer_running_running_DecidingColor_tr1_tr1() {
		return isStateActive(State.main_main_trafficlight_normal_normal_Red);
	}
	
	private boolean check_main_main_timer_running_running_Green_tr0_tr0() {
		return timeEvents[5];
	}
	
	private boolean check_main_main_timer_running_running_Red_tr0_tr0() {
		return timeEvents[6];
	}
	
	private boolean check_main_off_tr0_tr0() {
		return sCInterface.toggle;
	}
	
	private void effect_main_main_tr0() {
		exitSequence_main_main();
		enterSequence_main_off_default();
	}
	
	private void effect_main_main_trafficlight_interrupted_tr0() {
		exitSequence_main_main_trafficlight_interrupted();
		raiseEnableTimer();
		
		react_main_main_trafficlight_normal_normal_hist();
	}
	
	private void effect_main_main_trafficlight_interrupted_blinking_Black_tr0() {
		exitSequence_main_main_trafficlight_interrupted_blinking_Black();
		enterSequence_main_main_trafficlight_interrupted_blinking_Yellow_default();
	}
	
	private void effect_main_main_trafficlight_interrupted_blinking_Yellow_tr0() {
		exitSequence_main_main_trafficlight_interrupted_blinking_Yellow();
		enterSequence_main_main_trafficlight_interrupted_blinking_Black_default();
	}
	
	private void effect_main_main_trafficlight_normal_tr0() {
		exitSequence_main_main_trafficlight_normal();
		raiseDisableTimer();
		
		enterSequence_main_main_trafficlight_interrupted_default();
	}
	
	private void effect_main_main_trafficlight_normal_normal_Red_tr0() {
		exitSequence_main_main_trafficlight_normal_normal_Red();
		enterSequence_main_main_trafficlight_normal_normal_Green_default();
	}
	
	private void effect_main_main_trafficlight_normal_normal_Yellow_tr0() {
		exitSequence_main_main_trafficlight_normal_normal_Yellow();
		raiseEnableTimer();
		
		enterSequence_main_main_trafficlight_normal_normal_Red_default();
	}
	
	private void effect_main_main_trafficlight_normal_normal_Green_tr0() {
		exitSequence_main_main_trafficlight_normal_normal_Green();
		enterSequence_main_main_trafficlight_normal_normal_Yellow_default();
	}
	
	private void effect_main_main_timer_Disabled_tr0() {
		exitSequence_main_main_timer_Disabled();
		enterSequence_main_main_timer_running_default();
	}
	
	private void effect_main_main_timer_running_tr0() {
		exitSequence_main_main_timer_running();
		enterSequence_main_main_timer_Disabled_default();
	}
	
	private void effect_main_main_timer_running_tr1() {
		exitSequence_main_main_timer_running();
		enterSequence_main_main_timer_running_default();
	}
	
	private void effect_main_main_timer_running_running_DecidingColor_tr0() {
		exitSequence_main_main_timer_running_running_DecidingColor();
		sCITimer.raiseUpdateTimerColour("Green");
		
		enterSequence_main_main_timer_running_running_Green_default();
	}
	
	private void effect_main_main_timer_running_running_DecidingColor_tr1() {
		exitSequence_main_main_timer_running_running_DecidingColor();
		sCITimer.raiseUpdateTimerColour("Red");
		
		enterSequence_main_main_timer_running_running_Red_default();
	}
	
	private void effect_main_main_timer_running_running_Green_tr0() {
		exitSequence_main_main_timer_running_running_Green();
		setCounter(getCounter() - 1);
		
		enterSequence_main_main_timer_running_running_Green_default();
	}
	
	private void effect_main_main_timer_running_running_Red_tr0() {
		exitSequence_main_main_timer_running_running_Red();
		setCounter(getCounter() - 1);
		
		enterSequence_main_main_timer_running_running_Red_default();
	}
	
	private void effect_main_off_tr0() {
		exitSequence_main_off();
		enterSequence_main_main_default();
	}
	
	/* Entry action for state 'Black'. */
	private void entryAction_main_main_trafficlight_interrupted_blinking_Black() {
		timer.setTimer(this, 0, 500, false);
		
		sCITrafficLight.raiseDisplayNone();
	}
	
	/* Entry action for state 'Yellow'. */
	private void entryAction_main_main_trafficlight_interrupted_blinking_Yellow() {
		timer.setTimer(this, 1, 500, false);
		
		sCITrafficLight.raiseDisplayYellow();
	}
	
	/* Entry action for state 'Red'. */
	private void entryAction_main_main_trafficlight_normal_normal_Red() {
		timer.setTimer(this, 2, 60 * 1000, false);
		
		sCITrafficLight.raiseDisplayRed();
		
		setCounter(60);
		
		raiseResetTimer();
	}
	
	/* Entry action for state 'Yellow'. */
	private void entryAction_main_main_trafficlight_normal_normal_Yellow() {
		timer.setTimer(this, 3, 5 * 1000, false);
		
		sCITrafficLight.raiseDisplayYellow();
		
		raiseDisableTimer();
	}
	
	/* Entry action for state 'Green'. */
	private void entryAction_main_main_trafficlight_normal_normal_Green() {
		timer.setTimer(this, 4, 55 * 1000, false);
		
		sCITrafficLight.raiseDisplayGreen();
		
		setCounter(55);
		
		raiseResetTimer();
	}
	
	/* Entry action for state 'Green'. */
	private void entryAction_main_main_timer_running_running_Green() {
		timer.setTimer(this, 5, 1 * 1000, false);
		
		sCITimer.raiseUpdateTimerValue(getCounter());
	}
	
	/* Entry action for state 'Red'. */
	private void entryAction_main_main_timer_running_running_Red() {
		timer.setTimer(this, 6, 1 * 1000, false);
		
		sCITimer.raiseUpdateTimerValue(getCounter());
	}
	
	/* Exit action for state 'main'. */
	private void exitAction_main_main() {
		sCITrafficLight.raiseDisplayNone();
	}
	
	/* Exit action for state 'Black'. */
	private void exitAction_main_main_trafficlight_interrupted_blinking_Black() {
		timer.unsetTimer(this, 0);
	}
	
	/* Exit action for state 'Yellow'. */
	private void exitAction_main_main_trafficlight_interrupted_blinking_Yellow() {
		timer.unsetTimer(this, 1);
	}
	
	/* Exit action for state 'Red'. */
	private void exitAction_main_main_trafficlight_normal_normal_Red() {
		timer.unsetTimer(this, 2);
	}
	
	/* Exit action for state 'Yellow'. */
	private void exitAction_main_main_trafficlight_normal_normal_Yellow() {
		timer.unsetTimer(this, 3);
	}
	
	/* Exit action for state 'Green'. */
	private void exitAction_main_main_trafficlight_normal_normal_Green() {
		timer.unsetTimer(this, 4);
	}
	
	/* Exit action for state 'running'. */
	private void exitAction_main_main_timer_running() {
		sCITimer.raiseUpdateTimerValue(-1);
	}
	
	/* Exit action for state 'Green'. */
	private void exitAction_main_main_timer_running_running_Green() {
		timer.unsetTimer(this, 5);
	}
	
	/* Exit action for state 'Red'. */
	private void exitAction_main_main_timer_running_running_Red() {
		timer.unsetTimer(this, 6);
	}
	
	/* 'default' enter sequence for state main */
	private void enterSequence_main_main_default() {
		enterSequence_main_main_trafficlight_default();
		enterSequence_main_main_timer_default();
	}
	
	/* 'default' enter sequence for state interrupted */
	private void enterSequence_main_main_trafficlight_interrupted_default() {
		enterSequence_main_main_trafficlight_interrupted_blinking_default();
	}
	
	/* 'default' enter sequence for state Black */
	private void enterSequence_main_main_trafficlight_interrupted_blinking_Black_default() {
		entryAction_main_main_trafficlight_interrupted_blinking_Black();
		nextStateIndex = 0;
		stateVector[0] = State.main_main_trafficlight_interrupted_blinking_Black;
	}
	
	/* 'default' enter sequence for state Yellow */
	private void enterSequence_main_main_trafficlight_interrupted_blinking_Yellow_default() {
		entryAction_main_main_trafficlight_interrupted_blinking_Yellow();
		nextStateIndex = 0;
		stateVector[0] = State.main_main_trafficlight_interrupted_blinking_Yellow;
	}
	
	/* 'default' enter sequence for state normal */
	private void enterSequence_main_main_trafficlight_normal_default() {
		enterSequence_main_main_trafficlight_normal_normal_default();
	}
	
	/* 'default' enter sequence for state Red */
	private void enterSequence_main_main_trafficlight_normal_normal_Red_default() {
		entryAction_main_main_trafficlight_normal_normal_Red();
		nextStateIndex = 0;
		stateVector[0] = State.main_main_trafficlight_normal_normal_Red;
		
		historyVector[0] = stateVector[0];
	}
	
	/* 'default' enter sequence for state Yellow */
	private void enterSequence_main_main_trafficlight_normal_normal_Yellow_default() {
		entryAction_main_main_trafficlight_normal_normal_Yellow();
		nextStateIndex = 0;
		stateVector[0] = State.main_main_trafficlight_normal_normal_Yellow;
		
		historyVector[0] = stateVector[0];
	}
	
	/* 'default' enter sequence for state Green */
	private void enterSequence_main_main_trafficlight_normal_normal_Green_default() {
		entryAction_main_main_trafficlight_normal_normal_Green();
		nextStateIndex = 0;
		stateVector[0] = State.main_main_trafficlight_normal_normal_Green;
		
		historyVector[0] = stateVector[0];
	}
	
	/* 'default' enter sequence for state Disabled */
	private void enterSequence_main_main_timer_Disabled_default() {
		nextStateIndex = 1;
		stateVector[1] = State.main_main_timer_Disabled;
	}
	
	/* 'default' enter sequence for state running */
	private void enterSequence_main_main_timer_running_default() {
		enterSequence_main_main_timer_running_running_default();
	}
	
	/* 'default' enter sequence for state DecidingColor */
	private void enterSequence_main_main_timer_running_running_DecidingColor_default() {
		nextStateIndex = 1;
		stateVector[1] = State.main_main_timer_running_running_DecidingColor;
	}
	
	/* 'default' enter sequence for state Green */
	private void enterSequence_main_main_timer_running_running_Green_default() {
		entryAction_main_main_timer_running_running_Green();
		nextStateIndex = 1;
		stateVector[1] = State.main_main_timer_running_running_Green;
	}
	
	/* 'default' enter sequence for state Red */
	private void enterSequence_main_main_timer_running_running_Red_default() {
		entryAction_main_main_timer_running_running_Red();
		nextStateIndex = 1;
		stateVector[1] = State.main_main_timer_running_running_Red;
	}
	
	/* 'default' enter sequence for state off */
	private void enterSequence_main_off_default() {
		nextStateIndex = 0;
		stateVector[0] = State.main_off;
	}
	
	/* 'default' enter sequence for region main */
	private void enterSequence_main_default() {
		react_main__entry_Default();
	}
	
	/* 'default' enter sequence for region trafficlight */
	private void enterSequence_main_main_trafficlight_default() {
		react_main_main_trafficlight__entry_Default();
	}
	
	/* 'default' enter sequence for region blinking */
	private void enterSequence_main_main_trafficlight_interrupted_blinking_default() {
		react_main_main_trafficlight_interrupted_blinking__entry_Default();
	}
	
	/* 'default' enter sequence for region normal */
	private void enterSequence_main_main_trafficlight_normal_normal_default() {
		react_main_main_trafficlight_normal_normal__entry_Default();
	}
	
	/* deep enterSequence with history in child normal */
	private void deepEnterSequence_main_main_trafficlight_normal_normal() {
		switch (historyVector[0]) {
		case main_main_trafficlight_normal_normal_Red:
			enterSequence_main_main_trafficlight_normal_normal_Red_default();
			break;
		case main_main_trafficlight_normal_normal_Yellow:
			enterSequence_main_main_trafficlight_normal_normal_Yellow_default();
			break;
		case main_main_trafficlight_normal_normal_Green:
			enterSequence_main_main_trafficlight_normal_normal_Green_default();
			break;
		default:
			break;
		}
	}
	
	/* 'default' enter sequence for region timer */
	private void enterSequence_main_main_timer_default() {
		react_main_main_timer__entry_Default();
	}
	
	/* 'default' enter sequence for region running */
	private void enterSequence_main_main_timer_running_running_default() {
		react_main_main_timer_running_running__entry_Default();
	}
	
	/* Default exit sequence for state main */
	private void exitSequence_main_main() {
		exitSequence_main_main_trafficlight();
		exitSequence_main_main_timer();
		exitAction_main_main();
	}
	
	/* Default exit sequence for state interrupted */
	private void exitSequence_main_main_trafficlight_interrupted() {
		exitSequence_main_main_trafficlight_interrupted_blinking();
	}
	
	/* Default exit sequence for state Black */
	private void exitSequence_main_main_trafficlight_interrupted_blinking_Black() {
		nextStateIndex = 0;
		stateVector[0] = State.$NullState$;
		
		exitAction_main_main_trafficlight_interrupted_blinking_Black();
	}
	
	/* Default exit sequence for state Yellow */
	private void exitSequence_main_main_trafficlight_interrupted_blinking_Yellow() {
		nextStateIndex = 0;
		stateVector[0] = State.$NullState$;
		
		exitAction_main_main_trafficlight_interrupted_blinking_Yellow();
	}
	
	/* Default exit sequence for state normal */
	private void exitSequence_main_main_trafficlight_normal() {
		exitSequence_main_main_trafficlight_normal_normal();
	}
	
	/* Default exit sequence for state Red */
	private void exitSequence_main_main_trafficlight_normal_normal_Red() {
		nextStateIndex = 0;
		stateVector[0] = State.$NullState$;
		
		exitAction_main_main_trafficlight_normal_normal_Red();
	}
	
	/* Default exit sequence for state Yellow */
	private void exitSequence_main_main_trafficlight_normal_normal_Yellow() {
		nextStateIndex = 0;
		stateVector[0] = State.$NullState$;
		
		exitAction_main_main_trafficlight_normal_normal_Yellow();
	}
	
	/* Default exit sequence for state Green */
	private void exitSequence_main_main_trafficlight_normal_normal_Green() {
		nextStateIndex = 0;
		stateVector[0] = State.$NullState$;
		
		exitAction_main_main_trafficlight_normal_normal_Green();
	}
	
	/* Default exit sequence for state Disabled */
	private void exitSequence_main_main_timer_Disabled() {
		nextStateIndex = 1;
		stateVector[1] = State.$NullState$;
	}
	
	/* Default exit sequence for state running */
	private void exitSequence_main_main_timer_running() {
		exitSequence_main_main_timer_running_running();
		exitAction_main_main_timer_running();
	}
	
	/* Default exit sequence for state DecidingColor */
	private void exitSequence_main_main_timer_running_running_DecidingColor() {
		nextStateIndex = 1;
		stateVector[1] = State.$NullState$;
	}
	
	/* Default exit sequence for state Green */
	private void exitSequence_main_main_timer_running_running_Green() {
		nextStateIndex = 1;
		stateVector[1] = State.$NullState$;
		
		exitAction_main_main_timer_running_running_Green();
	}
	
	/* Default exit sequence for state Red */
	private void exitSequence_main_main_timer_running_running_Red() {
		nextStateIndex = 1;
		stateVector[1] = State.$NullState$;
		
		exitAction_main_main_timer_running_running_Red();
	}
	
	/* Default exit sequence for state off */
	private void exitSequence_main_off() {
		nextStateIndex = 0;
		stateVector[0] = State.$NullState$;
	}
	
	/* Default exit sequence for region main */
	private void exitSequence_main() {
		switch (stateVector[0]) {
		case main_main_trafficlight_interrupted_blinking_Black:
			exitSequence_main_main_trafficlight_interrupted_blinking_Black();
			break;
		case main_main_trafficlight_interrupted_blinking_Yellow:
			exitSequence_main_main_trafficlight_interrupted_blinking_Yellow();
			break;
		case main_main_trafficlight_normal_normal_Red:
			exitSequence_main_main_trafficlight_normal_normal_Red();
			break;
		case main_main_trafficlight_normal_normal_Yellow:
			exitSequence_main_main_trafficlight_normal_normal_Yellow();
			break;
		case main_main_trafficlight_normal_normal_Green:
			exitSequence_main_main_trafficlight_normal_normal_Green();
			break;
		case main_off:
			exitSequence_main_off();
			break;
		default:
			break;
		}
		
		switch (stateVector[1]) {
		case main_main_timer_Disabled:
			exitSequence_main_main_timer_Disabled();
			exitAction_main_main();
			break;
		case main_main_timer_running_running_DecidingColor:
			exitSequence_main_main_timer_running_running_DecidingColor();
			exitAction_main_main_timer_running();
			exitAction_main_main();
			break;
		case main_main_timer_running_running_Green:
			exitSequence_main_main_timer_running_running_Green();
			exitAction_main_main_timer_running();
			exitAction_main_main();
			break;
		case main_main_timer_running_running_Red:
			exitSequence_main_main_timer_running_running_Red();
			exitAction_main_main_timer_running();
			exitAction_main_main();
			break;
		default:
			break;
		}
	}
	
	/* Default exit sequence for region trafficlight */
	private void exitSequence_main_main_trafficlight() {
		switch (stateVector[0]) {
		case main_main_trafficlight_interrupted_blinking_Black:
			exitSequence_main_main_trafficlight_interrupted_blinking_Black();
			break;
		case main_main_trafficlight_interrupted_blinking_Yellow:
			exitSequence_main_main_trafficlight_interrupted_blinking_Yellow();
			break;
		case main_main_trafficlight_normal_normal_Red:
			exitSequence_main_main_trafficlight_normal_normal_Red();
			break;
		case main_main_trafficlight_normal_normal_Yellow:
			exitSequence_main_main_trafficlight_normal_normal_Yellow();
			break;
		case main_main_trafficlight_normal_normal_Green:
			exitSequence_main_main_trafficlight_normal_normal_Green();
			break;
		default:
			break;
		}
	}
	
	/* Default exit sequence for region blinking */
	private void exitSequence_main_main_trafficlight_interrupted_blinking() {
		switch (stateVector[0]) {
		case main_main_trafficlight_interrupted_blinking_Black:
			exitSequence_main_main_trafficlight_interrupted_blinking_Black();
			break;
		case main_main_trafficlight_interrupted_blinking_Yellow:
			exitSequence_main_main_trafficlight_interrupted_blinking_Yellow();
			break;
		default:
			break;
		}
	}
	
	/* Default exit sequence for region normal */
	private void exitSequence_main_main_trafficlight_normal_normal() {
		switch (stateVector[0]) {
		case main_main_trafficlight_normal_normal_Red:
			exitSequence_main_main_trafficlight_normal_normal_Red();
			break;
		case main_main_trafficlight_normal_normal_Yellow:
			exitSequence_main_main_trafficlight_normal_normal_Yellow();
			break;
		case main_main_trafficlight_normal_normal_Green:
			exitSequence_main_main_trafficlight_normal_normal_Green();
			break;
		default:
			break;
		}
	}
	
	/* Default exit sequence for region timer */
	private void exitSequence_main_main_timer() {
		switch (stateVector[1]) {
		case main_main_timer_Disabled:
			exitSequence_main_main_timer_Disabled();
			break;
		case main_main_timer_running_running_DecidingColor:
			exitSequence_main_main_timer_running_running_DecidingColor();
			exitAction_main_main_timer_running();
			break;
		case main_main_timer_running_running_Green:
			exitSequence_main_main_timer_running_running_Green();
			exitAction_main_main_timer_running();
			break;
		case main_main_timer_running_running_Red:
			exitSequence_main_main_timer_running_running_Red();
			exitAction_main_main_timer_running();
			break;
		default:
			break;
		}
	}
	
	/* Default exit sequence for region running */
	private void exitSequence_main_main_timer_running_running() {
		switch (stateVector[1]) {
		case main_main_timer_running_running_DecidingColor:
			exitSequence_main_main_timer_running_running_DecidingColor();
			break;
		case main_main_timer_running_running_Green:
			exitSequence_main_main_timer_running_running_Green();
			break;
		case main_main_timer_running_running_Red:
			exitSequence_main_main_timer_running_running_Red();
			break;
		default:
			break;
		}
	}
	
	/* The reactions of state Black. */
	private void react_main_main_trafficlight_interrupted_blinking_Black() {
		if (check_main_main_tr0_tr0()) {
			effect_main_main_tr0();
		} else {
			if (check_main_main_trafficlight_interrupted_tr0_tr0()) {
				effect_main_main_trafficlight_interrupted_tr0();
			} else {
				if (check_main_main_trafficlight_interrupted_blinking_Black_tr0_tr0()) {
					effect_main_main_trafficlight_interrupted_blinking_Black_tr0();
				}
			}
		}
	}
	
	/* The reactions of state Yellow. */
	private void react_main_main_trafficlight_interrupted_blinking_Yellow() {
		if (check_main_main_tr0_tr0()) {
			effect_main_main_tr0();
		} else {
			if (check_main_main_trafficlight_interrupted_tr0_tr0()) {
				effect_main_main_trafficlight_interrupted_tr0();
			} else {
				if (check_main_main_trafficlight_interrupted_blinking_Yellow_tr0_tr0()) {
					effect_main_main_trafficlight_interrupted_blinking_Yellow_tr0();
				}
			}
		}
	}
	
	/* The reactions of state Red. */
	private void react_main_main_trafficlight_normal_normal_Red() {
		if (check_main_main_tr0_tr0()) {
			effect_main_main_tr0();
		} else {
			if (check_main_main_trafficlight_normal_tr0_tr0()) {
				effect_main_main_trafficlight_normal_tr0();
			} else {
				if (check_main_main_trafficlight_normal_normal_Red_tr0_tr0()) {
					effect_main_main_trafficlight_normal_normal_Red_tr0();
				}
			}
		}
	}
	
	/* The reactions of state Yellow. */
	private void react_main_main_trafficlight_normal_normal_Yellow() {
		if (check_main_main_tr0_tr0()) {
			effect_main_main_tr0();
		} else {
			if (check_main_main_trafficlight_normal_tr0_tr0()) {
				effect_main_main_trafficlight_normal_tr0();
			} else {
				if (check_main_main_trafficlight_normal_normal_Yellow_tr0_tr0()) {
					effect_main_main_trafficlight_normal_normal_Yellow_tr0();
				}
			}
		}
	}
	
	/* The reactions of state Green. */
	private void react_main_main_trafficlight_normal_normal_Green() {
		if (check_main_main_tr0_tr0()) {
			effect_main_main_tr0();
		} else {
			if (check_main_main_trafficlight_normal_tr0_tr0()) {
				effect_main_main_trafficlight_normal_tr0();
			} else {
				if (check_main_main_trafficlight_normal_normal_Green_tr0_tr0()) {
					effect_main_main_trafficlight_normal_normal_Green_tr0();
				}
			}
		}
	}
	
	/* The reactions of state Disabled. */
	private void react_main_main_timer_Disabled() {
		if (check_main_main_timer_Disabled_tr0_tr0()) {
			effect_main_main_timer_Disabled_tr0();
		}
	}
	
	/* The reactions of state DecidingColor. */
	private void react_main_main_timer_running_running_DecidingColor() {
		if (check_main_main_timer_running_tr0_tr0()) {
			effect_main_main_timer_running_tr0();
		} else {
			if (check_main_main_timer_running_tr1_tr1()) {
				effect_main_main_timer_running_tr1();
			} else {
				if (check_main_main_timer_running_running_DecidingColor_tr0_tr0()) {
					effect_main_main_timer_running_running_DecidingColor_tr0();
				} else {
					if (check_main_main_timer_running_running_DecidingColor_tr1_tr1()) {
						effect_main_main_timer_running_running_DecidingColor_tr1();
					}
				}
			}
		}
	}
	
	/* The reactions of state Green. */
	private void react_main_main_timer_running_running_Green() {
		if (check_main_main_timer_running_tr0_tr0()) {
			effect_main_main_timer_running_tr0();
		} else {
			if (check_main_main_timer_running_tr1_tr1()) {
				effect_main_main_timer_running_tr1();
			} else {
				if (check_main_main_timer_running_running_Green_tr0_tr0()) {
					effect_main_main_timer_running_running_Green_tr0();
				}
			}
		}
	}
	
	/* The reactions of state Red. */
	private void react_main_main_timer_running_running_Red() {
		if (check_main_main_timer_running_tr0_tr0()) {
			effect_main_main_timer_running_tr0();
		} else {
			if (check_main_main_timer_running_tr1_tr1()) {
				effect_main_main_timer_running_tr1();
			} else {
				if (check_main_main_timer_running_running_Red_tr0_tr0()) {
					effect_main_main_timer_running_running_Red_tr0();
				}
			}
		}
	}
	
	/* The reactions of state off. */
	private void react_main_off() {
		if (check_main_off_tr0_tr0()) {
			effect_main_off_tr0();
		}
	}
	
	/* Default react sequence for initial entry  */
	private void react_main_main_trafficlight_interrupted_blinking__entry_Default() {
		enterSequence_main_main_trafficlight_interrupted_blinking_Yellow_default();
	}
	
	/* Default react sequence for initial entry  */
	private void react_main_main_trafficlight_normal_normal__entry_Default() {
		enterSequence_main_main_trafficlight_normal_normal_Red_default();
	}
	
	/* Default react sequence for deep history entry hist */
	private void react_main_main_trafficlight_normal_normal_hist() {
		/* Enter the region with deep history */
		if (historyVector[0] != State.$NullState$) {
			deepEnterSequence_main_main_trafficlight_normal_normal();
		}
	}
	
	/* Default react sequence for initial entry  */
	private void react_main_main_trafficlight__entry_Default() {
		enterSequence_main_main_trafficlight_normal_default();
	}
	
	/* Default react sequence for initial entry  */
	private void react_main_main_timer_running_running__entry_Default() {
		enterSequence_main_main_timer_running_running_DecidingColor_default();
	}
	
	/* Default react sequence for initial entry  */
	private void react_main_main_timer__entry_Default() {
		enterSequence_main_main_timer_running_default();
	}
	
	/* Default react sequence for initial entry  */
	private void react_main__entry_Default() {
		enterSequence_main_off_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_main_trafficlight_interrupted_blinking_Black:
				react_main_main_trafficlight_interrupted_blinking_Black();
				break;
			case main_main_trafficlight_interrupted_blinking_Yellow:
				react_main_main_trafficlight_interrupted_blinking_Yellow();
				break;
			case main_main_trafficlight_normal_normal_Red:
				react_main_main_trafficlight_normal_normal_Red();
				break;
			case main_main_trafficlight_normal_normal_Yellow:
				react_main_main_trafficlight_normal_normal_Yellow();
				break;
			case main_main_trafficlight_normal_normal_Green:
				react_main_main_trafficlight_normal_normal_Green();
				break;
			case main_main_timer_Disabled:
				react_main_main_timer_Disabled();
				break;
			case main_main_timer_running_running_DecidingColor:
				react_main_main_timer_running_running_DecidingColor();
				break;
			case main_main_timer_running_running_Green:
				react_main_main_timer_running_running_Green();
				break;
			case main_main_timer_running_running_Red:
				react_main_main_timer_running_running_Red();
				break;
			case main_off:
				react_main_off();
				break;
			default:
				// $NullState$
			}
		}
		clearEvents();
	}
}