Changed processing of orthogonal states to usage of state vector definitions ( YAKHMI-435 )

plugins/org.yakindu.sct.model.sexec.interpreter/src/org/yakindu/sct/model/sexec/interpreter/impl/ExecutionFlowInterpreter.xtend

@@ -62,6 +62,9 @@ import org.yakindu.sct.simulation.core.runtime.IExecutionFacade
 import org.yakindu.sct.model.sexec.interpreter.IExecutionFlowInterpreter
 import org.yakindu.sct.simulation.core.runtime.AbstractExecutionFacade
 import org.yakindu.sct.model.sexec.Trace
+import java.util.Arrays
+import org.yakindu.sct.model.sexec.impl.ExecutionStateImpl
+
 /**
  * 
  * @author andreas muelder - Initial contribution and API
@@ -82,12 +85,15 @@ class ExecutionFlowInterpreter extends AbstractExecutionFacade implements IExecu
 	String interpreterName
 	
 	ExecutionFlow flow
+	int nextSVIdx
 
 	override initialize(ExecutionFlow flow) {
 		this.flow = flow;
 		for(scope : flow.scopes){
 			scope.declareContents
 		} 
+		
+		executionContext.initStateConfigurationVector(flow.stateVector.size)
 	}
 	
 	override tearDown(){
@@ -121,10 +127,20 @@ class ExecutionFlowInterpreter extends AbstractExecutionFacade implements IExecu
 	}
 	
 	override runCycle() {
-		executionContext.stateConfiguration.toList.forEach(state | state.reactSequence.execute)
+		
+		nextSVIdx = 0; // this is a member that can be manipulated during state reactions in case of orthogonality
+		
+		while (nextSVIdx < executionContext.stateConfiguration.size) {
+			var state = executionContext.stateConfiguration.get(nextSVIdx)
+			if (state != null) state.reactSequence.execute			
+			nextSVIdx = nextSVIdx + 1
+		}  
+		
 		executionContext.resetRaisedEvents
+		
 	} 
 
+
 // begin TODO: this should be externalized
 	def isBoolean(Type type){
 		return type != null && type.name == "boolean"
@@ -206,20 +222,28 @@ class ExecutionFlowInterpreter extends AbstractExecutionFacade implements IExecu
 		return interpreterResult
 		
 	}
+	
 	def dispatch execute(EnterState enterState){
-		executionContext.stateConfiguration.add(enterState.state)
-//		notifyStateEntered(enterState.state)
+		executionContext.stateConfiguration.set(enterState.state.stateVector.offset, enterState.state)
+		nextSVIdx = enterState.state.stateVector.offset // mark all state vector elements up to this as processed ...		
+
+		System::out.println( "enter " + enterState.state.simpleName + " > " + executionContext.stateConfiguration.fold("scv: ", [ m, s | m + (if (s==null) " _" else " " + s.simpleName )] ) )
+
 		null
 	}
+	
 	def dispatch execute(Execution execution){ 
 		interpreter.evaluateStatement(execution.statement, executionContext)
 	}
 	
 	def dispatch execute(ExitState exitState){
-		executionContext.stateConfiguration.remove(exitState.state)
-//		notifyStateExited(exitState.state)
+		executionContext.stateConfiguration.set(exitState.state.stateVector.offset, null)
+
+		System::out.println( "exit " + exitState.state.simpleName + " > " + executionContext.stateConfiguration.fold("scv: ", [ m, s | m + (if (s==null) " _" else " " + s.simpleName )] ) )
+		
 		null
 	}
+	
 	def dispatch execute(If ifStep){
 		var check  = execute(ifStep.check)
 		if(check as Boolean){

plugins/org.yakindu.sct.model.sexec.interpreter/xtend-gen/org/yakindu/sct/model/sexec/interpreter/impl/ExecutionFlowInterpreter.java

@@ -7,8 +7,11 @@ import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.xtext.naming.QualifiedName;
 import org.eclipse.xtext.xbase.lib.BooleanExtensions;
-import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.ComparableExtensions;
+import org.eclipse.xtext.xbase.lib.Conversions;
+import org.eclipse.xtext.xbase.lib.Functions.Function2;
 import org.eclipse.xtext.xbase.lib.InputOutput;
+import org.eclipse.xtext.xbase.lib.IntegerExtensions;
 import org.eclipse.xtext.xbase.lib.IterableExtensions;
 import org.eclipse.xtext.xbase.lib.ObjectExtensions;
 import org.eclipse.xtext.xbase.lib.StringExtensions;
@@ -25,6 +28,7 @@ import org.yakindu.sct.model.sexec.ScheduleTimeEvent;
 import org.yakindu.sct.model.sexec.Sequence;
 import org.yakindu.sct.model.sexec.StateCase;
 import org.yakindu.sct.model.sexec.StateSwitch;
+import org.yakindu.sct.model.sexec.StateVector;
 import org.yakindu.sct.model.sexec.Step;
 import org.yakindu.sct.model.sexec.TimeEvent;
 import org.yakindu.sct.model.sexec.Trace;
@@ -67,13 +71,18 @@ public class ExecutionFlowInterpreter extends AbstractExecutionFacade implements
   
   private ExecutionFlow flow;
   
+  private int nextSVIdx;
+  
   public void initialize(final ExecutionFlow flow) throws NumberFormatException {
     {
       this.flow = flow;
       EList<Scope> _scopes = flow.getScopes();
-      for (final Scope scope : _scopes) {
+      for (Scope scope : _scopes) {
         this.declareContents(scope);
       }
+      StateVector _stateVector = flow.getStateVector();
+      int _size = _stateVector.getSize();
+      this.executionContext.initStateConfigurationVector(_size);
     }
   }
   
@@ -91,37 +100,50 @@ public class ExecutionFlowInterpreter extends AbstractExecutionFacade implements
   
   protected void _declareContents(final InternalScope scope) throws NumberFormatException {
     EList<Declaration> _declarations = scope.getDeclarations();
-    for (final Declaration declaration : _declarations) {
+    for (Declaration declaration : _declarations) {
       this.addToScope(declaration);
     }
   }
   
   protected void _declareContents(final Scope scope) throws NumberFormatException {
     EList<Declaration> _declarations = scope.getDeclarations();
-    for (final Declaration declaration : _declarations) {
+    for (Declaration declaration : _declarations) {
       this.addToScope(declaration);
     }
   }
   
   protected void _declareContents(final InterfaceScope scope) throws NumberFormatException {
     EList<Declaration> _declarations = scope.getDeclarations();
-    for (final Declaration declaration : _declarations) {
+    for (Declaration declaration : _declarations) {
       this.addToScope(declaration);
     }
   }
   
-  public void runCycle() {
+  public void runCycle() throws ExecutionException {
     {
-      List<ExecutionState> _stateConfiguration = this.executionContext.getStateConfiguration();
-      List<ExecutionState> _list = IterableExtensions.<ExecutionState>toList(_stateConfiguration);
-      final Function1<ExecutionState,Object> _function = new Function1<ExecutionState,Object>() {
-          public Object apply(final ExecutionState state) {
+      this.nextSVIdx = 0;
+      ExecutionState[] _stateConfiguration = this.executionContext.getStateConfiguration();
+      int _size = ((List<ExecutionState>)Conversions.doWrapArray(_stateConfiguration)).size();
+      boolean _operator_lessThan = ComparableExtensions.<Integer>operator_lessThan(((Integer)this.nextSVIdx), ((Integer)_size));
+      Boolean _xwhileexpression = _operator_lessThan;
+      while (_xwhileexpression) {
+        {
+          ExecutionState[] _stateConfiguration_1 = this.executionContext.getStateConfiguration();
+          ExecutionState _get = ((List<ExecutionState>)Conversions.doWrapArray(_stateConfiguration_1)).get(this.nextSVIdx);
+          ExecutionState state = _get;
+          boolean _operator_notEquals = ObjectExtensions.operator_notEquals(state, null);
+          if (_operator_notEquals) {
             Sequence _reactSequence = state.getReactSequence();
-            Object _execute = ExecutionFlowInterpreter.this.execute(_reactSequence);
-            return _execute;
+            this.execute(_reactSequence);
           }
-        };
-      IterableExtensions.<ExecutionState>forEach(_list, _function);
+          int _operator_plus = IntegerExtensions.operator_plus(((Integer)this.nextSVIdx), ((Integer)1));
+          this.nextSVIdx = _operator_plus;
+        }
+        ExecutionState[] _stateConfiguration_2 = this.executionContext.getStateConfiguration();
+        int _size_1 = ((List<ExecutionState>)Conversions.doWrapArray(_stateConfiguration_2)).size();
+        boolean _operator_lessThan_1 = ComparableExtensions.<Integer>operator_lessThan(((Integer)this.nextSVIdx), ((Integer)_size_1));
+        _xwhileexpression = _operator_lessThan_1;
+      }
       this.executionContext.resetRaisedEvents();
     }
   }
@@ -262,7 +284,7 @@ public class ExecutionFlowInterpreter extends AbstractExecutionFacade implements
   public void enter() throws ExecutionException {
     Sequence _enterSequence = this.flow.getEnterSequence();
     EList<Step> _steps = _enterSequence.getSteps();
-    for (final Step step : _steps) {
+    for (Step step : _steps) {
       this.execute(step);
     }
   }
@@ -297,7 +319,7 @@ public class ExecutionFlowInterpreter extends AbstractExecutionFacade implements
       Statement _condition = check.getCondition();
       boolean _operator_equals = ObjectExtensions.operator_equals(_condition, null);
       if (_operator_equals) {
-        return ((Boolean)true);
+        return true;
       }
       Statement _condition_1 = check.getCondition();
       Object _evaluateStatement = this.interpreter.evaluateStatement(_condition_1, this.executionContext);
@@ -309,9 +331,39 @@ public class ExecutionFlowInterpreter extends AbstractExecutionFacade implements
   protected Object _execute(final EnterState enterState) {
     Object _xblockexpression = null;
     {
-      List<ExecutionState> _stateConfiguration = this.executionContext.getStateConfiguration();
+      ExecutionState[] _stateConfiguration = this.executionContext.getStateConfiguration();
       ExecutionState _state = enterState.getState();
-      _stateConfiguration.add(_state);
+      StateVector _stateVector = _state.getStateVector();
+      int _offset = _stateVector.getOffset();
+      ExecutionState _state_1 = enterState.getState();
+      ((List<ExecutionState>)Conversions.doWrapArray(_stateConfiguration)).set(_offset, _state_1);
+      ExecutionState _state_2 = enterState.getState();
+      StateVector _stateVector_1 = _state_2.getStateVector();
+      int _offset_1 = _stateVector_1.getOffset();
+      this.nextSVIdx = _offset_1;
+      ExecutionState _state_3 = enterState.getState();
+      String _simpleName = _state_3.getSimpleName();
+      String _operator_plus = StringExtensions.operator_plus("enter ", _simpleName);
+      String _operator_plus_1 = StringExtensions.operator_plus(_operator_plus, " > ");
+      ExecutionState[] _stateConfiguration_1 = this.executionContext.getStateConfiguration();
+      final Function2<String,ExecutionState,String> _function = new Function2<String,ExecutionState,String>() {
+          public String apply(final String m , final ExecutionState s) {
+            String _xifexpression = null;
+            boolean _operator_equals = ObjectExtensions.operator_equals(s, null);
+            if (_operator_equals) {
+              _xifexpression = " _";
+            } else {
+              String _simpleName_1 = s.getSimpleName();
+              String _operator_plus_2 = StringExtensions.operator_plus(" ", _simpleName_1);
+              _xifexpression = _operator_plus_2;
+            }
+            String _operator_plus_3 = StringExtensions.operator_plus(m, _xifexpression);
+            return _operator_plus_3;
+          }
+        };
+      String _fold = IterableExtensions.<ExecutionState, String>fold(((Iterable<ExecutionState>)Conversions.doWrapArray(_stateConfiguration_1)), "scv: ", _function);
+      String _operator_plus_4 = StringExtensions.operator_plus(_operator_plus_1, _fold);
+      System.out.println(_operator_plus_4);
       _xblockexpression = (null);
     }
     return _xblockexpression;
@@ -326,9 +378,34 @@ public class ExecutionFlowInterpreter extends AbstractExecutionFacade implements
   protected Object _execute(final ExitState exitState) {
     Object _xblockexpression = null;
     {
-      List<ExecutionState> _stateConfiguration = this.executionContext.getStateConfiguration();
+      ExecutionState[] _stateConfiguration = this.executionContext.getStateConfiguration();
       ExecutionState _state = exitState.getState();
-      _stateConfiguration.remove(_state);
+      StateVector _stateVector = _state.getStateVector();
+      int _offset = _stateVector.getOffset();
+      ((List<ExecutionState>)Conversions.doWrapArray(_stateConfiguration)).set(_offset, null);
+      ExecutionState _state_1 = exitState.getState();
+      String _simpleName = _state_1.getSimpleName();
+      String _operator_plus = StringExtensions.operator_plus("exit ", _simpleName);
+      String _operator_plus_1 = StringExtensions.operator_plus(_operator_plus, " > ");
+      ExecutionState[] _stateConfiguration_1 = this.executionContext.getStateConfiguration();
+      final Function2<String,ExecutionState,String> _function = new Function2<String,ExecutionState,String>() {
+          public String apply(final String m , final ExecutionState s) {
+            String _xifexpression = null;
+            boolean _operator_equals = ObjectExtensions.operator_equals(s, null);
+            if (_operator_equals) {
+              _xifexpression = " _";
+            } else {
+              String _simpleName_1 = s.getSimpleName();
+              String _operator_plus_2 = StringExtensions.operator_plus(" ", _simpleName_1);
+              _xifexpression = _operator_plus_2;
+            }
+            String _operator_plus_3 = StringExtensions.operator_plus(m, _xifexpression);
+            return _operator_plus_3;
+          }
+        };
+      String _fold = IterableExtensions.<ExecutionState, String>fold(((Iterable<ExecutionState>)Conversions.doWrapArray(_stateConfiguration_1)), "scv: ", _function);
+      String _operator_plus_4 = StringExtensions.operator_plus(_operator_plus_1, _fold);
+      System.out.println(_operator_plus_4);
       _xblockexpression = (null);
     }
     return _xblockexpression;
@@ -360,7 +437,7 @@ public class ExecutionFlowInterpreter extends AbstractExecutionFacade implements
     Object _xblockexpression = null;
     {
       EList<Step> _steps = sequence.getSteps();
-      for (final Step step : _steps) {
+      for (Step step : _steps) {
         this.execute(step);
       }
       _xblockexpression = (null);
@@ -372,7 +449,7 @@ public class ExecutionFlowInterpreter extends AbstractExecutionFacade implements
     Object _xblockexpression = null;
     {
       EList<StateCase> _cases = stateSwitch.getCases();
-      for (final StateCase stateCase : _cases) {
+      for (StateCase stateCase : _cases) {
         this.execute(stateCase);
       }
       _xblockexpression = (null);
@@ -383,9 +460,9 @@ public class ExecutionFlowInterpreter extends AbstractExecutionFacade implements
   protected Object _execute(final StateCase stateCase) throws ExecutionException {
     Object _xblockexpression = null;
     {
-      List<ExecutionState> _stateConfiguration = this.executionContext.getStateConfiguration();
+      ExecutionState[] _stateConfiguration = this.executionContext.getStateConfiguration();
       ExecutionState _state = stateCase.getState();
-      boolean _contains = _stateConfiguration.contains(_state);
+      boolean _contains = ((List<ExecutionState>)Conversions.doWrapArray(_stateConfiguration)).contains(_state);
       if (_contains) {
         Step _step = stateCase.getStep();
         this.execute(_step);

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/IExecutionContext.java

@@ -87,10 +87,13 @@ public interface IExecutionContext {
 	 * Returns a set with all active leaf states including parents
 	 */
 	public Set<Vertex> getAllActiveStates();
