sexec transformation creates StateVector elements for all states. ( YAKHMI-107 )

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

@@ -741,11 +741,55 @@ class ModelSequencer {
 	/************** Calculating Structure information **************/
 
 	def defineStateVector(ExecutionFlow flow, Statechart sc) {
+		var offset = 0
+		for ( r : sc.regions ) {
+			offset = offset + defineStateVectors(r, offset)	
+		}	
+		
+		
+//		flow.stateVector = sexecFactory.createStateVector
+//		flow.stateVector.offset = 0;
+//		flow.stateVector.size = sc.maxOrthogonality	
+		
 		flow.stateVector = sexecFactory.createStateVector
 		flow.stateVector.offset = 0;
-		flow.stateVector.size = sc.maxOrthogonality		
+		flow.stateVector.size = offset			
+	}
+
+
+	/** calculates the maximum orthogonality (maximum number of possible active leaf states) of the statechart */
+	def int defineStateVectors(Statechart sc, int offset) {
+		sc.regions.fold(0, [o, r | r.maxOrthogonality + o])
+	}
+
+	/** calculates the maximum orthogonality (maximum number of possible active leaf states) of a region */
+	def int defineStateVectors(Region r, int offset) {
+		r.vertices.fold(0, [s, v | {
+			val mo = v.defineStateVectors(offset)
+			if (mo > s) mo else s }])
 	}
 
+	/** the maximum orthogonality of all  pseudo states is 0 */
+	def dispatch int defineStateVectors(Vertex v, int offset) { 0 }
+	
+	/** calculates the maximum orthogonality (maximum number of possible active leaf states) of a state */
+	def dispatch int defineStateVectors(State s, int offset) { 
+		var int maxOrthogonality = 0
+		if ( s.regions.size > 0 ) {
+			for ( r : s.regions ) {
+				maxOrthogonality = maxOrthogonality + r.defineStateVectors(offset+maxOrthogonality)
+			}
+		} else maxOrthogonality = 1
+		
+		val es = s.create
+		es.stateVector = sexecFactory.createStateVector
+		es.stateVector.offset = offset;
+		es.stateVector.size = maxOrthogonality			
+		
+		return maxOrthogonality
+	}
+
+
 
 	/************** Calculating execution sequences **************/
 	

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

@@ -1512,14 +1512,91 @@ public class ModelSequencer {
   
   public void defineStateVector(final ExecutionFlow flow, final Statechart sc) {
     {
+      int offset = 0;
+      EList<Region> _regions = sc.getRegions();
+      for (Region r : _regions) {
+        int _defineStateVectors = this.defineStateVectors(r, offset);
+        int _operator_plus = IntegerExtensions.operator_plus(((Integer)offset), ((Integer)_defineStateVectors));
+        offset = _operator_plus;
+      }
       SexecFactory _sexecFactory = this.sexecFactory();
       StateVector _createStateVector = _sexecFactory.createStateVector();
       flow.setStateVector(_createStateVector);
       StateVector _stateVector = flow.getStateVector();
       _stateVector.setOffset(0);
       StateVector _stateVector_1 = flow.getStateVector();
-      int _maxOrthogonality = this.sct.maxOrthogonality(sc);
-      _stateVector_1.setSize(_maxOrthogonality);
+      _stateVector_1.setSize(offset);
+    }
+  }
+  
+  public int defineStateVectors(final Statechart sc, final int offset) {
+    EList<Region> _regions = sc.getRegions();
+    final Function2<Integer,Region,Integer> _function = new Function2<Integer,Region,Integer>() {
+        public Integer apply(final Integer o , final Region r) {
+          int _maxOrthogonality = ModelSequencer.this.sct.maxOrthogonality(r);
+          int _operator_plus = IntegerExtensions.operator_plus(((Integer)_maxOrthogonality), o);
+          return ((Integer)_operator_plus);
+        }
+      };
+    Integer _fold = IterableExtensions.<Region, Integer>fold(_regions, ((Integer)0), _function);
+    return _fold;
+  }
+  
+  public int defineStateVectors(final Region r, final int offset) {
+    EList<Vertex> _vertices = r.getVertices();
+    final Function2<Integer,Vertex,Integer> _function = new Function2<Integer,Vertex,Integer>() {
+        public Integer apply(final Integer s , final Vertex v) {
+          int _xblockexpression = (int) 0;
+          {
+            int _defineStateVectors = ModelSequencer.this.defineStateVectors(v, ((Integer)offset));
+            final int mo = _defineStateVectors;
+            int _xifexpression = (int) 0;
+            boolean _operator_greaterThan = ComparableExtensions.<Integer>operator_greaterThan(((Integer)mo), s);
+            if (_operator_greaterThan) {
+              _xifexpression = mo;
+            } else {
+              _xifexpression = s;
+            }
+            _xblockexpression = (_xifexpression);
+          }
+          return ((Integer)_xblockexpression);
+        }
+      };
+    Integer _fold = IterableExtensions.<Vertex, Integer>fold(_vertices, ((Integer)0), _function);
+    return _fold;
+  }
+  
+  protected int _defineStateVectors(final Vertex v, final int offset) {
+    return 0;
+  }
+  
+  protected int _defineStateVectors(final State s, final int offset) {
+    {
+      int maxOrthogonality = 0;
+      EList<Region> _regions = s.getRegions();
+      int _size = _regions.size();
+      boolean _operator_greaterThan = ComparableExtensions.<Integer>operator_greaterThan(((Integer)_size), ((Integer)0));
+      if (_operator_greaterThan) {
+        EList<Region> _regions_1 = s.getRegions();
+        for (Region r : _regions_1) {
+          int _operator_plus = IntegerExtensions.operator_plus(((Integer)offset), ((Integer)maxOrthogonality));
+          int _defineStateVectors = this.defineStateVectors(r, _operator_plus);
+          int _operator_plus_1 = IntegerExtensions.operator_plus(((Integer)maxOrthogonality), ((Integer)_defineStateVectors));
+          maxOrthogonality = _operator_plus_1;
+        }
+      } else {
+        maxOrthogonality = 1;
+      }
+      ExecutionState _create = this.factory.create(s);
+      final ExecutionState es = _create;
+      SexecFactory _sexecFactory = this.sexecFactory();
+      StateVector _createStateVector = _sexecFactory.createStateVector();
+      es.setStateVector(_createStateVector);
+      StateVector _stateVector = es.getStateVector();
+      _stateVector.setOffset(offset);
+      StateVector _stateVector_1 = es.getStateVector();
+      _stateVector_1.setSize(maxOrthogonality);
+      return maxOrthogonality;
     }
   }
   
@@ -2201,6 +2278,19 @@ public class ModelSequencer {
     }
   }
   
+  public int defineStateVectors(final Vertex s, final Integer offset) {
+    if ((s instanceof State)
+         && (offset instanceof Integer)) {
+      return _defineStateVectors((State)s, (Integer)offset);
+    } else if ((s instanceof Vertex)
+         && (offset instanceof Integer)) {
+      return _defineStateVectors((Vertex)s, (Integer)offset);
+    } else {
+      throw new IllegalArgumentException("Unhandled parameter types: " +
+        java.util.Arrays.<Object>asList(s, offset).toString());
+    }
+  }
+  
   public void defineStateEnterSequence(final NamedElement state) {
     if ((state instanceof FinalState)) {
       _defineStateEnterSequence((FinalState)state);

test-plugins/org.yakindu.sct.model.sexec.test/src/org/yakindu/sct/model/sexec/transformation/test/ModelSequencerStateVectorTest.java

@@ -10,6 +10,8 @@ import static org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil._creat
 
 import org.junit.Test;
 import org.yakindu.sct.model.sexec.ExecutionFlow;
+import org.yakindu.sct.model.sexec.ExecutionState;
+import org.yakindu.sct.model.sexec.StateVector;
 import org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil.OrthogonalFlatTSC;
 import org.yakindu.sct.model.sexec.transformation.test.SCTTestUtil.SimpleFlatTSC;
 import org.yakindu.sct.model.sgraph.Entry;
@@ -57,21 +59,29 @@ public class ModelSequencerStateVectorTest extends ModelSequencerTest {
 	 */
 	@Test public void testSCStateVectorDeepNonOrthopgonal() {
 		Statechart sc = _createStatechart("test");
-		Region r = _createRegion("sc_r", sc);
-		State s1 = _createState("s1", r);
+		Region r = _createRegion("r", sc);
+		_createState("s1", r);
 		State s2 = _createState("s2", r);
-		Region s2_r = _createRegion("s2_r", s2);
+		Region s2_r = _createRegion("r", s2);
 		State s2_1 = _createState("s2_1", s2_r);
-		State s2_2 = _createState("s2_2", s2_r);
-		Region s2_1_r = _createRegion("s2_1_r", s2_1);
-		State s2_1_1 = _createState("s2_1_1", s2_1_r);
-		State s2_1_2 = _createState("s2_1_2", s2_1_r);
+		Region s2_1_r = _createRegion("r", s2_1);
+		_createState("s2_1_1", s2_1_r);
+		_createState("s2_1_2", s2_1_r);
+		_createState("s2_2", s2_r);
 
 		ExecutionFlow flow = sequencer.transform(sc);
 		
 		assertNotNull(flow.getStateVector());
-		assertEquals(1, flow.getStateVector().getSize());
-		assertEquals(0, flow.getStateVector().getOffset());
+		assertStateVector(0, 1, flow.getStateVector());
+
+		
+		assertStateVector(0, 1, getAssertedExState(flow, 0, "test.r.s1").getStateVector());
+		assertStateVector(0, 1, getAssertedExState(flow, 1, "test.r.s2").getStateVector());
+		assertStateVector(0, 1, getAssertedExState(flow, 2, "test.r.s2.r.s2_1").getStateVector());
+		assertStateVector(0, 1, getAssertedExState(flow, 3, "test.r.s2.r.s2_1.r.s2_1_1").getStateVector());
+		assertStateVector(0, 1, getAssertedExState(flow, 4, "test.r.s2.r.s2_1.r.s2_1_2").getStateVector());
+		assertStateVector(0, 1, getAssertedExState(flow, 5, "test.r.s2.r.s2_2").getStateVector());
+
 	}
 
 	
@@ -83,39 +93,63 @@ public class ModelSequencerStateVectorTest extends ModelSequencerTest {
 		Statechart sc = _createStatechart("test");
 		
 		{  // first top region 
-			Region r = _createRegion("sc_r1", sc);
-			State s1 = _createState("s1", r);
+			Region r = _createRegion("r1", sc);
+			_createState("s1", r);
 			State s2 = _createState("s2", r);
 			{ // first sub region 
-				Region s2_r = _createRegion("s2_r", s2);
+				Region s2_r = _createRegion("r", s2);
 				State s2_1 = _createState("s2_1", s2_r);
-				State s2_2 = _createState("s2_2", s2_r);
 				{ // first sub sub region
-					Region s2_1_r = _createRegion("s2_1_r", s2_1);
-					State s2_1_1 = _createState("s2_1_1", s2_1_r);
-					State s2_1_2 = _createState("s2_1_2", s2_1_r);
+					Region s2_1_r = _createRegion("r1", s2_1);
+					_createState("s2_1_1", s2_1_r);
+					_createState("s2_1_2", s2_1_r);
 				}
 				{ // second sub sub region
-					Region s2_2_r = _createRegion("s2_1_r2", s2_1);
-					State s2_1_3 = _createState("s2_1_3", s2_2_r);
-					State s2_1_4 = _createState("s2_2_4", s2_2_r);
+					Region s2_2_r = _createRegion("r2", s2_1);
+					_createState("s2_1_3", s2_2_r);
+					_createState("s2_1_4", s2_2_r);
 				}
+				_createState("s2_2", s2_r);
 			}
 		}
 		{  // second top region 
-			Region r = _createRegion("sc_r2", sc);
-			State s1 = _createState("r2_s1", r);
-			State s2 = _createState("r2_s2", r);
+			Region r = _createRegion("r2", sc);
+			_createState("s3", r);
+			_createState("s4", r);
 		}
 
 
 		ExecutionFlow flow = sequencer.transform(sc);
 		
 		assertNotNull(flow.getStateVector());
-		assertEquals(3, flow.getStateVector().getSize());
-		assertEquals(0, flow.getStateVector().getOffset());
+		assertStateVector(0, 3, flow.getStateVector());
+		
+		assertStateVector(0, 1, getAssertedExState(flow, 0, "test.r1.s1").getStateVector());
+		assertStateVector(0, 2, getAssertedExState(flow, 1, "test.r1.s2").getStateVector());
+		assertStateVector(0, 2, getAssertedExState(flow, 2, "test.r1.s2.r.s2_1").getStateVector());
+		assertStateVector(0, 1, getAssertedExState(flow, 3, "test.r1.s2.r.s2_1.r1.s2_1_1").getStateVector());
+		assertStateVector(0, 1, getAssertedExState(flow, 4, "test.r1.s2.r.s2_1.r1.s2_1_2").getStateVector());
+		assertStateVector(1, 1, getAssertedExState(flow, 5, "test.r1.s2.r.s2_1.r2.s2_1_3").getStateVector());
+		assertStateVector(1, 1, getAssertedExState(flow, 6, "test.r1.s2.r.s2_1.r2.s2_1_4").getStateVector());
+		assertStateVector(0, 1, getAssertedExState(flow, 7, "test.r1.s2.r.s2_2").getStateVector());
+		assertStateVector(2, 1, getAssertedExState(flow, 8, "test.r2.s3").getStateVector());
+		assertStateVector(2, 1, getAssertedExState(flow, 9, "test.r2.s4").getStateVector());
+
 	}
 
+	public ExecutionState getAssertedExState(ExecutionFlow flow, int offset, String name) {
+		ExecutionState s = flow.getStates().get(offset);
+		assertEquals(name, s.getName());
+		
+		return s;
+	}
+	
+	public void assertStateVector(int offset, int size, StateVector sv) {
+		assertNotNull("state vector is null", sv);
+		assertEquals("wrong state vector offset -", offset, sv.getOffset());
+		assertEquals("wrong state vector size -", size, sv.getSize());		
+	}
+	
 	
 	/**
 	 * The state vector descriptor of the ExecutionFlow must have an offset of 0 and a size that is 
@@ -125,7 +159,7 @@ public class ModelSequencerStateVectorTest extends ModelSequencerTest {
 		Statechart sc = _createStatechart("test");
 		
 		{  // first top region 
-			Region r = _createRegion("sc_r1", sc);
+			_createRegion("sc_r1", sc);
 		}
 	
 		ExecutionFlow flow = sequencer.transform(sc);