Fixed generated isStateActive(...) method.

plugins/org.yakindu.sct.generator.java/src/org/yakindu/sct/generator/java/extensions/ExecutionModelExtensions.java

@@ -1,6 +1,13 @@
 package org.yakindu.sct.generator.java.extensions;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.model.sexec.ExecutionNode;
+import org.yakindu.sct.model.sexec.ExecutionRegion;
+import org.yakindu.sct.model.sexec.ExecutionScope;
+import org.yakindu.sct.model.sexec.ExecutionState;
 import org.yakindu.sct.model.sgraph.Scope;
 
 public class ExecutionModelExtensions {
@@ -17,4 +24,22 @@ public class ExecutionModelExtensions {
 //		}
 		return scopeIndex;
 	}
+	
+	public static List<ExecutionState> getSubStates(ExecutionState state) {
+		List<ExecutionState> list = new ArrayList<ExecutionState>();
+		for (ExecutionScope subScope: state.getSubScopes()) {
+			if (subScope instanceof ExecutionState) {
+				list.add((ExecutionState) subScope);
+			}
+			else if (subScope instanceof ExecutionRegion) {
+				for (ExecutionNode node: ((ExecutionRegion)subScope).getNodes()) {
+					if (node instanceof ExecutionState) {
+						list.add((ExecutionState) node);
+						list.addAll(getSubStates((ExecutionState) node));
+					}
+				}
+			}
+		}
+		return list;
+	}
 }

plugins/org.yakindu.sct.generator.java/src/org/yakindu/sct/generator/java/templates/CoreStatemachine.xpt

@@ -55,9 +55,9 @@ import java.util.List;
 	
 	public enum State {
 		«FOREACH states AS state-»
-	      «state.getName()»,
-	    «ENDFOREACH-»
-	    «getNullStateName()»
+			«state.getName()»,
+		«ENDFOREACH-»
+		«getNullStateName()»
 	};
 	
 	«FOREACH getInternalScopeVariables() AS variable-»

plugins/org.yakindu.sct.generator.java/src/org/yakindu/sct/generator/java/templates/ExecutionModelExtensions.ext

@@ -29,6 +29,9 @@ getInternalScopeEvents(ExecutionFlow this) : getInternalScopeDeclarations().type
 getInternalScopeVoidEvents(ExecutionFlow this) :getInternalScopeEvents().select(e|e.type.isVoid());
 getInternalScopeValuedEvents(ExecutionFlow this) : getInternalScopeEvents().select(e|!e.type.isVoid());
 
+List[ExecutionState] getSubStates(ExecutionState state) :
+	JAVA org.yakindu.sct.generator.java.extensions.ExecutionModelExtensions.getSubStates(org.yakindu.sct.model.sexec.ExecutionState);
+
 getDefaultInterface(ExecutionFlow this) :
 	getInterfaceScope().select(interface|interface.name == null || interface.name == "");
 

plugins/org.yakindu.sct.generator.java/src/org/yakindu/sct/generator/java/templates/Naming.ext

@@ -193,7 +193,7 @@ String getEventValueIdentifier(ElementReferenceExpression this) : this.reference
 
 String getter(Event this) : "get"+this.getEventName()+"()";
 
-String getEventName(TimeEvent this) : name.replaceAll(" ","").toFirstUpper();
+String getEventName(TimeEvent this) : name.replaceAll("\\.","_").toFirstUpper();
 
 String getEventIdentifier(Event this):
 	getEventName().toFirstLower();

plugins/org.yakindu.sct.generator.java/src/org/yakindu/sct/generator/java/templates/StatemachineCycleBased.xpt

@@ -82,12 +82,23 @@ public class
 	}
 	
 	public boolean isStateActive(State state){
+		switch (state) {
+			«FOREACH states AS s»
+			case «s.getName()» : 
+				return «IF s.leaf»stateVector[«s.stateVector.offset»] == State.«s.getName()»
+				«ELSE»stateVector[«s.stateVector.offset»].ordinal() >= State.«s.getName()».ordinal()
+					&& stateVector[«s.stateVector.offset»].ordinal() <= State.«s.getSubStates().last().getName()».ordinal()«ENDIF»;
+			«ENDFOREACH»
+			default: return false;
+		}
+		/*
 		for (int i=0;i<stateVector.length;i++){
 			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		*/
 	}
 	
 	«IF isTimedStatemachine()-»

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

@@ -1,7 +1,9 @@
 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;
