new generated entryChoice statemachine

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/IStatemachine.java

@@ -1,27 +1,27 @@
-package org.yakindu.scr;
-
-/**
- * Basic interface for statemachines.
- */
-public interface IStatemachine {
-
-	/**
-	* Initializes the statemachine. Use to init internal variables etc.
-	*/
-	public void init();
-
-	/**
-	* Enters the statemachine. Sets the statemachine in a defined state.
-	*/
-	public void enter();
-
-	/**
-	* Exits the statemachine. Leaves the statemachine with a defined state.
-	*/
-	public void exit();
-
-	/**
-	* Start a run-to-completion cycle.
-	*/
-	public void runCycle();
-}
+package org.yakindu.scr;
+
+/**
+ * Basic interface for statemachines.
+ */
+public interface IStatemachine {
+
+	/**
+	* Initializes the statemachine. Use to init internal variables etc.
+	*/
+	public void init();
+
+	/**
+	* Enters the statemachine. Sets the statemachine in a defined state.
+	*/
+	public void enter();
+
+	/**
+	* Exits the statemachine. Leaves the statemachine with a defined state.
+	*/
+	public void exit();
+
+	/**
+	* Start a run-to-completion cycle.
+	*/
+	public void runCycle();
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/ITimer.java

@@ -1,38 +1,38 @@
-package org.yakindu.scr;
-
-/**
- * Interface a timer has to implement. Use to implement your own timer
- * service.
- * 
- */
-public interface ITimer {
-
-	/**
-	 * Starts the timing for a given time event id.
-	 * 
-	 * @param callback
-	 * 			  : The target callback where the time event has to be raised.
-	 * 
-	 * @param eventID
-	 *            : The eventID the timer should use if timed out.
-	 *            
-	 * @param time
-	 *            : Time in milliseconds after the given time event should be
-	 *            triggered
-	 *            
-	 * @param isPeriodic
-	 * 			  : Set to true if the time event should be triggered periodically
-	 */
-	public void setTimer(ITimerCallback callback, int eventID, long time, boolean isPeriodic);
-
-	/**
-	 * Unset a time event.
-	 * 
-	 * @param callback
-	 * 			: The target callback for which the time event has to be unset.
-	 * 
-	 * @param eventID
-	 * 			: The time event id.
-	 */
-	public void unsetTimer(ITimerCallback callback, int eventID);
-}
+package org.yakindu.scr;
+
+/**
+ * Interface a timer has to implement. Use to implement your own timer
+ * service.
+ * 
+ */
+public interface ITimer {
+
+	/**
+	 * Starts the timing for a given time event id.
+	 * 
+	 * @param callback
+	 * 			  : The target callback where the time event has to be raised.
+	 * 
+	 * @param eventID
+	 *            : The eventID the timer should use if timed out.
+	 *            
+	 * @param time
+	 *            : Time in milliseconds after the given time event should be
+	 *            triggered
+	 *            
+	 * @param isPeriodic
+	 * 			  : Set to true if the time event should be triggered periodically
+	 */
+	public void setTimer(ITimerCallback callback, int eventID, long time, boolean isPeriodic);
+
+	/**
+	 * Unset a time event.
+	 * 
+	 * @param callback
+	 * 			: The target callback for which the time event has to be unset.
+	 * 
+	 * @param eventID
+	 * 			: The time event id.
+	 */
+	public void unsetTimer(ITimerCallback callback, int eventID);
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/ITimerCallback.java

@@ -1,15 +1,15 @@
-package org.yakindu.scr;
-
-/**
-* Interface for state machines which use timed event triggers.
-*/
-public interface ITimerCallback {
-	
-	/**
-	* Callback method if a time event occurred.
-	* 
-	* @param eventID
-	* 			:The id of the occurred event.
-	*/
-	public void timeElapsed(int eventID);
-}
+package org.yakindu.scr;
+
+/**
+* Interface for state machines which use timed event triggers.
+*/
+public interface ITimerCallback {
+	
+	/**
+	* Callback method if a time event occurred.
+	* 
+	* @param eventID
+	* 			:The id of the occurred event.
+	*/
+	public void timeElapsed(int eventID);
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/RuntimeService.java

@@ -1,207 +1,207 @@
-package org.yakindu.scr;
-
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Timer;
-import java.util.TimerTask;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-
-/**
- * Runtime service for state machines to execute a run to completion step
- * periodically.
- * 
- */
-public class RuntimeService {
-
-	private static RuntimeService runtimeService;
-
-	private Timer timer = null;
-
-	private Map<Long, StatemachineTimerTask> timerTasks = new HashMap<Long, StatemachineTimerTask>();
-
-	private class StatemachineTimerTask extends TimerTask {
-
-		private List<IStatemachine> statemachineList = new LinkedList<IStatemachine>();
-
-		private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-
-		private boolean isPaused = false;
-
-		@Override
-		public void run() {
-			lock.readLock().lock();
-			if (!isPaused) {
-				for (IStatemachine statemachine : statemachineList) {
-					statemachine.runCycle();
-				}
-			}
-			lock.readLock().unlock();
-		}
-
-		/**
-		 * Adds the given state machine to the TimerTask.
-		 * 
-		 * @param statemachine
-		 * @return {@code true} if state machine is added properly.
-		 */
-		public boolean addStatemachine(IStatemachine statemachine) {
-			lock.writeLock().lock();
-			boolean ret = statemachineList.add(statemachine);
-			lock.writeLock().unlock();
-			return ret;
-		}
-
-		/**
-		 * Removes the given state machine from the TimerTask.
-		 * 
-		 * @param statemachine
-		 * @return {@code true} if state machine is removed properly.
-		 */
-		public boolean removeStatemachine(IStatemachine statemachine) {
-			lock.writeLock().lock();
-			boolean ret = statemachineList.remove(statemachine);
-			lock.writeLock().unlock();
-			return ret;
-		}
-
-		public void pause() {
-			isPaused = true;
-		}
-
-		public void resume() {
-			isPaused = false;
-		}
-	}
-
-	private RuntimeService() {
-		// Not intended to be instantiated.
-	}
-
-	/**
-	 * Returns the {@code RuntimeService} instance as singleton.
-	 * 
-	 * @return The singleton {@code RuntimeService} instance
-	 */
-	public static RuntimeService getInstance() {
-		if (runtimeService == null) {
-			runtimeService = new RuntimeService();
-		}
-		return runtimeService;
-	}
-
-	/**
-	 * Registers an {@link IStatemachine} for scheduled fixed rate execution
-	 * 
-	 * @param statemachine
-	 *            - The statemachine to execute
-	 * @param cyclePeriod
-	 *            - the fixed rate cycle period for scheduling
-	 * @return {@code true} if state machine is added properly.
-	 */
-	public boolean registerStatemachine(IStatemachine statemachine,
-			long cyclePeriod) {
-
-		if (timerTasks.containsKey(cyclePeriod)) {
-			// TimerTask for cycle time already existing -> add statemachine
-			return timerTasks.get(cyclePeriod).addStatemachine(statemachine);
-		} else {
-			// Create new TimerTask for cycle period and add statemachine
-			StatemachineTimerTask timerTask = new StatemachineTimerTask();
-			timerTasks.put(cyclePeriod, timerTask);
-			boolean ret = timerTask.addStatemachine(statemachine);
-			// Create a new Timer instance if runtime service was cancelled
-			// before
-			if (timer == null) {
-				timer = new Timer();
-			}
-			timer.scheduleAtFixedRate(timerTask, 0, cyclePeriod);
-			return ret;
-		}
-	}
-
-	/**
-	 * Removes the given state machine from runtime service.
-	 * 
-	 * @param statemachine
-	 *            - the statemachine which should be removed
-	 * @param cyclePeriod
-	 *            - the scheduling cycle period of the statemachine
-	 * @return {@code true} if state machine is removed properly.
-	 */
-	public boolean unregisterStatemachine(IStatemachine statemachine,
-			long cyclePeriod) {
-		if (timerTasks.containsKey(cyclePeriod)) {
-			boolean ret = timerTasks.get(cyclePeriod).removeStatemachine(
-					statemachine);
-
-			return ret;
-		}
-		return false;
-	}
-
-	/**
-	 * Cancels the execution of statemachines for the given cycle period. This
-	 * stops the execution of statemachines which are registered for the given
-	 * cycle period and cancels the executing {@link TimerTask}.
-	 * 
-	 * @return {@code true} if poperly cancelled
-	 */
-	public boolean cancelAll(long cyclePeriod) {
-		if (timer != null && timerTasks.containsKey(cyclePeriod)) {
-			TimerTask task = timerTasks.get(cyclePeriod);
-			task.cancel();
-			timer.purge();
-			timerTasks.remove(cyclePeriod);
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * Pauses the execution of all statemachines which are registered for the
-	 * given cyclePeriod.
-	 * 
-	 * @param cyclePeriod
-	 * @return {@code true} if properly paused
-	 * 
-	 */
-	public boolean pauseAll(long cyclePeriod) {
-		if (timerTasks.containsKey(cyclePeriod)) {
-			timerTasks.get(cyclePeriod).pause();
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * Resumes the execution of all statemachines which are registered for the
-	 * given cyclePeriod.
-	 * 
-	 * @param cyclePeriod
-	 * @return {@code true} if properly resumed
-	 * 
-	 */
-	public boolean resumeAll(long cyclePeriod) {
-		if (timerTasks.containsKey(cyclePeriod)) {
-			timerTasks.get(cyclePeriod).resume();
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * Cancels the execution of all registered statemachines. This cancels the
-	 * executing {@link Timer} freeing all allocated resources and terminates
-	 * all existing execution threads.
-	 */
-	public void cancelTimer() {
-		if (timer != null) {
-			timer.cancel();
-			timer.purge();
-			timerTasks.clear();
-			timer = null;
-		}
-	}
-}
+package org.yakindu.scr;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * Runtime service for state machines to execute a run to completion step
+ * periodically.
+ * 
+ */
+public class RuntimeService {
+
+	private static RuntimeService runtimeService;
+
+	private Timer timer = null;
+
+	private Map<Long, StatemachineTimerTask> timerTasks = new HashMap<Long, StatemachineTimerTask>();
+
+	private class StatemachineTimerTask extends TimerTask {
+
+		private List<IStatemachine> statemachineList = new LinkedList<IStatemachine>();
+
+		private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
+
+		private boolean isPaused = false;
+
+		@Override
+		public void run() {
+			lock.readLock().lock();
+			if (!isPaused) {
+				for (IStatemachine statemachine : statemachineList) {
+					statemachine.runCycle();
+				}
+			}
+			lock.readLock().unlock();
+		}
+
+		/**
+		 * Adds the given state machine to the TimerTask.
+		 * 
+		 * @param statemachine
+		 * @return {@code true} if state machine is added properly.
+		 */
+		public boolean addStatemachine(IStatemachine statemachine) {
+			lock.writeLock().lock();
+			boolean ret = statemachineList.add(statemachine);
+			lock.writeLock().unlock();
+			return ret;
+		}
+
+		/**
+		 * Removes the given state machine from the TimerTask.
+		 * 
+		 * @param statemachine
+		 * @return {@code true} if state machine is removed properly.
+		 */
+		public boolean removeStatemachine(IStatemachine statemachine) {
+			lock.writeLock().lock();
+			boolean ret = statemachineList.remove(statemachine);
+			lock.writeLock().unlock();
+			return ret;
+		}
+
+		public void pause() {
+			isPaused = true;
+		}
+
+		public void resume() {
+			isPaused = false;
+		}
+	}
+
+	private RuntimeService() {
+		// Not intended to be instantiated.
+	}
+
+	/**
+	 * Returns the {@code RuntimeService} instance as singleton.
+	 * 
+	 * @return The singleton {@code RuntimeService} instance
+	 */
+	public static RuntimeService getInstance() {
+		if (runtimeService == null) {
+			runtimeService = new RuntimeService();
+		}
+		return runtimeService;
+	}
+
+	/**
+	 * Registers an {@link IStatemachine} for scheduled fixed rate execution
+	 * 
+	 * @param statemachine
+	 *            - The statemachine to execute
+	 * @param cyclePeriod
+	 *            - the fixed rate cycle period for scheduling
+	 * @return {@code true} if state machine is added properly.
+	 */
+	public boolean registerStatemachine(IStatemachine statemachine,
+			long cyclePeriod) {
+
+		if (timerTasks.containsKey(cyclePeriod)) {
+			// TimerTask for cycle time already existing -> add statemachine
+			return timerTasks.get(cyclePeriod).addStatemachine(statemachine);
+		} else {
+			// Create new TimerTask for cycle period and add statemachine
+			StatemachineTimerTask timerTask = new StatemachineTimerTask();
+			timerTasks.put(cyclePeriod, timerTask);
+			boolean ret = timerTask.addStatemachine(statemachine);
+			// Create a new Timer instance if runtime service was cancelled
+			// before
+			if (timer == null) {
+				timer = new Timer();
+			}
+			timer.scheduleAtFixedRate(timerTask, 0, cyclePeriod);
+			return ret;
+		}
+	}
+
+	/**
+	 * Removes the given state machine from runtime service.
+	 * 
+	 * @param statemachine
+	 *            - the statemachine which should be removed
+	 * @param cyclePeriod
+	 *            - the scheduling cycle period of the statemachine
+	 * @return {@code true} if state machine is removed properly.
+	 */
+	public boolean unregisterStatemachine(IStatemachine statemachine,
+			long cyclePeriod) {
+		if (timerTasks.containsKey(cyclePeriod)) {
+			boolean ret = timerTasks.get(cyclePeriod).removeStatemachine(
+					statemachine);
+
+			return ret;
+		}
+		return false;
+	}
+
+	/**
+	 * Cancels the execution of statemachines for the given cycle period. This
+	 * stops the execution of statemachines which are registered for the given
+	 * cycle period and cancels the executing {@link TimerTask}.
+	 * 
+	 * @return {@code true} if poperly cancelled
+	 */
+	public boolean cancelAll(long cyclePeriod) {
+		if (timer != null && timerTasks.containsKey(cyclePeriod)) {
+			TimerTask task = timerTasks.get(cyclePeriod);
+			task.cancel();
+			timer.purge();
+			timerTasks.remove(cyclePeriod);
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Pauses the execution of all statemachines which are registered for the
+	 * given cyclePeriod.
+	 * 
+	 * @param cyclePeriod
+	 * @return {@code true} if properly paused
+	 * 
+	 */
+	public boolean pauseAll(long cyclePeriod) {
+		if (timerTasks.containsKey(cyclePeriod)) {
+			timerTasks.get(cyclePeriod).pause();
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Resumes the execution of all statemachines which are registered for the
+	 * given cyclePeriod.
+	 * 
+	 * @param cyclePeriod
+	 * @return {@code true} if properly resumed
+	 * 
+	 */
+	public boolean resumeAll(long cyclePeriod) {
+		if (timerTasks.containsKey(cyclePeriod)) {
+			timerTasks.get(cyclePeriod).resume();
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Cancels the execution of all registered statemachines. This cancels the
+	 * executing {@link Timer} freeing all allocated resources and terminates
+	 * all existing execution threads.
+	 */
+	public void cancelTimer() {
+		if (timer != null) {
+			timer.cancel();
+			timer.purge();
+			timerTasks.clear();
+			timer = null;
+		}
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/TimerService.java

@@ -1,91 +1,91 @@
-package org.yakindu.scr;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Timer;
-import java.util.TimerTask;
-
-/**
- * Default timer service implementation.
- * 
- */
-public class TimerService implements ITimer {
-
-	private final Timer timer = new Timer();
-	
-	private final List<TimeEventTask> timerTaskList = new ArrayList<TimeEventTask>();
-	
-	/**
-	 * Timer task that reflects a time event. It's internally used by
-	 * {@link TimerService}.
-	 * 
-	 */
-	private class TimeEventTask extends TimerTask {
-	
-		private ITimerCallback callback;
-	
-		int eventID;
-	
-		/**
-		 * Constructor for a time event.
-		 * 
-		 * @param callback
-		 *            : Set to {@code true} if event should be repeated
-		 *            periodically.
-		 * 
-		 * @param eventID
-		 *            : Index position within the state machine's timeEvent
-		 *            array.
-		 */
-		public TimeEventTask(ITimerCallback callback, int eventID) {
-			this.callback = callback;
-			this.eventID = eventID;
-		}
-	
-		public void run() {
-			callback.timeElapsed(eventID);
-		}
-	
-		public boolean equals(Object obj) {
-			if (obj instanceof TimeEventTask) {
-				return ((TimeEventTask) obj).callback.equals(callback)
-						&& ((TimeEventTask) obj).eventID == eventID;
-			}
-			return super.equals(obj);
-		}
-	}
-	
-	public void setTimer(final ITimerCallback callback, final int eventID,
-			long time, boolean isPeriodic) {
-	
-		// Create a new TimerTask for given event and store it.
-		TimeEventTask timerTask = new TimeEventTask(callback, eventID);
-		timerTaskList.add(timerTask);
-	
-		// start scheduling the timer
-		if (isPeriodic) {
-			timer.scheduleAtFixedRate(timerTask, time, time);
-		} else {
-			timer.schedule(timerTask, time);
-		}
-	}
-	
-	public void unsetTimer(ITimerCallback callback, int eventID) {
-		int index = timerTaskList.indexOf(new TimeEventTask(callback, eventID));
-		if (index != -1) {
-			timerTaskList.get(index).cancel();
-			timer.purge();
-			timerTaskList.remove(index);
-		}
-	}
-	
-	/**
-	 * Cancel timer service. Use this to end possible timing threads and free
-	 * memory resources.
-	 */
-	public void cancel() {
-		timer.cancel();
-		timer.purge();
-	}
-}
-
+package org.yakindu.scr;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Timer;
+import java.util.TimerTask;
+
+/**
+ * Default timer service implementation.
+ * 
+ */
+public class TimerService implements ITimer {
+
+	private final Timer timer = new Timer();
+	
+	private final List<TimeEventTask> timerTaskList = new ArrayList<TimeEventTask>();
+	
+	/**
+	 * Timer task that reflects a time event. It's internally used by
+	 * {@link TimerService}.
+	 * 
+	 */
+	private class TimeEventTask extends TimerTask {
+	
+		private ITimerCallback callback;
+	
+		int eventID;
+	
+		/**
+		 * Constructor for a time event.
+		 * 
+		 * @param callback
+		 *            : Set to {@code true} if event should be repeated
+		 *            periodically.
+		 * 
+		 * @param eventID
+		 *            : Index position within the state machine's timeEvent
+		 *            array.
+		 */
+		public TimeEventTask(ITimerCallback callback, int eventID) {
+			this.callback = callback;
+			this.eventID = eventID;
+		}
+	
+		public void run() {
+			callback.timeElapsed(eventID);
+		}
+	
+		public boolean equals(Object obj) {
+			if (obj instanceof TimeEventTask) {
+				return ((TimeEventTask) obj).callback.equals(callback)
+						&& ((TimeEventTask) obj).eventID == eventID;
+			}
+			return super.equals(obj);
+		}
+	}
+	
+	public void setTimer(final ITimerCallback callback, final int eventID,
+			long time, boolean isPeriodic) {
+	
+		// Create a new TimerTask for given event and store it.
+		TimeEventTask timerTask = new TimeEventTask(callback, eventID);
+		timerTaskList.add(timerTask);
+	
+		// start scheduling the timer
+		if (isPeriodic) {
+			timer.scheduleAtFixedRate(timerTask, time, time);
+		} else {
+			timer.schedule(timerTask, time);
+		}
+	}
+	
+	public void unsetTimer(ITimerCallback callback, int eventID) {
+		int index = timerTaskList.indexOf(new TimeEventTask(callback, eventID));
+		if (index != -1) {
+			timerTaskList.get(index).cancel();
+			timer.purge();
+			timerTaskList.remove(index);
+		}
+	}
+	
+	/**
+	 * Cancel timer service. Use this to end possible timing threads and free
+	 * memory resources.
+	 */
+	public void cancel() {
+		timer.cancel();
+		timer.purge();
+	}
+}
+

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/alwaysoncycle/AlwaysOncycleStatemachine.java

@@ -1,182 +1,191 @@
-package org.yakindu.scr.alwaysoncycle;
-
-public class AlwaysOncycleStatemachine implements IAlwaysOncycleStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private int value;
-
-		public int getValue() {
-			return value;
-		}
-
-		public void setValue(int value) {
-			this.value = value;
-		}
-
-		private boolean v2;
-
-		public boolean getV2() {
-			return v2;
-		}
-
-		public void setV2(boolean value) {
-			this.v2 = value;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_StateA, main_region_StateB, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public AlwaysOncycleStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.value = 0;
-
-		sCInterface.v2 = false;
-	}
-
-	public void enter() {
-		entryAction();
-
-		sCInterface.value = 0;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_StateA;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_StateA :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				sCInterface.value = 0;
-				break;
-
-			case main_region_StateB :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_StateA :
-				return stateVector[0] == State.main_region_StateA;
-			case main_region_StateB :
-				return stateVector[0] == State.main_region_StateB;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public int getValue() {
-		return sCInterface.getValue();
-	}
-
-	public void setValue(int value) {
-		sCInterface.setValue(value);
-	}
-	public boolean getV2() {
-		return sCInterface.getV2();
-	}
-
-	public void setV2(boolean value) {
-		sCInterface.setV2(value);
-	}
-
-	/* Entry action for statechart 'AlwaysOncycle'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'AlwaysOncycle'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state StateA. */
-	private void reactMain_region_StateA() {
-		if (sCInterface.value == 5) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.value = 0;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_StateB;
-		} else {
-			sCInterface.value += 1;
-		}
-	}
-
-	/* The reactions of state StateB. */
-	private void reactMain_region_StateB() {
-		if (sCInterface.value == 5) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.value = 0;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_StateA;
-		} else {
-			sCInterface.value += 1;
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_StateA :
-					reactMain_region_StateA();
-					break;
-				case main_region_StateB :
-					reactMain_region_StateB();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.alwaysoncycle;
+
+public class AlwaysOncycleStatemachine implements IAlwaysOncycleStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private long value;
+
+		public long getValue() {
+			return value;
+		}
+
+		public void setValue(long value) {
+			this.value = value;
+		}
+
+		private boolean v2;
+
+		public boolean getV2() {
+			return v2;
+		}
+
+		public void setV2(boolean value) {
+			this.v2 = value;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_StateA, main_region_StateB, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public AlwaysOncycleStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.value = 0;
+
+		sCInterface.v2 = false;
+	}
+
+	public void enter() {
+		entryAction();
+
+		sCInterface.value = 0;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_StateA;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_StateA :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				sCInterface.value = 0;
+				break;
+
+			case main_region_StateB :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_StateA :
+				return stateVector[0] == State.main_region_StateA;
+			case main_region_StateB :
+				return stateVector[0] == State.main_region_StateB;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public long getValue() {
+		return sCInterface.getValue();
+	}
+
+	public void setValue(long value) {
+		sCInterface.setValue(value);
+	}
+	public boolean getV2() {
+		return sCInterface.getV2();
+	}
+
+	public void setV2(boolean value) {
+		sCInterface.setV2(value);
+	}
+
+	/* Entry action for statechart 'AlwaysOncycle'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'AlwaysOncycle'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state StateA. */
+	private void reactMain_region_StateA() {
+		if (sCInterface.value == 5) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.value = 0;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_StateB;
+		} else {
+			sCInterface.value += 1;
+		}
+	}
+
+	/* The reactions of state StateB. */
+	private void reactMain_region_StateB() {
+		if (sCInterface.value == 5) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.value = 0;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_StateA;
+		} else {
+			sCInterface.value += 1;
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_StateA :
+					reactMain_region_StateA();
+					break;
+				case main_region_StateB :
+					reactMain_region_StateB();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/alwaysoncycle/IAlwaysOncycleStatemachine.java

@@ -1,16 +1,16 @@
-package org.yakindu.scr.alwaysoncycle;
-import org.yakindu.scr.IStatemachine;
-
-public interface IAlwaysOncycleStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public int getValue();
-		public void setValue(int value);
-		public boolean getV2();
-		public void setV2(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.alwaysoncycle;
+import org.yakindu.scr.IStatemachine;
+
+public interface IAlwaysOncycleStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public long getValue();
+		public void setValue(long value);
+		public boolean getV2();
+		public void setV2(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/assignmentasexpression/IAssignmentAsExpressionStatemachine.java

@@ -1,58 +1,58 @@
-package org.yakindu.scr.assignmentasexpression;
-import org.yakindu.scr.IStatemachine;
-
-public interface IAssignmentAsExpressionStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public int getA();
-		public void setA(int value);
-		public int getB();
-		public void setB(int value);
-		public int getC();
-		public void setC(int value);
-		public int getD();
-		public void setD(int value);
-		public int getE();
-		public void setE(int value);
-		public int getF();
-		public void setF(int value);
-		public int getG();
-		public void setG(int value);
-		public int getH();
-		public void setH(int value);
-		public int getI();
-		public void setI(int value);
-		public int getI1();
-		public void setI1(int value);
-		public int getJ();
-		public void setJ(int value);
-		public int getJ1();
-		public void setJ1(int value);
-		public int getK();
-		public void setK(int value);
-		public int getK1();
-		public void setK1(int value);
-		public int getL();
-		public void setL(int value);
-		public int getM();
-		public void setM(int value);
-		public int getN();
-		public void setN(int value);
-		public int getP();
-		public void setP(int value);
-		public int getR();
-		public void setR(int value);
-		public int getT();
-		public void setT(int value);
-		public int getU();
-		public void setU(int value);
-		public int getV();
-		public void setV(int value);
-		public int getW();
-		public void setW(int value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.assignmentasexpression;
+import org.yakindu.scr.IStatemachine;
+
+public interface IAssignmentAsExpressionStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public long getA();
+		public void setA(long value);
+		public long getB();
+		public void setB(long value);
+		public long getC();
+		public void setC(long value);
+		public long getD();
+		public void setD(long value);
+		public long getE();
+		public void setE(long value);
+		public long getF();
+		public void setF(long value);
+		public long getG();
+		public void setG(long value);
+		public long getH();
+		public void setH(long value);
+		public long getI();
+		public void setI(long value);
+		public long getI1();
+		public void setI1(long value);
+		public long getJ();
+		public void setJ(long value);
+		public long getJ1();
+		public void setJ1(long value);
+		public long getK();
+		public void setK(long value);
+		public long getK1();
+		public void setK1(long value);
+		public long getL();
+		public void setL(long value);
+		public long getM();
+		public void setM(long value);
+		public long getN();
+		public void setN(long value);
+		public long getP();
+		public void setP(long value);
+		public long getR();
+		public void setR(long value);
+		public long getT();
+		public void setT(long value);
+		public long getU();
+		public void setU(long value);
+		public long getV();
+		public void setV(long value);
+		public long getW();
+		public void setW(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/bitexpressions/BitExpressionsStatemachine.java

@@ -1,308 +1,317 @@
-package org.yakindu.scr.bitexpressions;
-
-public class BitExpressionsStatemachine implements IBitExpressionsStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e1;
-
-		public void raiseE1() {
-			e1 = true;
-		}
-
-		private int myBit1;
-
-		public int getMyBit1() {
-			return myBit1;
-		}
-
-		public void setMyBit1(int value) {
-			this.myBit1 = value;
-		}
-
-		private int myBit2;
-
-		public int getMyBit2() {
-			return myBit2;
-		}
-
-		public void setMyBit2(int value) {
-			this.myBit2 = value;
-		}
-
-		private int leftBitshift;
-
-		public int getLeftBitshift() {
-			return leftBitshift;
-		}
-
-		public void setLeftBitshift(int value) {
-			this.leftBitshift = value;
-		}
-
-		private int rightBitshift;
-
-		public int getRightBitshift() {
-			return rightBitshift;
-		}
-
-		public void setRightBitshift(int value) {
-			this.rightBitshift = value;
-		}
-
-		private int complementBitshift;
-
-		public int getComplementBitshift() {
-			return complementBitshift;
-		}
-
-		public void setComplementBitshift(int value) {
-			this.complementBitshift = value;
-		}
-
-		private int bitwiseAnd;
-
-		public int getBitwiseAnd() {
-			return bitwiseAnd;
-		}
-
-		public void setBitwiseAnd(int value) {
-			this.bitwiseAnd = value;
-		}
-
-		private int bitwiseOr;
-
-		public int getBitwiseOr() {
-			return bitwiseOr;
-		}
-
-		public void setBitwiseOr(int value) {
-			this.bitwiseOr = value;
-		}
-
-		private int bitwiseXor;
-
-		public int getBitwiseXor() {
-			return bitwiseXor;
-		}
-
-		public void setBitwiseXor(int value) {
-			this.bitwiseXor = value;
-		}
-
-		public void clearEvents() {
-			e1 = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_StateA, main_region_StateB, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public BitExpressionsStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.myBit1 = 0;
-
-		sCInterface.myBit2 = 0;
-
-		sCInterface.leftBitshift = 0;
-
-		sCInterface.rightBitshift = 0;
-
-		sCInterface.complementBitshift = 0;
-
-		sCInterface.bitwiseAnd = 0;
-
-		sCInterface.bitwiseOr = 0;
-
-		sCInterface.bitwiseXor = 0;
-	}
-
-	public void enter() {
-		entryAction();
-
-		sCInterface.myBit1 = 5;
-
-		sCInterface.myBit2 = 7;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_StateA;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_StateA :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_StateB :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_StateA :
-				return stateVector[0] == State.main_region_StateA;
-			case main_region_StateB :
-				return stateVector[0] == State.main_region_StateB;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE1() {
-		sCInterface.raiseE1();
-	}
-
-	public int getMyBit1() {
-		return sCInterface.getMyBit1();
-	}
-
-	public void setMyBit1(int value) {
-		sCInterface.setMyBit1(value);
-	}
-	public int getMyBit2() {
-		return sCInterface.getMyBit2();
-	}
-
-	public void setMyBit2(int value) {
-		sCInterface.setMyBit2(value);
-	}
-	public int getLeftBitshift() {
-		return sCInterface.getLeftBitshift();
-	}
-
-	public void setLeftBitshift(int value) {
-		sCInterface.setLeftBitshift(value);
-	}
-	public int getRightBitshift() {
-		return sCInterface.getRightBitshift();
-	}
-
-	public void setRightBitshift(int value) {
-		sCInterface.setRightBitshift(value);
-	}
-	public int getComplementBitshift() {
-		return sCInterface.getComplementBitshift();
-	}
-
-	public void setComplementBitshift(int value) {
-		sCInterface.setComplementBitshift(value);
-	}
-	public int getBitwiseAnd() {
-		return sCInterface.getBitwiseAnd();
-	}
-
-	public void setBitwiseAnd(int value) {
-		sCInterface.setBitwiseAnd(value);
-	}
-	public int getBitwiseOr() {
-		return sCInterface.getBitwiseOr();
-	}
-
-	public void setBitwiseOr(int value) {
-		sCInterface.setBitwiseOr(value);
-	}
-	public int getBitwiseXor() {
-		return sCInterface.getBitwiseXor();
-	}
-
-	public void setBitwiseXor(int value) {
-		sCInterface.setBitwiseXor(value);
-	}
-
-	/* Entry action for statechart 'BitExpressions'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'BitExpressions'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state StateA. */
-	private void reactMain_region_StateA() {
-		if (sCInterface.e1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.leftBitshift = sCInterface.myBit1 << 1;
-
-			sCInterface.rightBitshift = sCInterface.myBit1 >> 1;
-
-			sCInterface.complementBitshift = ~sCInterface.myBit1;
-
-			sCInterface.bitwiseAnd = sCInterface.myBit1 & sCInterface.myBit2;
-
-			sCInterface.bitwiseOr = sCInterface.myBit1 | sCInterface.myBit2;
-
-			sCInterface.bitwiseXor = sCInterface.myBit1 ^ sCInterface.myBit2;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_StateB;
-		}
-	}
-
-	/* The reactions of state StateB. */
-	private void reactMain_region_StateB() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_StateA :
-					reactMain_region_StateA();
-					break;
-				case main_region_StateB :
-					reactMain_region_StateB();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.bitexpressions;
+
+public class BitExpressionsStatemachine implements IBitExpressionsStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e1;
+
+		public void raiseE1() {
+			e1 = true;
+		}
+
+		private long myBit1;
+
+		public long getMyBit1() {
+			return myBit1;
+		}
+
+		public void setMyBit1(long value) {
+			this.myBit1 = value;
+		}
+
+		private long myBit2;
+
+		public long getMyBit2() {
+			return myBit2;
+		}
+
+		public void setMyBit2(long value) {
+			this.myBit2 = value;
+		}
+
+		private long leftBitshift;
+
+		public long getLeftBitshift() {
+			return leftBitshift;
+		}
+
+		public void setLeftBitshift(long value) {
+			this.leftBitshift = value;
+		}
+
+		private long rightBitshift;
+
+		public long getRightBitshift() {
+			return rightBitshift;
+		}
+
+		public void setRightBitshift(long value) {
+			this.rightBitshift = value;
+		}
+
+		private long complementBitshift;
+
+		public long getComplementBitshift() {
+			return complementBitshift;
+		}
+
+		public void setComplementBitshift(long value) {
+			this.complementBitshift = value;
+		}
+
+		private long bitwiseAnd;
+
+		public long getBitwiseAnd() {
+			return bitwiseAnd;
+		}
+
+		public void setBitwiseAnd(long value) {
+			this.bitwiseAnd = value;
+		}
+
+		private long bitwiseOr;
+
+		public long getBitwiseOr() {
+			return bitwiseOr;
+		}
+
+		public void setBitwiseOr(long value) {
+			this.bitwiseOr = value;
+		}
+
+		private long bitwiseXor;
+
+		public long getBitwiseXor() {
+			return bitwiseXor;
+		}
+
+		public void setBitwiseXor(long value) {
+			this.bitwiseXor = value;
+		}
+
+		public void clearEvents() {
+			e1 = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_StateA, main_region_StateB, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public BitExpressionsStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.myBit1 = 0;
+
+		sCInterface.myBit2 = 0;
+
+		sCInterface.leftBitshift = 0;
+
+		sCInterface.rightBitshift = 0;
+
+		sCInterface.complementBitshift = 0;
+
+		sCInterface.bitwiseAnd = 0;
+
+		sCInterface.bitwiseOr = 0;
+
+		sCInterface.bitwiseXor = 0;
+	}
+
+	public void enter() {
+		entryAction();
+
+		sCInterface.myBit1 = 5;
+
+		sCInterface.myBit2 = 7;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_StateA;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_StateA :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_StateB :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_StateA :
+				return stateVector[0] == State.main_region_StateA;
+			case main_region_StateB :
+				return stateVector[0] == State.main_region_StateB;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE1() {
+		sCInterface.raiseE1();
+	}
+
+	public long getMyBit1() {
+		return sCInterface.getMyBit1();
+	}
+
+	public void setMyBit1(long value) {
+		sCInterface.setMyBit1(value);
+	}
+	public long getMyBit2() {
+		return sCInterface.getMyBit2();
+	}
+
+	public void setMyBit2(long value) {
+		sCInterface.setMyBit2(value);
+	}
+	public long getLeftBitshift() {
+		return sCInterface.getLeftBitshift();
+	}
+
+	public void setLeftBitshift(long value) {
+		sCInterface.setLeftBitshift(value);
+	}
+	public long getRightBitshift() {
+		return sCInterface.getRightBitshift();
+	}
+
+	public void setRightBitshift(long value) {
+		sCInterface.setRightBitshift(value);
+	}
+	public long getComplementBitshift() {
+		return sCInterface.getComplementBitshift();
+	}
+
+	public void setComplementBitshift(long value) {
+		sCInterface.setComplementBitshift(value);
+	}
+	public long getBitwiseAnd() {
+		return sCInterface.getBitwiseAnd();
+	}
+
+	public void setBitwiseAnd(long value) {
+		sCInterface.setBitwiseAnd(value);
+	}
+	public long getBitwiseOr() {
+		return sCInterface.getBitwiseOr();
+	}
+
+	public void setBitwiseOr(long value) {
+		sCInterface.setBitwiseOr(value);
+	}
+	public long getBitwiseXor() {
+		return sCInterface.getBitwiseXor();
+	}
+
+	public void setBitwiseXor(long value) {
+		sCInterface.setBitwiseXor(value);
+	}
+
+	/* Entry action for statechart 'BitExpressions'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'BitExpressions'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state StateA. */
+	private void reactMain_region_StateA() {
+		if (sCInterface.e1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.leftBitshift = sCInterface.myBit1 << 1;
+
+			sCInterface.rightBitshift = sCInterface.myBit1 >> 1;
+
+			sCInterface.complementBitshift = ~sCInterface.myBit1;
+
+			sCInterface.bitwiseAnd = sCInterface.myBit1 & sCInterface.myBit2;
+
+			sCInterface.bitwiseOr = sCInterface.myBit1 | sCInterface.myBit2;
+
+			sCInterface.bitwiseXor = sCInterface.myBit1 ^ sCInterface.myBit2;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_StateB;
+		}
+	}
+
+	/* The reactions of state StateB. */
+	private void reactMain_region_StateB() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_StateA :
+					reactMain_region_StateA();
+					break;
+				case main_region_StateB :
+					reactMain_region_StateB();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/bitexpressions/IBitExpressionsStatemachine.java

@@ -1,29 +1,29 @@
-package org.yakindu.scr.bitexpressions;
-import org.yakindu.scr.IStatemachine;
-
-public interface IBitExpressionsStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE1();
-		public int getMyBit1();
-		public void setMyBit1(int value);
-		public int getMyBit2();
-		public void setMyBit2(int value);
-		public int getLeftBitshift();
-		public void setLeftBitshift(int value);
-		public int getRightBitshift();
-		public void setRightBitshift(int value);
-		public int getComplementBitshift();
-		public void setComplementBitshift(int value);
-		public int getBitwiseAnd();
-		public void setBitwiseAnd(int value);
-		public int getBitwiseOr();
-		public void setBitwiseOr(int value);
-		public int getBitwiseXor();
-		public void setBitwiseXor(int value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.bitexpressions;
+import org.yakindu.scr.IStatemachine;
+
+public interface IBitExpressionsStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE1();
+		public long getMyBit1();
+		public void setMyBit1(long value);
+		public long getMyBit2();
+		public void setMyBit2(long value);
+		public long getLeftBitshift();
+		public void setLeftBitshift(long value);
+		public long getRightBitshift();
+		public void setRightBitshift(long value);
+		public long getComplementBitshift();
+		public void setComplementBitshift(long value);
+		public long getBitwiseAnd();
+		public void setBitwiseAnd(long value);
+		public long getBitwiseOr();
+		public void setBitwiseOr(long value);
+		public long getBitwiseXor();
+		public void setBitwiseXor(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/booleanexpressions/BooleanExpressionsStatemachine.java

@@ -1,289 +1,298 @@
-package org.yakindu.scr.booleanexpressions;
-
-public class BooleanExpressionsStatemachine
-		implements
-			IBooleanExpressionsStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e1;
-
-		public void raiseE1() {
-			e1 = true;
-		}
-
-		private boolean myBool1;
-
-		public boolean getMyBool1() {
-			return myBool1;
-		}
-
-		public void setMyBool1(boolean value) {
-			this.myBool1 = value;
-		}
-
-		private boolean myBool2;
-
-		public boolean getMyBool2() {
-			return myBool2;
-		}
-
-		public void setMyBool2(boolean value) {
-			this.myBool2 = value;
-		}
-
-		private boolean and;
-
-		public boolean getAnd() {
-			return and;
-		}
-
-		public void setAnd(boolean value) {
-			this.and = value;
-		}
-
-		private boolean or;
-
-		public boolean getOr() {
-			return or;
-		}
-
-		public void setOr(boolean value) {
-			this.or = value;
-		}
-
-		private boolean not;
-
-		public boolean getNot() {
-			return not;
-		}
-
-		public void setNot(boolean value) {
-			this.not = value;
-		}
-
-		private boolean equal;
-
-		public boolean getEqual() {
-			return equal;
-		}
-
-		public void setEqual(boolean value) {
-			this.equal = value;
-		}
-
-		private boolean notequal;
-
-		public boolean getNotequal() {
-			return notequal;
-		}
-
-		public void setNotequal(boolean value) {
-			this.notequal = value;
-		}
-
-		public void clearEvents() {
-			e1 = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_StateA, main_region_StateB, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public BooleanExpressionsStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.myBool1 = false;
-
-		sCInterface.myBool2 = false;
-
-		sCInterface.and = false;
-
-		sCInterface.or = false;
-
-		sCInterface.not = false;
-
-		sCInterface.equal = false;
-
-		sCInterface.notequal = false;
-	}
-
-	public void enter() {
-		entryAction();
-
-		sCInterface.myBool1 = true;
-
-		sCInterface.myBool2 = false;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_StateA;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_StateA :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_StateB :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_StateA :
-				return stateVector[0] == State.main_region_StateA;
-			case main_region_StateB :
-				return stateVector[0] == State.main_region_StateB;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE1() {
-		sCInterface.raiseE1();
-	}
-
-	public boolean getMyBool1() {
-		return sCInterface.getMyBool1();
-	}
-
-	public void setMyBool1(boolean value) {
-		sCInterface.setMyBool1(value);
-	}
-	public boolean getMyBool2() {
-		return sCInterface.getMyBool2();
-	}
-
-	public void setMyBool2(boolean value) {
-		sCInterface.setMyBool2(value);
-	}
-	public boolean getAnd() {
-		return sCInterface.getAnd();
-	}
-
-	public void setAnd(boolean value) {
-		sCInterface.setAnd(value);
-	}
-	public boolean getOr() {
-		return sCInterface.getOr();
-	}
-
-	public void setOr(boolean value) {
-		sCInterface.setOr(value);
-	}
-	public boolean getNot() {
-		return sCInterface.getNot();
-	}
-
-	public void setNot(boolean value) {
-		sCInterface.setNot(value);
-	}
-	public boolean getEqual() {
-		return sCInterface.getEqual();
-	}
-
-	public void setEqual(boolean value) {
-		sCInterface.setEqual(value);
-	}
-	public boolean getNotequal() {
-		return sCInterface.getNotequal();
-	}
-
-	public void setNotequal(boolean value) {
-		sCInterface.setNotequal(value);
-	}
-
-	/* Entry action for statechart 'BooleanExpressions'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'BooleanExpressions'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state StateA. */
-	private void reactMain_region_StateA() {
-		if (sCInterface.e1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.and = sCInterface.myBool1 && sCInterface.myBool2;
-
-			sCInterface.or = sCInterface.myBool1 || sCInterface.myBool2;
-
-			sCInterface.not = !sCInterface.myBool1;
-
-			sCInterface.equal = sCInterface.myBool1 == sCInterface.myBool2;
-
-			sCInterface.notequal = (sCInterface.myBool1 != sCInterface.myBool2);
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_StateB;
-		}
-	}
-
-	/* The reactions of state StateB. */
-	private void reactMain_region_StateB() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_StateA :
-					reactMain_region_StateA();
-					break;
-				case main_region_StateB :
-					reactMain_region_StateB();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.booleanexpressions;
+
+public class BooleanExpressionsStatemachine
+		implements
+			IBooleanExpressionsStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e1;
+
+		public void raiseE1() {
+			e1 = true;
+		}
+
+		private boolean myBool1;
+
+		public boolean getMyBool1() {
+			return myBool1;
+		}
+
+		public void setMyBool1(boolean value) {
+			this.myBool1 = value;
+		}
+
+		private boolean myBool2;
+
+		public boolean getMyBool2() {
+			return myBool2;
+		}
+
+		public void setMyBool2(boolean value) {
+			this.myBool2 = value;
+		}
+
+		private boolean and;
+
+		public boolean getAnd() {
+			return and;
+		}
+
+		public void setAnd(boolean value) {
+			this.and = value;
+		}
+
+		private boolean or;
+
+		public boolean getOr() {
+			return or;
+		}
+
+		public void setOr(boolean value) {
+			this.or = value;
+		}
+
+		private boolean not;
+
+		public boolean getNot() {
+			return not;
+		}
+
+		public void setNot(boolean value) {
+			this.not = value;
+		}
+
+		private boolean equal;
+
+		public boolean getEqual() {
+			return equal;
+		}
+
+		public void setEqual(boolean value) {
+			this.equal = value;
+		}
+
+		private boolean notequal;
+
+		public boolean getNotequal() {
+			return notequal;
+		}
+
+		public void setNotequal(boolean value) {
+			this.notequal = value;
+		}
+
+		public void clearEvents() {
+			e1 = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_StateA, main_region_StateB, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public BooleanExpressionsStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.myBool1 = false;
+
+		sCInterface.myBool2 = false;
+
+		sCInterface.and = false;
+
+		sCInterface.or = false;
+
+		sCInterface.not = false;
+
+		sCInterface.equal = false;
+
+		sCInterface.notequal = false;
+	}
+
+	public void enter() {
+		entryAction();
+
+		sCInterface.myBool1 = true;
+
+		sCInterface.myBool2 = false;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_StateA;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_StateA :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_StateB :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_StateA :
+				return stateVector[0] == State.main_region_StateA;
+			case main_region_StateB :
+				return stateVector[0] == State.main_region_StateB;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE1() {
+		sCInterface.raiseE1();
+	}
+
+	public boolean getMyBool1() {
+		return sCInterface.getMyBool1();
+	}
+
+	public void setMyBool1(boolean value) {
+		sCInterface.setMyBool1(value);
+	}
+	public boolean getMyBool2() {
+		return sCInterface.getMyBool2();
+	}
+
+	public void setMyBool2(boolean value) {
+		sCInterface.setMyBool2(value);
+	}
+	public boolean getAnd() {
+		return sCInterface.getAnd();
+	}
+
+	public void setAnd(boolean value) {
+		sCInterface.setAnd(value);
+	}
+	public boolean getOr() {
+		return sCInterface.getOr();
+	}
+
+	public void setOr(boolean value) {
+		sCInterface.setOr(value);
+	}
+	public boolean getNot() {
+		return sCInterface.getNot();
+	}
+
+	public void setNot(boolean value) {
+		sCInterface.setNot(value);
+	}
+	public boolean getEqual() {
+		return sCInterface.getEqual();
+	}
+
+	public void setEqual(boolean value) {
+		sCInterface.setEqual(value);
+	}
+	public boolean getNotequal() {
+		return sCInterface.getNotequal();
+	}
+
+	public void setNotequal(boolean value) {
+		sCInterface.setNotequal(value);
+	}
+
+	/* Entry action for statechart 'BooleanExpressions'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'BooleanExpressions'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state StateA. */
+	private void reactMain_region_StateA() {
+		if (sCInterface.e1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.and = sCInterface.myBool1 && sCInterface.myBool2;
+
+			sCInterface.or = sCInterface.myBool1 || sCInterface.myBool2;
+
+			sCInterface.not = !sCInterface.myBool1;
+
+			sCInterface.equal = sCInterface.myBool1 == sCInterface.myBool2;
+
+			sCInterface.notequal = (sCInterface.myBool1 != sCInterface.myBool2);
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_StateB;
+		}
+	}
+
+	/* The reactions of state StateB. */
+	private void reactMain_region_StateB() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_StateA :
+					reactMain_region_StateA();
+					break;
+				case main_region_StateB :
+					reactMain_region_StateB();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/booleanexpressions/IBooleanExpressionsStatemachine.java

@@ -1,27 +1,27 @@
-package org.yakindu.scr.booleanexpressions;
-import org.yakindu.scr.IStatemachine;
-
-public interface IBooleanExpressionsStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE1();
-		public boolean getMyBool1();
-		public void setMyBool1(boolean value);
-		public boolean getMyBool2();
-		public void setMyBool2(boolean value);
-		public boolean getAnd();
-		public void setAnd(boolean value);
-		public boolean getOr();
-		public void setOr(boolean value);
-		public boolean getNot();
-		public void setNot(boolean value);
-		public boolean getEqual();
-		public void setEqual(boolean value);
-		public boolean getNotequal();
-		public void setNotequal(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.booleanexpressions;
+import org.yakindu.scr.IStatemachine;
+
+public interface IBooleanExpressionsStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE1();
+		public boolean getMyBool1();
+		public void setMyBool1(boolean value);
+		public boolean getMyBool2();
+		public void setMyBool2(boolean value);
+		public boolean getAnd();
+		public void setAnd(boolean value);
+		public boolean getOr();
+		public void setOr(boolean value);
+		public boolean getNot();
+		public void setNot(boolean value);
+		public boolean getEqual();
+		public void setEqual(boolean value);
+		public boolean getNotequal();
+		public void setNotequal(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/choice/ChoiceStatemachine.java

@@ -1,257 +1,266 @@
-package org.yakindu.scr.choice;
-
-public class ChoiceStatemachine implements IChoiceStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private boolean f;
-
-		public void raiseF() {
-			f = true;
-		}
-
-		private boolean g;
-
-		public void raiseG() {
-			g = true;
-		}
-
-		private boolean h;
-
-		public void raiseH() {
-			h = true;
-		}
-
-		private boolean c;
-
-		public boolean getC() {
-			return c;
-		}
-
-		public void setC(boolean value) {
-			this.c = value;
-		}
-
-		public void clearEvents() {
-			e = false;
-			f = false;
-			g = false;
-			h = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, main_region_B, main_region_C, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public ChoiceStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.c = false;
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_C :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0] == State.main_region_B;
-			case main_region_C :
-				return stateVector[0] == State.main_region_C;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-	public void raiseF() {
-		sCInterface.raiseF();
-	}
-	public void raiseG() {
-		sCInterface.raiseG();
-	}
-	public void raiseH() {
-		sCInterface.raiseH();
-	}
-
-	public boolean getC() {
-		return sCInterface.getC();
-	}
-
-	public void setC(boolean value) {
-		sCInterface.setC(value);
-	}
-
-	/* Entry action for statechart 'Choice'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'Choice'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			if (sCInterface.c) {
-				nextStateIndex = 0;
-				stateVector[0] = State.main_region_C;
-			} else {
-				nextStateIndex = 0;
-				stateVector[0] = State.main_region_B;
-			}
-		} else {
-			if (sCInterface.f) {
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				if (sCInterface.c) {
-					nextStateIndex = 0;
-					stateVector[0] = State.main_region_C;
-				} else {
-					nextStateIndex = 0;
-					stateVector[0] = State.main_region_B;
-				}
-			} else {
-				if (sCInterface.g) {
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-
-					if (sCInterface.c) {
-						nextStateIndex = 0;
-						stateVector[0] = State.main_region_C;
-					} else {
-						nextStateIndex = 0;
-						stateVector[0] = State.main_region_B;
-					}
-				} else {
-					if (sCInterface.h) {
-						nextStateIndex = 0;
-						stateVector[0] = State.$NullState$;
-
-						if (sCInterface.c) {
-							nextStateIndex = 0;
-							stateVector[0] = State.main_region_C;
-						} else {
-							nextStateIndex = 0;
-							stateVector[0] = State.main_region_B;
-						}
-					}
-				}
-			}
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactMain_region_B() {
-		nextStateIndex = 0;
-		stateVector[0] = State.$NullState$;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	/* The reactions of state C. */
-	private void reactMain_region_C() {
-		nextStateIndex = 0;
-		stateVector[0] = State.$NullState$;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B :
-					reactMain_region_B();
-					break;
-				case main_region_C :
-					reactMain_region_C();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.choice;
+
+public class ChoiceStatemachine implements IChoiceStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private boolean f;
+
+		public void raiseF() {
+			f = true;
+		}
+
+		private boolean g;
+
+		public void raiseG() {
+			g = true;
+		}
+
+		private boolean h;
+
+		public void raiseH() {
+			h = true;
+		}
+
+		private boolean c;
+
+		public boolean getC() {
+			return c;
+		}
+
+		public void setC(boolean value) {
+			this.c = value;
+		}
+
+		public void clearEvents() {
+			e = false;
+			f = false;
+			g = false;
+			h = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, main_region_B, main_region_C, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public ChoiceStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.c = false;
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_C :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0] == State.main_region_B;
+			case main_region_C :
+				return stateVector[0] == State.main_region_C;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+	public void raiseF() {
+		sCInterface.raiseF();
+	}
+	public void raiseG() {
+		sCInterface.raiseG();
+	}
+	public void raiseH() {
+		sCInterface.raiseH();
+	}
+
+	public boolean getC() {
+		return sCInterface.getC();
+	}
+
+	public void setC(boolean value) {
+		sCInterface.setC(value);
+	}
+
+	/* Entry action for statechart 'Choice'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'Choice'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.e) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			if (sCInterface.c) {
+				nextStateIndex = 0;
+				stateVector[0] = State.main_region_C;
+			} else {
+				nextStateIndex = 0;
+				stateVector[0] = State.main_region_B;
+			}
+		} else {
+			if (sCInterface.f) {
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				if (sCInterface.c) {
+					nextStateIndex = 0;
+					stateVector[0] = State.main_region_C;
+				} else {
+					nextStateIndex = 0;
+					stateVector[0] = State.main_region_B;
+				}
+			} else {
+				if (sCInterface.g) {
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+
+					if (sCInterface.c) {
+						nextStateIndex = 0;
+						stateVector[0] = State.main_region_C;
+					} else {
+						nextStateIndex = 0;
+						stateVector[0] = State.main_region_B;
+					}
+				} else {
+					if (sCInterface.h) {
+						nextStateIndex = 0;
+						stateVector[0] = State.$NullState$;
+
+						if (sCInterface.c) {
+							nextStateIndex = 0;
+							stateVector[0] = State.main_region_C;
+						} else {
+							nextStateIndex = 0;
+							stateVector[0] = State.main_region_B;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactMain_region_B() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	/* The reactions of state C. */
+	private void reactMain_region_C() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B :
+					reactMain_region_B();
+					break;
+				case main_region_C :
+					reactMain_region_C();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/choice/IChoiceStatemachine.java

@@ -1,18 +1,18 @@
-package org.yakindu.scr.choice;
-import org.yakindu.scr.IStatemachine;
-
-public interface IChoiceStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public void raiseF();
-		public void raiseG();
-		public void raiseH();
-		public boolean getC();
-		public void setC(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.choice;
+import org.yakindu.scr.IStatemachine;
+
+public interface IChoiceStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public void raiseF();
+		public void raiseG();
+		public void raiseH();
+		public boolean getC();
+		public void setC(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/ckeywords/ICKeywordsStatemachine.java

@@ -1,66 +1,66 @@
-package org.yakindu.scr.ckeywords;
-import org.yakindu.scr.IStatemachine;
-
-public interface ICKeywordsStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseAuto();
-		public void raiseBreak();
-		public boolean getCase();
-		public void setCase(boolean value);
-		public int getDo();
-		public void setDo(int value);
-		public boolean getContinue();
-		public void setContinue(boolean value);
-		public boolean getDouble();
-		public void setDouble(boolean value);
-		public boolean getEnum();
-		public void setEnum(boolean value);
-		public boolean getExtern();
-		public void setExtern(boolean value);
-		public boolean getFloat();
-		public void setFloat(boolean value);
-		public boolean getFor();
-		public void setFor(boolean value);
-		public boolean getGoto();
-		public void setGoto(boolean value);
-		public boolean getIf();
-		public void setIf(boolean value);
-		public boolean getInt();
-		public void setInt(boolean value);
-		public boolean getLong();
-		public void setLong(boolean value);
-		public boolean getRegister();
-		public void setRegister(boolean value);
-		public boolean getReturn();
-		public void setReturn(boolean value);
-		public boolean getShort();
-		public void setShort(boolean value);
-		public boolean getSigned();
-		public void setSigned(boolean value);
-		public boolean getSizeof();
-		public void setSizeof(boolean value);
-		public boolean getStatic();
-		public void setStatic(boolean value);
-		public boolean getStruct();
-		public void setStruct(boolean value);
-		public boolean getSwitch();
-		public void setSwitch(boolean value);
-		public boolean getTypedef();
-		public void setTypedef(boolean value);
-		public boolean getUnion();
-		public void setUnion(boolean value);
-		public boolean getUnsigned();
-		public void setUnsigned(boolean value);
-		public boolean getVoid();
-		public void setVoid(boolean value);
-		public boolean getVolatile();
-		public void setVolatile(boolean value);
-		public boolean getWhile();
-		public void setWhile(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.ckeywords;
+import org.yakindu.scr.IStatemachine;
+
+public interface ICKeywordsStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseAuto();
+		public void raiseBreak();
+		public boolean getCase();
+		public void setCase(boolean value);
+		public long getDo();
+		public void setDo(long value);
+		public boolean getContinue();
+		public void setContinue(boolean value);
+		public boolean getDouble();
+		public void setDouble(boolean value);
+		public boolean getEnum();
+		public void setEnum(boolean value);
+		public boolean getExtern();
+		public void setExtern(boolean value);
+		public boolean getFloat();
+		public void setFloat(boolean value);
+		public boolean getFor();
+		public void setFor(boolean value);
+		public boolean getGoto();
+		public void setGoto(boolean value);
+		public boolean getIf();
+		public void setIf(boolean value);
+		public boolean getInt();
+		public void setInt(boolean value);
+		public boolean getLong();
+		public void setLong(boolean value);
+		public boolean getRegister();
+		public void setRegister(boolean value);
+		public boolean getReturn();
+		public void setReturn(boolean value);
+		public boolean getShort();
+		public void setShort(boolean value);
+		public boolean getSigned();
+		public void setSigned(boolean value);
+		public boolean getSizeof();
+		public void setSizeof(boolean value);
+		public boolean getStatic();
+		public void setStatic(boolean value);
+		public boolean getStruct();
+		public void setStruct(boolean value);
+		public boolean getSwitch();
+		public void setSwitch(boolean value);
+		public boolean getTypedef();
+		public void setTypedef(boolean value);
+		public boolean getUnion();
+		public void setUnion(boolean value);
+		public boolean getUnsigned();
+		public void setUnsigned(boolean value);
+		public boolean getVoid();
+		public void setVoid(boolean value);
+		public boolean getVolatile();
+		public void setVolatile(boolean value);
+		public boolean getWhile();
+		public void setWhile(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/declarations/IDeclarationsStatemachine.java

@@ -1,50 +1,50 @@
-package org.yakindu.scr.declarations;
-import org.yakindu.scr.IStatemachine;
-
-public interface IDeclarationsStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseEvA();
-		public boolean isRaisedEvB();
-		public void raiseEvC(boolean value);
-		public boolean isRaisedEvD();
-		public int getEvDValue();
-		public void raiseEvE(double value);
-		public boolean isRaisedEvF();
-		public String getEvFValue();
-		public boolean getVarA();
-		public void setVarA(boolean value);
-		public int getVarB();
-		public void setVarB(int value);
-		public double getVarC();
-		public void setVarC(double value);
-		public String getVarD();
-		public void setVarD(String value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-	public interface SCIIfA {
-		public void raiseEvA();
-		public boolean isRaisedEvB();
-		public void raiseEvC(boolean value);
-		public boolean isRaisedEvD();
-		public int getEvDValue();
-		public void raiseEvE(double value);
-		public boolean isRaisedEvF();
-		public String getEvFValue();
-		public boolean getVarA();
-		public void setVarA(boolean value);
-		public int getVarB();
-		public void setVarB(int value);
-		public double getVarC();
-		public void setVarC(double value);
-		public String getVarD();
-		public void setVarD(String value);
-
-	}
-
-	public SCIIfA getSCIIfA();
-
-}
+package org.yakindu.scr.declarations;
+import org.yakindu.scr.IStatemachine;
+
+public interface IDeclarationsStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseEvA();
+		public boolean isRaisedEvB();
+		public void raiseEvC(boolean value);
+		public boolean isRaisedEvD();
+		public long getEvDValue();
+		public void raiseEvE(double value);
+		public boolean isRaisedEvF();
+		public String getEvFValue();
+		public boolean getVarA();
+		public void setVarA(boolean value);
+		public long getVarB();
+		public void setVarB(long value);
+		public double getVarC();
+		public void setVarC(double value);
+		public String getVarD();
+		public void setVarD(String value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+	public interface SCIIfA {
+		public void raiseEvA();
+		public boolean isRaisedEvB();
+		public void raiseEvC(boolean value);
+		public boolean isRaisedEvD();
+		public long getEvDValue();
+		public void raiseEvE(double value);
+		public boolean isRaisedEvF();
+		public String getEvFValue();
+		public boolean getVarA();
+		public void setVarA(boolean value);
+		public long getVarB();
+		public void setVarB(long value);
+		public double getVarC();
+		public void setVarC(double value);
+		public String getVarD();
+		public void setVarD(String value);
+
+	}
+
+	public SCIIfA getSCIIfA();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/deepentry/DeepEntryStatemachine.java

@@ -1,440 +1,452 @@
-package org.yakindu.scr.deepentry;
-
-public class DeepEntryStatemachine implements IDeepEntryStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private boolean f;
-
-		public void raiseF() {
-			f = true;
-		}
-
-		private int x;
-
-		public int getX() {
-			return x;
-		}
-
-		public void setX(int value) {
-			this.x = value;
-		}
-
-		private int y;
-
-		public int getY() {
-			return y;
-		}
-
-		public void setY(int value) {
-			this.y = value;
-		}
-
-		private int z;
-
-		public int getZ() {
-			return z;
-		}
-
-		public void setZ(int value) {
-			this.z = value;
-		}
-
-		public void clearEvents() {
-			e = false;
-			f = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		r_A, r_A_r_B, r2_B, r2_B_r_BA, r2_B_r_BA_r_BAA, r2_B_r_BB, r2_C, r3_D, r3_D_r_DA, r3_D_r_DA_r_DAA, $NullState$
-	};
-
-	private State[] historyVector = new State[4];
-	private final State[] stateVector = new State[3];
-
-	private int nextStateIndex;
-
-	public DeepEntryStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 3; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		for (int i = 0; i < 4; i++) {
-			historyVector[i] = State.$NullState$;
-		}
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.x = 0;
-
-		sCInterface.y = 0;
-
-		sCInterface.z = 0;
-	}
-
-	public void enter() {
-		entryAction();
-
-		sCInterface.x += 1;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.r_A_r_B;
-
-		/* Enter the region with shallow history */
-		if (historyVector[0] != State.$NullState$) {
-			shallowEnterSequenceR2_B_r();
-		} else {
-			sCInterface.y += 1;
-
-			nextStateIndex = 1;
-			stateVector[1] = State.r2_B_r_BA_r_BAA;
-		}
-
-		/* Enter the region with deep history */
-		if (historyVector[1] != State.$NullState$) {
-			deepEnterSequenceR3();
-		} else {
-			sCInterface.z += 1;
-
-			sCInterface.z += 1;
-
-			nextStateIndex = 2;
-			stateVector[2] = State.r3_D_r_DA_r_DAA;
-		}
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case r_A_r_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		switch (stateVector[1]) {
-			case r2_B_r_BA_r_BAA :
-				historyVector[0] = stateVector[1];
-
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case r2_B_r_BB :
-				historyVector[0] = stateVector[1];
-
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case r2_C :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		historyVector[1] = stateVector[2];
-
-		switch (stateVector[2]) {
-			case r3_D_r_DA_r_DAA :
-				historyVector[3] = stateVector[2];
-
-				historyVector[2] = stateVector[2];
-
-				nextStateIndex = 2;
-				stateVector[2] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case r_A :
-				return stateVector[0].ordinal() >= State.r_A.ordinal()
-						&& stateVector[0].ordinal() <= State.r_A_r_B.ordinal();
-			case r_A_r_B :
-				return stateVector[0] == State.r_A_r_B;
-			case r2_B :
-				return stateVector[1].ordinal() >= State.r2_B.ordinal()
-						&& stateVector[1].ordinal() <= State.r2_B_r_BB
-								.ordinal();
-			case r2_B_r_BA :
-				return stateVector[1].ordinal() >= State.r2_B_r_BA.ordinal()
-						&& stateVector[1].ordinal() <= State.r2_B_r_BA_r_BAA
-								.ordinal();
-			case r2_B_r_BA_r_BAA :
-				return stateVector[1] == State.r2_B_r_BA_r_BAA;
-			case r2_B_r_BB :
-				return stateVector[1] == State.r2_B_r_BB;
-			case r2_C :
-				return stateVector[1] == State.r2_C;
-			case r3_D :
-				return stateVector[2].ordinal() >= State.r3_D.ordinal()
-						&& stateVector[2].ordinal() <= State.r3_D_r_DA_r_DAA
-								.ordinal();
-			case r3_D_r_DA :
-				return stateVector[2].ordinal() >= State.r3_D_r_DA.ordinal()
-						&& stateVector[2].ordinal() <= State.r3_D_r_DA_r_DAA
-								.ordinal();
-			case r3_D_r_DA_r_DAA :
-				return stateVector[2] == State.r3_D_r_DA_r_DAA;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-	public void raiseF() {
-		sCInterface.raiseF();
-	}
-
-	public int getX() {
-		return sCInterface.getX();
-	}
-
-	public void setX(int value) {
-		sCInterface.setX(value);
-	}
-	public int getY() {
-		return sCInterface.getY();
-	}
-
-	public void setY(int value) {
-		sCInterface.setY(value);
-	}
-	public int getZ() {
-		return sCInterface.getZ();
-	}
-
-	public void setZ(int value) {
-		sCInterface.setZ(value);
-	}
-
-	/* Entry action for statechart 'DeepEntry'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'DeepEntry'. */
-	private void exitAction() {
-	}
-
-	/* shallow enterSequence with history in child r */
-	private void shallowEnterSequenceR2_B_r() {
-		switch (historyVector[0]) {
-			case r2_B_r_BA_r_BAA :
-				sCInterface.y += 1;
-				break;
-
-			case r2_B_r_BB :
-				nextStateIndex = 1;
-				stateVector[1] = State.r2_B_r_BB;
-				break;
-
-			default :
-				break;
-		}
-	}
-
-	/* deep enterSequence with history in child r3 */
-	private void deepEnterSequenceR3() {
-		switch (historyVector[1]) {
-			case r3_D_r_DA_r_DAA :
-				sCInterface.z += 1;
-
-				deepEnterSequenceR3_D_r();
-				break;
-
-			default :
-				break;
-		}
-	}
-
-	/* deep enterSequence with history in child r */
-	private void deepEnterSequenceR3_D_r() {
-		switch (historyVector[2]) {
-			case r3_D_r_DA_r_DAA :
-				sCInterface.z += 1;
-
-				deepEnterSequenceR3_D_r_DA_r();
-				break;
-
-			default :
-				break;
-		}
-	}
-
-	/* deep enterSequence with history in child r */
-	private void deepEnterSequenceR3_D_r_DA_r() {
-		switch (historyVector[3]) {
-			case r3_D_r_DA_r_DAA :
-				nextStateIndex = 2;
-				stateVector[2] = State.r3_D_r_DA_r_DAA;
-				break;
-
-			default :
-				break;
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactR_A_r_B() {
-	}
-
-	/* The reactions of state BAA. */
-	private void reactR2_B_r_BA_r_BAA() {
-		if (sCInterface.f) {
-			historyVector[0] = stateVector[1];
-
-			switch (stateVector[1]) {
-				case r2_B_r_BA_r_BAA :
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-					break;
-
-				case r2_B_r_BB :
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-					break;
-
-				default :
-					break;
-			}
-
-			nextStateIndex = 1;
-			stateVector[1] = State.r2_C;
-		} else {
-			if (sCInterface.e) {
-				switch (stateVector[1]) {
-					case r2_B_r_BA_r_BAA :
-						nextStateIndex = 1;
-						stateVector[1] = State.$NullState$;
-						break;
-
-					default :
-						break;
-				}
-
-				nextStateIndex = 1;
-				stateVector[1] = State.r2_B_r_BB;
-			} else {
-			}
-		}
-	}
-
-	/* The reactions of state BB. */
-	private void reactR2_B_r_BB() {
-		if (sCInterface.f) {
-			historyVector[0] = stateVector[1];
-
-			switch (stateVector[1]) {
-				case r2_B_r_BA_r_BAA :
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-					break;
-
-				case r2_B_r_BB :
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-					break;
-
-				default :
-					break;
-			}
-
-			nextStateIndex = 1;
-			stateVector[1] = State.r2_C;
-		} else {
-		}
-	}
-
-	/* The reactions of state C. */
-	private void reactR2_C() {
-		if (sCInterface.f) {
-			nextStateIndex = 1;
-			stateVector[1] = State.$NullState$;
-
-			/* Enter the region with shallow history */
-			if (historyVector[0] != State.$NullState$) {
-				shallowEnterSequenceR2_B_r();
-			} else {
-				sCInterface.y += 1;
-
-				nextStateIndex = 1;
-				stateVector[1] = State.r2_B_r_BA_r_BAA;
-			}
-		}
-	}
-
-	/* The reactions of state DAA. */
-	private void reactR3_D_r_DA_r_DAA() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case r_A_r_B :
-					reactR_A_r_B();
-					break;
-				case r2_B_r_BA_r_BAA :
-					reactR2_B_r_BA_r_BAA();
-					break;
-				case r2_B_r_BB :
-					reactR2_B_r_BB();
-					break;
-				case r2_C :
-					reactR2_C();
-					break;
-				case r3_D_r_DA_r_DAA :
-					reactR3_D_r_DA_r_DAA();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.deepentry;
+
+public class DeepEntryStatemachine implements IDeepEntryStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private boolean f;
+
+		public void raiseF() {
+			f = true;
+		}
+
+		private long x;
+
+		public long getX() {
+			return x;
+		}
+
+		public void setX(long value) {
+			this.x = value;
+		}
+
+		private long y;
+
+		public long getY() {
+			return y;
+		}
+
+		public void setY(long value) {
+			this.y = value;
+		}
+
+		private long z;
+
+		public long getZ() {
+			return z;
+		}
+
+		public void setZ(long value) {
+			this.z = value;
+		}
+
+		public void clearEvents() {
+			e = false;
+			f = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		r_A, r_A_r_B, r2_B, r2_B_r_BA, r2_B_r_BA_r_BAA, r2_B_r_BB, r2_C, r3_D, r3_D_r_DA, r3_D_r_DA_r_DAA, $NullState$
+	};
+
+	private State[] historyVector = new State[4];
+	private final State[] stateVector = new State[3];
+
+	private int nextStateIndex;
+
+	public DeepEntryStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 3; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		for (int i = 0; i < 4; i++) {
+			historyVector[i] = State.$NullState$;
+		}
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.x = 0;
+
+		sCInterface.y = 0;
+
+		sCInterface.z = 0;
+	}
+
+	public void enter() {
+		entryAction();
+
+		sCInterface.x += 1;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.r_A_r_B;
+
+		/* Enter the region with shallow history */
+		if (historyVector[0] != State.$NullState$) {
+			shallowEnterSequenceR2_B_r();
+		} else {
+			sCInterface.y += 1;
+
+			nextStateIndex = 1;
+			stateVector[1] = State.r2_B_r_BA_r_BAA;
+		}
+
+		/* Enter the region with deep history */
+		if (historyVector[1] != State.$NullState$) {
+			deepEnterSequenceR3();
+		} else {
+			sCInterface.z += 1;
+
+			sCInterface.z += 1;
+
+			nextStateIndex = 2;
+			stateVector[2] = State.r3_D_r_DA_r_DAA;
+		}
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case r_A_r_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		switch (stateVector[1]) {
+			case r2_B_r_BA_r_BAA :
+				historyVector[0] = stateVector[1];
+
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case r2_B_r_BB :
+				historyVector[0] = stateVector[1];
+
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case r2_C :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		historyVector[1] = stateVector[2];
+
+		switch (stateVector[2]) {
+			case r3_D_r_DA_r_DAA :
+				historyVector[3] = stateVector[2];
+
+				historyVector[2] = stateVector[2];
+
+				nextStateIndex = 2;
+				stateVector[2] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case r_A :
+				return stateVector[0].ordinal() >= State.r_A.ordinal()
+						&& stateVector[0].ordinal() <= State.r_A_r_B.ordinal();
+			case r_A_r_B :
+				return stateVector[0] == State.r_A_r_B;
+			case r2_B :
+				return stateVector[1].ordinal() >= State.r2_B.ordinal()
+						&& stateVector[1].ordinal() <= State.r2_B_r_BB
+								.ordinal();
+			case r2_B_r_BA :
+				return stateVector[1].ordinal() >= State.r2_B_r_BA.ordinal()
+						&& stateVector[1].ordinal() <= State.r2_B_r_BA_r_BAA
+								.ordinal();
+			case r2_B_r_BA_r_BAA :
+				return stateVector[1] == State.r2_B_r_BA_r_BAA;
+			case r2_B_r_BB :
+				return stateVector[1] == State.r2_B_r_BB;
+			case r2_C :
+				return stateVector[1] == State.r2_C;
+			case r3_D :
+				return stateVector[2].ordinal() >= State.r3_D.ordinal()
+						&& stateVector[2].ordinal() <= State.r3_D_r_DA_r_DAA
+								.ordinal();
+			case r3_D_r_DA :
+				return stateVector[2].ordinal() >= State.r3_D_r_DA.ordinal()
+						&& stateVector[2].ordinal() <= State.r3_D_r_DA_r_DAA
+								.ordinal();
+			case r3_D_r_DA_r_DAA :
+				return stateVector[2] == State.r3_D_r_DA_r_DAA;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+	public void raiseF() {
+		sCInterface.raiseF();
+	}
+
+	public long getX() {
+		return sCInterface.getX();
+	}
+
+	public void setX(long value) {
+		sCInterface.setX(value);
+	}
+	public long getY() {
+		return sCInterface.getY();
+	}
+
+	public void setY(long value) {
+		sCInterface.setY(value);
+	}
+	public long getZ() {
+		return sCInterface.getZ();
+	}
+
+	public void setZ(long value) {
+		sCInterface.setZ(value);
+	}
+
+	/* Entry action for statechart 'DeepEntry'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'DeepEntry'. */
+	private void exitAction() {
+	}
+
+	/* shallow enterSequence with history in child r */
+	private void shallowEnterSequenceR2_B_r() {
+		switch (historyVector[0]) {
+			case r2_B_r_BA_r_BAA :
+				sCInterface.y += 1;
+
+				nextStateIndex = 1;
+				stateVector[1] = State.r2_B_r_BA_r_BAA;
+				break;
+
+			case r2_B_r_BB :
+				nextStateIndex = 1;
+				stateVector[1] = State.r2_B_r_BB;
+				break;
+
+			default :
+				break;
+		}
+	}
+
+	/* deep enterSequence with history in child r3 */
+	private void deepEnterSequenceR3() {
+		switch (historyVector[1]) {
+			case r3_D_r_DA_r_DAA :
+				sCInterface.z += 1;
+
+				deepEnterSequenceR3_D_r();
+				break;
+
+			default :
+				break;
+		}
+	}
+
+	/* deep enterSequence with history in child r */
+	private void deepEnterSequenceR3_D_r() {
+		switch (historyVector[2]) {
+			case r3_D_r_DA_r_DAA :
+				sCInterface.z += 1;
+
+				deepEnterSequenceR3_D_r_DA_r();
+				break;
+
+			default :
+				break;
+		}
+	}
+
+	/* deep enterSequence with history in child r */
+	private void deepEnterSequenceR3_D_r_DA_r() {
+		switch (historyVector[3]) {
+			case r3_D_r_DA_r_DAA :
+				nextStateIndex = 2;
+				stateVector[2] = State.r3_D_r_DA_r_DAA;
+				break;
+
+			default :
+				break;
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactR_A_r_B() {
+	}
+
+	/* The reactions of state BAA. */
+	private void reactR2_B_r_BA_r_BAA() {
+		if (sCInterface.f) {
+			historyVector[0] = stateVector[1];
+
+			switch (stateVector[1]) {
+				case r2_B_r_BA_r_BAA :
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+					break;
+
+				case r2_B_r_BB :
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			nextStateIndex = 1;
+			stateVector[1] = State.r2_C;
+		} else {
+			if (sCInterface.e) {
+				switch (stateVector[1]) {
+					case r2_B_r_BA_r_BAA :
+						nextStateIndex = 1;
+						stateVector[1] = State.$NullState$;
+						break;
+
+					default :
+						break;
+				}
+
+				nextStateIndex = 1;
+				stateVector[1] = State.r2_B_r_BB;
+			} else {
+			}
+		}
+	}
+
+	/* The reactions of state BB. */
+	private void reactR2_B_r_BB() {
+		if (sCInterface.f) {
+			historyVector[0] = stateVector[1];
+
+			switch (stateVector[1]) {
+				case r2_B_r_BA_r_BAA :
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+					break;
+
+				case r2_B_r_BB :
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			nextStateIndex = 1;
+			stateVector[1] = State.r2_C;
+		} else {
+		}
+	}
+
+	/* The reactions of state C. */
+	private void reactR2_C() {
+		if (sCInterface.f) {
+			nextStateIndex = 1;
+			stateVector[1] = State.$NullState$;
+
+			/* Enter the region with shallow history */
+			if (historyVector[0] != State.$NullState$) {
+				shallowEnterSequenceR2_B_r();
+			} else {
+				sCInterface.y += 1;
+
+				nextStateIndex = 1;
+				stateVector[1] = State.r2_B_r_BA_r_BAA;
+			}
+		}
+	}
+
+	/* The reactions of state DAA. */
+	private void reactR3_D_r_DA_r_DAA() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case r_A_r_B :
+					reactR_A_r_B();
+					break;
+				case r2_B_r_BA_r_BAA :
+					reactR2_B_r_BA_r_BAA();
+					break;
+				case r2_B_r_BB :
+					reactR2_B_r_BB();
+					break;
+				case r2_C :
+					reactR2_C();
+					break;
+				case r3_D_r_DA_r_DAA :
+					reactR3_D_r_DA_r_DAA();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/deepentry/IDeepEntryStatemachine.java

@@ -1,20 +1,20 @@
-package org.yakindu.scr.deepentry;
-import org.yakindu.scr.IStatemachine;
-
-public interface IDeepEntryStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public void raiseF();
-		public int getX();
-		public void setX(int value);
-		public int getY();
-		public void setY(int value);
-		public int getZ();
-		public void setZ(int value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.deepentry;
+import org.yakindu.scr.IStatemachine;
+
+public interface IDeepEntryStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public void raiseF();
+		public long getX();
+		public void setX(long value);
+		public long getY();
+		public void setY(long value);
+		public long getZ();
+		public void setZ(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/deephistory/IDeepHistoryStatemachine.java

@@ -1,21 +1,21 @@
-package org.yakindu.scr.deephistory;
-import org.yakindu.scr.IStatemachine;
-
-public interface IDeepHistoryStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseEvent1();
-		public void raiseEvent2();
-		public void raiseEvent3();
-		public void raiseEvent4();
-		public void raiseEvent5();
-		public void raiseEvent6();
-		public void raiseEvent7();
-		public void raiseEvent8();
-		public void raiseEvent9();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.deephistory;
+import org.yakindu.scr.IStatemachine;
+
+public interface IDeepHistoryStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseEvent1();
+		public void raiseEvent2();
+		public void raiseEvent3();
+		public void raiseEvent4();
+		public void raiseEvent5();
+		public void raiseEvent6();
+		public void raiseEvent7();
+		public void raiseEvent8();
+		public void raiseEvent9();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/enterstate/EnterStateStatemachine.java

@@ -1,193 +1,202 @@
-package org.yakindu.scr.enterstate;
-
-public class EnterStateStatemachine implements IEnterStateStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private boolean f;
-
-		public void raiseF() {
-			f = true;
-		}
-
-		private boolean g;
-
-		public void raiseG() {
-			g = true;
-		}
-
-		public void clearEvents() {
-			e = false;
-			f = false;
-			g = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		r_A, r_B, r_B_r_E, r_B_r_F, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public EnterStateStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.r_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case r_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case r_B_r_E :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case r_B_r_F :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case r_A :
-				return stateVector[0] == State.r_A;
-			case r_B :
-				return stateVector[0].ordinal() >= State.r_B.ordinal()
-						&& stateVector[0].ordinal() <= State.r_B_r_F.ordinal();
-			case r_B_r_E :
-				return stateVector[0] == State.r_B_r_E;
-			case r_B_r_F :
-				return stateVector[0] == State.r_B_r_F;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-	public void raiseF() {
-		sCInterface.raiseF();
-	}
-	public void raiseG() {
-		sCInterface.raiseG();
-	}
-
-	/* Entry action for statechart 'EnterState'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'EnterState'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactR_A() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.r_B_r_E;
-		} else {
-			if (sCInterface.f) {
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				nextStateIndex = 0;
-				stateVector[0] = State.r_B_r_F;
-			} else {
-				if (sCInterface.g) {
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-
-					nextStateIndex = 0;
-					stateVector[0] = State.r_B_r_E;
-				}
-			}
-		}
-	}
-
-	/* The reactions of state E. */
-	private void reactR_B_r_E() {
-	}
-
-	/* The reactions of state F. */
-	private void reactR_B_r_F() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case r_A :
-					reactR_A();
-					break;
-				case r_B_r_E :
-					reactR_B_r_E();
-					break;
-				case r_B_r_F :
-					reactR_B_r_F();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.enterstate;
+
+public class EnterStateStatemachine implements IEnterStateStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private boolean f;
+
+		public void raiseF() {
+			f = true;
+		}
+
+		private boolean g;
+
+		public void raiseG() {
+			g = true;
+		}
+
+		public void clearEvents() {
+			e = false;
+			f = false;
+			g = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		r_A, r_B, r_B_r_E, r_B_r_F, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public EnterStateStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.r_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case r_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case r_B_r_E :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case r_B_r_F :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case r_A :
+				return stateVector[0] == State.r_A;
+			case r_B :
+				return stateVector[0].ordinal() >= State.r_B.ordinal()
+						&& stateVector[0].ordinal() <= State.r_B_r_F.ordinal();
+			case r_B_r_E :
+				return stateVector[0] == State.r_B_r_E;
+			case r_B_r_F :
+				return stateVector[0] == State.r_B_r_F;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+	public void raiseF() {
+		sCInterface.raiseF();
+	}
+	public void raiseG() {
+		sCInterface.raiseG();
+	}
+
+	/* Entry action for statechart 'EnterState'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'EnterState'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactR_A() {
+		if (sCInterface.e) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.r_B_r_E;
+		} else {
+			if (sCInterface.f) {
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				nextStateIndex = 0;
+				stateVector[0] = State.r_B_r_F;
+			} else {
+				if (sCInterface.g) {
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+
+					nextStateIndex = 0;
+					stateVector[0] = State.r_B_r_E;
+				}
+			}
+		}
+	}
+
+	/* The reactions of state E. */
+	private void reactR_B_r_E() {
+	}
+
+	/* The reactions of state F. */
+	private void reactR_B_r_F() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case r_A :
+					reactR_A();
+					break;
+				case r_B_r_E :
+					reactR_B_r_E();
+					break;
+				case r_B_r_F :
+					reactR_B_r_F();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/enterstate/IEnterStateStatemachine.java

@@ -1,15 +1,15 @@
-package org.yakindu.scr.enterstate;
-import org.yakindu.scr.IStatemachine;
-
-public interface IEnterStateStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public void raiseF();
-		public void raiseG();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.enterstate;
+import org.yakindu.scr.IStatemachine;
+
+public interface IEnterStateStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public void raiseF();
+		public void raiseG();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/entrychoice/EntryChoiceStatemachine.java

@@ -27,6 +27,8 @@ public class EntryChoiceStatemachine implements IEntryChoiceStatemachine {
 	public void enter() {
 		entryAction();
 
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
 	}
 
 	public void exit() {
@@ -43,13 +45,22 @@ public class EntryChoiceStatemachine implements IEntryChoiceStatemachine {
 		exitAction();
 	}
 
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
 	protected void clearEvents() {
 
 	}
 
+	/**
+	 * This method resets the outgoing events.
+	 */
 	protected void clearOutEvents() {
 	}
 
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
 	public boolean isStateActive(State state) {
 		switch (state) {
 			case main_region_A :

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/exitonselftransition/ExitOnSelfTransitionStatemachine.java

@@ -1,217 +1,226 @@
-package org.yakindu.scr.exitonselftransition;
-
-public class ExitOnSelfTransitionStatemachine
-		implements
-			IExitOnSelfTransitionStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private boolean f;
-
-		public void raiseF() {
-			f = true;
-		}
-
-		private int entryCount;
-
-		public int getEntryCount() {
-			return entryCount;
-		}
-
-		public void setEntryCount(int value) {
-			this.entryCount = value;
-		}
-
-		private int exitCount;
-
-		public int getExitCount() {
-			return exitCount;
-		}
-
-		public void setExitCount(int value) {
-			this.exitCount = value;
-		}
-
-		public void clearEvents() {
-			e = false;
-			f = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, main_region_B, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public ExitOnSelfTransitionStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.entryCount = 0;
-
-		sCInterface.exitCount = 0;
-	}
-
-	public void enter() {
-		entryAction();
-
-		sCInterface.entryCount += 1;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				sCInterface.exitCount += 1;
-				break;
-
-			case main_region_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0] == State.main_region_B;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-	public void raiseF() {
-		sCInterface.raiseF();
-	}
-
-	public int getEntryCount() {
-		return sCInterface.getEntryCount();
-	}
-
-	public void setEntryCount(int value) {
-		sCInterface.setEntryCount(value);
-	}
-	public int getExitCount() {
-		return sCInterface.getExitCount();
-	}
-
-	public void setExitCount(int value) {
-		sCInterface.setExitCount(value);
-	}
-
-	/* Entry action for statechart 'ExitOnSelfTransition'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'ExitOnSelfTransition'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.exitCount += 1;
-
-			sCInterface.entryCount += 1;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		} else {
-			if (sCInterface.f) {
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				sCInterface.exitCount += 1;
-
-				nextStateIndex = 0;
-				stateVector[0] = State.main_region_B;
-			}
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactMain_region_B() {
-		if (sCInterface.f) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.entryCount += 1;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B :
-					reactMain_region_B();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.exitonselftransition;
+
+public class ExitOnSelfTransitionStatemachine
+		implements
+			IExitOnSelfTransitionStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private boolean f;
+
+		public void raiseF() {
+			f = true;
+		}
+
+		private long entryCount;
+
+		public long getEntryCount() {
+			return entryCount;
+		}
+
+		public void setEntryCount(long value) {
+			this.entryCount = value;
+		}
+
+		private long exitCount;
+
+		public long getExitCount() {
+			return exitCount;
+		}
+
+		public void setExitCount(long value) {
+			this.exitCount = value;
+		}
+
+		public void clearEvents() {
+			e = false;
+			f = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, main_region_B, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public ExitOnSelfTransitionStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.entryCount = 0;
+
+		sCInterface.exitCount = 0;
+	}
+
+	public void enter() {
+		entryAction();
+
+		sCInterface.entryCount += 1;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				sCInterface.exitCount += 1;
+				break;
+
+			case main_region_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0] == State.main_region_B;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+	public void raiseF() {
+		sCInterface.raiseF();
+	}
+
+	public long getEntryCount() {
+		return sCInterface.getEntryCount();
+	}
+
+	public void setEntryCount(long value) {
+		sCInterface.setEntryCount(value);
+	}
+	public long getExitCount() {
+		return sCInterface.getExitCount();
+	}
+
+	public void setExitCount(long value) {
+		sCInterface.setExitCount(value);
+	}
+
+	/* Entry action for statechart 'ExitOnSelfTransition'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'ExitOnSelfTransition'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.e) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.exitCount += 1;
+
+			sCInterface.entryCount += 1;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		} else {
+			if (sCInterface.f) {
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				sCInterface.exitCount += 1;
+
+				nextStateIndex = 0;
+				stateVector[0] = State.main_region_B;
+			}
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactMain_region_B() {
+		if (sCInterface.f) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.entryCount += 1;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B :
+					reactMain_region_B();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/exitonselftransition/IExitOnSelfTransitionStatemachine.java

@@ -1,18 +1,18 @@
-package org.yakindu.scr.exitonselftransition;
-import org.yakindu.scr.IStatemachine;
-
-public interface IExitOnSelfTransitionStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public void raiseF();
-		public int getEntryCount();
-		public void setEntryCount(int value);
-		public int getExitCount();
-		public void setExitCount(int value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.exitonselftransition;
+import org.yakindu.scr.IStatemachine;
+
+public interface IExitOnSelfTransitionStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public void raiseF();
+		public long getEntryCount();
+		public void setEntryCount(long value);
+		public long getExitCount();
+		public void setExitCount(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/exitstate/ExitStateStatemachine.java

@@ -1,244 +1,253 @@
-package org.yakindu.scr.exitstate;
-
-public class ExitStateStatemachine implements IExitStateStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private boolean f;
-
-		public void raiseF() {
-			f = true;
-		}
-
-		private boolean g;
-
-		public void raiseG() {
-			g = true;
-		}
-
-		public void clearEvents() {
-			e = false;
-			f = false;
-			g = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		r_A, r_A_r_B, r_E, r_F, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public ExitStateStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.r_A_r_B;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case r_A_r_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case r_E :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case r_F :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case r_A :
-				return stateVector[0].ordinal() >= State.r_A.ordinal()
-						&& stateVector[0].ordinal() <= State.r_A_r_B.ordinal();
-			case r_A_r_B :
-				return stateVector[0] == State.r_A_r_B;
-			case r_E :
-				return stateVector[0] == State.r_E;
-			case r_F :
-				return stateVector[0] == State.r_F;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-	public void raiseF() {
-		sCInterface.raiseF();
-	}
-	public void raiseG() {
-		sCInterface.raiseG();
-	}
-
-	private boolean checkR_A_r_BTr0() {
-		return sCInterface.g;
-	}
-
-	private boolean checkR_A_r_BTr1() {
-		return sCInterface.f;
-	}
-
-	private boolean checkR_A_r_BTr2() {
-		return sCInterface.e;
-	}
-
-	private void effectR_ATr0() {
-		switch (stateVector[0]) {
-			case r_A_r_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		nextStateIndex = 0;
-		stateVector[0] = State.r_E;
-	}
-
-	private void effectR_ATr1() {
-		switch (stateVector[0]) {
-			case r_A_r_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		nextStateIndex = 0;
-		stateVector[0] = State.r_F;
-	}
-
-	private void effectR_A_r_BTr0() {
-		nextStateIndex = 0;
-		stateVector[0] = State.$NullState$;
-
-		effectR_ATr0();
-	}
-
-	private void effectR_A_r_BTr1() {
-		nextStateIndex = 0;
-		stateVector[0] = State.$NullState$;
-
-		effectR_ATr1();
-	}
-
-	private void effectR_A_r_BTr2() {
-		nextStateIndex = 0;
-		stateVector[0] = State.$NullState$;
-
-		effectR_ATr0();
-	}
-
-	/* Entry action for statechart 'ExitState'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'ExitState'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state B. */
-	private void reactR_A_r_B() {
-		if (checkR_A_r_BTr0()) {
-			effectR_A_r_BTr0();
-		} else {
-			if (checkR_A_r_BTr1()) {
-				effectR_A_r_BTr1();
-			} else {
-				if (checkR_A_r_BTr2()) {
-					effectR_A_r_BTr2();
-				}
-			}
-		}
-	}
-
-	/* The reactions of state E. */
-	private void reactR_E() {
-	}
-
-	/* The reactions of state F. */
-	private void reactR_F() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case r_A_r_B :
-					reactR_A_r_B();
-					break;
-				case r_E :
-					reactR_E();
-					break;
-				case r_F :
-					reactR_F();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.exitstate;
+
+public class ExitStateStatemachine implements IExitStateStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private boolean f;
+
+		public void raiseF() {
+			f = true;
+		}
+
+		private boolean g;
+
+		public void raiseG() {
+			g = true;
+		}
+
+		public void clearEvents() {
+			e = false;
+			f = false;
+			g = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		r_A, r_A_r_B, r_E, r_F, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public ExitStateStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.r_A_r_B;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case r_A_r_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case r_E :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case r_F :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case r_A :
+				return stateVector[0].ordinal() >= State.r_A.ordinal()
+						&& stateVector[0].ordinal() <= State.r_A_r_B.ordinal();
+			case r_A_r_B :
+				return stateVector[0] == State.r_A_r_B;
+			case r_E :
+				return stateVector[0] == State.r_E;
+			case r_F :
+				return stateVector[0] == State.r_F;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+	public void raiseF() {
+		sCInterface.raiseF();
+	}
+	public void raiseG() {
+		sCInterface.raiseG();
+	}
+
+	private boolean checkR_A_r_BTr0() {
+		return sCInterface.g;
+	}
+
+	private boolean checkR_A_r_BTr1() {
+		return sCInterface.f;
+	}
+
+	private boolean checkR_A_r_BTr2() {
+		return sCInterface.e;
+	}
+
+	private void effectR_ATr0() {
+		switch (stateVector[0]) {
+			case r_A_r_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		nextStateIndex = 0;
+		stateVector[0] = State.r_E;
+	}
+
+	private void effectR_ATr1() {
+		switch (stateVector[0]) {
+			case r_A_r_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		nextStateIndex = 0;
+		stateVector[0] = State.r_F;
+	}
+
+	private void effectR_A_r_BTr0() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+
+		effectR_ATr0();
+	}
+
+	private void effectR_A_r_BTr1() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+
+		effectR_ATr1();
+	}
+
+	private void effectR_A_r_BTr2() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+
+		effectR_ATr0();
+	}
+
+	/* Entry action for statechart 'ExitState'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'ExitState'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state B. */
+	private void reactR_A_r_B() {
+		if (checkR_A_r_BTr0()) {
+			effectR_A_r_BTr0();
+		} else {
+			if (checkR_A_r_BTr1()) {
+				effectR_A_r_BTr1();
+			} else {
+				if (checkR_A_r_BTr2()) {
+					effectR_A_r_BTr2();
+				}
+			}
+		}
+	}
+
+	/* The reactions of state E. */
+	private void reactR_E() {
+	}
+
+	/* The reactions of state F. */
+	private void reactR_F() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case r_A_r_B :
+					reactR_A_r_B();
+					break;
+				case r_E :
+					reactR_E();
+					break;
+				case r_F :
+					reactR_F();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/exitstate/IExitStateStatemachine.java

@@ -1,15 +1,15 @@
-package org.yakindu.scr.exitstate;
-import org.yakindu.scr.IStatemachine;
-
-public interface IExitStateStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public void raiseF();
-		public void raiseG();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.exitstate;
+import org.yakindu.scr.IStatemachine;
+
+public interface IExitStateStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public void raiseF();
+		public void raiseG();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/featurecalls/FeatureCallsStatemachine.java

@@ -1,158 +1,167 @@
-package org.yakindu.scr.featurecalls;
-
-public class FeatureCallsStatemachine implements IFeatureCallsStatemachine {
-
-	private final class SCIMyInterfaceImpl implements SCIMyInterface {
-
-		private boolean event1;
-
-		public void raiseEvent1() {
-			event1 = true;
-		}
-
-		private int myInt;
-
-		public int getMyInt() {
-			return myInt;
-		}
-
-		public void setMyInt(int value) {
-			this.myInt = value;
-		}
-
-		public void clearEvents() {
-			event1 = false;
-		}
-
-	}
-
-	private SCIMyInterfaceImpl sCIMyInterface;
-
-	public enum State {
-		main_region_A, main_region_B, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public FeatureCallsStatemachine() {
-
-		sCIMyInterface = new SCIMyInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCIMyInterface.myInt = 0;
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCIMyInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0] == State.main_region_B;
-			default :
-				return false;
-		}
-	}
-
-	public SCIMyInterface getSCIMyInterface() {
-		return sCIMyInterface;
-	}
-
-	/* Entry action for statechart 'FeatureCalls'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'FeatureCalls'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCIMyInterface.event1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCIMyInterface.myInt = 42;
-
-			sCIMyInterface.raiseEvent1();
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_B;
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactMain_region_B() {
-		if (sCIMyInterface.event1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B :
-					reactMain_region_B();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.featurecalls;
+
+public class FeatureCallsStatemachine implements IFeatureCallsStatemachine {
+
+	private final class SCIMyInterfaceImpl implements SCIMyInterface {
+
+		private boolean event1;
+
+		public void raiseEvent1() {
+			event1 = true;
+		}
+
+		private long myInt;
+
+		public long getMyInt() {
+			return myInt;
+		}
+
+		public void setMyInt(long value) {
+			this.myInt = value;
+		}
+
+		public void clearEvents() {
+			event1 = false;
+		}
+
+	}
+
+	private SCIMyInterfaceImpl sCIMyInterface;
+
+	public enum State {
+		main_region_A, main_region_B, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public FeatureCallsStatemachine() {
+
+		sCIMyInterface = new SCIMyInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCIMyInterface.myInt = 0;
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCIMyInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0] == State.main_region_B;
+			default :
+				return false;
+		}
+	}
+
+	public SCIMyInterface getSCIMyInterface() {
+		return sCIMyInterface;
+	}
+
+	/* Entry action for statechart 'FeatureCalls'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'FeatureCalls'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCIMyInterface.event1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCIMyInterface.myInt = 42;
+
+			sCIMyInterface.raiseEvent1();
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_B;
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactMain_region_B() {
+		if (sCIMyInterface.event1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B :
+					reactMain_region_B();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/featurecalls/IFeatureCallsStatemachine.java

@@ -1,15 +1,15 @@
-package org.yakindu.scr.featurecalls;
-import org.yakindu.scr.IStatemachine;
-
-public interface IFeatureCallsStatemachine extends IStatemachine {
-
-	public interface SCIMyInterface {
-		public void raiseEvent1();
-		public int getMyInt();
-		public void setMyInt(int value);
-
-	}
-
-	public SCIMyInterface getSCIMyInterface();
-
-}
+package org.yakindu.scr.featurecalls;
+import org.yakindu.scr.IStatemachine;
+
+public interface IFeatureCallsStatemachine extends IStatemachine {
+
+	public interface SCIMyInterface {
+		public void raiseEvent1();
+		public long getMyInt();
+		public void setMyInt(long value);
+
+	}
+
+	public SCIMyInterface getSCIMyInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/guard/GuardStatemachine.java

@@ -1,198 +1,207 @@
-package org.yakindu.scr.guard;
-
-public class GuardStatemachine implements IGuardStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean event1;
-
-		public void raiseEvent1() {
-			event1 = true;
-		}
-
-		private boolean event2;
-
-		public void raiseEvent2() {
-			event2 = true;
-		}
-
-		private boolean return_ID;
-
-		public void raiseReturn() {
-			return_ID = true;
-		}
-
-		private int myVar;
-
-		public int getMyVar() {
-			return myVar;
-		}
-
-		public void setMyVar(int value) {
-			this.myVar = value;
-		}
-
-		public void clearEvents() {
-			event1 = false;
-			event2 = false;
-			return_ID = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, main_region_B, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public GuardStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.myVar = 0;
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0] == State.main_region_B;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseEvent1() {
-		sCInterface.raiseEvent1();
-	}
-	public void raiseEvent2() {
-		sCInterface.raiseEvent2();
-	}
-	public void raiseReturn() {
-		sCInterface.raiseReturn();
-	}
-
-	public int getMyVar() {
-		return sCInterface.getMyVar();
-	}
-
-	public void setMyVar(int value) {
-		sCInterface.setMyVar(value);
-	}
-
-	/* Entry action for statechart 'Guard'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'Guard'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.event1 && sCInterface.myVar == 10) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.myVar = 10;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_B;
-		} else {
-			if (sCInterface.event2) {
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				sCInterface.myVar = 10;
-
-				nextStateIndex = 0;
-				stateVector[0] = State.main_region_B;
-			}
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactMain_region_B() {
-		if (sCInterface.return_ID) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B :
-					reactMain_region_B();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.guard;
+
+public class GuardStatemachine implements IGuardStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean event1;
+
+		public void raiseEvent1() {
+			event1 = true;
+		}
+
+		private boolean event2;
+
+		public void raiseEvent2() {
+			event2 = true;
+		}
+
+		private boolean return_ID;
+
+		public void raiseReturn() {
+			return_ID = true;
+		}
+
+		private long myVar;
+
+		public long getMyVar() {
+			return myVar;
+		}
+
+		public void setMyVar(long value) {
+			this.myVar = value;
+		}
+
+		public void clearEvents() {
+			event1 = false;
+			event2 = false;
+			return_ID = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, main_region_B, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public GuardStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.myVar = 0;
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0] == State.main_region_B;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseEvent1() {
+		sCInterface.raiseEvent1();
+	}
+	public void raiseEvent2() {
+		sCInterface.raiseEvent2();
+	}
+	public void raiseReturn() {
+		sCInterface.raiseReturn();
+	}
+
+	public long getMyVar() {
+		return sCInterface.getMyVar();
+	}
+
+	public void setMyVar(long value) {
+		sCInterface.setMyVar(value);
+	}
+
+	/* Entry action for statechart 'Guard'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'Guard'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.event1 && sCInterface.myVar == 10) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.myVar = 10;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_B;
+		} else {
+			if (sCInterface.event2) {
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				sCInterface.myVar = 10;
+
+				nextStateIndex = 0;
+				stateVector[0] = State.main_region_B;
+			}
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactMain_region_B() {
+		if (sCInterface.return_ID) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B :
+					reactMain_region_B();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/guard/IGuardStatemachine.java

@@ -1,17 +1,17 @@
-package org.yakindu.scr.guard;
-import org.yakindu.scr.IStatemachine;
-
-public interface IGuardStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseEvent1();
-		public void raiseEvent2();
-		public void raiseReturn();
-		public int getMyVar();
-		public void setMyVar(int value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.guard;
+import org.yakindu.scr.IStatemachine;
+
+public interface IGuardStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseEvent1();
+		public void raiseEvent2();
+		public void raiseReturn();
+		public long getMyVar();
+		public void setMyVar(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/guardedentry/GuardedEntryStatemachine.java

@@ -1,193 +1,202 @@
-package org.yakindu.scr.guardedentry;
-
-public class GuardedEntryStatemachine implements IGuardedEntryStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private boolean guard;
-
-		public boolean getGuard() {
-			return guard;
-		}
-
-		public void setGuard(boolean value) {
-			this.guard = value;
-		}
-
-		private boolean done;
-
-		public boolean getDone() {
-			return done;
-		}
-
-		public void setDone(boolean value) {
-			this.done = value;
-		}
-
-		public void clearEvents() {
-			e = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, main_region_B, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public GuardedEntryStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.guard = false;
-
-		sCInterface.done = false;
-	}
-
-	public void enter() {
-		entryAction();
-
-		if (sCInterface.guard) {
-			sCInterface.done = true;
-		}
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0] == State.main_region_B;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-
-	public boolean getGuard() {
-		return sCInterface.getGuard();
-	}
-
-	public void setGuard(boolean value) {
-		sCInterface.setGuard(value);
-	}
-	public boolean getDone() {
-		return sCInterface.getDone();
-	}
-
-	public void setDone(boolean value) {
-		sCInterface.setDone(value);
-	}
-
-	/* Entry action for statechart 'GuardedEntry'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'GuardedEntry'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_B;
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactMain_region_B() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			if (sCInterface.guard) {
-				sCInterface.done = true;
-			}
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B :
-					reactMain_region_B();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.guardedentry;
+
+public class GuardedEntryStatemachine implements IGuardedEntryStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private boolean guard;
+
+		public boolean getGuard() {
+			return guard;
+		}
+
+		public void setGuard(boolean value) {
+			this.guard = value;
+		}
+
+		private boolean done;
+
+		public boolean getDone() {
+			return done;
+		}
+
+		public void setDone(boolean value) {
+			this.done = value;
+		}
+
+		public void clearEvents() {
+			e = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, main_region_B, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public GuardedEntryStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.guard = false;
+
+		sCInterface.done = false;
+	}
+
+	public void enter() {
+		entryAction();
+
+		if (sCInterface.guard) {
+			sCInterface.done = true;
+		}
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0] == State.main_region_B;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+
+	public boolean getGuard() {
+		return sCInterface.getGuard();
+	}
+
+	public void setGuard(boolean value) {
+		sCInterface.setGuard(value);
+	}
+	public boolean getDone() {
+		return sCInterface.getDone();
+	}
+
+	public void setDone(boolean value) {
+		sCInterface.setDone(value);
+	}
+
+	/* Entry action for statechart 'GuardedEntry'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'GuardedEntry'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.e) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_B;
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactMain_region_B() {
+		if (sCInterface.e) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			if (sCInterface.guard) {
+				sCInterface.done = true;
+			}
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B :
+					reactMain_region_B();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/guardedentry/IGuardedEntryStatemachine.java

@@ -1,17 +1,17 @@
-package org.yakindu.scr.guardedentry;
-import org.yakindu.scr.IStatemachine;
-
-public interface IGuardedEntryStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public boolean getGuard();
-		public void setGuard(boolean value);
-		public boolean getDone();
-		public void setDone(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.guardedentry;
+import org.yakindu.scr.IStatemachine;
+
+public interface IGuardedEntryStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public boolean getGuard();
+		public void setGuard(boolean value);
+		public boolean getDone();
+		public void setDone(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/guardedexit/GuardedExitStatemachine.java

@@ -1,193 +1,202 @@
-package org.yakindu.scr.guardedexit;
-
-public class GuardedExitStatemachine implements IGuardedExitStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private boolean guard;
-
-		public boolean getGuard() {
-			return guard;
-		}
-
-		public void setGuard(boolean value) {
-			this.guard = value;
-		}
-
-		private boolean done;
-
-		public boolean getDone() {
-			return done;
-		}
-
-		public void setDone(boolean value) {
-			this.done = value;
-		}
-
-		public void clearEvents() {
-			e = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, main_region_B, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public GuardedExitStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.guard = false;
-
-		sCInterface.done = false;
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				if (sCInterface.guard) {
-					sCInterface.done = true;
-				}
-				break;
-
-			case main_region_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0] == State.main_region_B;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-
-	public boolean getGuard() {
-		return sCInterface.getGuard();
-	}
-
-	public void setGuard(boolean value) {
-		sCInterface.setGuard(value);
-	}
-	public boolean getDone() {
-		return sCInterface.getDone();
-	}
-
-	public void setDone(boolean value) {
-		sCInterface.setDone(value);
-	}
-
-	/* Entry action for statechart 'GuardedExit'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'GuardedExit'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			if (sCInterface.guard) {
-				sCInterface.done = true;
-			}
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_B;
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactMain_region_B() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B :
-					reactMain_region_B();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.guardedexit;
+
+public class GuardedExitStatemachine implements IGuardedExitStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private boolean guard;
+
+		public boolean getGuard() {
+			return guard;
+		}
+
+		public void setGuard(boolean value) {
+			this.guard = value;
+		}
+
+		private boolean done;
+
+		public boolean getDone() {
+			return done;
+		}
+
+		public void setDone(boolean value) {
+			this.done = value;
+		}
+
+		public void clearEvents() {
+			e = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, main_region_B, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public GuardedExitStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.guard = false;
+
+		sCInterface.done = false;
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				if (sCInterface.guard) {
+					sCInterface.done = true;
+				}
+				break;
+
+			case main_region_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0] == State.main_region_B;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+
+	public boolean getGuard() {
+		return sCInterface.getGuard();
+	}
+
+	public void setGuard(boolean value) {
+		sCInterface.setGuard(value);
+	}
+	public boolean getDone() {
+		return sCInterface.getDone();
+	}
+
+	public void setDone(boolean value) {
+		sCInterface.setDone(value);
+	}
+
+	/* Entry action for statechart 'GuardedExit'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'GuardedExit'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.e) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			if (sCInterface.guard) {
+				sCInterface.done = true;
+			}
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_B;
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactMain_region_B() {
+		if (sCInterface.e) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B :
+					reactMain_region_B();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/guardedexit/IGuardedExitStatemachine.java

@@ -1,17 +1,17 @@
-package org.yakindu.scr.guardedexit;
-import org.yakindu.scr.IStatemachine;
-
-public interface IGuardedExitStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public boolean getGuard();
-		public void setGuard(boolean value);
-		public boolean getDone();
-		public void setDone(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.guardedexit;
+import org.yakindu.scr.IStatemachine;
+
+public interface IGuardedExitStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public boolean getGuard();
+		public void setGuard(boolean value);
+		public boolean getDone();
+		public void setDone(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/historywithoutinitialstep/HistoryWithoutInitialStepStatemachine.java

@@ -1,265 +1,274 @@
-package org.yakindu.scr.historywithoutinitialstep;
-
-public class HistoryWithoutInitialStepStatemachine
-		implements
-			IHistoryWithoutInitialStepStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e1;
-
-		public void raiseE1() {
-			e1 = true;
-		}
-
-		private boolean e2;
-
-		public void raiseE2() {
-			e2 = true;
-		}
-
-		public void clearEvents() {
-			e1 = false;
-			e2 = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, main_region_B, main_region_B_r1_C, main_region_B_r1_D, $NullState$
-	};
-
-	private State[] historyVector = new State[1];
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public HistoryWithoutInitialStepStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		for (int i = 0; i < 1; i++) {
-			historyVector[i] = State.$NullState$;
-		}
-		clearEvents();
-		clearOutEvents();
-
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B_r1_C :
-				historyVector[0] = stateVector[0];
-
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B_r1_D :
-				historyVector[0] = stateVector[0];
-
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0].ordinal() >= State.main_region_B
-						.ordinal()
-						&& stateVector[0].ordinal() <= State.main_region_B_r1_D
-								.ordinal();
-			case main_region_B_r1_C :
-				return stateVector[0] == State.main_region_B_r1_C;
-			case main_region_B_r1_D :
-				return stateVector[0] == State.main_region_B_r1_D;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE1() {
-		sCInterface.raiseE1();
-	}
-	public void raiseE2() {
-		sCInterface.raiseE2();
-	}
-
-	/* Entry action for statechart 'HistoryWithoutInitialStep'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'HistoryWithoutInitialStep'. */
-	private void exitAction() {
-	}
-
-	/* shallow enterSequence with history in child r1 */
-	private void shallowEnterSequenceMain_region_B_r1() {
-		switch (historyVector[0]) {
-			case main_region_B_r1_C :
-				nextStateIndex = 0;
-				stateVector[0] = State.main_region_B_r1_C;
-				break;
-
-			case main_region_B_r1_D :
-				nextStateIndex = 0;
-				stateVector[0] = State.main_region_B_r1_D;
-				break;
-
-			default :
-				break;
-		}
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.e1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_B_r1_C;
-		} else {
-			if (sCInterface.e2) {
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				/* Enter the region with shallow history */
-				if (historyVector[0] != State.$NullState$) {
-					shallowEnterSequenceMain_region_B_r1();
-				}
-			}
-		}
-	}
-
-	/* The reactions of state C. */
-	private void reactMain_region_B_r1_C() {
-		if (sCInterface.e1) {
-			historyVector[0] = stateVector[0];
-
-			switch (stateVector[0]) {
-				case main_region_B_r1_C :
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-					break;
-
-				case main_region_B_r1_D :
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-					break;
-
-				default :
-					break;
-			}
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		} else {
-			if (sCInterface.e2) {
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				nextStateIndex = 0;
-				stateVector[0] = State.main_region_B_r1_D;
-			}
-		}
-	}
-
-	/* The reactions of state D. */
-	private void reactMain_region_B_r1_D() {
-		if (sCInterface.e1) {
-			historyVector[0] = stateVector[0];
-
-			switch (stateVector[0]) {
-				case main_region_B_r1_C :
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-					break;
-
-				case main_region_B_r1_D :
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-					break;
-
-				default :
-					break;
-			}
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		} else {
-			if (sCInterface.e2) {
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				nextStateIndex = 0;
-				stateVector[0] = State.main_region_B_r1_C;
-			}
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B_r1_C :
-					reactMain_region_B_r1_C();
-					break;
-				case main_region_B_r1_D :
-					reactMain_region_B_r1_D();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.historywithoutinitialstep;
+
+public class HistoryWithoutInitialStepStatemachine
+		implements
+			IHistoryWithoutInitialStepStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e1;
+
+		public void raiseE1() {
+			e1 = true;
+		}
+
+		private boolean e2;
+
+		public void raiseE2() {
+			e2 = true;
+		}
+
+		public void clearEvents() {
+			e1 = false;
+			e2 = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, main_region_B, main_region_B_r1_C, main_region_B_r1_D, $NullState$
+	};
+
+	private State[] historyVector = new State[1];
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public HistoryWithoutInitialStepStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		for (int i = 0; i < 1; i++) {
+			historyVector[i] = State.$NullState$;
+		}
+		clearEvents();
+		clearOutEvents();
+
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B_r1_C :
+				historyVector[0] = stateVector[0];
+
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B_r1_D :
+				historyVector[0] = stateVector[0];
+
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0].ordinal() >= State.main_region_B
+						.ordinal()
+						&& stateVector[0].ordinal() <= State.main_region_B_r1_D
+								.ordinal();
+			case main_region_B_r1_C :
+				return stateVector[0] == State.main_region_B_r1_C;
+			case main_region_B_r1_D :
+				return stateVector[0] == State.main_region_B_r1_D;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE1() {
+		sCInterface.raiseE1();
+	}
+	public void raiseE2() {
+		sCInterface.raiseE2();
+	}
+
+	/* Entry action for statechart 'HistoryWithoutInitialStep'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'HistoryWithoutInitialStep'. */
+	private void exitAction() {
+	}
+
+	/* shallow enterSequence with history in child r1 */
+	private void shallowEnterSequenceMain_region_B_r1() {
+		switch (historyVector[0]) {
+			case main_region_B_r1_C :
+				nextStateIndex = 0;
+				stateVector[0] = State.main_region_B_r1_C;
+				break;
+
+			case main_region_B_r1_D :
+				nextStateIndex = 0;
+				stateVector[0] = State.main_region_B_r1_D;
+				break;
+
+			default :
+				break;
+		}
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.e1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_B_r1_C;
+		} else {
+			if (sCInterface.e2) {
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				/* Enter the region with shallow history */
+				if (historyVector[0] != State.$NullState$) {
+					shallowEnterSequenceMain_region_B_r1();
+				}
+			}
+		}
+	}
+
+	/* The reactions of state C. */
+	private void reactMain_region_B_r1_C() {
+		if (sCInterface.e1) {
+			historyVector[0] = stateVector[0];
+
+			switch (stateVector[0]) {
+				case main_region_B_r1_C :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				case main_region_B_r1_D :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		} else {
+			if (sCInterface.e2) {
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				nextStateIndex = 0;
+				stateVector[0] = State.main_region_B_r1_D;
+			}
+		}
+	}
+
+	/* The reactions of state D. */
+	private void reactMain_region_B_r1_D() {
+		if (sCInterface.e1) {
+			historyVector[0] = stateVector[0];
+
+			switch (stateVector[0]) {
+				case main_region_B_r1_C :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				case main_region_B_r1_D :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		} else {
+			if (sCInterface.e2) {
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				nextStateIndex = 0;
+				stateVector[0] = State.main_region_B_r1_C;
+			}
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B_r1_C :
+					reactMain_region_B_r1_C();
+					break;
+				case main_region_B_r1_D :
+					reactMain_region_B_r1_D();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/historywithoutinitialstep/IHistoryWithoutInitialStepStatemachine.java

@@ -1,14 +1,14 @@
-package org.yakindu.scr.historywithoutinitialstep;
-import org.yakindu.scr.IStatemachine;
-
-public interface IHistoryWithoutInitialStepStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE1();
-		public void raiseE2();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.historywithoutinitialstep;
+import org.yakindu.scr.IStatemachine;
+
+public interface IHistoryWithoutInitialStepStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE1();
+		public void raiseE2();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/ineventlifecycle/IInEventLifeCycleStatemachine.java

@@ -1,15 +1,15 @@
-package org.yakindu.scr.ineventlifecycle;
-import org.yakindu.scr.IStatemachine;
-
-public interface IInEventLifeCycleStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public int getI();
-		public void setI(int value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.ineventlifecycle;
+import org.yakindu.scr.IStatemachine;
+
+public interface IInEventLifeCycleStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public long getI();
+		public void setI(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/ineventlifecycle/InEventLifeCycleStatemachine.java

@@ -1,143 +1,152 @@
-package org.yakindu.scr.ineventlifecycle;
-
-public class InEventLifeCycleStatemachine
-		implements
-			IInEventLifeCycleStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private int i;
-
-		public int getI() {
-			return i;
-		}
-
-		public void setI(int value) {
-			this.i = value;
-		}
-
-		public void clearEvents() {
-			e = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public InEventLifeCycleStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.i = 0;
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-
-	public int getI() {
-		return sCInterface.getI();
-	}
-
-	public void setI(int value) {
-		sCInterface.setI(value);
-	}
-
-	/* Entry action for statechart 'InEventLifeCycle'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'InEventLifeCycle'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.e) {
-			sCInterface.i += 1;
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.ineventlifecycle;
+
+public class InEventLifeCycleStatemachine
+		implements
+			IInEventLifeCycleStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private long i;
+
+		public long getI() {
+			return i;
+		}
+
+		public void setI(long value) {
+			this.i = value;
+		}
+
+		public void clearEvents() {
+			e = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public InEventLifeCycleStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.i = 0;
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+
+	public long getI() {
+		return sCInterface.getI();
+	}
+
+	public void setI(long value) {
+		sCInterface.setI(value);
+	}
+
+	/* Entry action for statechart 'InEventLifeCycle'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'InEventLifeCycle'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.e) {
+			sCInterface.i += 1;
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/integerexpressions/IIntegerExpressionsStatemachine.java

@@ -1,53 +1,53 @@
-package org.yakindu.scr.integerexpressions;
-import org.yakindu.scr.IStatemachine;
-
-public interface IIntegerExpressionsStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE1();
-		public int getMyInt1();
-		public void setMyInt1(int value);
-		public int getMyInt2();
-		public void setMyInt2(int value);
-		public boolean getLess();
-		public void setLess(boolean value);
-		public boolean getGreater();
-		public void setGreater(boolean value);
-		public boolean getEqualOrLess();
-		public void setEqualOrLess(boolean value);
-		public boolean getEqualOrGreater();
-		public void setEqualOrGreater(boolean value);
-		public boolean getEqual();
-		public void setEqual(boolean value);
-		public boolean getNotEqual();
-		public void setNotEqual(boolean value);
-		public int getPlus();
-		public void setPlus(int value);
-		public int getMinus();
-		public void setMinus(int value);
-		public int getMultiply();
-		public void setMultiply(int value);
-		public int getDivision();
-		public void setDivision(int value);
-		public int getModulo();
-		public void setModulo(int value);
-		public int getNegat();
-		public void setNegat(int value);
-		public boolean getComplement();
-		public void setComplement(boolean value);
-		public int getMultiAssign();
-		public void setMultiAssign(int value);
-		public int getDivAssign();
-		public void setDivAssign(int value);
-		public int getPlusAssign();
-		public void setPlusAssign(int value);
-		public int getMinusAssign();
-		public void setMinusAssign(int value);
-		public int getModuloAssign();
-		public void setModuloAssign(int value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.integerexpressions;
+import org.yakindu.scr.IStatemachine;
+
+public interface IIntegerExpressionsStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE1();
+		public long getMyInt1();
+		public void setMyInt1(long value);
+		public long getMyInt2();
+		public void setMyInt2(long value);
+		public boolean getLess();
+		public void setLess(boolean value);
+		public boolean getGreater();
+		public void setGreater(boolean value);
+		public boolean getEqualOrLess();
+		public void setEqualOrLess(boolean value);
+		public boolean getEqualOrGreater();
+		public void setEqualOrGreater(boolean value);
+		public boolean getEqual();
+		public void setEqual(boolean value);
+		public boolean getNotEqual();
+		public void setNotEqual(boolean value);
+		public long getPlus();
+		public void setPlus(long value);
+		public long getMinus();
+		public void setMinus(long value);
+		public long getMultiply();
+		public void setMultiply(long value);
+		public long getDivision();
+		public void setDivision(long value);
+		public long getModulo();
+		public void setModulo(long value);
+		public long getNegat();
+		public void setNegat(long value);
+		public boolean getComplement();
+		public void setComplement(boolean value);
+		public long getMultiAssign();
+		public void setMultiAssign(long value);
+		public long getDivAssign();
+		public void setDivAssign(long value);
+		public long getPlusAssign();
+		public void setPlusAssign(long value);
+		public long getMinusAssign();
+		public void setMinusAssign(long value);
+		public long getModuloAssign();
+		public void setModuloAssign(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/internaleventlifecycle/IInternalEventLifeCycleStatemachine.java

@@ -1,14 +1,14 @@
-package org.yakindu.scr.internaleventlifecycle;
-import org.yakindu.scr.IStatemachine;
-
-public interface IInternalEventLifeCycleStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public void raiseF();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.internaleventlifecycle;
+import org.yakindu.scr.IStatemachine;
+
+public interface IInternalEventLifeCycleStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public void raiseF();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/internaleventlifecycle/InternalEventLifeCycleStatemachine.java

@@ -1,229 +1,238 @@
-package org.yakindu.scr.internaleventlifecycle;
-
-public class InternalEventLifeCycleStatemachine
-		implements
-			IInternalEventLifeCycleStatemachine {
-
-	private boolean i1;
-
-	private boolean i2;
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private boolean f;
-
-		public void raiseF() {
-			f = true;
-		}
-
-		public void clearEvents() {
-			e = false;
-			f = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		r1_A, r1_B, r2_C, r2_D, $NullState$
-	};
-
-	private final State[] stateVector = new State[2];
-
-	private int nextStateIndex;
-
-	public InternalEventLifeCycleStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 2; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.r1_A;
-
-		nextStateIndex = 1;
-		stateVector[1] = State.r2_C;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case r1_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case r1_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		switch (stateVector[1]) {
-			case r2_C :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case r2_D :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-		i1 = false;
-		i2 = false;
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case r1_A :
-				return stateVector[0] == State.r1_A;
-			case r1_B :
-				return stateVector[0] == State.r1_B;
-			case r2_C :
-				return stateVector[1] == State.r2_C;
-			case r2_D :
-				return stateVector[1] == State.r2_D;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	private void raiseI1() {
-		i1 = true;
-	}
-
-	private void raiseI2() {
-		i2 = true;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-	public void raiseF() {
-		sCInterface.raiseF();
-	}
-
-	/* Entry action for statechart 'InternalEventLifeCycle'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'InternalEventLifeCycle'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactR1_A() {
-		if (i2) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.r1_B;
-		} else {
-			if (sCInterface.e) {
-				raiseI1();
-			}
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactR1_B() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.r1_A;
-		}
-	}
-
-	/* The reactions of state C. */
-	private void reactR2_C() {
-		if (i1) {
-			nextStateIndex = 1;
-			stateVector[1] = State.$NullState$;
-
-			nextStateIndex = 1;
-			stateVector[1] = State.r2_D;
-		}
-	}
-
-	/* The reactions of state D. */
-	private void reactR2_D() {
-		if (sCInterface.f) {
-			nextStateIndex = 1;
-			stateVector[1] = State.$NullState$;
-
-			raiseI2();
-
-			nextStateIndex = 1;
-			stateVector[1] = State.r2_C;
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case r1_A :
-					reactR1_A();
-					break;
-				case r1_B :
-					reactR1_B();
-					break;
-				case r2_C :
-					reactR2_C();
-					break;
-				case r2_D :
-					reactR2_D();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.internaleventlifecycle;
+
+public class InternalEventLifeCycleStatemachine
+		implements
+			IInternalEventLifeCycleStatemachine {
+
+	private boolean i1;
+
+	private boolean i2;
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private boolean f;
+
+		public void raiseF() {
+			f = true;
+		}
+
+		public void clearEvents() {
+			e = false;
+			f = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		r1_A, r1_B, r2_C, r2_D, $NullState$
+	};
+
+	private final State[] stateVector = new State[2];
+
+	private int nextStateIndex;
+
+	public InternalEventLifeCycleStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 2; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.r1_A;
+
+		nextStateIndex = 1;
+		stateVector[1] = State.r2_C;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case r1_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case r1_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		switch (stateVector[1]) {
+			case r2_C :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case r2_D :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+		i1 = false;
+		i2 = false;
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case r1_A :
+				return stateVector[0] == State.r1_A;
+			case r1_B :
+				return stateVector[0] == State.r1_B;
+			case r2_C :
+				return stateVector[1] == State.r2_C;
+			case r2_D :
+				return stateVector[1] == State.r2_D;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	private void raiseI1() {
+		i1 = true;
+	}
+
+	private void raiseI2() {
+		i2 = true;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+	public void raiseF() {
+		sCInterface.raiseF();
+	}
+
+	/* Entry action for statechart 'InternalEventLifeCycle'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'InternalEventLifeCycle'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactR1_A() {
+		if (i2) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.r1_B;
+		} else {
+			if (sCInterface.e) {
+				raiseI1();
+			}
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactR1_B() {
+		if (sCInterface.e) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.r1_A;
+		}
+	}
+
+	/* The reactions of state C. */
+	private void reactR2_C() {
+		if (i1) {
+			nextStateIndex = 1;
+			stateVector[1] = State.$NullState$;
+
+			nextStateIndex = 1;
+			stateVector[1] = State.r2_D;
+		}
+	}
+
+	/* The reactions of state D. */
+	private void reactR2_D() {
+		if (sCInterface.f) {
+			nextStateIndex = 1;
+			stateVector[1] = State.$NullState$;
+
+			raiseI2();
+
+			nextStateIndex = 1;
+			stateVector[1] = State.r2_C;
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case r1_A :
+					reactR1_A();
+					break;
+				case r1_B :
+					reactR1_B();
+					break;
+				case r2_C :
+					reactR2_C();
+					break;
+				case r2_D :
+					reactR2_D();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/javakeywords/IJavaKeywordsStatemachine.java

@@ -1,108 +1,108 @@
-package org.yakindu.scr.javakeywords;
-import org.yakindu.scr.IStatemachine;
-
-public interface IJavaKeywordsStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseWhile();
-		public void raiseEv();
-		public boolean getAbstract();
-		public void setAbstract(boolean value);
-		public boolean getAssert();
-		public void setAssert(boolean value);
-		public boolean getBoolean();
-		public void setBoolean(boolean value);
-		public boolean getBreak();
-		public void setBreak(boolean value);
-		public boolean getByte();
-		public void setByte(boolean value);
-		public boolean getCase();
-		public void setCase(boolean value);
-		public boolean getCatch();
-		public void setCatch(boolean value);
-		public boolean getChar();
-		public void setChar(boolean value);
-		public boolean getClass_ID();
-		public void setClass_ID(boolean value);
-		public boolean getConst();
-		public void setConst(boolean value);
-		public boolean getContinue();
-		public void setContinue(boolean value);
-		public boolean getDo();
-		public void setDo(boolean value);
-		public boolean getDouble();
-		public void setDouble(boolean value);
-		public boolean getEnum();
-		public void setEnum(boolean value);
-		public boolean getExtends();
-		public void setExtends(boolean value);
-		public boolean getFinal();
-		public void setFinal(boolean value);
-		public boolean getFinally();
-		public void setFinally(boolean value);
-		public boolean getFloat();
-		public void setFloat(boolean value);
-		public boolean getFor();
-		public void setFor(boolean value);
-		public boolean getGoto();
-		public void setGoto(boolean value);
-		public boolean getIf();
-		public void setIf(boolean value);
-		public boolean getImplements();
-		public void setImplements(boolean value);
-		public boolean getImport();
-		public void setImport(boolean value);
-		public boolean getInstanceof();
-		public void setInstanceof(boolean value);
-		public boolean getInt();
-		public void setInt(boolean value);
-		public boolean getLong();
-		public void setLong(boolean value);
-		public boolean getNative();
-		public void setNative(boolean value);
-		public boolean getNew();
-		public void setNew(boolean value);
-		public boolean getNull();
-		public void setNull(boolean value);
-		public boolean getPackage();
-		public void setPackage(boolean value);
-		public boolean getPrivate();
-		public void setPrivate(boolean value);
-		public boolean getProtected();
-		public void setProtected(boolean value);
-		public boolean getPublic();
-		public void setPublic(boolean value);
-		public boolean getReturn();
-		public void setReturn(boolean value);
-		public boolean getShort();
-		public void setShort(boolean value);
-		public boolean getStatic();
-		public void setStatic(boolean value);
-		public boolean getStrictfp();
-		public void setStrictfp(boolean value);
-		public boolean getSuper();
-		public void setSuper(boolean value);
-		public boolean getSwitch();
-		public void setSwitch(boolean value);
-		public boolean getSynchronized();
-		public void setSynchronized(boolean value);
-		public boolean getThis();
-		public void setThis(boolean value);
-		public boolean getThrow();
-		public void setThrow(boolean value);
-		public boolean getThrows();
-		public void setThrows(boolean value);
-		public boolean getTransient();
-		public void setTransient(boolean value);
-		public boolean getTry();
-		public void setTry(boolean value);
-		public boolean getVoid();
-		public void setVoid(boolean value);
-		public boolean getVolatile();
-		public void setVolatile(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.javakeywords;
+import org.yakindu.scr.IStatemachine;
+
+public interface IJavaKeywordsStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseWhile();
+		public void raiseEv();
+		public boolean getAbstract();
+		public void setAbstract(boolean value);
+		public boolean getAssert();
+		public void setAssert(boolean value);
+		public boolean getBoolean();
+		public void setBoolean(boolean value);
+		public boolean getBreak();
+		public void setBreak(boolean value);
+		public boolean getByte();
+		public void setByte(boolean value);
+		public boolean getCase();
+		public void setCase(boolean value);
+		public boolean getCatch();
+		public void setCatch(boolean value);
+		public boolean getChar();
+		public void setChar(boolean value);
+		public boolean getClass_ID();
+		public void setClass_ID(boolean value);
+		public boolean getConst();
+		public void setConst(boolean value);
+		public boolean getContinue();
+		public void setContinue(boolean value);
+		public boolean getDo();
+		public void setDo(boolean value);
+		public boolean getDouble();
+		public void setDouble(boolean value);
+		public boolean getEnum();
+		public void setEnum(boolean value);
+		public boolean getExtends();
+		public void setExtends(boolean value);
+		public boolean getFinal();
+		public void setFinal(boolean value);
+		public boolean getFinally();
+		public void setFinally(boolean value);
+		public boolean getFloat();
+		public void setFloat(boolean value);
+		public boolean getFor();
+		public void setFor(boolean value);
+		public boolean getGoto();
+		public void setGoto(boolean value);
+		public boolean getIf();
+		public void setIf(boolean value);
+		public boolean getImplements();
+		public void setImplements(boolean value);
+		public boolean getImport();
+		public void setImport(boolean value);
+		public boolean getInstanceof();
+		public void setInstanceof(boolean value);
+		public boolean getInt();
+		public void setInt(boolean value);
+		public boolean getLong();
+		public void setLong(boolean value);
+		public boolean getNative();
+		public void setNative(boolean value);
+		public boolean getNew();
+		public void setNew(boolean value);
+		public boolean getNull();
+		public void setNull(boolean value);
+		public boolean getPackage();
+		public void setPackage(boolean value);
+		public boolean getPrivate();
+		public void setPrivate(boolean value);
+		public boolean getProtected();
+		public void setProtected(boolean value);
+		public boolean getPublic();
+		public void setPublic(boolean value);
+		public boolean getReturn();
+		public void setReturn(boolean value);
+		public boolean getShort();
+		public void setShort(boolean value);
+		public boolean getStatic();
+		public void setStatic(boolean value);
+		public boolean getStrictfp();
+		public void setStrictfp(boolean value);
+		public boolean getSuper();
+		public void setSuper(boolean value);
+		public boolean getSwitch();
+		public void setSwitch(boolean value);
+		public boolean getSynchronized();
+		public void setSynchronized(boolean value);
+		public boolean getThis();
+		public void setThis(boolean value);
+		public boolean getThrow();
+		public void setThrow(boolean value);
+		public boolean getThrows();
+		public void setThrows(boolean value);
+		public boolean getTransient();
+		public void setTransient(boolean value);
+		public boolean getTry();
+		public void setTry(boolean value);
+		public boolean getVoid();
+		public void setVoid(boolean value);
+		public boolean getVolatile();
+		public void setVolatile(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/logicaland/ILogicalAndStatemachine.java

@@ -1,16 +1,16 @@
-package org.yakindu.scr.logicaland;
-import org.yakindu.scr.IStatemachine;
-
-public interface ILogicalAndStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public int getX();
-		public void setX(int value);
-		public boolean getB();
-		public void setB(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.logicaland;
+import org.yakindu.scr.IStatemachine;
+
+public interface ILogicalAndStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public long getX();
+		public void setX(long value);
+		public boolean getB();
+		public void setB(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/logicaland/LogicalAndStatemachine.java

@@ -1,151 +1,160 @@
-package org.yakindu.scr.logicaland;
-
-public class LogicalAndStatemachine implements ILogicalAndStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private int x;
-
-		public int getX() {
-			return x;
-		}
-
-		public void setX(int value) {
-			this.x = value;
-		}
-
-		private boolean b;
-
-		public boolean getB() {
-			return b;
-		}
-
-		public void setB(boolean value) {
-			this.b = value;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public LogicalAndStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.x = 1;
-
-		sCInterface.b = false;
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public int getX() {
-		return sCInterface.getX();
-	}
-
-	public void setX(int value) {
-		sCInterface.setX(value);
-	}
-	public boolean getB() {
-		return sCInterface.getB();
-	}
-
-	public void setB(boolean value) {
-		sCInterface.setB(value);
-	}
-
-	/* Entry action for statechart 'LogicalAnd'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'LogicalAnd'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.x == 1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.b = ((sCInterface.x += 1) == 2 && (sCInterface.x *= 2) == 4);
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.logicaland;
+
+public class LogicalAndStatemachine implements ILogicalAndStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private long x;
+
+		public long getX() {
+			return x;
+		}
+
+		public void setX(long value) {
+			this.x = value;
+		}
+
+		private boolean b;
+
+		public boolean getB() {
+			return b;
+		}
+
+		public void setB(boolean value) {
+			this.b = value;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public LogicalAndStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.x = 1;
+
+		sCInterface.b = false;
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public long getX() {
+		return sCInterface.getX();
+	}
+
+	public void setX(long value) {
+		sCInterface.setX(value);
+	}
+	public boolean getB() {
+		return sCInterface.getB();
+	}
+
+	public void setB(boolean value) {
+		sCInterface.setB(value);
+	}
+
+	/* Entry action for statechart 'LogicalAnd'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'LogicalAnd'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.x == 1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.b = ((sCInterface.x += 1) == 2 && (sCInterface.x *= 2) == 4);
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/logicalor/ILogicalOrStatemachine.java

@@ -1,16 +1,16 @@
-package org.yakindu.scr.logicalor;
-import org.yakindu.scr.IStatemachine;
-
-public interface ILogicalOrStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public int getX();
-		public void setX(int value);
-		public boolean getB();
-		public void setB(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.logicalor;
+import org.yakindu.scr.IStatemachine;
+
+public interface ILogicalOrStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public long getX();
+		public void setX(long value);
+		public boolean getB();
+		public void setB(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/logicalor/LogicalOrStatemachine.java

@@ -1,151 +1,160 @@
-package org.yakindu.scr.logicalor;
-
-public class LogicalOrStatemachine implements ILogicalOrStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private int x;
-
-		public int getX() {
-			return x;
-		}
-
-		public void setX(int value) {
-			this.x = value;
-		}
-
-		private boolean b;
-
-		public boolean getB() {
-			return b;
-		}
-
-		public void setB(boolean value) {
-			this.b = value;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public LogicalOrStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.x = 1;
-
-		sCInterface.b = false;
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public int getX() {
-		return sCInterface.getX();
-	}
-
-	public void setX(int value) {
-		sCInterface.setX(value);
-	}
-	public boolean getB() {
-		return sCInterface.getB();
-	}
-
-	public void setB(boolean value) {
-		sCInterface.setB(value);
-	}
-
-	/* Entry action for statechart 'LogicalOr'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'LogicalOr'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.x == 1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.b = ((sCInterface.x += 1) != 2 || (sCInterface.x *= 2) == 4);
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.logicalor;
+
+public class LogicalOrStatemachine implements ILogicalOrStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private long x;
+
+		public long getX() {
+			return x;
+		}
+
+		public void setX(long value) {
+			this.x = value;
+		}
+
+		private boolean b;
+
+		public boolean getB() {
+			return b;
+		}
+
+		public void setB(boolean value) {
+			this.b = value;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public LogicalOrStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.x = 1;
+
+		sCInterface.b = false;
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public long getX() {
+		return sCInterface.getX();
+	}
+
+	public void setX(long value) {
+		sCInterface.setX(value);
+	}
+	public boolean getB() {
+		return sCInterface.getB();
+	}
+
+	public void setB(boolean value) {
+		sCInterface.setB(value);
+	}
+
+	/* Entry action for statechart 'LogicalOr'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'LogicalOr'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.x == 1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.b = ((sCInterface.x += 1) != 2 || (sCInterface.x *= 2) == 4);
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/namedinterfaceaccess/INamedInterfaceAccessStatemachine.java

@@ -1,22 +1,22 @@
-package org.yakindu.scr.namedinterfaceaccess;
-import org.yakindu.scr.IStatemachine;
-
-public interface INamedInterfaceAccessStatemachine extends IStatemachine {
-
-	public interface SCISafe {
-		public boolean isRaisedOpen();
-		public boolean isRaisedClose();
-
-	}
-
-	public SCISafe getSCISafe();
-
-	public interface SCIUser {
-		public void raiseNumberPressed(int value);
-		public void raiseReset();
-
-	}
-
-	public SCIUser getSCIUser();
-
-}
+package org.yakindu.scr.namedinterfaceaccess;
+import org.yakindu.scr.IStatemachine;
+
+public interface INamedInterfaceAccessStatemachine extends IStatemachine {
+
+	public interface SCISafe {
+		public boolean isRaisedOpen();
+		public boolean isRaisedClose();
+
+	}
+
+	public SCISafe getSCISafe();
+
+	public interface SCIUser {
+		public void raiseNumberPressed(long value);
+		public void raiseReset();
+
+	}
+
+	public SCIUser getSCIUser();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/namedinterfaceaccess/NamedInterfaceAccessStatemachine.java

@@ -1,327 +1,336 @@
-package org.yakindu.scr.namedinterfaceaccess;
-
-public class NamedInterfaceAccessStatemachine
-		implements
-			INamedInterfaceAccessStatemachine {
-
-	private final class SCISafeImpl implements SCISafe {
-
-		private boolean open;
-
-		public boolean isRaisedOpen() {
-			return open;
-		}
-
-		private void raiseOpen() {
-			open = true;
-		}
-
-		private boolean close;
-
-		public boolean isRaisedClose() {
-			return close;
-		}
-
-		private void raiseClose() {
-			close = true;
-		}
-
-		public void clearEvents() {
-		}
-
-		public void clearOutEvents() {
-			open = false;
-			close = false;
-		}
-	}
-
-	private SCISafeImpl sCISafe;
-	private final class SCIUserImpl implements SCIUser {
-
-		private boolean numberPressed;
-
-		private int numberPressedValue;
-
-		public void raiseNumberPressed(int value) {
-			numberPressed = true;
-			numberPressedValue = value;
-		}
-
-		private int getNumberPressedValue() {
-			if (!numberPressed)
-				throw new IllegalStateException(
-						"Illegal event value acces. Event NumberPressed is not raised!");
-			return numberPressedValue;
-		}
-
-		private boolean reset;
-
-		public void raiseReset() {
-			reset = true;
-		}
-
-		public void clearEvents() {
-			numberPressed = false;
-			reset = false;
-		}
-
-	}
-
-	private SCIUserImpl sCIUser;
-
-	public enum State {
-		region_1_Idle, region_1_Number1Pressed, region_1_Number2Pressed, region_1_Number3Pressed, _region1_Closed, _region1_Open, $NullState$
-	};
-
-	private int number1;
-	private int number2;
-	private int number3;
-
-	private final State[] stateVector = new State[2];
-
-	private int nextStateIndex;
-
-	public NamedInterfaceAccessStatemachine() {
-
-		sCISafe = new SCISafeImpl();
-		sCIUser = new SCIUserImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 2; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		number1 = 3;
-
-		number2 = 7;
-
-		number3 = 5;
-	}
-
-	public void enter() {
-		entryAction();
-
-		sCISafe.raiseClose();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.region_1_Idle;
-
-		nextStateIndex = 1;
-		stateVector[1] = State._region1_Closed;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case region_1_Idle :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case region_1_Number1Pressed :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case region_1_Number2Pressed :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case region_1_Number3Pressed :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		switch (stateVector[1]) {
-			case _region1_Closed :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case _region1_Open :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCISafe.clearEvents();
-		sCIUser.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-		sCISafe.clearOutEvents();
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case region_1_Idle :
-				return stateVector[0] == State.region_1_Idle;
-			case region_1_Number1Pressed :
-				return stateVector[0] == State.region_1_Number1Pressed;
-			case region_1_Number2Pressed :
-				return stateVector[0] == State.region_1_Number2Pressed;
-			case region_1_Number3Pressed :
-				return stateVector[0] == State.region_1_Number3Pressed;
-			case _region1_Closed :
-				return stateVector[1] == State._region1_Closed;
-			case _region1_Open :
-				return stateVector[1] == State._region1_Open;
-			default :
-				return false;
-		}
-	}
-
-	public SCISafe getSCISafe() {
-		return sCISafe;
-	}
-	public SCIUser getSCIUser() {
-		return sCIUser;
-	}
-
-	/* Entry action for statechart 'NamedInterfaceAccess'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'NamedInterfaceAccess'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state Idle. */
-	private void reactRegion_1_Idle() {
-		if (sCIUser.numberPressed && sCIUser.numberPressedValue == number1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.region_1_Number1Pressed;
-		}
-	}
-
-	/* The reactions of state Number1Pressed. */
-	private void reactRegion_1_Number1Pressed() {
-		if (sCIUser.numberPressed && sCIUser.numberPressedValue == number2) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.region_1_Number2Pressed;
-		} else {
-			if (sCIUser.numberPressed) {
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				sCISafe.raiseClose();
-
-				nextStateIndex = 0;
-				stateVector[0] = State.region_1_Idle;
-			}
-		}
-	}
-
-	/* The reactions of state Number2Pressed. */
-	private void reactRegion_1_Number2Pressed() {
-		if (sCIUser.numberPressed && sCIUser.numberPressedValue == number3) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCISafe.raiseOpen();
-
-			nextStateIndex = 0;
-			stateVector[0] = State.region_1_Number3Pressed;
-		} else {
-			if (sCIUser.numberPressed) {
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				sCISafe.raiseClose();
-
-				nextStateIndex = 0;
-				stateVector[0] = State.region_1_Idle;
-			}
-		}
-	}
-
-	/* The reactions of state Number3Pressed. */
-	private void reactRegion_1_Number3Pressed() {
-		if (sCIUser.numberPressed) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCISafe.raiseClose();
-
-			nextStateIndex = 0;
-			stateVector[0] = State.region_1_Idle;
-		}
-	}
-
-	/* The reactions of state Closed. */
-	private void reactRegion1_Closed() {
-		if (sCISafe.open) {
-			nextStateIndex = 1;
-			stateVector[1] = State.$NullState$;
-
-			nextStateIndex = 1;
-			stateVector[1] = State._region1_Open;
-		}
-	}
-
-	/* The reactions of state Open. */
-	private void reactRegion1_Open() {
-		if (sCISafe.close) {
-			nextStateIndex = 1;
-			stateVector[1] = State.$NullState$;
-
-			nextStateIndex = 1;
-			stateVector[1] = State._region1_Closed;
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case region_1_Idle :
-					reactRegion_1_Idle();
-					break;
-				case region_1_Number1Pressed :
-					reactRegion_1_Number1Pressed();
-					break;
-				case region_1_Number2Pressed :
-					reactRegion_1_Number2Pressed();
-					break;
-				case region_1_Number3Pressed :
-					reactRegion_1_Number3Pressed();
-					break;
-				case _region1_Closed :
-					reactRegion1_Closed();
-					break;
-				case _region1_Open :
-					reactRegion1_Open();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.namedinterfaceaccess;
+
+public class NamedInterfaceAccessStatemachine
+		implements
+			INamedInterfaceAccessStatemachine {
+
+	private final class SCISafeImpl implements SCISafe {
+
+		private boolean open;
+
+		public boolean isRaisedOpen() {
+			return open;
+		}
+
+		private void raiseOpen() {
+			open = true;
+		}
+
+		private boolean close;
+
+		public boolean isRaisedClose() {
+			return close;
+		}
+
+		private void raiseClose() {
+			close = true;
+		}
+
+		public void clearEvents() {
+		}
+
+		public void clearOutEvents() {
+			open = false;
+			close = false;
+		}
+	}
+
+	private SCISafeImpl sCISafe;
+	private final class SCIUserImpl implements SCIUser {
+
+		private boolean numberPressed;
+
+		private long numberPressedValue;
+
+		public void raiseNumberPressed(long value) {
+			numberPressed = true;
+			numberPressedValue = value;
+		}
+
+		private long getNumberPressedValue() {
+			if (!numberPressed)
+				throw new IllegalStateException(
+						"Illegal event value acces. Event NumberPressed is not raised!");
+			return numberPressedValue;
+		}
+
+		private boolean reset;
+
+		public void raiseReset() {
+			reset = true;
+		}
+
+		public void clearEvents() {
+			numberPressed = false;
+			reset = false;
+		}
+
+	}
+
+	private SCIUserImpl sCIUser;
+
+	public enum State {
+		region_1_Idle, region_1_Number1Pressed, region_1_Number2Pressed, region_1_Number3Pressed, _region1_Closed, _region1_Open, $NullState$
+	};
+
+	private long number1;
+	private long number2;
+	private long number3;
+
+	private final State[] stateVector = new State[2];
+
+	private int nextStateIndex;
+
+	public NamedInterfaceAccessStatemachine() {
+
+		sCISafe = new SCISafeImpl();
+		sCIUser = new SCIUserImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 2; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		number1 = 3;
+
+		number2 = 7;
+
+		number3 = 5;
+	}
+
+	public void enter() {
+		entryAction();
+
+		sCISafe.raiseClose();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.region_1_Idle;
+
+		nextStateIndex = 1;
+		stateVector[1] = State._region1_Closed;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case region_1_Idle :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case region_1_Number1Pressed :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case region_1_Number2Pressed :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case region_1_Number3Pressed :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		switch (stateVector[1]) {
+			case _region1_Closed :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case _region1_Open :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCISafe.clearEvents();
+		sCIUser.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+		sCISafe.clearOutEvents();
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case region_1_Idle :
+				return stateVector[0] == State.region_1_Idle;
+			case region_1_Number1Pressed :
+				return stateVector[0] == State.region_1_Number1Pressed;
+			case region_1_Number2Pressed :
+				return stateVector[0] == State.region_1_Number2Pressed;
+			case region_1_Number3Pressed :
+				return stateVector[0] == State.region_1_Number3Pressed;
+			case _region1_Closed :
+				return stateVector[1] == State._region1_Closed;
+			case _region1_Open :
+				return stateVector[1] == State._region1_Open;
+			default :
+				return false;
+		}
+	}
+
+	public SCISafe getSCISafe() {
+		return sCISafe;
+	}
+	public SCIUser getSCIUser() {
+		return sCIUser;
+	}
+
+	/* Entry action for statechart 'NamedInterfaceAccess'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'NamedInterfaceAccess'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state Idle. */
+	private void reactRegion_1_Idle() {
+		if (sCIUser.numberPressed && sCIUser.numberPressedValue == number1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.region_1_Number1Pressed;
+		}
+	}
+
+	/* The reactions of state Number1Pressed. */
+	private void reactRegion_1_Number1Pressed() {
+		if (sCIUser.numberPressed && sCIUser.numberPressedValue == number2) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.region_1_Number2Pressed;
+		} else {
+			if (sCIUser.numberPressed) {
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				sCISafe.raiseClose();
+
+				nextStateIndex = 0;
+				stateVector[0] = State.region_1_Idle;
+			}
+		}
+	}
+
+	/* The reactions of state Number2Pressed. */
+	private void reactRegion_1_Number2Pressed() {
+		if (sCIUser.numberPressed && sCIUser.numberPressedValue == number3) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCISafe.raiseOpen();
+
+			nextStateIndex = 0;
+			stateVector[0] = State.region_1_Number3Pressed;
+		} else {
+			if (sCIUser.numberPressed) {
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				sCISafe.raiseClose();
+
+				nextStateIndex = 0;
+				stateVector[0] = State.region_1_Idle;
+			}
+		}
+	}
+
+	/* The reactions of state Number3Pressed. */
+	private void reactRegion_1_Number3Pressed() {
+		if (sCIUser.numberPressed) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCISafe.raiseClose();
+
+			nextStateIndex = 0;
+			stateVector[0] = State.region_1_Idle;
+		}
+	}
+
+	/* The reactions of state Closed. */
+	private void reactRegion1_Closed() {
+		if (sCISafe.open) {
+			nextStateIndex = 1;
+			stateVector[1] = State.$NullState$;
+
+			nextStateIndex = 1;
+			stateVector[1] = State._region1_Open;
+		}
+	}
+
+	/* The reactions of state Open. */
+	private void reactRegion1_Open() {
+		if (sCISafe.close) {
+			nextStateIndex = 1;
+			stateVector[1] = State.$NullState$;
+
+			nextStateIndex = 1;
+			stateVector[1] = State._region1_Closed;
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case region_1_Idle :
+					reactRegion_1_Idle();
+					break;
+				case region_1_Number1Pressed :
+					reactRegion_1_Number1Pressed();
+					break;
+				case region_1_Number2Pressed :
+					reactRegion_1_Number2Pressed();
+					break;
+				case region_1_Number3Pressed :
+					reactRegion_1_Number3Pressed();
+					break;
+				case _region1_Closed :
+					reactRegion1_Closed();
+					break;
+				case _region1_Open :
+					reactRegion1_Open();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/operations/IOperationsStatemachine.java

@@ -1,40 +1,40 @@
-package org.yakindu.scr.operations;
-import org.yakindu.scr.IStatemachine;
-
-public interface IOperationsStatemachine extends IStatemachine {
-
-	public interface InternalOperationCallback {
-		public void internalOperation1();
-		public boolean internalOperation2(int param1);
-	}
-
-	public void setInternalOperationCallback(
-			InternalOperationCallback operationCallback);
-	public interface SCIInterface1 {
-
-		public void setSCIInterface1OperationCallback(
-				SCIInterface1OperationCallback operationCallback);
-	}
-
-	public interface SCIInterface1OperationCallback {
-		public void interfaceOperation1();
-		public boolean interfaceOperation2(int param1);
-	}
-
-	public SCIInterface1 getSCIInterface1();
-
-	public interface SCInterface {
-		public void raiseEv();
-
-		public void setSCInterfaceOperationCallback(
-				SCInterfaceOperationCallback operationCallback);
-	}
-
-	public interface SCInterfaceOperationCallback {
-		public void unnamedInterfaceOperation1();
-		public boolean unnamedInterfaceOperation2(int param1);
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.operations;
+import org.yakindu.scr.IStatemachine;
+
+public interface IOperationsStatemachine extends IStatemachine {
+
+	public interface InternalOperationCallback {
+		public void internalOperation1();
+		public boolean internalOperation2(long param1);
+	}
+
+	public void setInternalOperationCallback(
+			InternalOperationCallback operationCallback);
+	public interface SCIInterface1 {
+
+		public void setSCIInterface1OperationCallback(
+				SCIInterface1OperationCallback operationCallback);
+	}
+
+	public interface SCIInterface1OperationCallback {
+		public void interfaceOperation1();
+		public boolean interfaceOperation2(long param1);
+	}
+
+	public SCIInterface1 getSCIInterface1();
+
+	public interface SCInterface {
+		public void raiseEv();
+
+		public void setSCInterfaceOperationCallback(
+				SCInterfaceOperationCallback operationCallback);
+	}
+
+	public interface SCInterfaceOperationCallback {
+		public void unnamedInterfaceOperation1();
+		public boolean unnamedInterfaceOperation2(long param1);
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/operations/OperationsStatemachine.java

@@ -1,206 +1,215 @@
-package org.yakindu.scr.operations;
-
-public class OperationsStatemachine implements IOperationsStatemachine {
-
-	private final class SCIInterface1Impl implements SCIInterface1 {
-
-		private SCIInterface1OperationCallback operationCallback;
-
-		public void setSCIInterface1OperationCallback(
-				SCIInterface1OperationCallback operationCallback) {
-			this.operationCallback = operationCallback;
-		}
-
-	}
-
-	private SCIInterface1Impl sCIInterface1;
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private SCInterfaceOperationCallback operationCallback;
-
-		public void setSCInterfaceOperationCallback(
-				SCInterfaceOperationCallback operationCallback) {
-			this.operationCallback = operationCallback;
-		}
-
-		private boolean ev;
-
-		public void raiseEv() {
-			ev = true;
-		}
-
-		public void clearEvents() {
-			ev = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, main_region_B, main_region_C, $NullState$
-	};
-
-	private boolean myBool;
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	private InternalOperationCallback operationCallback;
-
-	public OperationsStatemachine() {
-
-		sCIInterface1 = new SCIInterface1Impl();
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		myBool = false;
-	}
-
-	public void enter() {
-		entryAction();
-
-		operationCallback.internalOperation1();
-
-		myBool = operationCallback.internalOperation2(4);
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_C :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0] == State.main_region_B;
-			case main_region_C :
-				return stateVector[0] == State.main_region_C;
-			default :
-				return false;
-		}
-	}
-
-	public SCIInterface1 getSCIInterface1() {
-		return sCIInterface1;
-	}
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void setInternalOperationCallback(
-			InternalOperationCallback operationCallback) {
-		this.operationCallback = operationCallback;
-	}
-
-	public void raiseEv() {
-		sCInterface.raiseEv();
-	}
-
-	/* Entry action for statechart 'Operations'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'Operations'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.ev) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCIInterface1.operationCallback.interfaceOperation1();
-
-			sCIInterface1.operationCallback.interfaceOperation2(4);
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_B;
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactMain_region_B() {
-		if (sCInterface.ev) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.operationCallback.unnamedInterfaceOperation1();
-
-			sCInterface.operationCallback.unnamedInterfaceOperation2(4);
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_C;
-		}
-	}
-
-	/* The reactions of state C. */
-	private void reactMain_region_C() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B :
-					reactMain_region_B();
-					break;
-				case main_region_C :
-					reactMain_region_C();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.operations;
+
+public class OperationsStatemachine implements IOperationsStatemachine {
+
+	private final class SCIInterface1Impl implements SCIInterface1 {
+
+		private SCIInterface1OperationCallback operationCallback;
+
+		public void setSCIInterface1OperationCallback(
+				SCIInterface1OperationCallback operationCallback) {
+			this.operationCallback = operationCallback;
+		}
+
+	}
+
+	private SCIInterface1Impl sCIInterface1;
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private SCInterfaceOperationCallback operationCallback;
+
+		public void setSCInterfaceOperationCallback(
+				SCInterfaceOperationCallback operationCallback) {
+			this.operationCallback = operationCallback;
+		}
+
+		private boolean ev;
+
+		public void raiseEv() {
+			ev = true;
+		}
+
+		public void clearEvents() {
+			ev = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, main_region_B, main_region_C, $NullState$
+	};
+
+	private boolean myBool;
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	private InternalOperationCallback operationCallback;
+
+	public OperationsStatemachine() {
+
+		sCIInterface1 = new SCIInterface1Impl();
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		myBool = false;
+	}
+
+	public void enter() {
+		entryAction();
+
+		operationCallback.internalOperation1();
+
+		myBool = operationCallback.internalOperation2(4);
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_C :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0] == State.main_region_B;
+			case main_region_C :
+				return stateVector[0] == State.main_region_C;
+			default :
+				return false;
+		}
+	}
+
+	public SCIInterface1 getSCIInterface1() {
+		return sCIInterface1;
+	}
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void setInternalOperationCallback(
+			InternalOperationCallback operationCallback) {
+		this.operationCallback = operationCallback;
+	}
+
+	public void raiseEv() {
+		sCInterface.raiseEv();
+	}
+
+	/* Entry action for statechart 'Operations'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'Operations'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.ev) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCIInterface1.operationCallback.interfaceOperation1();
+
+			sCIInterface1.operationCallback.interfaceOperation2(4);
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_B;
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactMain_region_B() {
+		if (sCInterface.ev) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.operationCallback.unnamedInterfaceOperation1();
+
+			sCInterface.operationCallback.unnamedInterfaceOperation2(4);
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_C;
+		}
+	}
+
+	/* The reactions of state C. */
+	private void reactMain_region_C() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B :
+					reactMain_region_B();
+					break;
+				case main_region_C :
+					reactMain_region_C();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/outeventlifecycle/IOutEventLifeCycleStatemachine.java

@@ -1,18 +1,18 @@
-package org.yakindu.scr.outeventlifecycle;
-import org.yakindu.scr.IStatemachine;
-
-public interface IOutEventLifeCycleStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public boolean isRaisedF();
-		public boolean getF_available_in_cycle();
-		public void setF_available_in_cycle(boolean value);
-		public boolean getF_available_in_next_cycle();
-		public void setF_available_in_next_cycle(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.outeventlifecycle;
+import org.yakindu.scr.IStatemachine;
+
+public interface IOutEventLifeCycleStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public boolean isRaisedF();
+		public boolean getF_available_in_cycle();
+		public void setF_available_in_cycle(boolean value);
+		public boolean getF_available_in_next_cycle();
+		public void setF_available_in_next_cycle(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/outeventlifecycle/OutEventLifeCycleStatemachine.java

@@ -1,227 +1,236 @@
-package org.yakindu.scr.outeventlifecycle;
-
-public class OutEventLifeCycleStatemachine
-		implements
-			IOutEventLifeCycleStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private boolean f;
-
-		public boolean isRaisedF() {
-			return f;
-		}
-
-		private void raiseF() {
-			f = true;
-		}
-
-		private boolean f_available_in_cycle;
-
-		public boolean getF_available_in_cycle() {
-			return f_available_in_cycle;
-		}
-
-		public void setF_available_in_cycle(boolean value) {
-			this.f_available_in_cycle = value;
-		}
-
-		private boolean f_available_in_next_cycle;
-
-		public boolean getF_available_in_next_cycle() {
-			return f_available_in_next_cycle;
-		}
-
-		public void setF_available_in_next_cycle(boolean value) {
-			this.f_available_in_next_cycle = value;
-		}
-
-		public void clearEvents() {
-			e = false;
-		}
-
-		public void clearOutEvents() {
-			f = false;
-		}
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		r1_A, r1_B, r2_B, $NullState$
-	};
-
-	private final State[] stateVector = new State[2];
-
-	private int nextStateIndex;
-
-	public OutEventLifeCycleStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 2; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.f_available_in_cycle = false;
-
-		sCInterface.f_available_in_next_cycle = false;
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.r1_A;
-
-		nextStateIndex = 1;
-		stateVector[1] = State.r2_B;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case r1_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case r1_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		switch (stateVector[1]) {
-			case r2_B :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-		sCInterface.clearOutEvents();
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case r1_A :
-				return stateVector[0] == State.r1_A;
-			case r1_B :
-				return stateVector[0] == State.r1_B;
-			case r2_B :
-				return stateVector[1] == State.r2_B;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-	public boolean isRaisedF() {
-		return sCInterface.isRaisedF();
-	}
-
-	public boolean getF_available_in_cycle() {
-		return sCInterface.getF_available_in_cycle();
-	}
-
-	public void setF_available_in_cycle(boolean value) {
-		sCInterface.setF_available_in_cycle(value);
-	}
-	public boolean getF_available_in_next_cycle() {
-		return sCInterface.getF_available_in_next_cycle();
-	}
-
-	public void setF_available_in_next_cycle(boolean value) {
-		sCInterface.setF_available_in_next_cycle(value);
-	}
-
-	/* Entry action for statechart 'OutEventLifeCycle'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'OutEventLifeCycle'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactR1_A() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.raiseF();
-
-			nextStateIndex = 0;
-			stateVector[0] = State.r1_B;
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactR1_B() {
-		if (sCInterface.f) {
-			sCInterface.f_available_in_next_cycle = true;
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactR2_B() {
-		if (sCInterface.f) {
-			sCInterface.f_available_in_cycle = true;
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case r1_A :
-					reactR1_A();
-					break;
-				case r1_B :
-					reactR1_B();
-					break;
-				case r2_B :
-					reactR2_B();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.outeventlifecycle;
+
+public class OutEventLifeCycleStatemachine
+		implements
+			IOutEventLifeCycleStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private boolean f;
+
+		public boolean isRaisedF() {
+			return f;
+		}
+
+		private void raiseF() {
+			f = true;
+		}
+
+		private boolean f_available_in_cycle;
+
+		public boolean getF_available_in_cycle() {
+			return f_available_in_cycle;
+		}
+
+		public void setF_available_in_cycle(boolean value) {
+			this.f_available_in_cycle = value;
+		}
+
+		private boolean f_available_in_next_cycle;
+
+		public boolean getF_available_in_next_cycle() {
+			return f_available_in_next_cycle;
+		}
+
+		public void setF_available_in_next_cycle(boolean value) {
+			this.f_available_in_next_cycle = value;
+		}
+
+		public void clearEvents() {
+			e = false;
+		}
+
+		public void clearOutEvents() {
+			f = false;
+		}
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		r1_A, r1_B, r2_B, $NullState$
+	};
+
+	private final State[] stateVector = new State[2];
+
+	private int nextStateIndex;
+
+	public OutEventLifeCycleStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 2; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.f_available_in_cycle = false;
+
+		sCInterface.f_available_in_next_cycle = false;
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.r1_A;
+
+		nextStateIndex = 1;
+		stateVector[1] = State.r2_B;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case r1_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case r1_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		switch (stateVector[1]) {
+			case r2_B :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * 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 r1_A :
+				return stateVector[0] == State.r1_A;
+			case r1_B :
+				return stateVector[0] == State.r1_B;
+			case r2_B :
+				return stateVector[1] == State.r2_B;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+	public boolean isRaisedF() {
+		return sCInterface.isRaisedF();
+	}
+
+	public boolean getF_available_in_cycle() {
+		return sCInterface.getF_available_in_cycle();
+	}
+
+	public void setF_available_in_cycle(boolean value) {
+		sCInterface.setF_available_in_cycle(value);
+	}
+	public boolean getF_available_in_next_cycle() {
+		return sCInterface.getF_available_in_next_cycle();
+	}
+
+	public void setF_available_in_next_cycle(boolean value) {
+		sCInterface.setF_available_in_next_cycle(value);
+	}
+
+	/* Entry action for statechart 'OutEventLifeCycle'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'OutEventLifeCycle'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactR1_A() {
+		if (sCInterface.e) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.raiseF();
+
+			nextStateIndex = 0;
+			stateVector[0] = State.r1_B;
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactR1_B() {
+		if (sCInterface.f) {
+			sCInterface.f_available_in_next_cycle = true;
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactR2_B() {
+		if (sCInterface.f) {
+			sCInterface.f_available_in_cycle = true;
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case r1_A :
+					reactR1_A();
+					break;
+				case r1_B :
+					reactR1_B();
+					break;
+				case r2_B :
+					reactR2_B();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/parenthesis/IParenthesisStatemachine.java

@@ -1,14 +1,14 @@
-package org.yakindu.scr.parenthesis;
-import org.yakindu.scr.IStatemachine;
-
-public interface IParenthesisStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public int getErg();
-		public void setErg(int value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.parenthesis;
+import org.yakindu.scr.IStatemachine;
+
+public interface IParenthesisStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public long getErg();
+		public void setErg(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/parenthesis/ParenthesisStatemachine.java

@@ -1,125 +1,134 @@
-package org.yakindu.scr.parenthesis;
-
-public class ParenthesisStatemachine implements IParenthesisStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private int erg;
-
-		public int getErg() {
-			return erg;
-		}
-
-		public void setErg(int value) {
-			this.erg = value;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		mainRegion_A, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public ParenthesisStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.erg = 0;
-	}
-
-	public void enter() {
-		entryAction();
-
-		sCInterface.erg = 4 * (3 - 1);
-
-		nextStateIndex = 0;
-		stateVector[0] = State.mainRegion_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case mainRegion_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case mainRegion_A :
-				return stateVector[0] == State.mainRegion_A;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public int getErg() {
-		return sCInterface.getErg();
-	}
-
-	public void setErg(int value) {
-		sCInterface.setErg(value);
-	}
-
-	/* Entry action for statechart 'Parenthesis'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'Parenthesis'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMainRegion_A() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case mainRegion_A :
-					reactMainRegion_A();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.parenthesis;
+
+public class ParenthesisStatemachine implements IParenthesisStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private long erg;
+
+		public long getErg() {
+			return erg;
+		}
+
+		public void setErg(long value) {
+			this.erg = value;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		mainRegion_A, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public ParenthesisStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.erg = 0;
+	}
+
+	public void enter() {
+		entryAction();
+
+		sCInterface.erg = 4 * (3 - 1);
+
+		nextStateIndex = 0;
+		stateVector[0] = State.mainRegion_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case mainRegion_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case mainRegion_A :
+				return stateVector[0] == State.mainRegion_A;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public long getErg() {
+		return sCInterface.getErg();
+	}
+
+	public void setErg(long value) {
+		sCInterface.setErg(value);
+	}
+
+	/* Entry action for statechart 'Parenthesis'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'Parenthesis'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMainRegion_A() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case mainRegion_A :
+					reactMainRegion_A();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/performancetest/IPerformanceTestStatemachine.java

@@ -1,25 +1,25 @@
-package org.yakindu.scr.performancetest;
-import org.yakindu.scr.IStatemachine;
-import org.yakindu.scr.ITimerCallback;
-
-public interface IPerformanceTestStatemachine
-		extends
-			ITimerCallback,
-			IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE1();
-		public void raiseE2();
-		public void raiseE3();
-		public int getX();
-		public void setX(int value);
-		public int getA();
-		public void setA(int value);
-		public int getC();
-		public void setC(int value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.performancetest;
+import org.yakindu.scr.IStatemachine;
+import org.yakindu.scr.ITimerCallback;
+
+public interface IPerformanceTestStatemachine
+		extends
+			ITimerCallback,
+			IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE1();
+		public void raiseE2();
+		public void raiseE3();
+		public long getX();
+		public void setX(long value);
+		public long getA();
+		public void setA(long value);
+		public long getC();
+		public void setC(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/priorityvalues/IPriorityValuesStatemachine.java

@@ -1,14 +1,14 @@
-package org.yakindu.scr.priorityvalues;
-import org.yakindu.scr.IStatemachine;
-
-public interface IPriorityValuesStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseEvent1();
-		public void raiseEvent2();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.priorityvalues;
+import org.yakindu.scr.IStatemachine;
+
+public interface IPriorityValuesStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseEvent1();
+		public void raiseEvent2();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/priorityvalues/PriorityValuesStatemachine.java

@@ -1,260 +1,269 @@
-package org.yakindu.scr.priorityvalues;
-
-public class PriorityValuesStatemachine implements IPriorityValuesStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean event1;
-
-		public void raiseEvent1() {
-			event1 = true;
-		}
-
-		private boolean event2;
-
-		public void raiseEvent2() {
-			event2 = true;
-		}
-
-		public void clearEvents() {
-			event1 = false;
-			event2 = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		someRegion_A, someRegion_B, main_region_A, main_region_B, main_region_C, main_region_D, main_region_E, $NullState$
-	};
-
-	private final State[] stateVector = new State[2];
-
-	private int nextStateIndex;
-
-	public PriorityValuesStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 2; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.someRegion_A;
-
-		nextStateIndex = 1;
-		stateVector[1] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case someRegion_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case someRegion_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		switch (stateVector[1]) {
-			case main_region_A :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case main_region_B :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case main_region_C :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case main_region_D :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case main_region_E :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case someRegion_A :
-				return stateVector[0] == State.someRegion_A;
-			case someRegion_B :
-				return stateVector[0] == State.someRegion_B;
-			case main_region_A :
-				return stateVector[1] == State.main_region_A;
-			case main_region_B :
-				return stateVector[1] == State.main_region_B;
-			case main_region_C :
-				return stateVector[1] == State.main_region_C;
-			case main_region_D :
-				return stateVector[1] == State.main_region_D;
-			case main_region_E :
-				return stateVector[1] == State.main_region_E;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseEvent1() {
-		sCInterface.raiseEvent1();
-	}
-	public void raiseEvent2() {
-		sCInterface.raiseEvent2();
-	}
-
-	/* Entry action for statechart 'PriorityValues'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'PriorityValues'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactSomeRegion_A() {
-		if (sCInterface.event2) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.someRegion_B;
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactSomeRegion_B() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.event1) {
-			nextStateIndex = 1;
-			stateVector[1] = State.$NullState$;
-
-			nextStateIndex = 1;
-			stateVector[1] = State.main_region_C;
-		} else {
-			if (sCInterface.event1) {
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-
-				nextStateIndex = 1;
-				stateVector[1] = State.main_region_B;
-			} else {
-				if (sCInterface.event1) {
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-
-					nextStateIndex = 1;
-					stateVector[1] = State.main_region_D;
-				} else {
-					if (sCInterface.event2
-							&& !isStateActive(State.someRegion_B)) {
-						nextStateIndex = 1;
-						stateVector[1] = State.$NullState$;
-
-						nextStateIndex = 1;
-						stateVector[1] = State.main_region_E;
-					}
-				}
-			}
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactMain_region_B() {
-	}
-
-	/* The reactions of state C. */
-	private void reactMain_region_C() {
-	}
-
-	/* The reactions of state D. */
-	private void reactMain_region_D() {
-	}
-
-	/* The reactions of state E. */
-	private void reactMain_region_E() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case someRegion_A :
-					reactSomeRegion_A();
-					break;
-				case someRegion_B :
-					reactSomeRegion_B();
-					break;
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B :
-					reactMain_region_B();
-					break;
-				case main_region_C :
-					reactMain_region_C();
-					break;
-				case main_region_D :
-					reactMain_region_D();
-					break;
-				case main_region_E :
-					reactMain_region_E();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.priorityvalues;
+
+public class PriorityValuesStatemachine implements IPriorityValuesStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean event1;
+
+		public void raiseEvent1() {
+			event1 = true;
+		}
+
+		private boolean event2;
+
+		public void raiseEvent2() {
+			event2 = true;
+		}
+
+		public void clearEvents() {
+			event1 = false;
+			event2 = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		someRegion_A, someRegion_B, main_region_A, main_region_B, main_region_C, main_region_D, main_region_E, $NullState$
+	};
+
+	private final State[] stateVector = new State[2];
+
+	private int nextStateIndex;
+
+	public PriorityValuesStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 2; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.someRegion_A;
+
+		nextStateIndex = 1;
+		stateVector[1] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case someRegion_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case someRegion_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		switch (stateVector[1]) {
+			case main_region_A :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case main_region_B :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case main_region_C :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case main_region_D :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case main_region_E :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case someRegion_A :
+				return stateVector[0] == State.someRegion_A;
+			case someRegion_B :
+				return stateVector[0] == State.someRegion_B;
+			case main_region_A :
+				return stateVector[1] == State.main_region_A;
+			case main_region_B :
+				return stateVector[1] == State.main_region_B;
+			case main_region_C :
+				return stateVector[1] == State.main_region_C;
+			case main_region_D :
+				return stateVector[1] == State.main_region_D;
+			case main_region_E :
+				return stateVector[1] == State.main_region_E;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseEvent1() {
+		sCInterface.raiseEvent1();
+	}
+	public void raiseEvent2() {
+		sCInterface.raiseEvent2();
+	}
+
+	/* Entry action for statechart 'PriorityValues'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'PriorityValues'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactSomeRegion_A() {
+		if (sCInterface.event2) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.someRegion_B;
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactSomeRegion_B() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.event1) {
+			nextStateIndex = 1;
+			stateVector[1] = State.$NullState$;
+
+			nextStateIndex = 1;
+			stateVector[1] = State.main_region_C;
+		} else {
+			if (sCInterface.event1) {
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+
+				nextStateIndex = 1;
+				stateVector[1] = State.main_region_B;
+			} else {
+				if (sCInterface.event1) {
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+
+					nextStateIndex = 1;
+					stateVector[1] = State.main_region_D;
+				} else {
+					if (sCInterface.event2
+							&& !isStateActive(State.someRegion_B)) {
+						nextStateIndex = 1;
+						stateVector[1] = State.$NullState$;
+
+						nextStateIndex = 1;
+						stateVector[1] = State.main_region_E;
+					}
+				}
+			}
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactMain_region_B() {
+	}
+
+	/* The reactions of state C. */
+	private void reactMain_region_C() {
+	}
+
+	/* The reactions of state D. */
+	private void reactMain_region_D() {
+	}
+
+	/* The reactions of state E. */
+	private void reactMain_region_E() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case someRegion_A :
+					reactSomeRegion_A();
+					break;
+				case someRegion_B :
+					reactSomeRegion_B();
+					break;
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B :
+					reactMain_region_B();
+					break;
+				case main_region_C :
+					reactMain_region_C();
+					break;
+				case main_region_D :
+					reactMain_region_D();
+					break;
+				case main_region_E :
+					reactMain_region_E();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/raiseevent/IRaiseEventStatemachine.java

@@ -1,14 +1,14 @@
-package org.yakindu.scr.raiseevent;
-import org.yakindu.scr.IStatemachine;
-
-public interface IRaiseEventStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public boolean isRaisedE1();
-		public void raiseE2();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.raiseevent;
+import org.yakindu.scr.IStatemachine;
+
+public interface IRaiseEventStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public boolean isRaisedE1();
+		public void raiseE2();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/raiseevent/RaiseEventStatemachine.java

@@ -1,202 +1,211 @@
-package org.yakindu.scr.raiseevent;
-
-public class RaiseEventStatemachine implements IRaiseEventStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e1;
-
-		public boolean isRaisedE1() {
-			return e1;
-		}
-
-		private void raiseE1() {
-			e1 = true;
-		}
-
-		private boolean e2;
-
-		public void raiseE2() {
-			e2 = true;
-		}
-
-		public void clearEvents() {
-			e2 = false;
-		}
-
-		public void clearOutEvents() {
-			e1 = false;
-		}
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_StateA, main_region_StateB, second_region_SateA, second_region_StateB, $NullState$
-	};
-
-	private final State[] stateVector = new State[2];
-
-	private int nextStateIndex;
-
-	public RaiseEventStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 2; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_StateA;
-
-		nextStateIndex = 1;
-		stateVector[1] = State.second_region_SateA;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_StateA :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_StateB :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		switch (stateVector[1]) {
-			case second_region_SateA :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case second_region_StateB :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-		sCInterface.clearOutEvents();
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_StateA :
-				return stateVector[0] == State.main_region_StateA;
-			case main_region_StateB :
-				return stateVector[0] == State.main_region_StateB;
-			case second_region_SateA :
-				return stateVector[1] == State.second_region_SateA;
-			case second_region_StateB :
-				return stateVector[1] == State.second_region_StateB;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public boolean isRaisedE1() {
-		return sCInterface.isRaisedE1();
-	}
-	public void raiseE2() {
-		sCInterface.raiseE2();
-	}
-
-	/* Entry action for statechart 'RaiseEvent'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'RaiseEvent'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state StateA. */
-	private void reactMain_region_StateA() {
-		if (sCInterface.e2) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.raiseE1();
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_StateB;
-		}
-	}
-
-	/* The reactions of state StateB. */
-	private void reactMain_region_StateB() {
-	}
-
-	/* The reactions of state SateA. */
-	private void reactSecond_region_SateA() {
-		if (sCInterface.e1) {
-			nextStateIndex = 1;
-			stateVector[1] = State.$NullState$;
-
-			nextStateIndex = 1;
-			stateVector[1] = State.second_region_StateB;
-		}
-	}
-
-	/* The reactions of state StateB. */
-	private void reactSecond_region_StateB() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_StateA :
-					reactMain_region_StateA();
-					break;
-				case main_region_StateB :
-					reactMain_region_StateB();
-					break;
-				case second_region_SateA :
-					reactSecond_region_SateA();
-					break;
-				case second_region_StateB :
-					reactSecond_region_StateB();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.raiseevent;
+
+public class RaiseEventStatemachine implements IRaiseEventStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e1;
+
+		public boolean isRaisedE1() {
+			return e1;
+		}
+
+		private void raiseE1() {
+			e1 = true;
+		}
+
+		private boolean e2;
+
+		public void raiseE2() {
+			e2 = true;
+		}
+
+		public void clearEvents() {
+			e2 = false;
+		}
+
+		public void clearOutEvents() {
+			e1 = false;
+		}
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_StateA, main_region_StateB, second_region_SateA, second_region_StateB, $NullState$
+	};
+
+	private final State[] stateVector = new State[2];
+
+	private int nextStateIndex;
+
+	public RaiseEventStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 2; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_StateA;
+
+		nextStateIndex = 1;
+		stateVector[1] = State.second_region_SateA;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_StateA :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_StateB :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		switch (stateVector[1]) {
+			case second_region_SateA :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case second_region_StateB :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * 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_region_StateA :
+				return stateVector[0] == State.main_region_StateA;
+			case main_region_StateB :
+				return stateVector[0] == State.main_region_StateB;
+			case second_region_SateA :
+				return stateVector[1] == State.second_region_SateA;
+			case second_region_StateB :
+				return stateVector[1] == State.second_region_StateB;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public boolean isRaisedE1() {
+		return sCInterface.isRaisedE1();
+	}
+	public void raiseE2() {
+		sCInterface.raiseE2();
+	}
+
+	/* Entry action for statechart 'RaiseEvent'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'RaiseEvent'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state StateA. */
+	private void reactMain_region_StateA() {
+		if (sCInterface.e2) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.raiseE1();
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_StateB;
+		}
+	}
+
+	/* The reactions of state StateB. */
+	private void reactMain_region_StateB() {
+	}
+
+	/* The reactions of state SateA. */
+	private void reactSecond_region_SateA() {
+		if (sCInterface.e1) {
+			nextStateIndex = 1;
+			stateVector[1] = State.$NullState$;
+
+			nextStateIndex = 1;
+			stateVector[1] = State.second_region_StateB;
+		}
+	}
+
+	/* The reactions of state StateB. */
+	private void reactSecond_region_StateB() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_StateA :
+					reactMain_region_StateA();
+					break;
+				case main_region_StateB :
+					reactMain_region_StateB();
+					break;
+				case second_region_SateA :
+					reactSecond_region_SateA();
+					break;
+				case second_region_StateB :
+					reactSecond_region_StateB();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/realexpressions/IRealExpressionsStatemachine.java

@@ -1,53 +1,53 @@
-package org.yakindu.scr.realexpressions;
-import org.yakindu.scr.IStatemachine;
-
-public interface IRealExpressionsStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE1();
-		public double getMyReal1();
-		public void setMyReal1(double value);
-		public double getMyReal2();
-		public void setMyReal2(double value);
-		public boolean getLess();
-		public void setLess(boolean value);
-		public boolean getGreater();
-		public void setGreater(boolean value);
-		public boolean getEqualOrLess();
-		public void setEqualOrLess(boolean value);
-		public boolean getEqualOrGreater();
-		public void setEqualOrGreater(boolean value);
-		public boolean getEqual();
-		public void setEqual(boolean value);
-		public boolean getNotEqual();
-		public void setNotEqual(boolean value);
-		public boolean getPlus();
-		public void setPlus(boolean value);
-		public boolean getMinus();
-		public void setMinus(boolean value);
-		public boolean getMultiply();
-		public void setMultiply(boolean value);
-		public boolean getDivision();
-		public void setDivision(boolean value);
-		public boolean getModulo();
-		public void setModulo(boolean value);
-		public double getNegat();
-		public void setNegat(double value);
-		public boolean getComplement();
-		public void setComplement(boolean value);
-		public double getMultiAssign();
-		public void setMultiAssign(double value);
-		public double getDivAssign();
-		public void setDivAssign(double value);
-		public double getPlusAssign();
-		public void setPlusAssign(double value);
-		public double getMinusAssign();
-		public void setMinusAssign(double value);
-		public boolean getModuloAssign();
-		public void setModuloAssign(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.realexpressions;
+import org.yakindu.scr.IStatemachine;
+
+public interface IRealExpressionsStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE1();
+		public double getMyReal1();
+		public void setMyReal1(double value);
+		public double getMyReal2();
+		public void setMyReal2(double value);
+		public boolean getLess();
+		public void setLess(boolean value);
+		public boolean getGreater();
+		public void setGreater(boolean value);
+		public boolean getEqualOrLess();
+		public void setEqualOrLess(boolean value);
+		public boolean getEqualOrGreater();
+		public void setEqualOrGreater(boolean value);
+		public boolean getEqual();
+		public void setEqual(boolean value);
+		public boolean getNotEqual();
+		public void setNotEqual(boolean value);
+		public boolean getPlus();
+		public void setPlus(boolean value);
+		public boolean getMinus();
+		public void setMinus(boolean value);
+		public boolean getMultiply();
+		public void setMultiply(boolean value);
+		public boolean getDivision();
+		public void setDivision(boolean value);
+		public boolean getModulo();
+		public void setModulo(boolean value);
+		public double getNegat();
+		public void setNegat(double value);
+		public boolean getComplement();
+		public void setComplement(boolean value);
+		public double getMultiAssign();
+		public void setMultiAssign(double value);
+		public double getDivAssign();
+		public void setDivAssign(double value);
+		public double getPlusAssign();
+		public void setPlusAssign(double value);
+		public double getMinusAssign();
+		public void setMinusAssign(double value);
+		public boolean getModuloAssign();
+		public void setModuloAssign(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/samenamedifferentregion/ISameNameDifferentRegionStatemachine.java

@@ -1,13 +1,13 @@
-package org.yakindu.scr.samenamedifferentregion;
-import org.yakindu.scr.IStatemachine;
-
-public interface ISameNameDifferentRegionStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE1();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.samenamedifferentregion;
+import org.yakindu.scr.IStatemachine;
+
+public interface ISameNameDifferentRegionStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE1();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/samenamedifferentregion/SameNameDifferentRegionStatemachine.java

@@ -1,168 +1,177 @@
-package org.yakindu.scr.samenamedifferentregion;
-
-public class SameNameDifferentRegionStatemachine
-		implements
-			ISameNameDifferentRegionStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e1;
-
-		public void raiseE1() {
-			e1 = true;
-		}
-
-		public void clearEvents() {
-			e1 = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_StateA, main_region_StateB, main_region_StateB_r1_StateA, main_region_StateB_r1_StateB, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public SameNameDifferentRegionStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_StateA;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_StateA :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_StateB_r1_StateA :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_StateB_r1_StateB :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_StateA :
-				return stateVector[0] == State.main_region_StateA;
-			case main_region_StateB :
-				return stateVector[0].ordinal() >= State.main_region_StateB
-						.ordinal()
-						&& stateVector[0].ordinal() <= State.main_region_StateB_r1_StateB
-								.ordinal();
-			case main_region_StateB_r1_StateA :
-				return stateVector[0] == State.main_region_StateB_r1_StateA;
-			case main_region_StateB_r1_StateB :
-				return stateVector[0] == State.main_region_StateB_r1_StateB;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE1() {
-		sCInterface.raiseE1();
-	}
-
-	/* Entry action for statechart 'SameNameDifferentRegion'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'SameNameDifferentRegion'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state StateA. */
-	private void reactMain_region_StateA() {
-		if (sCInterface.e1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_StateB_r1_StateA;
-		}
-	}
-
-	/* The reactions of state StateA. */
-	private void reactMain_region_StateB_r1_StateA() {
-		if (sCInterface.e1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_StateB_r1_StateB;
-		}
-	}
-
-	/* The reactions of state StateB. */
-	private void reactMain_region_StateB_r1_StateB() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_StateA :
-					reactMain_region_StateA();
-					break;
-				case main_region_StateB_r1_StateA :
-					reactMain_region_StateB_r1_StateA();
-					break;
-				case main_region_StateB_r1_StateB :
-					reactMain_region_StateB_r1_StateB();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.samenamedifferentregion;
+
+public class SameNameDifferentRegionStatemachine
+		implements
+			ISameNameDifferentRegionStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e1;
+
+		public void raiseE1() {
+			e1 = true;
+		}
+
+		public void clearEvents() {
+			e1 = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_StateA, main_region_StateB, main_region_StateB_r1_StateA, main_region_StateB_r1_StateB, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public SameNameDifferentRegionStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_StateA;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_StateA :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_StateB_r1_StateA :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_StateB_r1_StateB :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_StateA :
+				return stateVector[0] == State.main_region_StateA;
+			case main_region_StateB :
+				return stateVector[0].ordinal() >= State.main_region_StateB
+						.ordinal()
+						&& stateVector[0].ordinal() <= State.main_region_StateB_r1_StateB
+								.ordinal();
+			case main_region_StateB_r1_StateA :
+				return stateVector[0] == State.main_region_StateB_r1_StateA;
+			case main_region_StateB_r1_StateB :
+				return stateVector[0] == State.main_region_StateB_r1_StateB;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE1() {
+		sCInterface.raiseE1();
+	}
+
+	/* Entry action for statechart 'SameNameDifferentRegion'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'SameNameDifferentRegion'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state StateA. */
+	private void reactMain_region_StateA() {
+		if (sCInterface.e1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_StateB_r1_StateA;
+		}
+	}
+
+	/* The reactions of state StateA. */
+	private void reactMain_region_StateB_r1_StateA() {
+		if (sCInterface.e1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_StateB_r1_StateB;
+		}
+	}
+
+	/* The reactions of state StateB. */
+	private void reactMain_region_StateB_r1_StateB() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_StateA :
+					reactMain_region_StateA();
+					break;
+				case main_region_StateB_r1_StateA :
+					reactMain_region_StateB_r1_StateA();
+					break;
+				case main_region_StateB_r1_StateB :
+					reactMain_region_StateB_r1_StateB();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/shallowhistory/IShallowHistoryStatemachine.java

@@ -1,20 +1,20 @@
-package org.yakindu.scr.shallowhistory;
-import org.yakindu.scr.IStatemachine;
-
-public interface IShallowHistoryStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseEvent1();
-		public void raiseEvent2();
-		public void raiseEvent3();
-		public void raiseEvent4();
-		public void raiseEvent5();
-		public void raiseEvent6();
-		public void raiseEvent7();
-		public void raiseEvent8();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.shallowhistory;
+import org.yakindu.scr.IStatemachine;
+
+public interface IShallowHistoryStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseEvent1();
+		public void raiseEvent2();
+		public void raiseEvent3();
+		public void raiseEvent4();
+		public void raiseEvent5();
+		public void raiseEvent6();
+		public void raiseEvent7();
+		public void raiseEvent8();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/simpleevent/ISimpleEventStatemachine.java

@@ -1,13 +1,13 @@
-package org.yakindu.scr.simpleevent;
-import org.yakindu.scr.IStatemachine;
-
-public interface ISimpleEventStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseEvent1();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.simpleevent;
+import org.yakindu.scr.IStatemachine;
+
+public interface ISimpleEventStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseEvent1();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/simpleevent/SimpleEventStatemachine.java

@@ -1,140 +1,149 @@
-package org.yakindu.scr.simpleevent;
-
-public class SimpleEventStatemachine implements ISimpleEventStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean event1;
-
-		public void raiseEvent1() {
-			event1 = true;
-		}
-
-		public void clearEvents() {
-			event1 = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, main_region_B, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public SimpleEventStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0] == State.main_region_B;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseEvent1() {
-		sCInterface.raiseEvent1();
-	}
-
-	/* Entry action for statechart 'SimpleEvent'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'SimpleEvent'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.event1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_B;
-		}
-	}
-
-	/* The reactions of state B. */
-	private void reactMain_region_B() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B :
-					reactMain_region_B();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.simpleevent;
+
+public class SimpleEventStatemachine implements ISimpleEventStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean event1;
+
+		public void raiseEvent1() {
+			event1 = true;
+		}
+
+		public void clearEvents() {
+			event1 = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, main_region_B, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public SimpleEventStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0] == State.main_region_B;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseEvent1() {
+		sCInterface.raiseEvent1();
+	}
+
+	/* Entry action for statechart 'SimpleEvent'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'SimpleEvent'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.event1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_B;
+		}
+	}
+
+	/* The reactions of state B. */
+	private void reactMain_region_B() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B :
+					reactMain_region_B();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/simplehierachy/ISimpleHierachyStatemachine.java

@@ -1,13 +1,13 @@
-package org.yakindu.scr.simplehierachy;
-import org.yakindu.scr.IStatemachine;
-
-public interface ISimpleHierachyStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseEvent1();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.simplehierachy;
+import org.yakindu.scr.IStatemachine;
+
+public interface ISimpleHierachyStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseEvent1();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/simplehierachy/SimpleHierachyStatemachine.java

@@ -1,145 +1,154 @@
-package org.yakindu.scr.simplehierachy;
-
-public class SimpleHierachyStatemachine implements ISimpleHierachyStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean event1;
-
-		public void raiseEvent1() {
-			event1 = true;
-		}
-
-		public void clearEvents() {
-			event1 = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, main_region_B, main_region_B_subregion1_B1, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public SimpleHierachyStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B_subregion1_B1 :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0].ordinal() >= State.main_region_B
-						.ordinal()
-						&& stateVector[0].ordinal() <= State.main_region_B_subregion1_B1
-								.ordinal();
-			case main_region_B_subregion1_B1 :
-				return stateVector[0] == State.main_region_B_subregion1_B1;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseEvent1() {
-		sCInterface.raiseEvent1();
-	}
-
-	/* Entry action for statechart 'SimpleHierachy'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'SimpleHierachy'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.event1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_B_subregion1_B1;
-		}
-	}
-
-	/* The reactions of state B1. */
-	private void reactMain_region_B_subregion1_B1() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B_subregion1_B1 :
-					reactMain_region_B_subregion1_B1();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.simplehierachy;
+
+public class SimpleHierachyStatemachine implements ISimpleHierachyStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean event1;
+
+		public void raiseEvent1() {
+			event1 = true;
+		}
+
+		public void clearEvents() {
+			event1 = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, main_region_B, main_region_B_subregion1_B1, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public SimpleHierachyStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B_subregion1_B1 :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0].ordinal() >= State.main_region_B
+						.ordinal()
+						&& stateVector[0].ordinal() <= State.main_region_B_subregion1_B1
+								.ordinal();
+			case main_region_B_subregion1_B1 :
+				return stateVector[0] == State.main_region_B_subregion1_B1;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseEvent1() {
+		sCInterface.raiseEvent1();
+	}
+
+	/* Entry action for statechart 'SimpleHierachy'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'SimpleHierachy'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.event1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_B_subregion1_B1;
+		}
+	}
+
+	/* The reactions of state B1. */
+	private void reactMain_region_B_subregion1_B1() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B_subregion1_B1 :
+					reactMain_region_B_subregion1_B1();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/statechartlocalreactions/IStatechartLocalReactionsStatemachine.java

@@ -1,14 +1,14 @@
-package org.yakindu.scr.statechartlocalreactions;
-import org.yakindu.scr.IStatemachine;
-
-public interface IStatechartLocalReactionsStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public int getMyInt();
-		public void setMyInt(int value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.statechartlocalreactions;
+import org.yakindu.scr.IStatemachine;
+
+public interface IStatechartLocalReactionsStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public long getMyInt();
+		public void setMyInt(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/statechartlocalreactions/StatechartLocalReactionsStatemachine.java

@@ -1,183 +1,192 @@
-package org.yakindu.scr.statechartlocalreactions;
-
-public class StatechartLocalReactionsStatemachine
-		implements
-			IStatechartLocalReactionsStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private int myInt;
-
-		public int getMyInt() {
-			return myInt;
-		}
-
-		public void setMyInt(int value) {
-			this.myInt = value;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_S1, main_region_S2, region2_a, $NullState$
-	};
-
-	private final State[] stateVector = new State[2];
-
-	private int nextStateIndex;
-
-	public StatechartLocalReactionsStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 2; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.myInt = 0;
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_S1;
-
-		nextStateIndex = 1;
-		stateVector[1] = State.region2_a;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_S1 :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_S2 :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		switch (stateVector[1]) {
-			case region2_a :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_S1 :
-				return stateVector[0] == State.main_region_S1;
-			case main_region_S2 :
-				return stateVector[0] == State.main_region_S2;
-			case region2_a :
-				return stateVector[1] == State.region2_a;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public int getMyInt() {
-		return sCInterface.getMyInt();
-	}
-
-	public void setMyInt(int value) {
-		sCInterface.setMyInt(value);
-	}
-
-	private boolean checkLr0() {
-		return true;
-	}
-
-	private void effectLr0() {
-		sCInterface.myInt += 1;
-	}
-
-	/* Entry action for statechart 'StatechartLocalReactions'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'StatechartLocalReactions'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state S1. */
-	private void reactMain_region_S1() {
-		effectLr0();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.$NullState$;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_S2;
-	}
-
-	/* The reactions of state S2. */
-	private void reactMain_region_S2() {
-		effectLr0();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.$NullState$;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_S1;
-	}
-
-	/* The reactions of state a. */
-	private void reactRegion2_a() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_S1 :
-					reactMain_region_S1();
-					break;
-				case main_region_S2 :
-					reactMain_region_S2();
-					break;
-				case region2_a :
-					reactRegion2_a();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.statechartlocalreactions;
+
+public class StatechartLocalReactionsStatemachine
+		implements
+			IStatechartLocalReactionsStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private long myInt;
+
+		public long getMyInt() {
+			return myInt;
+		}
+
+		public void setMyInt(long value) {
+			this.myInt = value;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_S1, main_region_S2, region2_a, $NullState$
+	};
+
+	private final State[] stateVector = new State[2];
+
+	private int nextStateIndex;
+
+	public StatechartLocalReactionsStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 2; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.myInt = 0;
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_S1;
+
+		nextStateIndex = 1;
+		stateVector[1] = State.region2_a;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_S1 :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_S2 :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		switch (stateVector[1]) {
+			case region2_a :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_S1 :
+				return stateVector[0] == State.main_region_S1;
+			case main_region_S2 :
+				return stateVector[0] == State.main_region_S2;
+			case region2_a :
+				return stateVector[1] == State.region2_a;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public long getMyInt() {
+		return sCInterface.getMyInt();
+	}
+
+	public void setMyInt(long value) {
+		sCInterface.setMyInt(value);
+	}
+
+	private boolean checkLr0() {
+		return true;
+	}
+
+	private void effectLr0() {
+		sCInterface.myInt += 1;
+	}
+
+	/* Entry action for statechart 'StatechartLocalReactions'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'StatechartLocalReactions'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state S1. */
+	private void reactMain_region_S1() {
+		effectLr0();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_S2;
+	}
+
+	/* The reactions of state S2. */
+	private void reactMain_region_S2() {
+		effectLr0();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_S1;
+	}
+
+	/* The reactions of state a. */
+	private void reactRegion2_a() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_S1 :
+					reactMain_region_S1();
+					break;
+				case main_region_S2 :
+					reactMain_region_S2();
+					break;
+				case region2_a :
+					reactRegion2_a();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/stateisactive/IStateIsActiveStatemachine.java

@@ -1,13 +1,13 @@
-package org.yakindu.scr.stateisactive;
-import org.yakindu.scr.IStatemachine;
-
-public interface IStateIsActiveStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseEvent1();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.stateisactive;
+import org.yakindu.scr.IStatemachine;
+
+public interface IStateIsActiveStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseEvent1();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/stateisactive/StateIsActiveStatemachine.java

@@ -1,183 +1,192 @@
-package org.yakindu.scr.stateisactive;
-
-public class StateIsActiveStatemachine implements IStateIsActiveStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean event1;
-
-		public void raiseEvent1() {
-			event1 = true;
-		}
-
-		public void clearEvents() {
-			event1 = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		r1_R1A, r1_R1B, r2_R2A, r2_R2B, $NullState$
-	};
-
-	private final State[] stateVector = new State[2];
-
-	private int nextStateIndex;
-
-	public StateIsActiveStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 2; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.r1_R1A;
-
-		nextStateIndex = 1;
-		stateVector[1] = State.r2_R2A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case r1_R1A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case r1_R1B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		switch (stateVector[1]) {
-			case r2_R2A :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case r2_R2B :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case r1_R1A :
-				return stateVector[0] == State.r1_R1A;
-			case r1_R1B :
-				return stateVector[0] == State.r1_R1B;
-			case r2_R2A :
-				return stateVector[1] == State.r2_R2A;
-			case r2_R2B :
-				return stateVector[1] == State.r2_R2B;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseEvent1() {
-		sCInterface.raiseEvent1();
-	}
-
-	/* Entry action for statechart 'StateIsActive'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'StateIsActive'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state R1A. */
-	private void reactR1_R1A() {
-		if (isStateActive(State.r2_R2B)) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.r1_R1B;
-		}
-	}
-
-	/* The reactions of state R1B. */
-	private void reactR1_R1B() {
-	}
-
-	/* The reactions of state R2A. */
-	private void reactR2_R2A() {
-		if (sCInterface.event1) {
-			nextStateIndex = 1;
-			stateVector[1] = State.$NullState$;
-
-			nextStateIndex = 1;
-			stateVector[1] = State.r2_R2B;
-		}
-	}
-
-	/* The reactions of state R2B. */
-	private void reactR2_R2B() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case r1_R1A :
-					reactR1_R1A();
-					break;
-				case r1_R1B :
-					reactR1_R1B();
-					break;
-				case r2_R2A :
-					reactR2_R2A();
-					break;
-				case r2_R2B :
-					reactR2_R2B();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.stateisactive;
+
+public class StateIsActiveStatemachine implements IStateIsActiveStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean event1;
+
+		public void raiseEvent1() {
+			event1 = true;
+		}
+
+		public void clearEvents() {
+			event1 = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		r1_R1A, r1_R1B, r2_R2A, r2_R2B, $NullState$
+	};
+
+	private final State[] stateVector = new State[2];
+
+	private int nextStateIndex;
+
+	public StateIsActiveStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 2; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.r1_R1A;
+
+		nextStateIndex = 1;
+		stateVector[1] = State.r2_R2A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case r1_R1A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case r1_R1B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		switch (stateVector[1]) {
+			case r2_R2A :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case r2_R2B :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case r1_R1A :
+				return stateVector[0] == State.r1_R1A;
+			case r1_R1B :
+				return stateVector[0] == State.r1_R1B;
+			case r2_R2A :
+				return stateVector[1] == State.r2_R2A;
+			case r2_R2B :
+				return stateVector[1] == State.r2_R2B;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseEvent1() {
+		sCInterface.raiseEvent1();
+	}
+
+	/* Entry action for statechart 'StateIsActive'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'StateIsActive'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state R1A. */
+	private void reactR1_R1A() {
+		if (isStateActive(State.r2_R2B)) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.r1_R1B;
+		}
+	}
+
+	/* The reactions of state R1B. */
+	private void reactR1_R1B() {
+	}
+
+	/* The reactions of state R2A. */
+	private void reactR2_R2A() {
+		if (sCInterface.event1) {
+			nextStateIndex = 1;
+			stateVector[1] = State.$NullState$;
+
+			nextStateIndex = 1;
+			stateVector[1] = State.r2_R2B;
+		}
+	}
+
+	/* The reactions of state R2B. */
+	private void reactR2_R2B() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case r1_R1A :
+					reactR1_R1A();
+					break;
+				case r1_R1B :
+					reactR1_R1B();
+					break;
+				case r2_R2A :
+					reactR2_R2A();
+					break;
+				case r2_R2B :
+					reactR2_R2B();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/stextkeywordsinstatesandregions/ISTextKeywordsInStatesAndRegionsStatemachine.java

@@ -1,16 +1,16 @@
-package org.yakindu.scr.stextkeywordsinstatesandregions;
-import org.yakindu.scr.IStatemachine;
-
-public interface ISTextKeywordsInStatesAndRegionsStatemachine
-		extends
-			IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE1();
-		public void raiseE2();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.stextkeywordsinstatesandregions;
+import org.yakindu.scr.IStatemachine;
+
+public interface ISTextKeywordsInStatesAndRegionsStatemachine
+		extends
+			IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE1();
+		public void raiseE2();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/stringexpressions/IStringExpressionsStatemachine.java

@@ -1,23 +1,23 @@
-package org.yakindu.scr.stringexpressions;
-import org.yakindu.scr.IStatemachine;
-
-public interface IStringExpressionsStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE1();
-		public String getMyString();
-		public void setMyString(String value);
-		public String getMyString2();
-		public void setMyString2(String value);
-		public String getQuotedString();
-		public void setQuotedString(String value);
-		public boolean getEquals();
-		public void setEquals(boolean value);
-		public boolean getNotEqual();
-		public void setNotEqual(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.stringexpressions;
+import org.yakindu.scr.IStatemachine;
+
+public interface IStringExpressionsStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE1();
+		public String getMyString();
+		public void setMyString(String value);
+		public String getMyString2();
+		public void setMyString2(String value);
+		public String getQuotedString();
+		public void setQuotedString(String value);
+		public boolean getEquals();
+		public void setEquals(boolean value);
+		public boolean getNotEqual();
+		public void setNotEqual(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/stringexpressions/StringExpressionsStatemachine.java

@@ -1,253 +1,262 @@
-package org.yakindu.scr.stringexpressions;
-
-public class StringExpressionsStatemachine
-		implements
-			IStringExpressionsStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e1;
-
-		public void raiseE1() {
-			e1 = true;
-		}
-
-		private String myString;
-
-		public String getMyString() {
-			return myString;
-		}
-
-		public void setMyString(String value) {
-			this.myString = value;
-		}
-
-		private String myString2;
-
-		public String getMyString2() {
-			return myString2;
-		}
-
-		public void setMyString2(String value) {
-			this.myString2 = value;
-		}
-
-		private String quotedString;
-
-		public String getQuotedString() {
-			return quotedString;
-		}
-
-		public void setQuotedString(String value) {
-			this.quotedString = value;
-		}
-
-		private boolean equals;
-
-		public boolean getEquals() {
-			return equals;
-		}
-
-		public void setEquals(boolean value) {
-			this.equals = value;
-		}
-
-		private boolean notEqual;
-
-		public boolean getNotEqual() {
-			return notEqual;
-		}
-
-		public void setNotEqual(boolean value) {
-			this.notEqual = value;
-		}
-
-		public void clearEvents() {
-			e1 = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_StateA, main_region_StateB, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public StringExpressionsStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.myString = "";
-
-		sCInterface.myString2 = "";
-
-		sCInterface.quotedString = "\"x\"";
-
-		sCInterface.equals = false;
-
-		sCInterface.notEqual = false;
-	}
-
-	public void enter() {
-		entryAction();
-
-		sCInterface.myString = "hello";
-
-		sCInterface.myString2 = "world";
-
-		sCInterface.quotedString = "'y'";
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_StateA;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_StateA :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_StateB :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_StateA :
-				return stateVector[0] == State.main_region_StateA;
-			case main_region_StateB :
-				return stateVector[0] == State.main_region_StateB;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE1() {
-		sCInterface.raiseE1();
-	}
-
-	public String getMyString() {
-		return sCInterface.getMyString();
-	}
-
-	public void setMyString(String value) {
-		sCInterface.setMyString(value);
-	}
-	public String getMyString2() {
-		return sCInterface.getMyString2();
-	}
-
-	public void setMyString2(String value) {
-		sCInterface.setMyString2(value);
-	}
-	public String getQuotedString() {
-		return sCInterface.getQuotedString();
-	}
-
-	public void setQuotedString(String value) {
-		sCInterface.setQuotedString(value);
-	}
-	public boolean getEquals() {
-		return sCInterface.getEquals();
-	}
-
-	public void setEquals(boolean value) {
-		sCInterface.setEquals(value);
-	}
-	public boolean getNotEqual() {
-		return sCInterface.getNotEqual();
-	}
-
-	public void setNotEqual(boolean value) {
-		sCInterface.setNotEqual(value);
-	}
-
-	/* Entry action for statechart 'StringExpressions'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'StringExpressions'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state StateA. */
-	private void reactMain_region_StateA() {
-		if (sCInterface.e1) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.equals = (sCInterface.myString == null
-					? sCInterface.myString2 == null
-					: sCInterface.myString.equals(sCInterface.myString2));
-
-			sCInterface.notEqual = (sCInterface.myString == null
-					? sCInterface.myString2 == null
-					: !sCInterface.myString.equals(sCInterface.myString2));
-
-			sCInterface.quotedString = "\"z\"";
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_StateB;
-		}
-	}
-
-	/* The reactions of state StateB. */
-	private void reactMain_region_StateB() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_StateA :
-					reactMain_region_StateA();
-					break;
-				case main_region_StateB :
-					reactMain_region_StateB();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.stringexpressions;
+
+public class StringExpressionsStatemachine
+		implements
+			IStringExpressionsStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e1;
+
+		public void raiseE1() {
+			e1 = true;
+		}
+
+		private String myString;
+
+		public String getMyString() {
+			return myString;
+		}
+
+		public void setMyString(String value) {
+			this.myString = value;
+		}
+
+		private String myString2;
+
+		public String getMyString2() {
+			return myString2;
+		}
+
+		public void setMyString2(String value) {
+			this.myString2 = value;
+		}
+
+		private String quotedString;
+
+		public String getQuotedString() {
+			return quotedString;
+		}
+
+		public void setQuotedString(String value) {
+			this.quotedString = value;
+		}
+
+		private boolean equals;
+
+		public boolean getEquals() {
+			return equals;
+		}
+
+		public void setEquals(boolean value) {
+			this.equals = value;
+		}
+
+		private boolean notEqual;
+
+		public boolean getNotEqual() {
+			return notEqual;
+		}
+
+		public void setNotEqual(boolean value) {
+			this.notEqual = value;
+		}
+
+		public void clearEvents() {
+			e1 = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_StateA, main_region_StateB, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public StringExpressionsStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.myString = "";
+
+		sCInterface.myString2 = "";
+
+		sCInterface.quotedString = "\"x\"";
+
+		sCInterface.equals = false;
+
+		sCInterface.notEqual = false;
+	}
+
+	public void enter() {
+		entryAction();
+
+		sCInterface.myString = "hello";
+
+		sCInterface.myString2 = "world";
+
+		sCInterface.quotedString = "'y'";
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_StateA;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_StateA :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_StateB :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_StateA :
+				return stateVector[0] == State.main_region_StateA;
+			case main_region_StateB :
+				return stateVector[0] == State.main_region_StateB;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE1() {
+		sCInterface.raiseE1();
+	}
+
+	public String getMyString() {
+		return sCInterface.getMyString();
+	}
+
+	public void setMyString(String value) {
+		sCInterface.setMyString(value);
+	}
+	public String getMyString2() {
+		return sCInterface.getMyString2();
+	}
+
+	public void setMyString2(String value) {
+		sCInterface.setMyString2(value);
+	}
+	public String getQuotedString() {
+		return sCInterface.getQuotedString();
+	}
+
+	public void setQuotedString(String value) {
+		sCInterface.setQuotedString(value);
+	}
+	public boolean getEquals() {
+		return sCInterface.getEquals();
+	}
+
+	public void setEquals(boolean value) {
+		sCInterface.setEquals(value);
+	}
+	public boolean getNotEqual() {
+		return sCInterface.getNotEqual();
+	}
+
+	public void setNotEqual(boolean value) {
+		sCInterface.setNotEqual(value);
+	}
+
+	/* Entry action for statechart 'StringExpressions'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'StringExpressions'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state StateA. */
+	private void reactMain_region_StateA() {
+		if (sCInterface.e1) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.equals = (sCInterface.myString == null
+					? sCInterface.myString2 == null
+					: sCInterface.myString.equals(sCInterface.myString2));
+
+			sCInterface.notEqual = (sCInterface.myString == null
+					? sCInterface.myString2 == null
+					: !sCInterface.myString.equals(sCInterface.myString2));
+
+			sCInterface.quotedString = "\"z\"";
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_StateB;
+		}
+	}
+
+	/* The reactions of state StateB. */
+	private void reactMain_region_StateB() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_StateA :
+					reactMain_region_StateA();
+					break;
+				case main_region_StateB :
+					reactMain_region_StateB();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/syncfork/ISyncForkStatemachine.java

@@ -1,14 +1,14 @@
-package org.yakindu.scr.syncfork;
-import org.yakindu.scr.IStatemachine;
-
-public interface ISyncForkStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public void raiseF();
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.syncfork;
+import org.yakindu.scr.IStatemachine;
+
+public interface ISyncForkStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public void raiseF();
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/syncfork/SyncForkStatemachine.java

@@ -1,305 +1,314 @@
-package org.yakindu.scr.syncfork;
-
-public class SyncForkStatemachine implements ISyncForkStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private boolean f;
-
-		public void raiseF() {
-			f = true;
-		}
-
-		public void clearEvents() {
-			e = false;
-			f = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, main_region_B, main_region_B_r1_C1, main_region_B_r1_C2, main_region_B_r2_D1, main_region_B_r2_D2, $NullState$
-	};
-
-	private final State[] stateVector = new State[2];
-
-	private int nextStateIndex;
-
-	public SyncForkStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 2; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B_r1_C1 :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B_r1_C2 :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		switch (stateVector[1]) {
-			case main_region_B_r2_D1 :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case main_region_B_r2_D2 :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0].ordinal() >= State.main_region_B
-						.ordinal()
-						&& stateVector[0].ordinal() <= State.main_region_B_r2_D2
-								.ordinal();
-			case main_region_B_r1_C1 :
-				return stateVector[0] == State.main_region_B_r1_C1;
-			case main_region_B_r1_C2 :
-				return stateVector[0] == State.main_region_B_r1_C2;
-			case main_region_B_r2_D1 :
-				return stateVector[1] == State.main_region_B_r2_D1;
-			case main_region_B_r2_D2 :
-				return stateVector[1] == State.main_region_B_r2_D2;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-	public void raiseF() {
-		sCInterface.raiseF();
-	}
-
-	/* Entry action for statechart 'SyncFork'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'SyncFork'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			reactSyncFork_main_region__sync0();
-		} else {
-			if (sCInterface.f) {
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				nextStateIndex = 0;
-				stateVector[0] = State.main_region_B_r1_C1;
-
-				nextStateIndex = 1;
-				stateVector[1] = State.main_region_B_r2_D1;
-			}
-		}
-	}
-
-	/* The reactions of state C1. */
-	private void reactMain_region_B_r1_C1() {
-		if (sCInterface.e) {
-			switch (stateVector[0]) {
-				case main_region_B_r1_C1 :
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-					break;
-
-				case main_region_B_r1_C2 :
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-					break;
-
-				default :
-					break;
-			}
-
-			switch (stateVector[1]) {
-				case main_region_B_r2_D1 :
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-					break;
-
-				case main_region_B_r2_D2 :
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-					break;
-
-				default :
-					break;
-			}
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		} else {
-			if (sCInterface.f) {
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				nextStateIndex = 0;
-				stateVector[0] = State.main_region_B_r1_C2;
-			}
-		}
-	}
-
-	/* The reactions of state C2. */
-	private void reactMain_region_B_r1_C2() {
-		if (sCInterface.e) {
-			switch (stateVector[0]) {
-				case main_region_B_r1_C1 :
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-					break;
-
-				case main_region_B_r1_C2 :
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-					break;
-
-				default :
-					break;
-			}
-
-			switch (stateVector[1]) {
-				case main_region_B_r2_D1 :
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-					break;
-
-				case main_region_B_r2_D2 :
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-					break;
-
-				default :
-					break;
-			}
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		} else {
-		}
-	}
-
-	/* The reactions of state D1. */
-	private void reactMain_region_B_r2_D1() {
-		if (sCInterface.f) {
-			nextStateIndex = 1;
-			stateVector[1] = State.$NullState$;
-
-			nextStateIndex = 1;
-			stateVector[1] = State.main_region_B_r2_D2;
-		}
-	}
-
-	/* The reactions of state D2. */
-	private void reactMain_region_B_r2_D2() {
-	}
-
-	/* The reactions of state null. */
-	private void reactSyncFork_main_region__sync0() {
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_B_r1_C2;
-
-		nextStateIndex = 1;
-		stateVector[1] = State.main_region_B_r2_D2;
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B_r1_C1 :
-					reactMain_region_B_r1_C1();
-					break;
-				case main_region_B_r1_C2 :
-					reactMain_region_B_r1_C2();
-					break;
-				case main_region_B_r2_D1 :
-					reactMain_region_B_r2_D1();
-					break;
-				case main_region_B_r2_D2 :
-					reactMain_region_B_r2_D2();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.syncfork;
+
+public class SyncForkStatemachine implements ISyncForkStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private boolean f;
+
+		public void raiseF() {
+			f = true;
+		}
+
+		public void clearEvents() {
+			e = false;
+			f = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, main_region_B, main_region_B_r1_C1, main_region_B_r1_C2, main_region_B_r2_D1, main_region_B_r2_D2, $NullState$
+	};
+
+	private final State[] stateVector = new State[2];
+
+	private int nextStateIndex;
+
+	public SyncForkStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 2; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B_r1_C1 :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B_r1_C2 :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		switch (stateVector[1]) {
+			case main_region_B_r2_D1 :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case main_region_B_r2_D2 :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0].ordinal() >= State.main_region_B
+						.ordinal()
+						&& stateVector[0].ordinal() <= State.main_region_B_r2_D2
+								.ordinal();
+			case main_region_B_r1_C1 :
+				return stateVector[0] == State.main_region_B_r1_C1;
+			case main_region_B_r1_C2 :
+				return stateVector[0] == State.main_region_B_r1_C2;
+			case main_region_B_r2_D1 :
+				return stateVector[1] == State.main_region_B_r2_D1;
+			case main_region_B_r2_D2 :
+				return stateVector[1] == State.main_region_B_r2_D2;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+	public void raiseF() {
+		sCInterface.raiseF();
+	}
+
+	/* Entry action for statechart 'SyncFork'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'SyncFork'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.e) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			reactSyncFork_main_region__sync0();
+		} else {
+			if (sCInterface.f) {
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				nextStateIndex = 0;
+				stateVector[0] = State.main_region_B_r1_C1;
+
+				nextStateIndex = 1;
+				stateVector[1] = State.main_region_B_r2_D1;
+			}
+		}
+	}
+
+	/* The reactions of state C1. */
+	private void reactMain_region_B_r1_C1() {
+		if (sCInterface.e) {
+			switch (stateVector[0]) {
+				case main_region_B_r1_C1 :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				case main_region_B_r1_C2 :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			switch (stateVector[1]) {
+				case main_region_B_r2_D1 :
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+					break;
+
+				case main_region_B_r2_D2 :
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		} else {
+			if (sCInterface.f) {
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				nextStateIndex = 0;
+				stateVector[0] = State.main_region_B_r1_C2;
+			}
+		}
+	}
+
+	/* The reactions of state C2. */
+	private void reactMain_region_B_r1_C2() {
+		if (sCInterface.e) {
+			switch (stateVector[0]) {
+				case main_region_B_r1_C1 :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				case main_region_B_r1_C2 :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			switch (stateVector[1]) {
+				case main_region_B_r2_D1 :
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+					break;
+
+				case main_region_B_r2_D2 :
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		} else {
+		}
+	}
+
+	/* The reactions of state D1. */
+	private void reactMain_region_B_r2_D1() {
+		if (sCInterface.f) {
+			nextStateIndex = 1;
+			stateVector[1] = State.$NullState$;
+
+			nextStateIndex = 1;
+			stateVector[1] = State.main_region_B_r2_D2;
+		}
+	}
+
+	/* The reactions of state D2. */
+	private void reactMain_region_B_r2_D2() {
+	}
+
+	/* The reactions of state null. */
+	private void reactSyncFork_main_region__sync0() {
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_B_r1_C2;
+
+		nextStateIndex = 1;
+		stateVector[1] = State.main_region_B_r2_D2;
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B_r1_C1 :
+					reactMain_region_B_r1_C1();
+					break;
+				case main_region_B_r1_C2 :
+					reactMain_region_B_r1_C2();
+					break;
+				case main_region_B_r2_D1 :
+					reactMain_region_B_r2_D1();
+					break;
+				case main_region_B_r2_D2 :
+					reactMain_region_B_r2_D2();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/syncjoin/ISyncJoinStatemachine.java

@@ -1,18 +1,18 @@
-package org.yakindu.scr.syncjoin;
-import org.yakindu.scr.IStatemachine;
-
-public interface ISyncJoinStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public void raiseF();
-		public void raiseJc();
-		public void raiseJd();
-		public int getX();
-		public void setX(int value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.syncjoin;
+import org.yakindu.scr.IStatemachine;
+
+public interface ISyncJoinStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public void raiseF();
+		public void raiseJc();
+		public void raiseJd();
+		public long getX();
+		public void setX(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/syncjoin/SyncJoinStatemachine.java

@@ -1,337 +1,346 @@
-package org.yakindu.scr.syncjoin;
-
-public class SyncJoinStatemachine implements ISyncJoinStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private boolean f;
-
-		public void raiseF() {
-			f = true;
-		}
-
-		private boolean jc;
-
-		public void raiseJc() {
-			jc = true;
-		}
-
-		private boolean jd;
-
-		public void raiseJd() {
-			jd = true;
-		}
-
-		private int x;
-
-		public int getX() {
-			return x;
-		}
-
-		public void setX(int value) {
-			this.x = value;
-		}
-
-		public void clearEvents() {
-			e = false;
-			f = false;
-			jc = false;
-			jd = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, main_region_B, main_region_B_r1_C1, main_region_B_r1_C2, main_region_B_r2_D1, main_region_B_r2_D2, $NullState$
-	};
-
-	private final State[] stateVector = new State[2];
-
-	private int nextStateIndex;
-
-	public SyncJoinStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 2; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.x = 0;
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_B_r1_C1;
-
-		nextStateIndex = 1;
-		stateVector[1] = State.main_region_B_r2_D1;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B_r1_C1 :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B_r1_C2 :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		switch (stateVector[1]) {
-			case main_region_B_r2_D1 :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case main_region_B_r2_D2 :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0].ordinal() >= State.main_region_B
-						.ordinal()
-						&& stateVector[0].ordinal() <= State.main_region_B_r2_D2
-								.ordinal();
-			case main_region_B_r1_C1 :
-				return stateVector[0] == State.main_region_B_r1_C1;
-			case main_region_B_r1_C2 :
-				return stateVector[0] == State.main_region_B_r1_C2;
-			case main_region_B_r2_D1 :
-				return stateVector[1] == State.main_region_B_r2_D1;
-			case main_region_B_r2_D2 :
-				return stateVector[1] == State.main_region_B_r2_D2;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-	public void raiseF() {
-		sCInterface.raiseF();
-	}
-	public void raiseJc() {
-		sCInterface.raiseJc();
-	}
-	public void raiseJd() {
-		sCInterface.raiseJd();
-	}
-
-	public int getX() {
-		return sCInterface.getX();
-	}
-
-	public void setX(int value) {
-		sCInterface.setX(value);
-	}
-
-	/* Entry action for statechart 'SyncJoin'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'SyncJoin'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.e || sCInterface.f) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_B_r1_C1;
-
-			nextStateIndex = 1;
-			stateVector[1] = State.main_region_B_r2_D1;
-		}
-	}
-
-	/* The reactions of state C1. */
-	private void reactMain_region_B_r1_C1() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_B_r1_C2;
-		}
-	}
-
-	/* The reactions of state C2. */
-	private void reactMain_region_B_r1_C2() {
-		if (sCInterface.jc && isStateActive(State.main_region_B_r2_D2)
-				&& sCInterface.jd) {
-			switch (stateVector[0]) {
-				case main_region_B_r1_C1 :
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-					break;
-
-				case main_region_B_r1_C2 :
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-					break;
-
-				default :
-					break;
-			}
-
-			switch (stateVector[1]) {
-				case main_region_B_r2_D1 :
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-					break;
-
-				case main_region_B_r2_D2 :
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-					break;
-
-				default :
-					break;
-			}
-
-			reactSyncJoin_main_region__sync0();
-		}
-	}
-
-	/* The reactions of state D1. */
-	private void reactMain_region_B_r2_D1() {
-		if (sCInterface.f) {
-			nextStateIndex = 1;
-			stateVector[1] = State.$NullState$;
-
-			nextStateIndex = 1;
-			stateVector[1] = State.main_region_B_r2_D2;
-		}
-	}
-
-	/* The reactions of state D2. */
-	private void reactMain_region_B_r2_D2() {
-		if (sCInterface.jd && isStateActive(State.main_region_B_r1_C2)
-				&& sCInterface.jc) {
-			switch (stateVector[0]) {
-				case main_region_B_r1_C1 :
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-					break;
-
-				case main_region_B_r1_C2 :
-					nextStateIndex = 0;
-					stateVector[0] = State.$NullState$;
-					break;
-
-				default :
-					break;
-			}
-
-			switch (stateVector[1]) {
-				case main_region_B_r2_D1 :
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-					break;
-
-				case main_region_B_r2_D2 :
-					nextStateIndex = 1;
-					stateVector[1] = State.$NullState$;
-					break;
-
-				default :
-					break;
-			}
-
-			reactSyncJoin_main_region__sync0();
-		}
-	}
-
-	/* The reactions of state null. */
-	private void reactSyncJoin_main_region__sync0() {
-		sCInterface.x += 1;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B_r1_C1 :
-					reactMain_region_B_r1_C1();
-					break;
-				case main_region_B_r1_C2 :
-					reactMain_region_B_r1_C2();
-					break;
-				case main_region_B_r2_D1 :
-					reactMain_region_B_r2_D1();
-					break;
-				case main_region_B_r2_D2 :
-					reactMain_region_B_r2_D2();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.syncjoin;
+
+public class SyncJoinStatemachine implements ISyncJoinStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private boolean f;
+
+		public void raiseF() {
+			f = true;
+		}
+
+		private boolean jc;
+
+		public void raiseJc() {
+			jc = true;
+		}
+
+		private boolean jd;
+
+		public void raiseJd() {
+			jd = true;
+		}
+
+		private long x;
+
+		public long getX() {
+			return x;
+		}
+
+		public void setX(long value) {
+			this.x = value;
+		}
+
+		public void clearEvents() {
+			e = false;
+			f = false;
+			jc = false;
+			jd = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, main_region_B, main_region_B_r1_C1, main_region_B_r1_C2, main_region_B_r2_D1, main_region_B_r2_D2, $NullState$
+	};
+
+	private final State[] stateVector = new State[2];
+
+	private int nextStateIndex;
+
+	public SyncJoinStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 2; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.x = 0;
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_B_r1_C1;
+
+		nextStateIndex = 1;
+		stateVector[1] = State.main_region_B_r2_D1;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B_r1_C1 :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B_r1_C2 :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		switch (stateVector[1]) {
+			case main_region_B_r2_D1 :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case main_region_B_r2_D2 :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0].ordinal() >= State.main_region_B
+						.ordinal()
+						&& stateVector[0].ordinal() <= State.main_region_B_r2_D2
+								.ordinal();
+			case main_region_B_r1_C1 :
+				return stateVector[0] == State.main_region_B_r1_C1;
+			case main_region_B_r1_C2 :
+				return stateVector[0] == State.main_region_B_r1_C2;
+			case main_region_B_r2_D1 :
+				return stateVector[1] == State.main_region_B_r2_D1;
+			case main_region_B_r2_D2 :
+				return stateVector[1] == State.main_region_B_r2_D2;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+	public void raiseF() {
+		sCInterface.raiseF();
+	}
+	public void raiseJc() {
+		sCInterface.raiseJc();
+	}
+	public void raiseJd() {
+		sCInterface.raiseJd();
+	}
+
+	public long getX() {
+		return sCInterface.getX();
+	}
+
+	public void setX(long value) {
+		sCInterface.setX(value);
+	}
+
+	/* Entry action for statechart 'SyncJoin'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'SyncJoin'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.e || sCInterface.f) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_B_r1_C1;
+
+			nextStateIndex = 1;
+			stateVector[1] = State.main_region_B_r2_D1;
+		}
+	}
+
+	/* The reactions of state C1. */
+	private void reactMain_region_B_r1_C1() {
+		if (sCInterface.e) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_B_r1_C2;
+		}
+	}
+
+	/* The reactions of state C2. */
+	private void reactMain_region_B_r1_C2() {
+		if (sCInterface.jc && isStateActive(State.main_region_B_r2_D2)
+				&& sCInterface.jd) {
+			switch (stateVector[0]) {
+				case main_region_B_r1_C1 :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				case main_region_B_r1_C2 :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			switch (stateVector[1]) {
+				case main_region_B_r2_D1 :
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+					break;
+
+				case main_region_B_r2_D2 :
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			reactSyncJoin_main_region__sync0();
+		}
+	}
+
+	/* The reactions of state D1. */
+	private void reactMain_region_B_r2_D1() {
+		if (sCInterface.f) {
+			nextStateIndex = 1;
+			stateVector[1] = State.$NullState$;
+
+			nextStateIndex = 1;
+			stateVector[1] = State.main_region_B_r2_D2;
+		}
+	}
+
+	/* The reactions of state D2. */
+	private void reactMain_region_B_r2_D2() {
+		if (sCInterface.jd && isStateActive(State.main_region_B_r1_C2)
+				&& sCInterface.jc) {
+			switch (stateVector[0]) {
+				case main_region_B_r1_C1 :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				case main_region_B_r1_C2 :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			switch (stateVector[1]) {
+				case main_region_B_r2_D1 :
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+					break;
+
+				case main_region_B_r2_D2 :
+					nextStateIndex = 1;
+					stateVector[1] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			reactSyncJoin_main_region__sync0();
+		}
+	}
+
+	/* The reactions of state null. */
+	private void reactSyncJoin_main_region__sync0() {
+		sCInterface.x += 1;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B_r1_C1 :
+					reactMain_region_B_r1_C1();
+					break;
+				case main_region_B_r1_C2 :
+					reactMain_region_B_r1_C2();
+					break;
+				case main_region_B_r2_D1 :
+					reactMain_region_B_r2_D1();
+					break;
+				case main_region_B_r2_D2 :
+					reactMain_region_B_r2_D2();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/timedtransitions/TimedTransitionsStatemachine.java

@@ -67,6 +67,9 @@ public class TimedTransitionsStatemachine
 		exitAction();
 	}
 
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
 	protected void clearEvents() {
 
 		for (int i = 0; i < timeEvents.length; i++) {
@@ -74,9 +77,15 @@ public class TimedTransitionsStatemachine
 		}
 	}
 
+	/**
+	 * This method resets the outgoing events.
+	 */
 	protected void clearOutEvents() {
 	}
 
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
 	public boolean isStateActive(State state) {
 		switch (state) {
 			case main_region_Start :

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/transitionwithoutcondition/ITransitionWithoutConditionStatemachine.java

@@ -1,6 +1,6 @@
-package org.yakindu.scr.transitionwithoutcondition;
-import org.yakindu.scr.IStatemachine;
-
-public interface ITransitionWithoutConditionStatemachine extends IStatemachine {
-
-}
+package org.yakindu.scr.transitionwithoutcondition;
+import org.yakindu.scr.IStatemachine;
+
+public interface ITransitionWithoutConditionStatemachine extends IStatemachine {
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/transitionwithoutcondition/TransitionWithoutConditionStatemachine.java

@@ -1,114 +1,123 @@
-package org.yakindu.scr.transitionwithoutcondition;
-
-public class TransitionWithoutConditionStatemachine
-		implements
-			ITransitionWithoutConditionStatemachine {
-
-	public enum State {
-		main_region_A, main_region_B, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public TransitionWithoutConditionStatemachine() {
-
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-	}
-
-	public void enter() {
-		entryAction();
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			case main_region_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case main_region_B :
-				return stateVector[0] == State.main_region_B;
-			default :
-				return false;
-		}
-	}
-
-	/* Entry action for statechart 'TransitionWithoutCondition'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'TransitionWithoutCondition'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		nextStateIndex = 0;
-		stateVector[0] = State.$NullState$;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_B;
-	}
-
-	/* The reactions of state B. */
-	private void reactMain_region_B() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B :
-					reactMain_region_B();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.transitionwithoutcondition;
+
+public class TransitionWithoutConditionStatemachine
+		implements
+			ITransitionWithoutConditionStatemachine {
+
+	public enum State {
+		main_region_A, main_region_B, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public TransitionWithoutConditionStatemachine() {
+
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+	}
+
+	public void enter() {
+		entryAction();
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			case main_region_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case main_region_B :
+				return stateVector[0] == State.main_region_B;
+			default :
+				return false;
+		}
+	}
+
+	/* Entry action for statechart 'TransitionWithoutCondition'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'TransitionWithoutCondition'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_B;
+	}
+
+	/* The reactions of state B. */
+	private void reactMain_region_B() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case main_region_B :
+					reactMain_region_B();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/valuedevents/IValuedEventsStatemachine.java

@@ -1,15 +1,15 @@
-package org.yakindu.scr.valuedevents;
-import org.yakindu.scr.IStatemachine;
-
-public interface IValuedEventsStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseIntegerEvent(int value);
-		public int getMyVar();
-		public void setMyVar(int value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.valuedevents;
+import org.yakindu.scr.IStatemachine;
+
+public interface IValuedEventsStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseIntegerEvent(long value);
+		public long getMyVar();
+		public void setMyVar(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

test-plugins/org.yakindu.sct.generator.java.test/src-gen/org/yakindu/scr/valuedevents/ValuedEventsStatemachine.java

@@ -1,195 +1,204 @@
-package org.yakindu.scr.valuedevents;
-
-public class ValuedEventsStatemachine implements IValuedEventsStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean integerEvent;
-
-		private int integerEventValue;
-
-		public void raiseIntegerEvent(int value) {
-			integerEvent = true;
-			integerEventValue = value;
-		}
-
-		private int getIntegerEventValue() {
-			if (!integerEvent)
-				throw new IllegalStateException(
-						"Illegal event value acces. Event IntegerEvent is not raised!");
-			return integerEventValue;
-		}
-
-		private int myVar;
-
-		public int getMyVar() {
-			return myVar;
-		}
-
-		public void setMyVar(int value) {
-			this.myVar = value;
-		}
-
-		public void clearEvents() {
-			integerEvent = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, _region1_B, _region1_C, $NullState$
-	};
-
-	private final State[] stateVector = new State[2];
-
-	private int nextStateIndex;
-
-	public ValuedEventsStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 2; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.myVar = 0;
-	}
-
-	public void enter() {
-		entryAction();
-
-		sCInterface.raiseIntegerEvent(2 * 21);
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A;
-
-		nextStateIndex = 1;
-		stateVector[1] = State._region1_B;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		switch (stateVector[1]) {
-			case _region1_B :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			case _region1_C :
-				nextStateIndex = 1;
-				stateVector[1] = State.$NullState$;
-				break;
-
-			default :
-				break;
-		}
-
-		exitAction();
-	}
-
-	protected void clearEvents() {
-		sCInterface.clearEvents();
-
-	}
-
-	protected void clearOutEvents() {
-	}
-
-	public boolean isStateActive(State state) {
-		switch (state) {
-			case main_region_A :
-				return stateVector[0] == State.main_region_A;
-			case _region1_B :
-				return stateVector[1] == State._region1_B;
-			case _region1_C :
-				return stateVector[1] == State._region1_C;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseIntegerEvent(int value) {
-		sCInterface.raiseIntegerEvent(value);
-	}
-
-	public int getMyVar() {
-		return sCInterface.getMyVar();
-	}
-
-	public void setMyVar(int value) {
-		sCInterface.setMyVar(value);
-	}
-
-	/* Entry action for statechart 'ValuedEvents'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'ValuedEvents'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-	}
-
-	/* The reactions of state B. */
-	private void reactRegion1_B() {
-		if (sCInterface.integerEvent) {
-			nextStateIndex = 1;
-			stateVector[1] = State.$NullState$;
-
-			sCInterface.myVar = sCInterface.integerEventValue;
-
-			nextStateIndex = 1;
-			stateVector[1] = State._region1_C;
-		}
-	}
-
-	/* The reactions of state C. */
-	private void reactRegion1_C() {
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case _region1_B :
-					reactRegion1_B();
-					break;
-				case _region1_C :
-					reactRegion1_C();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.valuedevents;
+
+public class ValuedEventsStatemachine implements IValuedEventsStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean integerEvent;
+
+		private long integerEventValue;
+
+		public void raiseIntegerEvent(long value) {
+			integerEvent = true;
+			integerEventValue = value;
+		}
+
+		private long getIntegerEventValue() {
+			if (!integerEvent)
+				throw new IllegalStateException(
+						"Illegal event value acces. Event IntegerEvent is not raised!");
+			return integerEventValue;
+		}
+
+		private long myVar;
+
+		public long getMyVar() {
+			return myVar;
+		}
+
+		public void setMyVar(long value) {
+			this.myVar = value;
+		}
+
+		public void clearEvents() {
+			integerEvent = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, _region1_B, _region1_C, $NullState$
+	};
+
+	private final State[] stateVector = new State[2];
+
+	private int nextStateIndex;
+
+	public ValuedEventsStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 2; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.myVar = 0;
+	}
+
+	public void enter() {
+		entryAction();
+
+		sCInterface.raiseIntegerEvent(2 * 21);
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A;
+
+		nextStateIndex = 1;
+		stateVector[1] = State._region1_B;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		switch (stateVector[1]) {
+			case _region1_B :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			case _region1_C :
+				nextStateIndex = 1;
+				stateVector[1] = State.$NullState$;
+				break;
+
+			default :
+				break;
+		}
+
+		exitAction();
+	}
+
+	/**
+	 * This method resets the incoming events (time events included).
+	 */
+	protected void clearEvents() {
+		sCInterface.clearEvents();
+
+	}
+
+	/**
+	 * This method resets the outgoing events.
+	 */
+	protected void clearOutEvents() {
+	}
+
+	/**
+	 * Returns true if the given state is currently active otherwise false.
+	 */
+	public boolean isStateActive(State state) {
+		switch (state) {
+			case main_region_A :
+				return stateVector[0] == State.main_region_A;
+			case _region1_B :
+				return stateVector[1] == State._region1_B;
+			case _region1_C :
+				return stateVector[1] == State._region1_C;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseIntegerEvent(long value) {
+		sCInterface.raiseIntegerEvent(value);
+	}
+
+	public long getMyVar() {
+		return sCInterface.getMyVar();
+	}
+
+	public void setMyVar(long value) {
+		sCInterface.setMyVar(value);
+	}
+
+	/* Entry action for statechart 'ValuedEvents'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'ValuedEvents'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+	}
+
+	/* The reactions of state B. */
+	private void reactRegion1_B() {
+		if (sCInterface.integerEvent) {
+			nextStateIndex = 1;
+			stateVector[1] = State.$NullState$;
+
+			sCInterface.myVar = sCInterface.integerEventValue;
+
+			nextStateIndex = 1;
+			stateVector[1] = State._region1_C;
+		}
+	}
+
+	/* The reactions of state C. */
+	private void reactRegion1_C() {
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A :
+					reactMain_region_A();
+					break;
+				case _region1_B :
+					reactRegion1_B();
+					break;
+				case _region1_C :
+					reactRegion1_C();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}