fixed bug #1099: Exit and entry actions are not executed for hierarchical self transitions

test-plugins/org.yakindu.sct.generator.c.test/gtests/EntryExitSelfTransition/EntryExitSelfTransition.cc

@@ -15,14 +15,35 @@
 
 EntryExitSelfTransition handle;
 
-TEST(StatemachineTest, EntryExitSelfTransitionTest) {
+TEST(StatemachineTest, SelfTransitionToChildState) {
 	entryExitSelfTransition_init(&handle);
 	entryExitSelfTransition_enter(&handle);
 	entryExitSelfTransition_runCycle(&handle);
-	EXPECT_TRUE(entryExitSelfTransitionIface_get_x(&handle) == 1);
+	EXPECT_TRUE(entryExitSelfTransitionIface_get_entries(&handle) == 1);
+	EXPECT_TRUE(entryExitSelfTransition_isActive(&handle, EntryExitSelfTransition_B));
+	entryExitSelfTransitionIface_set_entries(&handle, 0);
 	entryExitSelfTransitionIface_raise_e(&handle);
 	entryExitSelfTransition_runCycle(&handle);
-	EXPECT_TRUE(entryExitSelfTransitionIface_get_x(&handle) == 3);
+	EXPECT_TRUE(entryExitSelfTransitionIface_get_entries(&handle) == 1);
+	EXPECT_TRUE(entryExitSelfTransitionIface_get_exits(&handle) == 1);
+	EXPECT_TRUE(entryExitSelfTransition_isActive(&handle, EntryExitSelfTransition_C));
+}
+TEST(StatemachineTest, SelfTransitionFromChildState) {
+	entryExitSelfTransition_init(&handle);
+	entryExitSelfTransition_enter(&handle);
+	entryExitSelfTransition_runCycle(&handle);
+	EXPECT_TRUE(entryExitSelfTransitionIface_get_entries(&handle) == 1);
+	entryExitSelfTransitionIface_set_entries(&handle, 0);
+	entryExitSelfTransitionIface_raise_e1(&handle);
+	entryExitSelfTransition_runCycle(&handle);
+	EXPECT_TRUE(entryExitSelfTransitionIface_get_entries(&handle) == 0);
+	EXPECT_TRUE(entryExitSelfTransitionIface_get_exits(&handle) == 0);
+	EXPECT_TRUE(entryExitSelfTransition_isActive(&handle, EntryExitSelfTransition_C));
+	entryExitSelfTransitionIface_raise_e1(&handle);
+	entryExitSelfTransition_runCycle(&handle);
+	EXPECT_TRUE(entryExitSelfTransition_isActive(&handle, EntryExitSelfTransition_B));
+	EXPECT_TRUE(entryExitSelfTransitionIface_get_entries(&handle) == 1);
+	EXPECT_TRUE(entryExitSelfTransitionIface_get_exits(&handle) == 1);
 }
 
 		

test-plugins/org.yakindu.sct.generator.cpp.test/gtests/ConditionalExpressionTest/ConditionalExpressionTest.cc

@@ -1,26 +1,26 @@
-/**
-* Copyright (c) 2014 committers of YAKINDU and others.
-* All rights reserved. This program and the accompanying materials
-* are made available under the terms of the Eclipse Public License v1.0
-* which accompanies this distribution, and is available at
-* http://www.eclipse.org/legal/epl-v10.html
-*
-* Contributors:
-*     committers of YAKINDU - initial API and implementation
-*/
-#include <string>
-#include "gtest/gtest.h"
-#include "ConditionalExpressions.h"
-
-TEST(StatemachineTest, ConditionalExpressionTest) {
-	ConditionalExpressions* statechart = new ConditionalExpressions();
-	statechart->init();
-	statechart->enter();
-	EXPECT_TRUE(statechart->isActive(ConditionalExpressions::A));
-	EXPECT_TRUE(statechart->getSCInterface()->get_condition()== 1);
-	statechart->raise_e();
-	statechart->runCycle();
-	EXPECT_TRUE(statechart->isActive(ConditionalExpressions::B));
-	EXPECT_TRUE(statechart->getSCInterface()->get_condition()== 2);
-	delete statechart;
-}
+/**
+* Copyright (c) 2014 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "ConditionalExpressions.h"
+
+TEST(StatemachineTest, ConditionalExpressionTest) {
+	ConditionalExpressions* statechart = new ConditionalExpressions();
+	statechart->init();
+	statechart->enter();
+	EXPECT_TRUE(statechart->isActive(ConditionalExpressions::A));
+	EXPECT_TRUE(statechart->getSCInterface()->get_condition()== 1);
+	statechart->raise_e();
+	statechart->runCycle();
+	EXPECT_TRUE(statechart->isActive(ConditionalExpressions::B));
+	EXPECT_TRUE(statechart->getSCInterface()->get_condition()== 2);
+	delete statechart;
+}

test-plugins/org.yakindu.sct.generator.cpp.test/gtests/ConditionalExpressionTest/ConditionalExpressions.sgen

@@ -1,8 +1,8 @@
-GeneratorModel for yakindu::cpp {
-	statechart ConditionalExpressions {
-		feature Outlet {
-			targetProject = "gtests"
-			targetFolder = "ConditionalExpressionTest"
-		}
-	}
-}
+GeneratorModel for yakindu::cpp {
+	statechart ConditionalExpressions {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "ConditionalExpressionTest"
+		}
+	}
+}

test-plugins/org.yakindu.sct.generator.cpp.test/gtests/EntryExitSelfTransitionTest/EntryExitSelfTransition.sgen

@@ -1,8 +1,8 @@
-GeneratorModel for yakindu::cpp {
-	statechart EntryExitSelfTransition {
-		feature Outlet {
-			targetProject = "gtests"
-			targetFolder = "EntryExitSelfTransitionTest"
-		}
-	}
-}
+GeneratorModel for yakindu::cpp {
+	statechart EntryExitSelfTransition {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "EntryExitSelfTransitionTest"
+		}
+	}
+}

test-plugins/org.yakindu.sct.generator.cpp.test/gtests/EntryExitSelfTransitionTest/EntryExitSelfTransitionTest.cc

@@ -1,25 +1,48 @@
-/**
-* Copyright (c) 2014 committers of YAKINDU and others.
-* All rights reserved. This program and the accompanying materials
-* are made available under the terms of the Eclipse Public License v1.0
-* which accompanies this distribution, and is available at
-* http://www.eclipse.org/legal/epl-v10.html
-*
-* Contributors:
-*     committers of YAKINDU - initial API and implementation
-*/
-#include <string>
-#include "gtest/gtest.h"
-#include "EntryExitSelfTransition.h"
-
-TEST(StatemachineTest, EntryExitSelfTransitionTest) {
-	EntryExitSelfTransition* statechart = new EntryExitSelfTransition();
-	statechart->init();
-	statechart->enter();
-	statechart->runCycle();
-	EXPECT_TRUE(statechart->getSCInterface()->get_x()== 1);
-	statechart->raise_e();
-	statechart->runCycle();
-	EXPECT_TRUE(statechart->getSCInterface()->get_x()== 3);
-	delete statechart;
-}
+/**
+* Copyright (c) 2014 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "EntryExitSelfTransition.h"
+
+TEST(StatemachineTest, SelfTransitionToChildState) {
+	EntryExitSelfTransition* statechart = new EntryExitSelfTransition();
+	statechart->init();
+	statechart->enter();
+	statechart->runCycle();
+	EXPECT_TRUE(statechart->getSCInterface()->get_entries()== 1);
+	EXPECT_TRUE(statechart->isActive(EntryExitSelfTransition::B));
+	statechart->getSCInterface()->set_entries(0);
+	statechart->raise_e();
+	statechart->runCycle();
+	EXPECT_TRUE(statechart->getSCInterface()->get_entries()== 1);
+	EXPECT_TRUE(statechart->getSCInterface()->get_exits()== 1);
+	EXPECT_TRUE(statechart->isActive(EntryExitSelfTransition::C));
+	delete statechart;
+}
+TEST(StatemachineTest, SelfTransitionFromChildState) {
+	EntryExitSelfTransition* statechart = new EntryExitSelfTransition();
+	statechart->init();
+	statechart->enter();
+	statechart->runCycle();
+	EXPECT_TRUE(statechart->getSCInterface()->get_entries()== 1);
+	statechart->getSCInterface()->set_entries(0);
+	statechart->raise_e1();
+	statechart->runCycle();
+	EXPECT_TRUE(statechart->getSCInterface()->get_entries()== 0);
+	EXPECT_TRUE(statechart->getSCInterface()->get_exits()== 0);
+	EXPECT_TRUE(statechart->isActive(EntryExitSelfTransition::C));
+	statechart->raise_e1();
+	statechart->runCycle();
+	EXPECT_TRUE(statechart->isActive(EntryExitSelfTransition::B));
+	EXPECT_TRUE(statechart->getSCInterface()->get_entries()== 1);
+	EXPECT_TRUE(statechart->getSCInterface()->get_exits()== 1);
+	delete statechart;
+}

test-plugins/org.yakindu.sct.generator.cpp.test/gtests/LocalReactionsTest/LocalReactions.sgen

@@ -1,8 +1,8 @@
-GeneratorModel for yakindu::cpp {
-	statechart LocalReactions {
-		feature Outlet {
-			targetProject = "gtests"
-			targetFolder = "LocalReactionsTest"
-		}
-	}
-}
+GeneratorModel for yakindu::cpp {
+	statechart LocalReactions {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "LocalReactionsTest"
+		}
+	}
+}

test-plugins/org.yakindu.sct.generator.cpp.test/gtests/LocalReactionsTest/LocalReactionsTest.cc

@@ -1,23 +1,23 @@
-/**
-* Copyright (c) 2014 committers of YAKINDU and others.
-* All rights reserved. This program and the accompanying materials
-* are made available under the terms of the Eclipse Public License v1.0
-* which accompanies this distribution, and is available at
-* http://www.eclipse.org/legal/epl-v10.html
-*
-* Contributors:
-*     committers of YAKINDU - initial API and implementation
-*/
-#include <string>
-#include "gtest/gtest.h"
-#include "LocalReactions.h"
-
-TEST(StatemachineTest, LocalReactionsTest) {
-	LocalReactions* statechart = new LocalReactions();
-	statechart->init();
-	statechart->enter();
-	EXPECT_TRUE(statechart->isActive(LocalReactions::A));
-	statechart->runCycle();
-	EXPECT_TRUE(statechart->getSCInterface()->get_x()== 1);
-	delete statechart;
-}
+/**
+* Copyright (c) 2014 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "LocalReactions.h"
+
+TEST(StatemachineTest, LocalReactionsTest) {
+	LocalReactions* statechart = new LocalReactions();
+	statechart->init();
+	statechart->enter();
+	EXPECT_TRUE(statechart->isActive(LocalReactions::A));
+	statechart->runCycle();
+	EXPECT_TRUE(statechart->getSCInterface()->get_x()== 1);
+	delete statechart;
+}

test-plugins/org.yakindu.sct.generator.cpp.test/gtests/SimpleEventTest/SimpleEvent.sgen

@@ -1,8 +1,8 @@
-GeneratorModel for yakindu::cpp {
-	statechart SimpleEvent {
-		feature Outlet {
-			targetProject = "gtests"
-			targetFolder = "SimpleEventTest"
-		}
-	}
-}
+GeneratorModel for yakindu::cpp {
+	statechart SimpleEvent {
+		feature Outlet {
+			targetProject = "gtests"
+			targetFolder = "SimpleEventTest"
+		}
+	}
+}

test-plugins/org.yakindu.sct.generator.cpp.test/gtests/SimpleEventTest/SimpleEventTest.cc

@@ -1,27 +1,27 @@
-/**
-* Copyright (c) 2014 committers of YAKINDU and others.
-* All rights reserved. This program and the accompanying materials
-* are made available under the terms of the Eclipse Public License v1.0
-* which accompanies this distribution, and is available at
-* http://www.eclipse.org/legal/epl-v10.html
-*
-* Contributors:
-*     committers of YAKINDU - initial API and implementation
-*/
-#include <string>
-#include "gtest/gtest.h"
-#include "SimpleEvent.h"
-
-TEST(StatemachineTest, simpleEventTest) {
-	SimpleEvent* statechart = new SimpleEvent();
-	statechart->init();
-	statechart->enter();
-	EXPECT_TRUE(statechart->isActive(SimpleEvent::A)) << "Expected A to be active" ;
-	EXPECT_TRUE(5== 5);
-	statechart->raise_event1();
-	statechart->runCycle();
-	EXPECT_TRUE(statechart->isActive(SimpleEvent::B)) << "Expected B to be active" ;
-	statechart->runCycle();
-	EXPECT_TRUE(!statechart->isActive(SimpleEvent::B));
-	delete statechart;
-}
+/**
+* Copyright (c) 2014 committers of YAKINDU and others.
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v1.0
+* which accompanies this distribution, and is available at
+* http://www.eclipse.org/legal/epl-v10.html
+*
+* Contributors:
+*     committers of YAKINDU - initial API and implementation
+*/
+#include <string>
+#include "gtest/gtest.h"
+#include "SimpleEvent.h"
+
+TEST(StatemachineTest, simpleEventTest) {
+	SimpleEvent* statechart = new SimpleEvent();
+	statechart->init();
+	statechart->enter();
+	EXPECT_TRUE(statechart->isActive(SimpleEvent::A)) << "Expected A to be active" ;
+	EXPECT_TRUE(5== 5);
+	statechart->raise_event1();
+	statechart->runCycle();
+	EXPECT_TRUE(statechart->isActive(SimpleEvent::B)) << "Expected B to be active" ;
+	statechart->runCycle();
+	EXPECT_TRUE(!statechart->isActive(SimpleEvent::B));
+	delete statechart;
+}

test-plugins/org.yakindu.sct.generator.cpp.test/test-gen/org/yakindu/sct/generator/cpp/test/AllTestsTest.java

@@ -1,38 +1,38 @@
-/**
- * Copyright (c) 2014 committers of YAKINDU and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     committers of YAKINDU - initial API and implementation
- */
-package org.yakindu.sct.generator.cpp.test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-import org.junit.runners.Suite.SuiteClasses;
-
-@RunWith(Suite.class)
-@SuiteClasses({AlwaysOncycleTest.class, AssignmentAsExpressionTest.class,
-		BitExpressionsTest.class, BooleanExpressionsTest.class,
-		ChoiceTest.class, CKeywordsTest.class, ConditionalExpressionTest.class,
-		DeclarationsTest.class, DeepEntryTest.class, DeepHistoryTest.class,
-		DynamicChoiceTest.class, EnterStateTest.class, EntryChoiceTest.class,
-		EntryExitSelfTransitionTest.class, ExitOnSelfTransitionTest.class,
-		ExitStateTest.class, FeatureCallsTest.class, GuardTest.class,
-		GuardedEntryTest.class, GuardedExitTest.class,
-		HistoryWithoutInitialStepTest.class, InEventLifeCycleTest.class,
-		IntegerExpressionsTest.class, InternalEventLifeCycleTest.class,
-		LocalReactionsTest.class, LogicalAndTestsTest.class,
-		LogicalOrTestsTest.class, NamedInterfaceAccessTest.class,
-		OutEventLifeCycleTest.class, ParenthesisTest.class,
-		PriorityValuesTest.class, RaiseEventTest.class,
-		SameNameDifferentRegionTest.class, ShallowHistoryTest.class,
-		SimpleEventTest.class, StatechartLocalReactionsTest.class,
-		SimpleHierachyTest.class, StateIsActiveTest.class,
-		StaticChoiceTest.class, STextKeywordsInStatesAndRegionsTest.class,
-		StringExpressionsTest.class, SyncForkTest.class, SyncJoinTest.class,
-		TransitionWithoutConditionTest.class, ValuedEventsTest.class})
-public class AllTestsTest {
-}
+/**
+ * Copyright (c) 2014 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.generator.cpp.test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({AlwaysOncycleTest.class, AssignmentAsExpressionTest.class,
+		BitExpressionsTest.class, BooleanExpressionsTest.class,
+		ChoiceTest.class, CKeywordsTest.class, ConditionalExpressionTest.class,
+		DeclarationsTest.class, DeepEntryTest.class, DeepHistoryTest.class,
+		DynamicChoiceTest.class, EnterStateTest.class, EntryChoiceTest.class,
+		EntryExitSelfTransitionTest.class, ExitOnSelfTransitionTest.class,
+		ExitStateTest.class, FeatureCallsTest.class, GuardTest.class,
+		GuardedEntryTest.class, GuardedExitTest.class,
+		HistoryWithoutInitialStepTest.class, InEventLifeCycleTest.class,
+		IntegerExpressionsTest.class, InternalEventLifeCycleTest.class,
+		LocalReactionsTest.class, LogicalAndTestsTest.class,
+		LogicalOrTestsTest.class, NamedInterfaceAccessTest.class,
+		OutEventLifeCycleTest.class, ParenthesisTest.class,
+		PriorityValuesTest.class, RaiseEventTest.class,
+		SameNameDifferentRegionTest.class, ShallowHistoryTest.class,
+		SimpleEventTest.class, StatechartLocalReactionsTest.class,
+		SimpleHierachyTest.class, StateIsActiveTest.class,
+		StaticChoiceTest.class, STextKeywordsInStatesAndRegionsTest.class,
+		StringExpressionsTest.class, SyncForkTest.class, SyncJoinTest.class,
+		TransitionWithoutConditionTest.class, ValuedEventsTest.class})
+public class AllTestsTest {
+}

test-plugins/org.yakindu.sct.generator.cpp.test/test-gen/org/yakindu/sct/generator/cpp/test/ConditionalExpressionTest.java

@@ -1,39 +1,39 @@
-/**
- * Copyright (c) 2014 committers of YAKINDU and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     committers of YAKINDU - initial API and implementation
- */
-package org.yakindu.sct.generator.cpp.test;
-
-import java.util.Collection;
-
-import org.junit.Before;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.generator.c.gtest.GTest;
-import org.yakindu.sct.generator.c.gtest.GTestRunner;
-import org.yakindu.sct.generator.c.gtest.GTestHelper;
-
-@GTest(sourceFile = "gtests/ConditionalExpressionTest/ConditionalExpressionTest.cc", program = "gtests/ConditionalExpressionTest/ConditionalExpressions", model = "testmodels/SCTUnit/ConditionalExpressions.sct")
-@RunWith(GTestRunner.class)
-public class ConditionalExpressionTest {
-
-	protected final GTestHelper helper = new GTestHelper(this) {
-
-		@Override
-		protected void getSourceFiles(Collection<String> files) {
-			super.getSourceFiles(files);
-			files.add(getFileName(getTestProgram()) + ".cpp");
-		}
-	};
-
-	@Before
-	public void setUp() {
-		helper.generate();
-		helper.compile();
-	}
-}
+/**
+ * Copyright (c) 2014 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.generator.cpp.test;
+
+import java.util.Collection;
+
+import org.junit.Before;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.generator.c.gtest.GTest;
+import org.yakindu.sct.generator.c.gtest.GTestRunner;
+import org.yakindu.sct.generator.c.gtest.GTestHelper;
+
+@GTest(sourceFile = "gtests/ConditionalExpressionTest/ConditionalExpressionTest.cc", program = "gtests/ConditionalExpressionTest/ConditionalExpressions", model = "testmodels/SCTUnit/ConditionalExpressions.sct")
+@RunWith(GTestRunner.class)
+public class ConditionalExpressionTest {
+
+	protected final GTestHelper helper = new GTestHelper(this) {
+
+		@Override
+		protected void getSourceFiles(Collection<String> files) {
+			super.getSourceFiles(files);
+			files.add(getFileName(getTestProgram()) + ".cpp");
+		}
+	};
+
+	@Before
+	public void setUp() {
+		helper.generate();
+		helper.compile();
+	}
+}

test-plugins/org.yakindu.sct.generator.cpp.test/test-gen/org/yakindu/sct/generator/cpp/test/EntryExitSelfTransitionTest.java

@@ -1,39 +1,39 @@
-/**
- * Copyright (c) 2014 committers of YAKINDU and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     committers of YAKINDU - initial API and implementation
- */
-package org.yakindu.sct.generator.cpp.test;
-
-import java.util.Collection;
-
-import org.junit.Before;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.generator.c.gtest.GTest;
-import org.yakindu.sct.generator.c.gtest.GTestRunner;
-import org.yakindu.sct.generator.c.gtest.GTestHelper;
-
-@GTest(sourceFile = "gtests/EntryExitSelfTransitionTest/EntryExitSelfTransitionTest.cc", program = "gtests/EntryExitSelfTransitionTest/EntryExitSelfTransition", model = "testmodels/SCTUnit/EntryExitSelfTransition.sct")
-@RunWith(GTestRunner.class)
-public class EntryExitSelfTransitionTest {
-
-	protected final GTestHelper helper = new GTestHelper(this) {
-
-		@Override
-		protected void getSourceFiles(Collection<String> files) {
-			super.getSourceFiles(files);
-			files.add(getFileName(getTestProgram()) + ".cpp");
-		}
-	};
-
-	@Before
-	public void setUp() {
-		helper.generate();
-		helper.compile();
-	}
-}
+/**
+ * Copyright (c) 2014 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.generator.cpp.test;
+
+import java.util.Collection;
+
+import org.junit.Before;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.generator.c.gtest.GTest;
+import org.yakindu.sct.generator.c.gtest.GTestRunner;
+import org.yakindu.sct.generator.c.gtest.GTestHelper;
+
+@GTest(sourceFile = "gtests/EntryExitSelfTransitionTest/EntryExitSelfTransitionTest.cc", program = "gtests/EntryExitSelfTransitionTest/EntryExitSelfTransition", model = "testmodels/SCTUnit/EntryExitSelfTransition.sct")
+@RunWith(GTestRunner.class)
+public class EntryExitSelfTransitionTest {
+
+	protected final GTestHelper helper = new GTestHelper(this) {
+
+		@Override
+		protected void getSourceFiles(Collection<String> files) {
+			super.getSourceFiles(files);
+			files.add(getFileName(getTestProgram()) + ".cpp");
+		}
+	};
+
+	@Before
+	public void setUp() {
+		helper.generate();
+		helper.compile();
+	}
+}

test-plugins/org.yakindu.sct.generator.cpp.test/test-gen/org/yakindu/sct/generator/cpp/test/LocalReactionsTest.java

@@ -1,39 +1,39 @@
-/**
- * Copyright (c) 2014 committers of YAKINDU and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     committers of YAKINDU - initial API and implementation
- */
-package org.yakindu.sct.generator.cpp.test;
-
-import java.util.Collection;
-
-import org.junit.Before;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.generator.c.gtest.GTest;
-import org.yakindu.sct.generator.c.gtest.GTestRunner;
-import org.yakindu.sct.generator.c.gtest.GTestHelper;
-
-@GTest(sourceFile = "gtests/LocalReactionsTest/LocalReactionsTest.cc", program = "gtests/LocalReactionsTest/LocalReactions", model = "testmodels/SCTUnit/LocalReactions.sct")
-@RunWith(GTestRunner.class)
-public class LocalReactionsTest {
-
-	protected final GTestHelper helper = new GTestHelper(this) {
-
-		@Override
-		protected void getSourceFiles(Collection<String> files) {
-			super.getSourceFiles(files);
-			files.add(getFileName(getTestProgram()) + ".cpp");
-		}
-	};
-
-	@Before
-	public void setUp() {
-		helper.generate();
-		helper.compile();
-	}
-}
+/**
+ * Copyright (c) 2014 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.generator.cpp.test;
+
+import java.util.Collection;
+
+import org.junit.Before;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.generator.c.gtest.GTest;
+import org.yakindu.sct.generator.c.gtest.GTestRunner;
+import org.yakindu.sct.generator.c.gtest.GTestHelper;
+
+@GTest(sourceFile = "gtests/LocalReactionsTest/LocalReactionsTest.cc", program = "gtests/LocalReactionsTest/LocalReactions", model = "testmodels/SCTUnit/LocalReactions.sct")
+@RunWith(GTestRunner.class)
+public class LocalReactionsTest {
+
+	protected final GTestHelper helper = new GTestHelper(this) {
+
+		@Override
+		protected void getSourceFiles(Collection<String> files) {
+			super.getSourceFiles(files);
+			files.add(getFileName(getTestProgram()) + ".cpp");
+		}
+	};
+
+	@Before
+	public void setUp() {
+		helper.generate();
+		helper.compile();
+	}
+}

test-plugins/org.yakindu.sct.generator.cpp.test/test-gen/org/yakindu/sct/generator/cpp/test/SimpleEventTest.java

@@ -1,39 +1,39 @@
-/**
- * Copyright (c) 2014 committers of YAKINDU and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     committers of YAKINDU - initial API and implementation
- */
-package org.yakindu.sct.generator.cpp.test;
-
-import java.util.Collection;
-
-import org.junit.Before;
-import org.junit.runner.RunWith;
-import org.yakindu.sct.generator.c.gtest.GTest;
-import org.yakindu.sct.generator.c.gtest.GTestRunner;
-import org.yakindu.sct.generator.c.gtest.GTestHelper;
-
-@GTest(sourceFile = "gtests/SimpleEventTest/SimpleEventTest.cc", program = "gtests/SimpleEventTest/SimpleEvent", model = "testmodels/SCTUnit/SimpleEvent.sct")
-@RunWith(GTestRunner.class)
-public class SimpleEventTest {
-
-	protected final GTestHelper helper = new GTestHelper(this) {
-
-		@Override
-		protected void getSourceFiles(Collection<String> files) {
-			super.getSourceFiles(files);
-			files.add(getFileName(getTestProgram()) + ".cpp");
-		}
-	};
-
-	@Before
-	public void setUp() {
-		helper.generate();
-		helper.compile();
-	}
-}
+/**
+ * Copyright (c) 2014 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.generator.cpp.test;
+
+import java.util.Collection;
+
+import org.junit.Before;
+import org.junit.runner.RunWith;
+import org.yakindu.sct.generator.c.gtest.GTest;
+import org.yakindu.sct.generator.c.gtest.GTestRunner;
+import org.yakindu.sct.generator.c.gtest.GTestHelper;
+
+@GTest(sourceFile = "gtests/SimpleEventTest/SimpleEventTest.cc", program = "gtests/SimpleEventTest/SimpleEvent", model = "testmodels/SCTUnit/SimpleEvent.sct")
+@RunWith(GTestRunner.class)
+public class SimpleEventTest {
+
+	protected final GTestHelper helper = new GTestHelper(this) {
+
+		@Override
+		protected void getSourceFiles(Collection<String> files) {
+			super.getSourceFiles(files);
+			files.add(getFileName(getTestProgram()) + ".cpp");
+		}
+	};
+
+	@Before
+	public void setUp() {
+		helper.generate();
+		helper.compile();
+	}
+}

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,191 +1,191 @@
-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();
-	}
-}
+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 long getValue();
-		public void setValue(long 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 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();
-
-}
+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,317 +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 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();
-	}
-}
+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 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();
-
-}
+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,298 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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,266 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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 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();
-
-}
+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/conditionalexpressions/ConditionalExpressionsStatemachine.java

@@ -1,193 +1,193 @@
-package org.yakindu.scr.conditionalexpressions;
-
-public class ConditionalExpressionsStatemachine
-		implements
-			IConditionalExpressionsStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private long condition;
-
-		public long getCondition() {
-			return condition;
-		}
-
-		public void setCondition(long value) {
-			this.condition = value;
-		}
-
-		private boolean boolVar;
-
-		public boolean getBoolVar() {
-			return boolVar;
-		}
-
-		public void setBoolVar(boolean value) {
-			this.boolVar = 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 ConditionalExpressionsStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.condition = sCInterface.boolVar ? 3 : 2;
-
-		sCInterface.boolVar = true;
-	}
-
-	public void enter() {
-		entryAction();
-
-		sCInterface.condition = sCInterface.boolVar ? 1 : 0;
-
-		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 long getCondition() {
-		return sCInterface.getCondition();
-	}
-
-	public void setCondition(long value) {
-		sCInterface.setCondition(value);
-	}
-	public boolean getBoolVar() {
-		return sCInterface.getBoolVar();
-	}
-
-	public void setBoolVar(boolean value) {
-		sCInterface.setBoolVar(value);
-	}
-
-	/* Entry action for statechart 'ConditionalExpressions'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'ConditionalExpressions'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.e && 1 == (sCInterface.boolVar ? 1 : 0)) {
-			nextStateIndex = 0;
-			stateVector[0] = State.$NullState$;
-
-			sCInterface.condition = ((sCInterface.condition == 2) ? 1 : 2);
-
-			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.conditionalexpressions;
+
+public class ConditionalExpressionsStatemachine
+		implements
+			IConditionalExpressionsStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private long condition;
+
+		public long getCondition() {
+			return condition;
+		}
+
+		public void setCondition(long value) {
+			this.condition = value;
+		}
+
+		private boolean boolVar;
+
+		public boolean getBoolVar() {
+			return boolVar;
+		}
+
+		public void setBoolVar(boolean value) {
+			this.boolVar = 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 ConditionalExpressionsStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.condition = sCInterface.boolVar ? 3 : 2;
+
+		sCInterface.boolVar = true;
+	}
+
+	public void enter() {
+		entryAction();
+
+		sCInterface.condition = sCInterface.boolVar ? 1 : 0;
+
+		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 long getCondition() {
+		return sCInterface.getCondition();
+	}
+
+	public void setCondition(long value) {
+		sCInterface.setCondition(value);
+	}
+	public boolean getBoolVar() {
+		return sCInterface.getBoolVar();
+	}
+
+	public void setBoolVar(boolean value) {
+		sCInterface.setBoolVar(value);
+	}
+
+	/* Entry action for statechart 'ConditionalExpressions'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'ConditionalExpressions'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.e && 1 == (sCInterface.boolVar ? 1 : 0)) {
+			nextStateIndex = 0;
+			stateVector[0] = State.$NullState$;
+
+			sCInterface.condition = ((sCInterface.condition == 2) ? 1 : 2);
+
+			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/conditionalexpressions/IConditionalExpressionsStatemachine.java

@@ -1,17 +1,17 @@
-package org.yakindu.scr.conditionalexpressions;
-import org.yakindu.scr.IStatemachine;
-
-public interface IConditionalExpressionsStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public long getCondition();
-		public void setCondition(long value);
-		public boolean getBoolVar();
-		public void setBoolVar(boolean value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.conditionalexpressions;
+import org.yakindu.scr.IStatemachine;
+
+public interface IConditionalExpressionsStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public long getCondition();
+		public void setCondition(long value);
+		public boolean getBoolVar();
+		public void setBoolVar(boolean value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

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

@@ -1,54 +1,54 @@
-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 long getVarE();
-		public void setVarE(long 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 long getVarE();
-		public void setVarE(long 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 long getVarE();
+		public void setVarE(long 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 long getVarE();
+		public void setVarE(long value);
+
+	}
+
+	public SCIIfA getSCIIfA();
+
+}

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

@@ -1,452 +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 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();
-	}
-}
+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 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();
-
-}
+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/dynamicchoice/DynamicChoiceStatemachine.java

@@ -1,189 +1,189 @@
-package org.yakindu.scr.dynamicchoice;
-
-public class DynamicChoiceStatemachine implements IDynamicChoiceStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean reset;
-
-		public void raiseReset() {
-			reset = true;
-		}
-
-		private long number;
-
-		public long getNumber() {
-			return number;
-		}
-
-		public void setNumber(long value) {
-			this.number = value;
-		}
-
-		public void clearEvents() {
-			reset = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_Start, main_region_A, main_region_B, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public DynamicChoiceStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.number = 0;
-	}
-
-	public void enter() {
-		entryAction();
-
-		sCInterface.number = 1;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_Start;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_Start :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-				break;
-
-			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_Start :
-				return stateVector[0] == State.main_region_Start;
-			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 raiseReset() {
-		sCInterface.raiseReset();
-	}
-
-	public long getNumber() {
-		return sCInterface.getNumber();
-	}
-
-	public void setNumber(long value) {
-		sCInterface.setNumber(value);
-	}
-
-	/* Entry action for statechart 'DynamicChoice'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'DynamicChoice'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state Start. */
-	private void reactMain_region_Start() {
-		nextStateIndex = 0;
-		stateVector[0] = State.$NullState$;
-
-		sCInterface.number += 1;
-
-		if (sCInterface.number == 2) {
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A;
-		} else {
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_B;
-		}
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-	}
-
-	/* 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_Start :
-					reactMain_region_Start();
-					break;
-				case main_region_A :
-					reactMain_region_A();
-					break;
-				case main_region_B :
-					reactMain_region_B();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.dynamicchoice;
+
+public class DynamicChoiceStatemachine implements IDynamicChoiceStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean reset;
+
+		public void raiseReset() {
+			reset = true;
+		}
+
+		private long number;
+
+		public long getNumber() {
+			return number;
+		}
+
+		public void setNumber(long value) {
+			this.number = value;
+		}
+
+		public void clearEvents() {
+			reset = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_Start, main_region_A, main_region_B, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public DynamicChoiceStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.number = 0;
+	}
+
+	public void enter() {
+		entryAction();
+
+		sCInterface.number = 1;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_Start;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_Start :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+				break;
+
+			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_Start :
+				return stateVector[0] == State.main_region_Start;
+			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 raiseReset() {
+		sCInterface.raiseReset();
+	}
+
+	public long getNumber() {
+		return sCInterface.getNumber();
+	}
+
+	public void setNumber(long value) {
+		sCInterface.setNumber(value);
+	}
+
+	/* Entry action for statechart 'DynamicChoice'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'DynamicChoice'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state Start. */
+	private void reactMain_region_Start() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+
+		sCInterface.number += 1;
+
+		if (sCInterface.number == 2) {
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A;
+		} else {
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_B;
+		}
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+	}
+
+	/* 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_Start :
+					reactMain_region_Start();
+					break;
+				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/dynamicchoice/IDynamicChoiceStatemachine.java

@@ -1,15 +1,15 @@
-package org.yakindu.scr.dynamicchoice;
-import org.yakindu.scr.IStatemachine;
-
-public interface IDynamicChoiceStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseReset();
-		public long getNumber();
-		public void setNumber(long value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.dynamicchoice;
+import org.yakindu.scr.IStatemachine;
+
+public interface IDynamicChoiceStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseReset();
+		public long getNumber();
+		public void setNumber(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

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

@@ -1,202 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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

@@ -1,102 +1,102 @@
-package org.yakindu.scr.entrychoice;
-
-public class EntryChoiceStatemachine implements IEntryChoiceStatemachine {
-
-	public enum State {
-		main_region_A, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public EntryChoiceStatemachine() {
-
-	}
-
-	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;
-
-			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;
-		}
-	}
-
-	/* Entry action for statechart 'EntryChoice'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'EntryChoice'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_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.entrychoice;
+
+public class EntryChoiceStatemachine implements IEntryChoiceStatemachine {
+
+	public enum State {
+		main_region_A, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public EntryChoiceStatemachine() {
+
+	}
+
+	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;
+
+			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;
+		}
+	}
+
+	/* Entry action for statechart 'EntryChoice'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'EntryChoice'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_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/entrychoice/IEntryChoiceStatemachine.java

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

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

@@ -1,201 +1,281 @@
-package org.yakindu.scr.entryexitselftransition;
-
-public class EntryExitSelfTransitionStatemachine
-		implements
-			IEntryExitSelfTransitionStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private boolean e;
-
-		public void raiseE() {
-			e = true;
-		}
-
-		private boolean e1;
-
-		public void raiseE1() {
-			e1 = true;
-		}
-
-		private long x;
-
-		public long getX() {
-			return x;
-		}
-
-		public void setX(long value) {
-			this.x = value;
-		}
-
-		public void clearEvents() {
-			e = false;
-			e1 = false;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, main_region_A__region0_B, main_region_A__region0_C, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public EntryExitSelfTransitionStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.x = 0;
-	}
-
-	public void enter() {
-		entryAction();
-
-		sCInterface.x += 1;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region_A__region0_B;
-	}
-
-	public void exit() {
-		switch (stateVector[0]) {
-			case main_region_A__region0_B :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				sCInterface.x += 1;
-				break;
-
-			case main_region_A__region0_C :
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				sCInterface.x += 1;
-				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].ordinal() >= State.main_region_A
-						.ordinal()
-						&& stateVector[0].ordinal() <= State.main_region_A__region0_C
-								.ordinal();
-			case main_region_A__region0_B :
-				return stateVector[0] == State.main_region_A__region0_B;
-			case main_region_A__region0_C :
-				return stateVector[0] == State.main_region_A__region0_C;
-			default :
-				return false;
-		}
-	}
-
-	public SCInterface getSCInterface() {
-		return sCInterface;
-	}
-
-	public void raiseE() {
-		sCInterface.raiseE();
-	}
-	public void raiseE1() {
-		sCInterface.raiseE1();
-	}
-
-	public long getX() {
-		return sCInterface.getX();
-	}
-
-	public void setX(long value) {
-		sCInterface.setX(value);
-	}
-
-	/* Entry action for statechart 'EntryExitSelfTransition'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'EntryExitSelfTransition'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state B. */
-	private void reactMain_region_A_region0_B() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A__region0_C;
-		} else {
-			if (sCInterface.e1) {
-				nextStateIndex = 0;
-				stateVector[0] = State.$NullState$;
-
-				nextStateIndex = 0;
-				stateVector[0] = State.main_region_A__region0_C;
-			}
-		}
-	}
-
-	/* The reactions of state C. */
-	private void reactMain_region_A_region0_C() {
-		if (sCInterface.e) {
-			nextStateIndex = 0;
-			stateVector[0] = State.main_region_A__region0_C;
-		} else {
-		}
-	}
-
-	public void runCycle() {
-
-		clearOutEvents();
-
-		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
-
-			switch (stateVector[nextStateIndex]) {
-				case main_region_A__region0_B :
-					reactMain_region_A_region0_B();
-					break;
-				case main_region_A__region0_C :
-					reactMain_region_A_region0_C();
-					break;
-				default :
-					// $NullState$
-			}
-		}
-
-		clearEvents();
-	}
-}
+package org.yakindu.scr.entryexitselftransition;
+
+public class EntryExitSelfTransitionStatemachine
+		implements
+			IEntryExitSelfTransitionStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private boolean e;
+
+		public void raiseE() {
+			e = true;
+		}
+
+		private boolean e1;
+
+		public void raiseE1() {
+			e1 = true;
+		}
+
+		private long exits;
+
+		public long getExits() {
+			return exits;
+		}
+
+		public void setExits(long value) {
+			this.exits = value;
+		}
+
+		private long entries;
+
+		public long getEntries() {
+			return entries;
+		}
+
+		public void setEntries(long value) {
+			this.entries = value;
+		}
+
+		public void clearEvents() {
+			e = false;
+			e1 = false;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, main_region_A__region0_B, main_region_A__region0_C, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public EntryExitSelfTransitionStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.exits = 0;
+
+		sCInterface.entries = 0;
+	}
+
+	public void enter() {
+		entryAction();
+
+		sCInterface.entries += 1;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region_A__region0_B;
+	}
+
+	public void exit() {
+		switch (stateVector[0]) {
+			case main_region_A__region0_B :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				sCInterface.exits += 1;
+				break;
+
+			case main_region_A__region0_C :
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				sCInterface.exits += 1;
+				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].ordinal() >= State.main_region_A
+						.ordinal()
+						&& stateVector[0].ordinal() <= State.main_region_A__region0_C
+								.ordinal();
+			case main_region_A__region0_B :
+				return stateVector[0] == State.main_region_A__region0_B;
+			case main_region_A__region0_C :
+				return stateVector[0] == State.main_region_A__region0_C;
+			default :
+				return false;
+		}
+	}
+
+	public SCInterface getSCInterface() {
+		return sCInterface;
+	}
+
+	public void raiseE() {
+		sCInterface.raiseE();
+	}
+	public void raiseE1() {
+		sCInterface.raiseE1();
+	}
+
+	public long getExits() {
+		return sCInterface.getExits();
+	}
+
+	public void setExits(long value) {
+		sCInterface.setExits(value);
+	}
+	public long getEntries() {
+		return sCInterface.getEntries();
+	}
+
+	public void setEntries(long value) {
+		sCInterface.setEntries(value);
+	}
+
+	/* Entry action for statechart 'EntryExitSelfTransition'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'EntryExitSelfTransition'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state B. */
+	private void reactMain_region_A_region0_B() {
+		if (sCInterface.e) {
+			switch (stateVector[0]) {
+				case main_region_A__region0_B :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				case main_region_A__region0_C :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			sCInterface.exits += 1;
+
+			sCInterface.entries += 1;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A__region0_C;
+		} else {
+			if (sCInterface.e1) {
+				nextStateIndex = 0;
+				stateVector[0] = State.$NullState$;
+
+				nextStateIndex = 0;
+				stateVector[0] = State.main_region_A__region0_C;
+			}
+		}
+	}
+
+	/* The reactions of state C. */
+	private void reactMain_region_A_region0_C() {
+		if (sCInterface.e) {
+			switch (stateVector[0]) {
+				case main_region_A__region0_B :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				case main_region_A__region0_C :
+					nextStateIndex = 0;
+					stateVector[0] = State.$NullState$;
+					break;
+
+				default :
+					break;
+			}
+
+			sCInterface.exits += 1;
+
+			sCInterface.entries += 1;
+
+			nextStateIndex = 0;
+			stateVector[0] = State.main_region_A__region0_C;
+		} else {
+			if (sCInterface.e1) {
+				switch (stateVector[0]) {
+					case main_region_A__region0_B :
+						nextStateIndex = 0;
+						stateVector[0] = State.$NullState$;
+						break;
+
+					case main_region_A__region0_C :
+						nextStateIndex = 0;
+						stateVector[0] = State.$NullState$;
+						break;
+
+					default :
+						break;
+				}
+
+				sCInterface.exits += 1;
+
+				sCInterface.entries += 1;
+
+				nextStateIndex = 0;
+				stateVector[0] = State.main_region_A__region0_B;
+			}
+		}
+	}
+
+	public void runCycle() {
+
+		clearOutEvents();
+
+		for (nextStateIndex = 0; nextStateIndex < stateVector.length; nextStateIndex++) {
+
+			switch (stateVector[nextStateIndex]) {
+				case main_region_A__region0_B :
+					reactMain_region_A_region0_B();
+					break;
+				case main_region_A__region0_C :
+					reactMain_region_A_region0_C();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}

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

@@ -1,16 +1,18 @@
-package org.yakindu.scr.entryexitselftransition;
-import org.yakindu.scr.IStatemachine;
-
-public interface IEntryExitSelfTransitionStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public void raiseE();
-		public void raiseE1();
-		public long getX();
-		public void setX(long value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.entryexitselftransition;
+import org.yakindu.scr.IStatemachine;
+
+public interface IEntryExitSelfTransitionStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public void raiseE();
+		public void raiseE1();
+		public long getExits();
+		public void setExits(long value);
+		public long getEntries();
+		public void setEntries(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

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

@@ -1,226 +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 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();
-	}
-}
+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 long getEntryCount();
-		public void setEntryCount(long value);
-		public long getExitCount();
-		public void setExitCount(long 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,253 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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,167 +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 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();
-	}
-}
+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 long getMyInt();
-		public void setMyInt(long 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,207 +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 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();
-	}
-}
+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 long getMyVar();
-		public void setMyVar(long 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,202 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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,202 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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,274 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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 long getI();
-		public void setI(long 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,152 +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 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();
-	}
-}
+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 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();
-
-}
+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,238 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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,104 +1,104 @@
-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 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 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 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 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/localreactions/ILocalReactionsStatemachine.java