@@ -13,65 +15,174 @@ import java.util.concurrent.locks.ReentrantReadWriteLock;
  */
 public class RuntimeService {
 
+	private static RuntimeService runtimeService;
+
 	private Timer timer = new Timer();
 
-	private List<IStatemachine> statemachineSet = new LinkedList<IStatemachine>();
+	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 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 
-	private TimerTask timerTask = new TimerTask() {
+		private boolean isPaused = false;
 
 		@Override
 		public void run() {
 			lock.readLock().lock();
-			for (IStatemachine statemachine : statemachineSet) {
-				statemachine.runCycle();
+			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.
+	}
 
 	/**
-	 * Create runtime service.
+	 * Returns the {@code RuntimeService} instance as singleton.
 	 * 
-	 * @param cyclePeriod
-	 *            : The period with which the registered state machines run
-	 *            cycle method is called.
+	 * @return The singleton {@code RuntimeService} instance
 	 */
-	public RuntimeService(long cyclePeriod) {
-		timer.scheduleAtFixedRate(timerTask, 0, cyclePeriod);
+	public static RuntimeService getInstance() {
+		if (runtimeService == null) {
+			runtimeService = new RuntimeService();
+		}
+		return runtimeService;
 	}
 
 	/**
-	 * Adds the given state machine to runtime service.
+	 * 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 addStatemachine(IStatemachine statemachine) {
-		lock.writeLock().lock();
-		boolean ret = statemachineSet.add(statemachine);
-		lock.writeLock().unlock();
-		return ret;
+	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);
+			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 removeStatemachine(IStatemachine statemachine) {
-		lock.writeLock().lock();
-		boolean ret = statemachineSet.remove(statemachine);
-		lock.writeLock().unlock();
-		return ret;
+	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 timer task.
+	 * 
+	 * @return {@code true} if poperly cancelled
+	 */
+	public boolean cancelAll(long cyclePeriod) {
+		if (timerTasks.containsKey(cyclePeriod)) {
+			TimerTask task = timerTasks.get(cyclePeriod);
+			task.cancel();
+			timer.purge();
+			timerTasks.remove(cyclePeriod);
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Pauses the execution of all statemachine which are registered for the
+	 * given cyclePeriod.
+	 * 
+	 * @param cyclePeriod
+	 * @return {@code true} if poperly paused
+	 * 
+	 */
+	public boolean pauseAll(long cyclePeriod) {
+		if (timerTasks.containsKey(cyclePeriod)) {
+			timerTasks.get(cyclePeriod).pause();
+			return true;
+		}
+		return false;
 	}
 
 	/**
-	 * Ends the runtime service.
+	 * Resumes the execution of all statemachine which are registered for the
+	 * given cyclePeriod.
+	 * 
+	 * @param cyclePeriod
+	 * @return {@code true} if poperly resumed
+	 * 
 	 */
-	public void cancel() {
-		timer.cancel();
+	public boolean resumeAll(long cyclePeriod) {
+		if (timerTasks.containsKey(cyclePeriod)) {
+			timerTasks.get(cyclePeriod).resume();
+			return true;
+		}
+		return false;
 	}
 }

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

@@ -53,5 +53,6 @@ public class TimerService implements ITimerService {
 	 */
 	public void cancel() {
 		timer.cancel();
+		timer.purge();
 	}
 }

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

@@ -49,12 +49,25 @@ public class AlwaysOncycleStatemachine implements IAlwaysOncycleStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {
@@ -71,7 +84,7 @@ public class AlwaysOncycleStatemachine implements IAlwaysOncycleStatemachine {
 
 	public void enter() {
 		entryActionAlwaysOncycle();
-		sCIDefault.setValue(0);
+		sCIDefault.value = 0;
 
 		nextStateIndex = 0;
 		stateVector[0] = State.Main_region_StateA;
@@ -84,7 +97,7 @@ public class AlwaysOncycleStatemachine implements IAlwaysOncycleStatemachine {
 
 			case Main_region_StateA :
 				stateVector[0] = State.$NullState$;
-				sCIDefault.setValue(0);
+				sCIDefault.value = 0;
 
 				break;
 
@@ -109,30 +122,30 @@ public class AlwaysOncycleStatemachine implements IAlwaysOncycleStatemachine {
 	}
 
 	private void reactMain_region_StateA() {
-		if ((sCIDefault.getValue() == 5)) {
+		if ((sCIDefault.value == 5)) {
 			stateVector[0] = State.$NullState$;
-			sCIDefault.setValue(0);
+			sCIDefault.value = 0;
 
 			nextStateIndex = 0;
 			stateVector[0] = State.Main_region_StateB;
 
 		} else {
-			sCIDefault.setValue(sCIDefault.getValue() + (1));
+			sCIDefault.value += 1;
 
 		}
 
 	}
 	private void reactMain_region_StateB() {
-		if ((sCIDefault.getValue() == 5)) {
+		if ((sCIDefault.value == 5)) {
 			stateVector[0] = State.$NullState$;
 
-			sCIDefault.setValue(0);
+			sCIDefault.value = 0;
 
 			nextStateIndex = 0;
 			stateVector[0] = State.Main_region_StateA;
 
 		} else {
-			sCIDefault.setValue(sCIDefault.getValue() + (1));
+			sCIDefault.value += 1;
 
 		}
 

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

@@ -130,12 +130,25 @@ public class BitExpressionsStatemachine implements IBitExpressionsStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {
@@ -205,8 +218,9 @@ public class BitExpressionsStatemachine implements IBitExpressionsStatemachine {
 
 	public void enter() {
 		entryActionBitExpressions();
-		sCIDefault.setMyBit1(5);
-		sCIDefault.setMyBit2(7);
+		sCIDefault.myBit1 = 5;
+
+		sCIDefault.myBit2 = 7;
 
 		nextStateIndex = 0;
 		stateVector[0] = State.Main_region_StateA;
@@ -246,15 +260,17 @@ public class BitExpressionsStatemachine implements IBitExpressionsStatemachine {
 		if (sCIDefault.e1) {
 			stateVector[0] = State.$NullState$;
 
-			sCIDefault.setLeftBitshift((sCIDefault.getMyBit1() << 1));
-			sCIDefault.setRightBitshift((sCIDefault.getMyBit1() >> 1));
-			sCIDefault.setComplementBitshift(~(sCIDefault.getMyBit1()));
-			sCIDefault.setBitwiseAnd((sCIDefault.getMyBit1() & sCIDefault
-					.getMyBit2()));
-			sCIDefault.setBitwiseOr((sCIDefault.getMyBit1() | sCIDefault
-					.getMyBit2()));
-			sCIDefault.setBitwiseXor((sCIDefault.getMyBit1() ^ sCIDefault
-					.getMyBit2()));
+			sCIDefault.leftBitshift = (sCIDefault.myBit1 << 1);
+
+			sCIDefault.rightBitshift = (sCIDefault.myBit1 >> 1);
+
+			sCIDefault.complementBitshift = ~(sCIDefault.myBit1);
+
+			sCIDefault.bitwiseAnd = (sCIDefault.myBit1 & sCIDefault.myBit2);
+
+			sCIDefault.bitwiseOr = (sCIDefault.myBit1 | sCIDefault.myBit2);
+
+			sCIDefault.bitwiseXor = (sCIDefault.myBit1 ^ sCIDefault.myBit2);
 
 			nextStateIndex = 0;
 			stateVector[0] = State.Main_region_StateB;

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

@@ -122,12 +122,25 @@ public class BooleanExpressionsStatemachine
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {
@@ -190,8 +203,9 @@ public class BooleanExpressionsStatemachine
 
 	public void enter() {
 		entryActionBooleanExpressions();
-		sCIDefault.setMyBool1(true);
-		sCIDefault.setMyBool2(false);
+		sCIDefault.myBool1 = true;
+
+		sCIDefault.myBool2 = false;
 
 		nextStateIndex = 0;
 		stateVector[0] = State.Main_region_StateA;
@@ -231,15 +245,15 @@ public class BooleanExpressionsStatemachine
 		if (sCIDefault.e1) {
 			stateVector[0] = State.$NullState$;
 
-			sCIDefault.setAnd((sCIDefault.getMyBool1() && sCIDefault
-					.getMyBool2()));
-			sCIDefault.setOr((sCIDefault.getMyBool1() || sCIDefault
-					.getMyBool2()));
-			sCIDefault.setNot(!sCIDefault.getMyBool1());
-			sCIDefault.setEqual((sCIDefault.getMyBool1() == sCIDefault
-					.getMyBool2()));
-			sCIDefault.setNotequal((sCIDefault.getMyBool1() != sCIDefault
-					.getMyBool2()));
+			sCIDefault.and = (sCIDefault.myBool1 && sCIDefault.myBool2);
+
+			sCIDefault.or = (sCIDefault.myBool1 || sCIDefault.myBool2);
+
+			sCIDefault.not = !sCIDefault.myBool1;
+
+			sCIDefault.equal = (sCIDefault.myBool1 == sCIDefault.myBool2);
+
+			sCIDefault.notequal = (sCIDefault.myBool1 != sCIDefault.myBool2);
 
 			nextStateIndex = 0;
 			stateVector[0] = State.Main_region_StateB;

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

@@ -60,12 +60,28 @@ public class ChoiceStatemachine implements IChoiceStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {
@@ -85,7 +101,8 @@ public class ChoiceStatemachine implements IChoiceStatemachine {
 	}
 
 	public void enter() {
-		sCIDefault.setValue(4);
+		sCIDefault.value = 4;
+
 		entryActionChoice();
 		nextStateIndex = 0;
 		stateVector[0] = State.Main_region_A;
@@ -130,14 +147,14 @@ public class ChoiceStatemachine implements IChoiceStatemachine {
 		if (sCIDefault.pressKey) {
 			stateVector[0] = State.$NullState$;
 
-			if (((sCIDefault.getValue() % 2) == 0)) {
-				sCIDefault.setValue(sCIDefault.getValue() - (1));
+			if (((sCIDefault.value % 2) == 0)) {
+				sCIDefault.value -= 1;
 
 				nextStateIndex = 0;
 				stateVector[0] = State.Main_region_B;
 
 			} else {
-				sCIDefault.setValue(sCIDefault.getValue() - (1));
+				sCIDefault.value -= 1;
 
 				nextStateIndex = 0;
 				stateVector[0] = State.Main_region_C;
@@ -161,8 +178,8 @@ public class ChoiceStatemachine implements IChoiceStatemachine {
 		if (sCIDefault.pressKey) {
 			stateVector[0] = State.$NullState$;
 
-			if ((sCIDefault.getValue() == 2)) {
-				sCIDefault.setValue(sCIDefault.getValue() - (1));
+			if ((sCIDefault.value == 2)) {
+				sCIDefault.value -= 1;
 
 				nextStateIndex = 0;
 				stateVector[0] = State.Main_region_B;

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

@@ -111,12 +111,55 @@ public class DeepHistoryStatemachine implements IDeepHistoryStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == state) {
+		switch (state) {
+
+			case MainRegion_State1 :
+				return stateVector[0] == State.MainRegion_State1;
+
+			case MainRegion_State2 :
+				return stateVector[0].ordinal() >= State.MainRegion_State2
+						.ordinal()
+						&& stateVector[0].ordinal() <= State.MainRegion_State2__region0_State5
+								.ordinal();
+
+			case MainRegion_State2__region0_a :
+				return stateVector[0] == State.MainRegion_State2__region0_a;
+
+			case MainRegion_State2__region0_State4 :
+				return stateVector[0].ordinal() >= State.MainRegion_State2__region0_State4
+						.ordinal()
+						&& stateVector[0].ordinal() <= State.MainRegion_State2__region0_State4__region0_State7__region0_State9
+								.ordinal();
+
+			case MainRegion_State2__region0_State4__region0_State6 :
+				return stateVector[0] == State.MainRegion_State2__region0_State4__region0_State6;
+
+			case MainRegion_State2__region0_State4__region0_State7 :
+				return stateVector[0].ordinal() >= State.MainRegion_State2__region0_State4__region0_State7
+						.ordinal()
+						&& stateVector[0].ordinal() <= State.MainRegion_State2__region0_State4__region0_State7__region0_State9
+								.ordinal();
+
+			case MainRegion_State2__region0_State4__region0_State7__region0_State8 :
+				return stateVector[0] == State.MainRegion_State2__region0_State4__region0_State7__region0_State8;
+
+			case MainRegion_State2__region0_State4__region0_State7__region0_State9 :
+				return stateVector[0] == State.MainRegion_State2__region0_State4__region0_State7__region0_State9;
+
+			case MainRegion_State2__region0_State5 :
+				return stateVector[0] == State.MainRegion_State2__region0_State5;
+
+			default :
+				return false;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {

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

@@ -60,12 +60,25 @@ public class FeatureCallsStatemachine implements IFeatureCallsStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIMyInterface getSCIMyInterface() {
@@ -112,7 +125,7 @@ public class FeatureCallsStatemachine implements IFeatureCallsStatemachine {
 		if (sCIMyInterface.event1) {
 			stateVector[0] = State.$NullState$;
 
-			sCIMyInterface.setMyInt(42);
+			sCIMyInterface.myInt = 42;
 
 			sCIMyInterface.raiseEvent1();
 

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

@@ -2,24 +2,58 @@ package org.yakindu.scr.guard;
 
 public class GuardStatemachine implements IGuardStatemachine {
 
-	private boolean event1;
+	private final class SCIDefaultImpl implements SCIDefault {
 
-	private boolean event2;
+		private boolean event1;
 
-	private boolean eventReturn;
+		public void raiseEvent1() {
+			event1 = true;
+		}
+
+		private boolean event2;
+
+		public void raiseEvent2() {
+			event2 = true;
+		}
+
+		private boolean eventReturn;
+
+		public void raiseReturn() {
+			eventReturn = true;
+		}
+
+		private int myVar = 0;
+
+		public int getMyVar() {
+			return myVar;
+		}
+
+		public void setMyVar(int value) {
+			this.myVar = value;
+		}
+
+		public void clearEvents() {
+			event1 = false;
+			event2 = false;
+			eventReturn = false;
+		}
+
+	}
+
+	private SCIDefaultImpl sCIDefault;
 
 	public enum State {
 		Main_region_A, Main_region_B, $NullState$
 	};
 
-	private int myVar = 0;
-
 	private final State[] stateVector = new State[1];
 
 	private int nextStateIndex;
 
 	public GuardStatemachine() {
 
+		sCIDefault = new SCIDefaultImpl();
+
 	}
 
 	public void init() {
@@ -32,6 +66,7 @@ public class GuardStatemachine implements IGuardStatemachine {
 	}
 
 	protected void clearEvents() {
+		sCIDefault.clearEvents();
 
 	}
 
@@ -39,36 +74,54 @@ public class GuardStatemachine implements IGuardStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
-	private void raiseEvent1() {
-		event1 = true;
+	public SCIDefault getSCIDefault() {
+		return sCIDefault;
 	}
 
-	private void raiseEvent2() {
-		event2 = true;
+	public void raiseEvent1() {
+		sCIDefault.raiseEvent1();
 	}
 
-	private void raiseEventReturn() {
-		eventReturn = true;
+	public void raiseEvent2() {
+		sCIDefault.raiseEvent2();
 	}
 
-	private int getMyVar() {
-		return myVar;
+	public void raiseReturn() {
+		sCIDefault.raiseReturn();
 	}
 
-	private void setMyVar(int value) {
-		myVar = value;
+	public int getMyVar() {
+		return sCIDefault.getMyVar();
+	}
+
+	public void setMyVar(int value) {
+		sCIDefault.setMyVar(value);
 	}
 
 	public void enter() {
-		setMyVar(0);
+		sCIDefault.myVar = 0;
+
 		entryActionGuard();
 		nextStateIndex = 0;
 		stateVector[0] = State.Main_region_A;
@@ -105,19 +158,19 @@ public class GuardStatemachine implements IGuardStatemachine {
 	}
 
 	private void reactMain_region_A() {
-		if ((event1 && (getMyVar() == 10))) {
+		if ((sCIDefault.event1 && (sCIDefault.myVar == 10))) {
 			stateVector[0] = State.$NullState$;
 
-			setMyVar(10);
+			sCIDefault.myVar = 10;
 
 			nextStateIndex = 0;
 			stateVector[0] = State.Main_region_B;
 
 		} else {
-			if (event2) {
+			if (sCIDefault.event2) {
 				stateVector[0] = State.$NullState$;
 
-				setMyVar(10);
+				sCIDefault.myVar = 10;
 
 				nextStateIndex = 0;
 				stateVector[0] = State.Main_region_B;
@@ -127,7 +180,7 @@ public class GuardStatemachine implements IGuardStatemachine {
 
 	}
 	private void reactMain_region_B() {
-		if (eventReturn) {
+		if (sCIDefault.eventReturn) {
 			stateVector[0] = State.$NullState$;
 
 			nextStateIndex = 0;

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

@@ -4,4 +4,19 @@ import org.yakindu.scr.IStatemachine;
 
 public interface IGuardStatemachine extends IStatemachine {
 
+	public interface SCIDefault {
+
+		public void raiseEvent1();
+
+		public void raiseEvent2();
+
+		public void raiseReturn();
+
+		public int getMyVar();
+		public void setMyVar(int value);
+
+	}
+
+	public SCIDefault getSCIDefault();
+
 }

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

@@ -252,12 +252,25 @@ public class IntegerExpressionsStatemachine
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {
@@ -410,14 +423,20 @@ public class IntegerExpressionsStatemachine
 	}
 
 	public void enter() {
-		sCIDefault.setMultiAssign(2);
-		sCIDefault.setDivAssign(20);
-		sCIDefault.setPlusAssign(2);
-		sCIDefault.setMinusAssign(2);
-		sCIDefault.setModuloAssign(20);
+		sCIDefault.multiAssign = 2;
+
+		sCIDefault.divAssign = 20;
+
+		sCIDefault.plusAssign = 2;
+
+		sCIDefault.minusAssign = 2;
+
+		sCIDefault.moduloAssign = 20;
+
 		entryActionIntegerExpressions();
-		sCIDefault.setMyInt1(10);
-		sCIDefault.setMyInt2(5);
+		sCIDefault.myInt1 = 10;
+
+		sCIDefault.myInt2 = 5;
 
 		nextStateIndex = 0;
 		stateVector[0] = State.Main_region_StateA;
@@ -457,39 +476,39 @@ public class IntegerExpressionsStatemachine
 		if (sCIDefault.e1) {
 			stateVector[0] = State.$NullState$;
 
-			sCIDefault
-					.setLess((sCIDefault.getMyInt1() < sCIDefault.getMyInt2()));
-			sCIDefault.setGreater((sCIDefault.getMyInt1() > sCIDefault
-					.getMyInt2()));
-			sCIDefault.setEqualOrLess((sCIDefault.getMyInt1() <= sCIDefault
-					.getMyInt2()));
-			sCIDefault.setEqualOrGreater((sCIDefault.getMyInt1() >= sCIDefault
-					.getMyInt2()));
-			sCIDefault.setEqual((sCIDefault.getMyInt1() == sCIDefault
-					.getMyInt2()));
-			sCIDefault.setNotEqual((sCIDefault.getMyInt1() != sCIDefault
-					.getMyInt2()));
-			sCIDefault
-					.setPlus((sCIDefault.getMyInt1() + sCIDefault.getMyInt2()));
-			sCIDefault.setMinus((sCIDefault.getMyInt1() - sCIDefault
-					.getMyInt2()));
-			sCIDefault.setMultiply((sCIDefault.getMyInt1() * sCIDefault
-					.getMyInt2()));
-			sCIDefault.setDivision((sCIDefault.getMyInt1() / sCIDefault
-					.getMyInt2()));
-			sCIDefault.setModulo((sCIDefault.getMyInt1() % sCIDefault
-					.getMyInt2()));
-			sCIDefault.setNegat(-(sCIDefault.getMyInt1()));
-			sCIDefault.setMultiAssign(sCIDefault.getMultiAssign()
-					* (sCIDefault.getMyInt1()));
-			sCIDefault.setDivAssign(sCIDefault.getDivAssign()
-					/ (sCIDefault.getMyInt1()));
-			sCIDefault.setPlusAssign(sCIDefault.getPlusAssign()
-					+ (sCIDefault.getMyInt1()));
-			sCIDefault.setMinusAssign(sCIDefault.getMinusAssign()
-					- (sCIDefault.getMyInt1()));
-			sCIDefault.setModuloAssign(sCIDefault.getModuloAssign()
-					% (sCIDefault.getMyInt1()));
+			sCIDefault.less = (sCIDefault.myInt1 < sCIDefault.myInt2);
+
+			sCIDefault.greater = (sCIDefault.myInt1 > sCIDefault.myInt2);
+
+			sCIDefault.equalOrLess = (sCIDefault.myInt1 <= sCIDefault.myInt2);
+
+			sCIDefault.equalOrGreater = (sCIDefault.myInt1 >= sCIDefault.myInt2);
+
+			sCIDefault.equal = (sCIDefault.myInt1 == sCIDefault.myInt2);
+
+			sCIDefault.notEqual = (sCIDefault.myInt1 != sCIDefault.myInt2);
+
+			sCIDefault.plus = (sCIDefault.myInt1 + sCIDefault.myInt2);
+
+			sCIDefault.minus = (sCIDefault.myInt1 - sCIDefault.myInt2);
+
+			sCIDefault.multiply = (sCIDefault.myInt1 * sCIDefault.myInt2);
+
+			sCIDefault.division = (sCIDefault.myInt1 / sCIDefault.myInt2);
+
+			sCIDefault.modulo = (sCIDefault.myInt1 % sCIDefault.myInt2);
+
+			sCIDefault.negat = -(sCIDefault.myInt1);
+
+			sCIDefault.multiAssign *= sCIDefault.myInt1;
+
+			sCIDefault.divAssign /= sCIDefault.myInt1;
+
+			sCIDefault.plusAssign += sCIDefault.myInt1;
+
+			sCIDefault.minusAssign -= sCIDefault.myInt1;
+
+			sCIDefault.moduloAssign %= sCIDefault.myInt1;
 
 			nextStateIndex = 0;
 			stateVector[0] = State.Main_region_StateB;

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

@@ -57,12 +57,40 @@ public class PriorityValuesStatemachine implements IPriorityValuesStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {

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

@@ -0,0 +1,56 @@
+package org.yakindu.scr.realexpressions;
+
+import org.yakindu.scr.IStatemachine;
+
+public interface IRealExpressionsStatemachine extends IStatemachine {
+
+	public interface SCIDefault {
+
+		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 SCIDefault getSCIDefault();
+
+}

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

@@ -0,0 +1,541 @@
+package org.yakindu.scr.realexpressions;
+
+public class RealExpressionsStatemachine
+		implements
+			IRealExpressionsStatemachine {
+
+	private final class SCIDefaultImpl implements SCIDefault {
+
+		private boolean e1;
+
+		public void raiseE1() {
+			e1 = true;
+		}
+
+		private double myReal1;
+
+		public double getMyReal1() {
+			return myReal1;
+		}
+
+		public void setMyReal1(double value) {
+			this.myReal1 = value;
+		}
+
+		private double myReal2;
+
+		public double getMyReal2() {
+			return myReal2;
+		}
+
+		public void setMyReal2(double value) {
+			this.myReal2 = value;
+		}
+
+		private boolean less;
+
+		public boolean getLess() {
+			return less;
+		}
+
+		public void setLess(boolean value) {
+			this.less = value;
+		}
+
+		private boolean greater;
+
+		public boolean getGreater() {
+			return greater;
+		}
+
+		public void setGreater(boolean value) {
+			this.greater = value;
+		}
+
+		private boolean equalOrLess;
+
+		public boolean getEqualOrLess() {
+			return equalOrLess;
+		}
+
+		public void setEqualOrLess(boolean value) {
+			this.equalOrLess = value;
+		}
+
+		private boolean equalOrGreater;
+
+		public boolean getEqualOrGreater() {
+			return equalOrGreater;
+		}
+
+		public void setEqualOrGreater(boolean value) {
+			this.equalOrGreater = 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;
+		}
+
+		private boolean plus;
+
+		public boolean getPlus() {
+			return plus;
+		}
+
+		public void setPlus(boolean value) {
+			this.plus = value;
+		}
+
+		private boolean minus;
+
+		public boolean getMinus() {
+			return minus;
+		}
+
+		public void setMinus(boolean value) {
+			this.minus = value;
+		}
+
+		private boolean multiply;
+
+		public boolean getMultiply() {
+			return multiply;
+		}
+
+		public void setMultiply(boolean value) {
+			this.multiply = value;
+		}
+
+		private boolean division;
+
+		public boolean getDivision() {
+			return division;
+		}
+
+		public void setDivision(boolean value) {
+			this.division = value;
+		}
+
+		private boolean modulo;
+
+		public boolean getModulo() {
+			return modulo;
+		}
+
+		public void setModulo(boolean value) {
+			this.modulo = value;
+		}
+
+		private double negat;
+
+		public double getNegat() {
+			return negat;
+		}
+
+		public void setNegat(double value) {
+			this.negat = value;
+		}
+
+		private boolean complement;
+
+		public boolean getComplement() {
+			return complement;
+		}
+
+		public void setComplement(boolean value) {
+			this.complement = value;
+		}
+
+		private double multiAssign = 2.2;
+
+		public double getMultiAssign() {
+			return multiAssign;
+		}
+
+		public void setMultiAssign(double value) {
+			this.multiAssign = value;
+		}
+
+		private double divAssign = 22.79;
+
+		public double getDivAssign() {
+			return divAssign;
+		}
+
+		public void setDivAssign(double value) {
+			this.divAssign = value;
+		}
+
+		private double plusAssign = 2.2;
+
+		public double getPlusAssign() {
+			return plusAssign;
+		}
+
+		public void setPlusAssign(double value) {
+			this.plusAssign = value;
+		}
+
+		private double minusAssign = 8.6;
+
+		public double getMinusAssign() {
+			return minusAssign;
+		}
+
+		public void setMinusAssign(double value) {
+			this.minusAssign = value;
+		}
+
+		private boolean moduloAssign;
+
+		public boolean getModuloAssign() {
+			return moduloAssign;
+		}
+
+		public void setModuloAssign(boolean value) {
+			this.moduloAssign = value;
+		}
+
+		public void clearEvents() {
+			e1 = false;
+		}
+
+	}
+
+	private SCIDefaultImpl sCIDefault;
+
+	public enum State {
+		Main_region_StateA, Main_region_StateB, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public RealExpressionsStatemachine() {
+
+		sCIDefault = new SCIDefaultImpl();
+
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+	}
+
+	protected void clearEvents() {
+		sCIDefault.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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
+				return true;
+			}
+		}
+		return false;
+		 */
+	}
+
+	public SCIDefault getSCIDefault() {
+		return sCIDefault;
+	}
+
+	public void raiseE1() {
+		sCIDefault.raiseE1();
+	}
+
+	public double getMyReal1() {
+		return sCIDefault.getMyReal1();
+	}
+
+	public void setMyReal1(double value) {
+		sCIDefault.setMyReal1(value);
+	}
+	public double getMyReal2() {
+		return sCIDefault.getMyReal2();
+	}
+
+	public void setMyReal2(double value) {
+		sCIDefault.setMyReal2(value);
+	}
+	public boolean getLess() {
+		return sCIDefault.getLess();
+	}
+
+	public void setLess(boolean value) {
+		sCIDefault.setLess(value);
+	}
+	public boolean getGreater() {
+		return sCIDefault.getGreater();
+	}
+
+	public void setGreater(boolean value) {
+		sCIDefault.setGreater(value);
+	}
+	public boolean getEqualOrLess() {
+		return sCIDefault.getEqualOrLess();
+	}
+
+	public void setEqualOrLess(boolean value) {
+		sCIDefault.setEqualOrLess(value);
+	}
+	public boolean getEqualOrGreater() {
+		return sCIDefault.getEqualOrGreater();
+	}
+
+	public void setEqualOrGreater(boolean value) {
+		sCIDefault.setEqualOrGreater(value);
+	}
+	public boolean getEqual() {
+		return sCIDefault.getEqual();
+	}
+
+	public void setEqual(boolean value) {
+		sCIDefault.setEqual(value);
+	}
+	public boolean getNotEqual() {
+		return sCIDefault.getNotEqual();
+	}
+
+	public void setNotEqual(boolean value) {
+		sCIDefault.setNotEqual(value);
+	}
+	public boolean getPlus() {
+		return sCIDefault.getPlus();
+	}
+
+	public void setPlus(boolean value) {
+		sCIDefault.setPlus(value);
+	}
+	public boolean getMinus() {
+		return sCIDefault.getMinus();
+	}
+
+	public void setMinus(boolean value) {
+		sCIDefault.setMinus(value);
+	}
+	public boolean getMultiply() {
+		return sCIDefault.getMultiply();
+	}
+
+	public void setMultiply(boolean value) {
+		sCIDefault.setMultiply(value);
+	}
+	public boolean getDivision() {
+		return sCIDefault.getDivision();
+	}
+
+	public void setDivision(boolean value) {
+		sCIDefault.setDivision(value);
+	}
+	public boolean getModulo() {
+		return sCIDefault.getModulo();
+	}
+
+	public void setModulo(boolean value) {
+		sCIDefault.setModulo(value);
+	}
+	public double getNegat() {
+		return sCIDefault.getNegat();
+	}
+
+	public void setNegat(double value) {
+		sCIDefault.setNegat(value);
+	}
+	public boolean getComplement() {
+		return sCIDefault.getComplement();
+	}
+
+	public void setComplement(boolean value) {
+		sCIDefault.setComplement(value);
+	}
+	public double getMultiAssign() {
+		return sCIDefault.getMultiAssign();
+	}
+
+	public void setMultiAssign(double value) {
+		sCIDefault.setMultiAssign(value);
+	}
+	public double getDivAssign() {
+		return sCIDefault.getDivAssign();
+	}
+
+	public void setDivAssign(double value) {
+		sCIDefault.setDivAssign(value);
+	}
+	public double getPlusAssign() {
+		return sCIDefault.getPlusAssign();
+	}
+
+	public void setPlusAssign(double value) {
+		sCIDefault.setPlusAssign(value);
+	}
+	public double getMinusAssign() {
+		return sCIDefault.getMinusAssign();
+	}
+
+	public void setMinusAssign(double value) {
+		sCIDefault.setMinusAssign(value);
+	}
+	public boolean getModuloAssign() {
+		return sCIDefault.getModuloAssign();
+	}
+
+	public void setModuloAssign(boolean value) {
+		sCIDefault.setModuloAssign(value);
+	}
+
+	public void enter() {
+		sCIDefault.multiAssign = 2.2;
+
+		sCIDefault.divAssign = 22.79;
+
+		sCIDefault.plusAssign = 2.2;
+
+		sCIDefault.minusAssign = 8.6;
+
+		entryActionRealExpressions();
+		sCIDefault.myReal1 = 5.3;
+
+		sCIDefault.myReal2 = 10.6;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.Main_region_StateA;
+
+	}
+
+	public void exit() {
+		//Handle exit of all possible states (of main region) at position 0...
+		switch (stateVector[0]) {
+
+			case Main_region_StateA :
+				stateVector[0] = State.$NullState$;
+
+				break;
+
+			case Main_region_StateB :
+				stateVector[0] = State.$NullState$;
+
+				break;
+
+			default :
+				break;
+		}
+
+		exitActionRealExpressions();
+	}
+
+	private void entryActionRealExpressions() {
+
+	}
+
+	private void exitActionRealExpressions() {
+
+	}
+
+	private void reactMain_region_StateA() {
+		if (sCIDefault.e1) {
+			stateVector[0] = State.$NullState$;
+
+			sCIDefault.less = (sCIDefault.myReal1 < sCIDefault.myReal2);
+
+			sCIDefault.greater = (sCIDefault.myReal1 > sCIDefault.myReal2);
+
+			sCIDefault.equalOrLess = (sCIDefault.myReal1 <= sCIDefault.myReal2);
+
+			sCIDefault.equalOrGreater = (sCIDefault.myReal1 >= sCIDefault.myReal2);
+
+			sCIDefault.equal = (sCIDefault.myReal1 == sCIDefault.myReal2);
+
+			sCIDefault.notEqual = (sCIDefault.myReal1 != sCIDefault.myReal2);
+
+			sCIDefault.plus = ((15.89 <= (sCIDefault.myReal1 + sCIDefault.myReal2)) && ((sCIDefault.myReal1 + sCIDefault.myReal2) <= 16.91));
+
+			sCIDefault.minus = ((5.29 <= (sCIDefault.myReal2 - sCIDefault.myReal1)) && ((sCIDefault.myReal1 - sCIDefault.myReal2) <= 5.31));
+
+			sCIDefault.multiply = ((56.17 <= (sCIDefault.myReal1 * sCIDefault.myReal2)) && ((sCIDefault.myReal1 * sCIDefault.myReal2) <= 56.19));
+
+			sCIDefault.division = ((1.9 <= (sCIDefault.myReal2 / sCIDefault.myReal1)) && ((sCIDefault.myReal1 / sCIDefault.myReal2) <= 2.1));
+
+			sCIDefault.modulo = ((-(0.1) <= (sCIDefault.myReal2 % sCIDefault.myReal1)) && ((sCIDefault.myReal1 % sCIDefault.myReal2) <= 0.1));
+
+			sCIDefault.negat = -(sCIDefault.myReal1);
+
+			sCIDefault.multiAssign *= sCIDefault.myReal1;
+
+			sCIDefault.divAssign /= sCIDefault.myReal1;
+
+			sCIDefault.plusAssign += sCIDefault.myReal1;
+
+			sCIDefault.minusAssign -= sCIDefault.myReal1;
+
+			sCIDefault.moduloAssign = (-(0.1) <= (sCIDefault.myReal1 %= sCIDefault.myReal1));
+
+			nextStateIndex = 0;
+			stateVector[0] = State.Main_region_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/shallowhistory/ShallowHistoryStatemachine.java

@@ -104,12 +104,55 @@ public class ShallowHistoryStatemachine implements IShallowHistoryStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == state) {
+		switch (state) {
+
+			case MainRegion_State1 :
+				return stateVector[0] == State.MainRegion_State1;
+
+			case MainRegion_State2 :
+				return stateVector[0].ordinal() >= State.MainRegion_State2
+						.ordinal()
+						&& stateVector[0].ordinal() <= State.MainRegion_State2__region0_State5
+								.ordinal();
+
+			case MainRegion_State2__region0_State3 :
+				return stateVector[0] == State.MainRegion_State2__region0_State3;
+
+			case MainRegion_State2__region0_State4 :
+				return stateVector[0].ordinal() >= State.MainRegion_State2__region0_State4
+						.ordinal()
+						&& stateVector[0].ordinal() <= State.MainRegion_State2__region0_State4__region0_State7__region0_State9
+								.ordinal();
+
+			case MainRegion_State2__region0_State4__region0_State6 :
+				return stateVector[0] == State.MainRegion_State2__region0_State4__region0_State6;
+
+			case MainRegion_State2__region0_State4__region0_State7 :
+				return stateVector[0].ordinal() >= State.MainRegion_State2__region0_State4__region0_State7
+						.ordinal()
+						&& stateVector[0].ordinal() <= State.MainRegion_State2__region0_State4__region0_State7__region0_State9
+								.ordinal();
+
+			case MainRegion_State2__region0_State4__region0_State7__region0_State8 :
+				return stateVector[0] == State.MainRegion_State2__region0_State4__region0_State7__region0_State8;
+
+			case MainRegion_State2__region0_State4__region0_State7__region0_State9 :
+				return stateVector[0] == State.MainRegion_State2__region0_State4__region0_State7__region0_State9;
+
+			case MainRegion_State2__region0_State5 :
+				return stateVector[0] == State.MainRegion_State2__region0_State5;
+
+			default :
+				return false;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {

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

@@ -50,12 +50,25 @@ public class SimpleEventStatemachine implements ISimpleEventStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {

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

@@ -50,12 +50,31 @@ public class SimpleHierachyStatemachine implements ISimpleHierachyStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {

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

@@ -51,12 +51,28 @@ public class StatechartLocalReactionsStatemachine
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {
@@ -126,7 +142,7 @@ public class StatechartLocalReactionsStatemachine
 		return true;
 	}
 	private void actionsStatechartLocalReactionsLr0() {
-		sCIDefault.setMyInt(sCIDefault.getMyInt() + (1));
+		sCIDefault.myInt += 1;
 
 	}
 

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

@@ -50,12 +50,31 @@ public class StateIsActiveStatemachine implements IStateIsActiveStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {

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

@@ -0,0 +1,24 @@
+package org.yakindu.scr.stringexpressions;
+
+import org.yakindu.scr.IStatemachine;
+
+public interface IStringExpressionsStatemachine extends IStatemachine {
+
+	public interface SCIDefault {
+
+		public void raiseE1();
+
+		public String getMyString();
+		public void setMyString(String value);
+		public String getMyString2();
+		public void setMyString2(String value);
+		public boolean getEquals();
+		public void setEquals(boolean value);
+		public boolean getNotEqual();
+		public void setNotEqual(boolean value);
+
+	}
+
+	public SCIDefault getSCIDefault();
+
+}

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

@@ -0,0 +1,235 @@
+package org.yakindu.scr.stringexpressions;
+
+public class StringExpressionsStatemachine
+		implements
+			IStringExpressionsStatemachine {
+
+	private final class SCIDefaultImpl implements SCIDefault {
+
+		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 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 SCIDefaultImpl sCIDefault;
+
+	public enum State {
+		Main_region_StateA, Main_region_StateB, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public StringExpressionsStatemachine() {
+
+		sCIDefault = new SCIDefaultImpl();
+
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+	}
+
+	protected void clearEvents() {
+		sCIDefault.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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
+				return true;
+			}
+		}
+		return false;
+		 */
+	}
+
+	public SCIDefault getSCIDefault() {
+		return sCIDefault;
+	}
+
+	public void raiseE1() {
+		sCIDefault.raiseE1();
+	}
+
+	public String getMyString() {
+		return sCIDefault.getMyString();
+	}
+
+	public void setMyString(String value) {
+		sCIDefault.setMyString(value);
+	}
+	public String getMyString2() {
+		return sCIDefault.getMyString2();
+	}
+
+	public void setMyString2(String value) {
+		sCIDefault.setMyString2(value);
+	}
+	public boolean getEquals() {
+		return sCIDefault.getEquals();
+	}
+
+	public void setEquals(boolean value) {
+		sCIDefault.setEquals(value);
+	}
+	public boolean getNotEqual() {
+		return sCIDefault.getNotEqual();
+	}
+
+	public void setNotEqual(boolean value) {
+		sCIDefault.setNotEqual(value);
+	}
+
+	public void enter() {
+		entryActionStringExpressions();
+		sCIDefault.myString = "hello";
+
+		sCIDefault.myString2 = "world";
+
+		nextStateIndex = 0;
+		stateVector[0] = State.Main_region_StateA;
+
+	}
+
+	public void exit() {
+		//Handle exit of all possible states (of main region) at position 0...
+		switch (stateVector[0]) {
+
+			case Main_region_StateA :
+				stateVector[0] = State.$NullState$;
+
+				break;
+
+			case Main_region_StateB :
+				stateVector[0] = State.$NullState$;
+
+				break;
+
+			default :
+				break;
+		}
+
+		exitActionStringExpressions();
+	}
+
+	private void entryActionStringExpressions() {
+
+	}
+
+	private void exitActionStringExpressions() {
+
+	}
+
+	private void reactMain_region_StateA() {
+		if (sCIDefault.e1) {
+			stateVector[0] = State.$NullState$;
+
+			sCIDefault.equals = (sCIDefault.myString == null
+					? sCIDefault.myString2 == null
+					: sCIDefault.myString.equals(sCIDefault.myString2));
+
+			sCIDefault.notEqual = (sCIDefault.myString == null
+					? sCIDefault.myString2 == null
+					: sCIDefault.myString.equals(sCIDefault.myString2));
+
+			nextStateIndex = 0;
+			stateVector[0] = State.Main_region_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/SyncForkStatemachine.java

@@ -57,12 +57,40 @@ public class SyncForkStatemachine implements ISyncForkStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {
@@ -138,6 +166,8 @@ public class SyncForkStatemachine implements ISyncForkStatemachine {
 		if (sCIDefault.e) {
 			stateVector[0] = State.$NullState$;
 
+			react_sync0_();
+
 		} else {
 			if (sCIDefault.f) {
 				stateVector[0] = State.$NullState$;
@@ -260,6 +290,14 @@ public class SyncForkStatemachine implements ISyncForkStatemachine {
 	}
 	private void reactMain_region_B_r2_D2() {
 	}
+	private void react_sync0_() {
+		nextStateIndex = 0;
+		stateVector[0] = State.Main_region_B_r1_C2;
+
+		nextStateIndex = 1;
+		stateVector[1] = State.Main_region_B_r2_D2;
+
+	}
 
 	public void runCycle() {
 

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

@@ -71,12 +71,40 @@ public class SyncJoinStatemachine implements ISyncJoinStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {
@@ -185,7 +213,7 @@ public class SyncJoinStatemachine implements ISyncJoinStatemachine {
 
 	}
 	private void reactMain_region_B_r1_C2() {
-		if (sCIDefault.jc) {
+		if (((sCIDefault.jc && isStateActive(State.Main_region_B_r2_D2)) && sCIDefault.jd)) {
 			//Handle exit of all possible states (of r1) at position 0...
 			switch (stateVector[0]) {
 
@@ -220,6 +248,9 @@ public class SyncJoinStatemachine implements ISyncJoinStatemachine {
 					break;
 			}
 
+			react_sync0_();
+			react_sync0_();
+
 		}
 
 	}
@@ -233,7 +264,7 @@ public class SyncJoinStatemachine implements ISyncJoinStatemachine {
 		}
 	}
 	private void reactMain_region_B_r2_D2() {
-		if (sCIDefault.jd) {
+		if (((sCIDefault.jd && isStateActive(State.Main_region_B_r1_C2)) && sCIDefault.jc)) {
 			//Handle exit of all possible states (of r1) at position 0...
 			switch (stateVector[0]) {
 
@@ -268,8 +299,16 @@ public class SyncJoinStatemachine implements ISyncJoinStatemachine {
 					break;
 			}
 
+			react_sync0_();
+			react_sync0_();
+
 		}
 	}
+	private void react_sync0_() {
+		nextStateIndex = 0;
+		stateVector[0] = State.Main_region_A;
+
+	}
 
 	public void runCycle() {
 

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

@@ -5,8 +5,10 @@ import org.yakindu.scr.ITimerService;
 
 public class TimeTriggerStatemachine implements ITimeTriggerStatemachine {
 
-	private final TimeEvent stateA_time_event_0 = new TimeEvent(false, 0);
-	private final TimeEvent stateB_time_event_0 = new TimeEvent(true, 1);
+	private final TimeEvent timeTrigger_mainRegion_StateA_time_event_0 = new TimeEvent(
+			false, 0);
+	private final TimeEvent timeTrigger_mainRegion_StateB_time_event_0 = new TimeEvent(
+			true, 1);
 
 	private final boolean[] timeEvents = new boolean[2];
 
@@ -42,8 +44,8 @@ public class TimeTriggerStatemachine implements ITimeTriggerStatemachine {
 
 		sCIDefault = new SCIDefaultImpl();
 
-		stateA_time_event_0.setStatemachine(this);
-		stateB_time_event_0.setStatemachine(this);
+		timeTrigger_mainRegion_StateA_time_event_0.setStatemachine(this);
+		timeTrigger_mainRegion_StateB_time_event_0.setStatemachine(this);
 
 	}
 
@@ -70,12 +72,25 @@ public class TimeTriggerStatemachine implements ITimeTriggerStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == state) {
+		switch (state) {
+
+			case MainRegion_StateA :
+				return stateVector[0] == State.MainRegion_StateA;
+
+			case MainRegion_StateB :
+				return stateVector[0] == State.MainRegion_StateB;
+
+			default :
+				return false;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public void setTimerService(ITimerService timerService) {
@@ -108,8 +123,9 @@ public class TimeTriggerStatemachine implements ITimeTriggerStatemachine {
 		}
 		cycleStartTime = System.currentTimeMillis();
 		entryActionTimeTrigger();
-		getTimerService().setTimer(stateA_time_event_0, 100, cycleStartTime);
-		sCIDefault.setValue(0);
+		getTimerService().setTimer(timeTrigger_mainRegion_StateA_time_event_0,
+				100, cycleStartTime);
+		sCIDefault.value = 0;
 
 		nextStateIndex = 0;
 		stateVector[0] = State.MainRegion_StateA;
@@ -122,13 +138,15 @@ public class TimeTriggerStatemachine implements ITimeTriggerStatemachine {
 
 			case MainRegion_StateA :
 				stateVector[0] = State.$NullState$;
-				getTimerService().resetTimer(stateA_time_event_0);
+				getTimerService().resetTimer(
+						timeTrigger_mainRegion_StateA_time_event_0);
 
 				break;
 
 			case MainRegion_StateB :
 				stateVector[0] = State.$NullState$;
-				getTimerService().resetTimer(stateB_time_event_0);
+				getTimerService().resetTimer(
+						timeTrigger_mainRegion_StateB_time_event_0);
 
 				break;
 
@@ -148,11 +166,14 @@ public class TimeTriggerStatemachine implements ITimeTriggerStatemachine {
 	}
 
 	private void reactMainRegion_StateA() {
-		if (timeEvents[stateA_time_event_0.getIndex()]) {
+		if (timeEvents[timeTrigger_mainRegion_StateA_time_event_0.getIndex()]) {
 			stateVector[0] = State.$NullState$;
-			getTimerService().resetTimer(stateA_time_event_0);
+			getTimerService().resetTimer(
+					timeTrigger_mainRegion_StateA_time_event_0);
 
-			getTimerService().setTimer(stateB_time_event_0, 20, cycleStartTime);
+			getTimerService().setTimer(
+					timeTrigger_mainRegion_StateB_time_event_0, 20,
+					cycleStartTime);
 
 			nextStateIndex = 0;
 			stateVector[0] = State.MainRegion_StateB;
@@ -161,20 +182,23 @@ public class TimeTriggerStatemachine implements ITimeTriggerStatemachine {
 
 	}
 	private void reactMainRegion_StateB() {
-		if ((sCIDefault.getValue() == 10)) {
+		if ((sCIDefault.value == 10)) {
 			stateVector[0] = State.$NullState$;
-			getTimerService().resetTimer(stateB_time_event_0);
+			getTimerService().resetTimer(
+					timeTrigger_mainRegion_StateB_time_event_0);
 
-			getTimerService()
-					.setTimer(stateA_time_event_0, 100, cycleStartTime);
-			sCIDefault.setValue(0);
+			getTimerService().setTimer(
+					timeTrigger_mainRegion_StateA_time_event_0, 100,
+					cycleStartTime);
+			sCIDefault.value = 0;
 
 			nextStateIndex = 0;
 			stateVector[0] = State.MainRegion_StateA;
 
 		} else {
-			if (timeEvents[stateB_time_event_0.getIndex()]) {
-				sCIDefault.setValue(sCIDefault.getValue() + (1));
+			if (timeEvents[timeTrigger_mainRegion_StateB_time_event_0
+					.getIndex()]) {
+				sCIDefault.value += 1;
 
 			}
 

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

@@ -70,12 +70,28 @@ public class ValuedEventsStatemachine implements IValuedEventsStatemachine {
 	}
 
 	public boolean isStateActive(State state) {
-		for (int i = 0; i < stateVector.length; i++) {
-			if (stateVector[i] == 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;
+		}
+		/*
+		for (int i=0;i<stateVector.length;i++){
+			if (stateVector[i]==state) {
 				return true;
 			}
 		}
 		return false;
+		 */
 	}
 
 	public SCIDefault getSCIDefault() {
@@ -154,7 +170,7 @@ public class ValuedEventsStatemachine implements IValuedEventsStatemachine {
 		if (sCIDefault.integerEvent) {
 			stateVector[1] = State.$NullState$;
 
-			sCIDefault.setMyVar(sCIDefault.integerEventValue);
+			sCIDefault.myVar = sCIDefault.integerEventValue;
 
 			nextStateIndex = 1;
 			stateVector[1] = State._region1_C;