+	
 	/**
 	 * Returns the active state configuration
 	 */
-	public List<ExecutionState> getStateConfiguration();
+	public ExecutionState[] getStateConfiguration();
+
+	public  void initStateConfigurationVector(int size);
 
 	/**
 	 * Calls a declared operation
@@ -108,4 +111,5 @@ public interface IExecutionContext {
 	public void removeExecutionContextListener(
 			IExecutionContextListener listener);
 
+
 }

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/impl/ExecutionContextImpl.java

@@ -35,13 +35,13 @@ public class ExecutionContextImpl extends AbstractExecutionContext implements
 	private List<ExecutionVariable> variables;
 	private List<ExecutionEvent> declaredEvents;
 	private List<ExecutionEvent> raisedEvents;
-	private List<ExecutionState> activeStateConfig;
+	private ExecutionState[] activeStateConfig;
 
 	public ExecutionContextImpl() {
 		variables = new ArrayList<ExecutionVariable>();
 		declaredEvents = new ArrayList<ExecutionEvent>();
 		raisedEvents = new ArrayList<ExecutionEvent>();
-		activeStateConfig = new ArrayList<ExecutionState>();
+		activeStateConfig = null;
 	}
 
 	public List<ExecutionEvent> getDeclaredEvents() {
@@ -132,10 +132,19 @@ public class ExecutionContextImpl extends AbstractExecutionContext implements
 
 	}
 
-	public List<ExecutionState> getStateConfiguration() {
+	public ExecutionState[] getStateConfiguration() {
 		return activeStateConfig;
 	}
 
+	
+	public void initStateConfigurationVector(int size) {
+		 activeStateConfig = new ExecutionState[size];
+		 for ( int i=0 ; i<size ; i++ ) {
+			 activeStateConfig[i] = null;
+		 }
+	}
+
+	
 	public void call(String procedureId) {
 		// TODO: Implement me
 	}
@@ -143,7 +152,7 @@ public class ExecutionContextImpl extends AbstractExecutionContext implements
 	public Set<Vertex> getActiveLeafStates() {
 		Set<Vertex> vertices = new HashSet<Vertex>();
 		for (ExecutionState state : activeStateConfig) {
-			vertices.add((Vertex) state.getSourceElement());
+			if (state != null) vertices.add((Vertex) state.getSourceElement());
 		}
 		return vertices;
 	}
@@ -151,7 +160,7 @@ public class ExecutionContextImpl extends AbstractExecutionContext implements
 	public Set<Vertex> getAllActiveStates() {
 		Set<Vertex> vertices = new HashSet<Vertex>();
 		for (ExecutionState state : activeStateConfig) {
-			vertices.addAll(getActiveHierachy((Vertex) state.getSourceElement()));
+			if (state != null) vertices.addAll(getActiveHierachy((Vertex) state.getSourceElement()));
 		}
 		return vertices;
 	}