Inlining Enter and Exit sequences for Regions

plugins/org.yakindu.sct.generator.core/src/org/yakindu/sct/generator/core/features/ICoreFeatureConstants.java

@@ -19,7 +19,7 @@ package org.yakindu.sct.generator.core.features;
 public interface ICoreFeatureConstants {
 
 	public static final String LIBRARY_NAME = "Core";
-	
+
 	public static final String OUTLET_FEATURE = "Outlet";
 	public static final String OUTLET_FEATURE_TARGET_PROJECT = "targetProject";
 	public static final String OUTLET_FEATURE_TARGET_FOLDER = "targetFolder";
@@ -35,6 +35,8 @@ public interface ICoreFeatureConstants {
 	public static final String FUNCTION_INLINING_FEATURE_INLINE_EXIT_ACTIONS = "inlineExitActions";
 	public static final String FUNCTION_INLINING_FEATURE_INLINE_EXIT_SEQUENCES = "inlineExitSequences";
 	public static final String FUNCTION_INLINING_FEATURE_INLINE_CHOICES = "inlineChoices";
+	public static final String FUNCTION_INLINING_FEATURE_INLINE_ENTER_REGION = "inlineEnterRegion";
+	public static final String FUNCTION_INLINING_FEATURE_INLINE_EXIT_REGION = "inlineExitRegion";
 
 	public static final String LICENSE_HEADER = "licenseHeader";
 	public static final String LICENSE_TEXT = "licenseText";

plugins/org.yakindu.sct.generator.core/src/org/yakindu/sct/generator/core/impl/AbstractSExecModelGenerator.java

@@ -19,6 +19,8 @@ import static org.yakindu.sct.generator.core.features.ICoreFeatureConstants.FUNC
 import static org.yakindu.sct.generator.core.features.ICoreFeatureConstants.FUNCTION_INLINING_FEATURE_INLINE_EXIT_ACTIONS;
 import static org.yakindu.sct.generator.core.features.ICoreFeatureConstants.FUNCTION_INLINING_FEATURE_INLINE_EXIT_SEQUENCES;
 import static org.yakindu.sct.generator.core.features.ICoreFeatureConstants.FUNCTION_INLINING_FEATURE_INLINE_REACTIONS;
+import static org.yakindu.sct.generator.core.features.ICoreFeatureConstants.FUNCTION_INLINING_FEATURE_INLINE_ENTER_REGION;
+import static org.yakindu.sct.generator.core.features.ICoreFeatureConstants.FUNCTION_INLINING_FEATURE_INLINE_EXIT_REGION;
 import static org.yakindu.sct.generator.core.features.ICoreFeatureConstants.OUTLET_FEATURE;
 import static org.yakindu.sct.generator.core.features.ICoreFeatureConstants.OUTLET_FEATURE_TARGET_PROJECT;
 
@@ -141,6 +143,10 @@ public abstract class AbstractSExecModelGenerator implements ISCTGenerator {
 				FUNCTION_INLINING_FEATURE_INLINE_EXIT_SEQUENCES, true));
 		optimizer.inlineChoices(getBoolValue(optimizeConfig,
 				FUNCTION_INLINING_FEATURE_INLINE_CHOICES, true));
+		optimizer.inlineEnterRegion(getBoolValue(optimizeConfig,
+				FUNCTION_INLINING_FEATURE_INLINE_ENTER_REGION, true));
+		optimizer.inlineExitRegion(getBoolValue(optimizeConfig,
+				FUNCTION_INLINING_FEATURE_INLINE_EXIT_REGION, true));
 
 		flow = optimizer.transform(flow);
 

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

@@ -75,6 +75,9 @@ String getName(ExecutionState this) :
 String getName(ExecutionNode this) :
 	simpleName.replaceAll(" ","").toFirstUpper();
 	
+String getName(ExecutionRegion this) :
+	name.replaceAll(" ","").toFirstUpper();
+	
 String getName(ExecutionFlow this) :
 	name.replaceAll(" ","").toFirstUpper();
 

plugins/org.yakindu.sct.model.sexec/src/org/yakindu/sct/model/sexec/transformation/FlowOptimizer.xtend

@@ -1,5 +1,7 @@
 package org.yakindu.sct.model.sexec.transformation
 
+import static extension org.eclipse.xtext.xtend2.lib.EObjectExtensions.*
+
 import com.google.inject.Inject
 import org.eclipse.xtext.naming.IQualifiedNameProvider
 import org.yakindu.sct.model.sexec.ExecutionFlow
@@ -19,6 +21,8 @@ import org.yakindu.sct.model.sgraph.SGraphFactory
 import org.yakindu.sct.model.stext.stext.StextFactory
 import org.yakindu.sct.model.sexec.StateSwitch
 import org.yakindu.sct.model.sexec.StateCase
+import org.eclipse.xtext.EcoreUtil2
+import org.yakindu.sct.model.sexec.ExecutionRegion
  
 class FlowOptimizer {
 
@@ -29,6 +33,8 @@ class FlowOptimizer {
 	boolean _inlineEntryActions     def inlineEntryActions(boolean b)   {_inlineEntryActions = b}
 	boolean _inlineExitActions      def inlineExitActions(boolean b)    {_inlineExitActions = b}
 	boolean _inlineEnterSequences   def inlineEnterSequences(boolean b) {_inlineEnterSequences = b}
+	boolean _inlineEnterRegion   def inlineEnterRegion(boolean b) {_inlineEnterRegion = b}
+	boolean _inlineExitRegion   def inlineExitRegion(boolean b) {_inlineExitRegion = b}
 	boolean _inlineExitSequences    def inlineExitSequences(boolean b)  {_inlineExitSequences = b}
 	boolean _inlineChoices          def inlineChoices(boolean b)        {_inlineChoices = b}
 	
@@ -44,6 +50,8 @@ class FlowOptimizer {
 		if (_inlineExitActions)   flow.states.forEach( state | state.exitAction.inline )
 		if (_inlineEnterSequences) flow.states.forEach( state | state.enterSequence.inline )
 		if (_inlineExitSequences)  flow.states.forEach( state | state.exitSequence.inline )
+		if (_inlineExitRegion) flow.allContentsIterable.filter(typeof(ExecutionRegion)).forEach( region | region.exitSequence.inline )
+		if (_inlineEnterRegion) flow.allContentsIterable.filter(typeof(ExecutionRegion)).forEach( region | region.enterSequence.inline )
 
 				
 		if (_inlineChoices) {

plugins/org.yakindu.sct.model.sexec/xtend-gen/org/yakindu/sct/model/sexec/transformation/FlowOptimizer.java

@@ -12,11 +12,13 @@ import org.eclipse.xtext.xbase.lib.IterableExtensions;
 import org.eclipse.xtext.xbase.lib.ListExtensions;
 import org.eclipse.xtext.xbase.lib.ObjectExtensions;
 import org.eclipse.xtext.xbase.lib.StringExtensions;
+import org.eclipse.xtext.xtend2.lib.EObjectExtensions;
 import org.yakindu.sct.model.sexec.Call;
 import org.yakindu.sct.model.sexec.Check;
 import org.yakindu.sct.model.sexec.CheckRef;
 import org.yakindu.sct.model.sexec.ExecutionFlow;
 import org.yakindu.sct.model.sexec.ExecutionNode;
+import org.yakindu.sct.model.sexec.ExecutionRegion;
 import org.yakindu.sct.model.sexec.ExecutionState;
 import org.yakindu.sct.model.sexec.If;
 import org.yakindu.sct.model.sexec.Reaction;
@@ -66,6 +68,20 @@ public class FlowOptimizer {
     return __inlineEnterSequences;
   }
   
+  private boolean _inlineEnterRegion;
+  
+  public boolean inlineEnterRegion(final boolean b) {
+    boolean __inlineEnterRegion = this._inlineEnterRegion = b;
+    return __inlineEnterRegion;
+  }
+  
+  private boolean _inlineExitRegion;
+  
+  public boolean inlineExitRegion(final boolean b) {
+    boolean __inlineExitRegion = this._inlineExitRegion = b;
+    return __inlineExitRegion;
+  }
+  
   private boolean _inlineExitSequences;
   
   public boolean inlineExitSequences(final boolean b) {
@@ -133,43 +149,67 @@ public class FlowOptimizer {
           };
         IterableExtensions.<ExecutionState>forEach(_states_3, _function_3);
       }
+      if (this._inlineExitRegion) {
+        Iterable<EObject> _allContentsIterable = EObjectExtensions.allContentsIterable(flow);
+        Iterable<ExecutionRegion> _filter = IterableExtensions.<ExecutionRegion>filter(_allContentsIterable, org.yakindu.sct.model.sexec.ExecutionRegion.class);
+        final Function1<ExecutionRegion,Step> _function_4 = new Function1<ExecutionRegion,Step>() {
+            public Step apply(final ExecutionRegion region) {
+              Sequence _exitSequence_1 = region.getExitSequence();
+              Step _inline_4 = FlowOptimizer.this.inline(_exitSequence_1);
+              return _inline_4;
+            }
+          };
+        IterableExtensions.<ExecutionRegion>forEach(_filter, _function_4);
+      }
+      if (this._inlineEnterRegion) {
+        Iterable<EObject> _allContentsIterable_1 = EObjectExtensions.allContentsIterable(flow);
+        Iterable<ExecutionRegion> _filter_1 = IterableExtensions.<ExecutionRegion>filter(_allContentsIterable_1, org.yakindu.sct.model.sexec.ExecutionRegion.class);
+        final Function1<ExecutionRegion,Step> _function_5 = new Function1<ExecutionRegion,Step>() {
+            public Step apply(final ExecutionRegion region_1) {
+              Sequence _enterSequence_1 = region_1.getEnterSequence();
+              Step _inline_5 = FlowOptimizer.this.inline(_enterSequence_1);
+              return _inline_5;
+            }
+          };
+        IterableExtensions.<ExecutionRegion>forEach(_filter_1, _function_5);
+      }
       if (this._inlineChoices) {
         {
           EList<ExecutionNode> _nodes = flow.getNodes();
-          final Function1<ExecutionNode,ExecutionNode> _function_4 = new Function1<ExecutionNode,ExecutionNode>() {
+          final Function1<ExecutionNode,ExecutionNode> _function_6 = new Function1<ExecutionNode,ExecutionNode>() {
               public ExecutionNode apply(final ExecutionNode node) {
                 ExecutionNode _xblockexpression_1 = null;
                 {
                   EList<Reaction> _reactions = node.getReactions();
-                  final Function1<Reaction,Step> _function_5 = new Function1<Reaction,Step>() {
+                  final Function1<Reaction,Step> _function_7 = new Function1<Reaction,Step>() {
                       public Step apply(final Reaction r) {
                         Step _xblockexpression_2 = null;
                         {
                           Check _check = r.getCheck();
                           FlowOptimizer.this.inline(_check);
                           Step _effect = r.getEffect();
-                          Step _inline_4 = FlowOptimizer.this.inline(_effect);
-                          _xblockexpression_2 = (_inline_4);
+                          Step _inline_6 = FlowOptimizer.this.inline(_effect);
+                          _xblockexpression_2 = (_inline_6);
                         }
                         return _xblockexpression_2;
                       }
                     };
-                  IterableExtensions.<Reaction>forEach(_reactions, _function_5);
+                  IterableExtensions.<Reaction>forEach(_reactions, _function_7);
                   _xblockexpression_1 = (node);
                 }
                 return _xblockexpression_1;
               }
             };
-          IterableExtensions.<ExecutionNode>forEach(_nodes, _function_4);
+          IterableExtensions.<ExecutionNode>forEach(_nodes, _function_6);
           EList<ExecutionNode> _nodes_1 = flow.getNodes();
-          final Function1<ExecutionNode,Step> _function_6 = new Function1<ExecutionNode,Step>() {
+          final Function1<ExecutionNode,Step> _function_8 = new Function1<ExecutionNode,Step>() {
               public Step apply(final ExecutionNode node_1) {
                 Sequence _reactSequence = node_1.getReactSequence();
-                Step _inline_5 = FlowOptimizer.this.inline(_reactSequence);
-                return _inline_5;
+                Step _inline_7 = FlowOptimizer.this.inline(_reactSequence);
+                return _inline_7;
               }
             };
-          IterableExtensions.<ExecutionNode>forEach(_nodes_1, _function_6);
+          IterableExtensions.<ExecutionNode>forEach(_nodes_1, _function_8);
         }
       }
       _xblockexpression = (flow);