@@ -1,14 +1,14 @@
-package org.yakindu.scr.localreactions;
-import org.yakindu.scr.IStatemachine;
-
-public interface ILocalReactionsStatemachine extends IStatemachine {
-
-	public interface SCInterface {
-		public long getX();
-		public void setX(long value);
-
-	}
-
-	public SCInterface getSCInterface();
-
-}
+package org.yakindu.scr.localreactions;
+import org.yakindu.scr.IStatemachine;
+
+public interface ILocalReactionsStatemachine extends IStatemachine {
+
+	public interface SCInterface {
+		public long getX();
+		public void setX(long value);
+
+	}
+
+	public SCInterface getSCInterface();
+
+}

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

@@ -1,135 +1,135 @@
-package org.yakindu.scr.localreactions;
-
-public class LocalReactionsStatemachine implements ILocalReactionsStatemachine {
-
-	private final class SCInterfaceImpl implements SCInterface {
-
-		private long x;
-
-		public long getX() {
-			return x;
-		}
-
-		public void setX(long value) {
-			this.x = value;
-		}
-
-	}
-
-	private SCInterfaceImpl sCInterface;
-
-	public enum State {
-		main_region_A, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public LocalReactionsStatemachine() {
-
-		sCInterface = new SCInterfaceImpl();
-	}
-
-	public void init() {
-		for (int i = 0; i < 1; i++) {
-			stateVector[i] = State.$NullState$;
-		}
-
-		clearEvents();
-		clearOutEvents();
-
-		sCInterface.x = 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() {
-
-	}
-
-	/**
-	 * 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);
-	}
-
-	/* Entry action for statechart 'LocalReactions'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'LocalReactions'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (sCInterface.x == 0) {
-			sCInterface.x += 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.localreactions;
+
+public class LocalReactionsStatemachine implements ILocalReactionsStatemachine {
+
+	private final class SCInterfaceImpl implements SCInterface {
+
+		private long x;
+
+		public long getX() {
+			return x;
+		}
+
+		public void setX(long value) {
+			this.x = value;
+		}
+
+	}
+
+	private SCInterfaceImpl sCInterface;
+
+	public enum State {
+		main_region_A, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public LocalReactionsStatemachine() {
+
+		sCInterface = new SCInterfaceImpl();
+	}
+
+	public void init() {
+		for (int i = 0; i < 1; i++) {
+			stateVector[i] = State.$NullState$;
+		}
+
+		clearEvents();
+		clearOutEvents();
+
+		sCInterface.x = 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() {
+
+	}
+
+	/**
+	 * 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);
+	}
+
+	/* Entry action for statechart 'LocalReactions'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'LocalReactions'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (sCInterface.x == 0) {
+			sCInterface.x += 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/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 long getX();
-		public void setX(long 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,160 +1,160 @@
-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();
-	}
-}
+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 long getX();
-		public void setX(long 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,160 +1,160 @@
-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();
-	}
-}
+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(long 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,336 +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 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();
-	}
-}
+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/nullcheck/INullCheckStatemachine.java

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

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

@@ -1,123 +1,123 @@
-package org.yakindu.scr.nullcheck;
-
-public class NullCheckStatemachine implements INullCheckStatemachine {
-
-	public enum State {
-		main_region_A, main_region_B, $NullState$
-	};
-
-	private final State[] stateVector = new State[1];
-
-	private int nextStateIndex;
-
-	public NullCheckStatemachine() {
-
-	}
-
-	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 'NullCheck'. */
-	private void entryAction() {
-	}
-
-	/* Exit action for state 'NullCheck'. */
-	private void exitAction() {
-	}
-
-	/* The reactions of state A. */
-	private void reactMain_region_A() {
-		if (null == null) {
-			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.nullcheck;
+
+public class NullCheckStatemachine implements INullCheckStatemachine {
+
+	public enum State {
+		main_region_A, main_region_B, $NullState$
+	};
+
+	private final State[] stateVector = new State[1];
+
+	private int nextStateIndex;
+
+	public NullCheckStatemachine() {
+
+	}
+
+	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 'NullCheck'. */
+	private void entryAction() {
+	}
+
+	/* Exit action for state 'NullCheck'. */
+	private void exitAction() {
+	}
+
+	/* The reactions of state A. */
+	private void reactMain_region_A() {
+		if (null == null) {
+			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/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(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();
-
-}
+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,215 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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,236 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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 long getErg();
-		public void setErg(long 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,134 +1,134 @@
-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();
-	}
-}
+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 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();
-
-}
+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,269 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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,211 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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,177 +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();
-	}
-
-	/**
-	 * 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();
-	}
-}
+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,168 +1,168 @@
-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, main_region__final_, $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;
-
-			case main_region__final_ :
-				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__final_ :
-				return stateVector[0] == State.main_region__final_;
-			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() {
-		nextStateIndex = 0;
-		stateVector[0] = State.$NullState$;
-
-		nextStateIndex = 0;
-		stateVector[0] = State.main_region__final_;
-	}
-
-	/* The reactions of state null. */
-	private void reactMain_region__final_0() {
-	}
-
-	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__final_ :
-					reactMain_region__final_0();
-					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, main_region__final_, $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;
+
+			case main_region__final_ :
+				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__final_ :
+				return stateVector[0] == State.main_region__final_;
+			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() {
+		nextStateIndex = 0;
+		stateVector[0] = State.$NullState$;
+
+		nextStateIndex = 0;
+		stateVector[0] = State.main_region__final_;
+	}
+
+	/* The reactions of state null. */
+	private void reactMain_region__final_0() {
+	}
+
+	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__final_ :
+					reactMain_region__final_0();
+					break;
+				default :
+					// $NullState$
+			}
+		}
+
+		clearEvents();
+	}
+}