clean up + renaming constructs

TraceComparison/TraceChecker.py

@@ -2,7 +2,7 @@ import os
 import subprocess
 import importlib.util
 import re
-from sccd.runtime.DEVS_loop import DEVSSimulator
+from sccd.runtime.DEVSSimulatorWrapper import DEVSSimulator
 import Tester
 from sccd.runtime.DEVS_statecharts_core import Event
 
@@ -126,6 +126,14 @@ class PythonSCCDTraceChecker(SCCDTraceChecker):
         return None
         
     def extract_internalio(self, line, context):
+        event_pattern = re.compile(r'^\s*\\Event: \(event name:.*\)$')
+        event_match = event_pattern.match(line)
+        if event_match and context["context"] is not None:
+            if context["context"] == "internal input" or context["context"] == "internal output":
+                event = line.strip()
+                # Remove everything before '(' in each string
+                event = event[event.index('('):]
+                return f"{context["time"]:.2f} {event}"
         return None
 
     def extract_statechart(self, line, context):
@@ -149,12 +157,21 @@ class PythonSCCDTraceChecker(SCCDTraceChecker):
         return None
 
     def check_state(self, line, context):
-        if "INPUT EVENT" in line:
+        if "INPUT EVENT from <ObjectManager>" in line:
+            context = {
+                "time": context["time"],
+                "context": "internal input",
+            }
+        elif "OUTPUT EVENT to <ObjectManager>" in line:
+            context = {
+                "time": context["time"],
+                "context": "internal output",
+            }
+        elif "INPUT EVENT" in line:
             context = {
                 "time": context["time"],
                 "context": "global input",
             }
-
         elif "OUTPUT EVENT" in line:
             context = {
                 "time": context["time"],
@@ -291,7 +308,7 @@ class PydevsSCCDTraceChecker(SCCDTraceChecker):
             "python", 
             os.path.join("sccd", "compiler", "sccdc.py"), 
             "-o", output_file, 
-            "-p", "pypDEVS", 
+            "-p", "classicdevs", 
             sccd_file
         ]
 
@@ -345,6 +362,18 @@ class PydevsSCCDTraceChecker(SCCDTraceChecker):
         return None
         
     def extract_internalio(self, line, context):
+        if context["extra_info"] == "obj_manager_in" or context["extra_info"] == "obj_manager_out":
+            event_pattern = re.compile(r'\(event name:.*\)$')
+            event_pattern = r'\(event name.*?\)'
+            event_match = re.search(event_pattern, line)
+
+            if event_match and context["time"] is not None:
+                event = event_match.group(0)
+                #event = line.strip()
+                # Remove everything before '(' in each string
+                #event = event[event.index('('):]
+                return f"{context["time"]:.2f} {event}"
+        
         return None
 
     def extract_statechart(self, line, context):
@@ -394,12 +423,17 @@ class PydevsSCCDTraceChecker(SCCDTraceChecker):
             }   
         elif "New State:" in line:
             context["context"] = "state"
-        elif "Output Port Configuration:" in line:
+        elif "Input Port Configuration:" in line:
             context["context"] = "input"
         elif "Output Port Configuration:" in line:
             context["context"] = "output"
         elif "Next scheduled internal transition at time" in line:
             context["context"] = "next"
+        elif context["context"] == "input" and "obj_manager_in" in line:
+            context["extra_info"] = "obj_manager_in"
+        elif context["context"] == "output" and "obj_manager_out" in line:
+            context["extra_info"] = "obj_manager_out"
+            
         return context
     
     def extract_info(self, log_file_path, options):

examples/BouncingBalls/PyDEVS/runner.py

@@ -1,7 +1,7 @@
 import tkinter as tk
-import examples.BouncingBalls.PyDEVS.target as target
+import target as target
 from sccd.runtime.libs.ui_v2 import UI
-from sccd.runtime.DEVS_loop import DEVSSimulator
+from sccd.runtime.DEVSSimulatorWrapper import DEVSSimulator
 
 class OutputListener:
 	def __init__(self, ui):

examples/BouncingBalls/PyDEVS/target.py

@@ -18,8 +18,6 @@ CANVAS_DIMS = (800, 550)
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["fields"] = Association("Field", 0, -1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -33,10 +31,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -207,7 +203,6 @@ class MainApp(ClassBase):
         self.outputs["fields"] = self.addOutPort("fields")
         new_instance = self.constructObject(0, 0, [])
         self.state.instances[new_instance.instance_id] = new_instance
-        self.state.next_instance = self.state.next_instance + 1
     
     def constructObject(self, id, start_port_id, parameters):
         new_instance = MainAppInstance(self, id, start_port_id)
@@ -216,10 +211,6 @@ class MainApp(ClassBase):
 class FieldInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["balls"] = Association("Ball", 0, -1)
-        self.associations["buttons"] = Association("Button", 0, -1)
-        self.associations["parent"] = Association("MainApp", 1, 1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -237,13 +228,10 @@ class FieldInstance(RuntimeClassBase):
         # call user defined constructor
         FieldInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
-        port_name = addInputPort("field_ui", start_port_id)
-        atomdevs.addInPort(port_name)
+        port_name = addInputPort("field_ui", start_port_id + 1)
         atomdevs.state.port_mappings[port_name] = id
         self.inports["field_ui"] = port_name
     
@@ -494,8 +482,6 @@ class Field(ClassBase):
 class ButtonInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id, window_id, event_name, button_text):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["parent"] = Association("Field", 1, 1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -514,13 +500,10 @@ class ButtonInstance(RuntimeClassBase):
         # call user defined constructor
         ButtonInstance.user_defined_constructor(self, window_id, event_name, button_text)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
-        port_name = addInputPort("button_ui", start_port_id)
-        atomdevs.addInPort(port_name)
+        port_name = addInputPort("button_ui", start_port_id + 1)
         atomdevs.state.port_mappings[port_name] = id
         self.inports["button_ui"] = port_name
     
@@ -604,8 +587,6 @@ class Button(ClassBase):
 class BallInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id, canvas_id, x, y):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["parent"] = Association("Field", 1, 1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -623,13 +604,10 @@ class BallInstance(RuntimeClassBase):
         # call user defined constructor
         BallInstance.user_defined_constructor(self, canvas_id, x, y)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
-        port_name = addInputPort("ball_ui", start_port_id)
-        atomdevs.addInPort(port_name)
+        port_name = addInputPort("ball_ui", start_port_id + 1)
         atomdevs.state.port_mappings[port_name] = id
         self.inports["ball_ui"] = port_name
     
@@ -830,39 +808,36 @@ class Ball(ClassBase):
         new_instance = BallInstance(self, id, start_port_id, parameters[1], parameters[2], parameters[3])
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-            instance["associations"]["fields"] = Association("Field", 0, -1)
-        elif class_name == "Field":
-            self.narrow_cast_id = self.narrow_cast_id + 1
-            instance["associations"] = {}
-            instance["associations"]["balls"] = Association("Ball", 0, -1)
-            instance["associations"]["buttons"] = Association("Button", 0, -1)
-            instance["associations"]["parent"] = Association("MainApp", 1, 1)
-        elif class_name == "Button":
-            self.narrow_cast_id = self.narrow_cast_id + 1
-            instance["associations"] = {}
-            instance["associations"]["parent"] = Association("Field", 1, 1)
-        elif class_name == "Ball":
-            self.narrow_cast_id = self.narrow_cast_id + 1
-            instance["associations"] = {}
-            instance["associations"]["parent"] = Association("Field", 1, 1)
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["fields"] = Association("Field", 0, -1)
+    elif class_name == "Field":
+        self.narrow_cast_id = self.narrow_cast_id + 1
+        instance["associations"] = {}
+        instance["associations"]["balls"] = Association("Ball", 0, -1)
+        instance["associations"]["buttons"] = Association("Button", 0, -1)
+        instance["associations"]["parent"] = Association("MainApp", 1, 1)
+    elif class_name == "Button":
+        self.narrow_cast_id = self.narrow_cast_id + 1
+        instance["associations"] = {}
+        instance["associations"]["parent"] = Association("Field", 1, 1)
+    elif class_name == "Ball":
+        self.narrow_cast_id = self.narrow_cast_id + 1
+        instance["associations"] = {}
+        instance["associations"]["parent"] = Association("Field", 1, 1)
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.output["Field"] = self.addOutPort()

examples/BouncingBalls/PyDEVS/thetarget.py

@@ -0,0 +1,898 @@
+"""
+Generated by Statechart compiler by Glenn De Jonghe, Joeri Exelmans, Simon Van Mierlo, and Yentl Van Tendeloo (for the inspiration) and Sam Pieters (DEVS)
+
+Model author: Sam Pieters
+Model name:   Bouncing_Balls_DEVS_Version
+Model description:
+Tkinter frame with bouncing balls in it.
+"""
+
+from sccd.runtime.DEVS_statecharts_core import *
+from sccd.runtime.libs import ui_v2 as ui
+import random
+
+CANVAS_DIMS = (800, 550)
+
+# package "Bouncing_Balls_DEVS_Version"
+
+class MainAppInstance(RuntimeClassBase):
+    def __init__(self, atomdevs, id, start_port_id):
+        RuntimeClassBase.__init__(self, atomdevs, id)
+        self.associations = {}
+        self.associations["fields"] = Association("Field", 0, -1)
+        
+        self.semantics.big_step_maximality = StatechartSemantics.TakeMany
+        self.semantics.internal_event_lifeline = StatechartSemantics.Queue
+        self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
+        self.semantics.priority = StatechartSemantics.SourceParent
+        self.semantics.concurrency = StatechartSemantics.Single
+        
+        # build Statechart structure
+        self.build_statechart_structure()
+        
+        # call user defined constructor
+        MainAppInstance.user_defined_constructor(self)
+        port_name = addInputPort("ui", start_port_id, True)
+        atomdevs.state.port_mappings[port_name] = id
+        port_name = addInputPort("<narrow_cast>", start_port_id)
+        atomdevs.state.port_mappings[port_name] = id
+    
+    def user_defined_constructor(self):
+        self.nr_of_fields = 0
+    
+    def user_defined_destructor(self):
+        pass
+    
+    
+    # builds Statechart structure
+    def build_statechart_structure(self):
+        
+        # state <root>
+        self.states[""] = State(0, "", self)
+        
+        # state /running
+        self.states["/running"] = State(1, "/running", self)
+        
+        # state /running/root
+        self.states["/running/root"] = ParallelState(2, "/running/root", self)
+        
+        # state /running/root/main_behaviour
+        self.states["/running/root/main_behaviour"] = State(3, "/running/root/main_behaviour", self)
+        
+        # state /running/root/main_behaviour/initializing
+        self.states["/running/root/main_behaviour/initializing"] = State(4, "/running/root/main_behaviour/initializing", self)
+        
+        # state /running/root/main_behaviour/running
+        self.states["/running/root/main_behaviour/running"] = State(5, "/running/root/main_behaviour/running", self)
+        
+        # state /running/root/cd_behaviour
+        self.states["/running/root/cd_behaviour"] = State(6, "/running/root/cd_behaviour", self)
+        
+        # state /running/root/cd_behaviour/waiting
+        self.states["/running/root/cd_behaviour/waiting"] = State(7, "/running/root/cd_behaviour/waiting", self)
+        
+        # state /running/root/cd_behaviour/creating
+        self.states["/running/root/cd_behaviour/creating"] = State(8, "/running/root/cd_behaviour/creating", self)
+        
+        # state /running/root/cd_behaviour/check_nr_of_fields
+        self.states["/running/root/cd_behaviour/check_nr_of_fields"] = State(9, "/running/root/cd_behaviour/check_nr_of_fields", self)
+        self.states["/running/root/cd_behaviour/check_nr_of_fields"].setEnter(self._running_root_cd_behaviour_check_nr_of_fields_enter)
+        self.states["/running/root/cd_behaviour/check_nr_of_fields"].setExit(self._running_root_cd_behaviour_check_nr_of_fields_exit)
+        
+        # state /running/root/cd_behaviour/stopped
+        self.states["/running/root/cd_behaviour/stopped"] = State(10, "/running/root/cd_behaviour/stopped", self)
+        
+        # state /running/stopped
+        self.states["/running/stopped"] = State(11, "/running/stopped", self)
+        
+        # add children
+        self.states[""].addChild(self.states["/running"])
+        self.states["/running"].addChild(self.states["/running/root"])
+        self.states["/running"].addChild(self.states["/running/stopped"])
+        self.states["/running/root"].addChild(self.states["/running/root/main_behaviour"])
+        self.states["/running/root"].addChild(self.states["/running/root/cd_behaviour"])
+        self.states["/running/root/main_behaviour"].addChild(self.states["/running/root/main_behaviour/initializing"])
+        self.states["/running/root/main_behaviour"].addChild(self.states["/running/root/main_behaviour/running"])
+        self.states["/running/root/cd_behaviour"].addChild(self.states["/running/root/cd_behaviour/waiting"])
+        self.states["/running/root/cd_behaviour"].addChild(self.states["/running/root/cd_behaviour/creating"])
+        self.states["/running/root/cd_behaviour"].addChild(self.states["/running/root/cd_behaviour/check_nr_of_fields"])
+        self.states["/running/root/cd_behaviour"].addChild(self.states["/running/root/cd_behaviour/stopped"])
+        self.states[""].fixTree()
+        self.states[""].default_state = self.states["/running"]
+        self.states["/running"].default_state = self.states["/running/root"]
+        self.states["/running/root/main_behaviour"].default_state = self.states["/running/root/main_behaviour/initializing"]
+        self.states["/running/root/cd_behaviour"].default_state = self.states["/running/root/cd_behaviour/waiting"]
+        
+        # transition /running/root/main_behaviour/initializing
+        _running_root_main_behaviour_initializing_0 = Transition(self, self.states["/running/root/main_behaviour/initializing"], [self.states["/running/root/main_behaviour/running"]])
+        _running_root_main_behaviour_initializing_0.setAction(self._running_root_main_behaviour_initializing_0_exec)
+        _running_root_main_behaviour_initializing_0.setTrigger(None)
+        self.states["/running/root/main_behaviour/initializing"].addTransition(_running_root_main_behaviour_initializing_0)
+        
+        # transition /running/root/main_behaviour/running
+        _running_root_main_behaviour_running_0 = Transition(self, self.states["/running/root/main_behaviour/running"], [self.states["/running/root/main_behaviour/running"]])
+        _running_root_main_behaviour_running_0.setAction(self._running_root_main_behaviour_running_0_exec)
+        _running_root_main_behaviour_running_0.setTrigger(Event("button_pressed", None))
+        _running_root_main_behaviour_running_0.setGuard(self._running_root_main_behaviour_running_0_guard)
+        self.states["/running/root/main_behaviour/running"].addTransition(_running_root_main_behaviour_running_0)
+        
+        # transition /running/root/cd_behaviour/waiting
+        _running_root_cd_behaviour_waiting_0 = Transition(self, self.states["/running/root/cd_behaviour/waiting"], [self.states["/running/root/cd_behaviour/creating"]])
+        _running_root_cd_behaviour_waiting_0.setAction(self._running_root_cd_behaviour_waiting_0_exec)
+        _running_root_cd_behaviour_waiting_0.setTrigger(Event("create_field", None))
+        self.states["/running/root/cd_behaviour/waiting"].addTransition(_running_root_cd_behaviour_waiting_0)
+        _running_root_cd_behaviour_waiting_1 = Transition(self, self.states["/running/root/cd_behaviour/waiting"], [self.states["/running/root/cd_behaviour/check_nr_of_fields"]])
+        _running_root_cd_behaviour_waiting_1.setAction(self._running_root_cd_behaviour_waiting_1_exec)
+        _running_root_cd_behaviour_waiting_1.setTrigger(Event("delete_field", None))
+        self.states["/running/root/cd_behaviour/waiting"].addTransition(_running_root_cd_behaviour_waiting_1)
+        
+        # transition /running/root/cd_behaviour/creating
+        _running_root_cd_behaviour_creating_0 = Transition(self, self.states["/running/root/cd_behaviour/creating"], [self.states["/running/root/cd_behaviour/waiting"]])
+        _running_root_cd_behaviour_creating_0.setAction(self._running_root_cd_behaviour_creating_0_exec)
+        _running_root_cd_behaviour_creating_0.setTrigger(Event("instance_created", None))
+        self.states["/running/root/cd_behaviour/creating"].addTransition(_running_root_cd_behaviour_creating_0)
+        
+        # transition /running/root/cd_behaviour/check_nr_of_fields
+        _running_root_cd_behaviour_check_nr_of_fields_0 = Transition(self, self.states["/running/root/cd_behaviour/check_nr_of_fields"], [self.states["/running/root/cd_behaviour/stopped"]])
+        _running_root_cd_behaviour_check_nr_of_fields_0.setAction(self._running_root_cd_behaviour_check_nr_of_fields_0_exec)
+        _running_root_cd_behaviour_check_nr_of_fields_0.setTrigger(Event("_0after"))
+        _running_root_cd_behaviour_check_nr_of_fields_0.setGuard(self._running_root_cd_behaviour_check_nr_of_fields_0_guard)
+        self.states["/running/root/cd_behaviour/check_nr_of_fields"].addTransition(_running_root_cd_behaviour_check_nr_of_fields_0)
+        _running_root_cd_behaviour_check_nr_of_fields_1 = Transition(self, self.states["/running/root/cd_behaviour/check_nr_of_fields"], [self.states["/running/root/cd_behaviour/waiting"]])
+        _running_root_cd_behaviour_check_nr_of_fields_1.setTrigger(None)
+        _running_root_cd_behaviour_check_nr_of_fields_1.setGuard(self._running_root_cd_behaviour_check_nr_of_fields_1_guard)
+        self.states["/running/root/cd_behaviour/check_nr_of_fields"].addTransition(_running_root_cd_behaviour_check_nr_of_fields_1)
+        
+        # transition /running/root
+        _running_root_0 = Transition(self, self.states["/running/root"], [self.states["/running/stopped"]])
+        _running_root_0.setAction(self._running_root_0_exec)
+        _running_root_0.setTrigger(Event("stop", None))
+        self.states["/running/root"].addTransition(_running_root_0)
+    
+    def _running_root_cd_behaviour_check_nr_of_fields_enter(self):
+        self.addTimer(0, 0.05)
+    
+    def _running_root_cd_behaviour_check_nr_of_fields_exit(self):
+        self.removeTimer(0)
+    
+    def _running_root_0_exec(self, parameters):
+        self.big_step.outputEvent(Event("destroy_all", self.getOutPortName("ui"), []))
+    
+    def _running_root_main_behaviour_initializing_0_exec(self, parameters):
+        self.raiseInternalEvent(Event("create_field", None, []))
+    
+    def _running_root_main_behaviour_running_0_exec(self, parameters):
+        event_name = parameters[0]
+        self.raiseInternalEvent(Event("create_field", None, []))
+    
+    def _running_root_main_behaviour_running_0_guard(self, parameters):
+        event_name = parameters[0]
+        return event_name == "create_new_field"
+    
+    def _running_root_cd_behaviour_waiting_0_exec(self, parameters):
+        self.big_step.outputEventOM(Event("create_instance", None, [self, "fields"]))
+    
+    def _running_root_cd_behaviour_waiting_1_exec(self, parameters):
+        association_name = parameters[0]
+        self.big_step.outputEventOM(Event("delete_instance", None, [self, association_name]))
+        self.nr_of_fields -= 1
+    
+    def _running_root_cd_behaviour_creating_0_exec(self, parameters):
+        association_name = parameters[0]
+        self.big_step.outputEventOM(Event("start_instance", None, [self, association_name]))
+        self.big_step.outputEventOM(Event("narrow_cast", None, [self, association_name, Event("set_association_name", None, [association_name])]))
+        self.nr_of_fields += 1
+    
+    def _running_root_cd_behaviour_check_nr_of_fields_0_exec(self, parameters):
+        self.raiseInternalEvent(Event("stop", None, []))
+    
+    def _running_root_cd_behaviour_check_nr_of_fields_0_guard(self, parameters):
+        return self.nr_of_fields == 0
+    
+    def _running_root_cd_behaviour_check_nr_of_fields_1_guard(self, parameters):
+        return self.nr_of_fields != 0
+    
+    def initializeStatechart(self):
+        # enter default state
+        self.default_targets = self.states["/running"].getEffectiveTargetStates()
+        RuntimeClassBase.initializeStatechart(self)
+
+class MainApp(ClassBase):
+    def __init__(self, name):
+        ClassBase.__init__(self, name)
+        self.input = self.addInPort("input")
+        self.glob_outputs["ui"] = self.addOutPort("ui")
+        self.outputs["fields"] = self.addOutPort("fields")
+        new_instance = self.constructObject(0, 0, [])
+        self.state.instances[new_instance.instance_id] = new_instance
+        self.state.next_instance = self.state.next_instance + 1
+    
+    def constructObject(self, id, start_port_id, parameters):
+        new_instance = MainAppInstance(self, id, start_port_id)
+        return new_instance
+
+class FieldInstance(RuntimeClassBase):
+    def __init__(self, atomdevs, id, start_port_id):
+        RuntimeClassBase.__init__(self, atomdevs, id)
+        self.associations = {}
+        self.associations["balls"] = Association("Ball", 0, -1)
+        self.associations["buttons"] = Association("Button", 0, -1)
+        self.associations["parent"] = Association("MainApp", 1, 1)
+        
+        self.semantics.big_step_maximality = StatechartSemantics.TakeMany
+        self.semantics.internal_event_lifeline = StatechartSemantics.Queue
+        self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
+        self.semantics.priority = StatechartSemantics.SourceParent
+        self.semantics.concurrency = StatechartSemantics.Single
+        
+        # build Statechart structure
+        self.build_statechart_structure()
+        
+        # user defined attributes
+        self.window_id = None
+        self.canvas_id = None
+        
+        # call user defined constructor
+        FieldInstance.user_defined_constructor(self)
+        port_name = addInputPort("ui", start_port_id, True)
+        atomdevs.state.port_mappings[port_name] = id
+        port_name = addInputPort("<narrow_cast>", start_port_id)
+        atomdevs.state.port_mappings[port_name] = id
+        port_name = addInputPort("field_ui", start_port_id)
+        atomdevs.state.port_mappings[port_name] = id
+        self.inports["field_ui"] = port_name
+    
+    def user_defined_constructor(self):
+        pass
+    
+    def user_defined_destructor(self):
+        pass
+    
+    
+    # builds Statechart structure
+    def build_statechart_structure(self):
+        
+        # state <root>
+        self.states[""] = State(0, "", self)
+        
+        # state /root
+        self.states["/root"] = State(1, "/root", self)
+        
+        # state /root/waiting
+        self.states["/root/waiting"] = State(2, "/root/waiting", self)
+        
+        # state /root/creating_window
+        self.states["/root/creating_window"] = State(3, "/root/creating_window", self)
+        self.states["/root/creating_window"].setEnter(self._root_creating_window_enter)
+        
+        # state /root/creating_canvas
+        self.states["/root/creating_canvas"] = State(4, "/root/creating_canvas", self)
+        self.states["/root/creating_canvas"].setEnter(self._root_creating_canvas_enter)
+        
+        # state /root/creating_button
+        self.states["/root/creating_button"] = State(5, "/root/creating_button", self)
+        self.states["/root/creating_button"].setEnter(self._root_creating_button_enter)
+        
+        # state /root/running
+        self.states["/root/running"] = ParallelState(6, "/root/running", self)
+        
+        # state /root/running/main_behaviour
+        self.states["/root/running/main_behaviour"] = State(7, "/root/running/main_behaviour", self)
+        
+        # state /root/running/main_behaviour/running
+        self.states["/root/running/main_behaviour/running"] = State(8, "/root/running/main_behaviour/running", self)
+        
+        # state /root/running/main_behaviour/creating_ball
+        self.states["/root/running/main_behaviour/creating_ball"] = State(9, "/root/running/main_behaviour/creating_ball", self)
+        
+        # state /root/running/deleting_behaviour
+        self.states["/root/running/deleting_behaviour"] = State(10, "/root/running/deleting_behaviour", self)
+        
+        # state /root/running/deleting_behaviour/running
+        self.states["/root/running/deleting_behaviour/running"] = State(11, "/root/running/deleting_behaviour/running", self)
+        
+        # state /root/running/child_behaviour
+        self.states["/root/running/child_behaviour"] = State(12, "/root/running/child_behaviour", self)
+        
+        # state /root/running/child_behaviour/listening
+        self.states["/root/running/child_behaviour/listening"] = State(13, "/root/running/child_behaviour/listening", self)
+        
+        # state /root/running/deleting_balls_behaviour
+        self.states["/root/running/deleting_balls_behaviour"] = State(14, "/root/running/deleting_balls_behaviour", self)
+        
+        # state /root/running/deleting_balls_behaviour/listening
+        self.states["/root/running/deleting_balls_behaviour/listening"] = State(15, "/root/running/deleting_balls_behaviour/listening", self)
+        
+        # state /root/deleting
+        self.states["/root/deleting"] = State(16, "/root/deleting", self)
+        
+        # state /root/deleted
+        self.states["/root/deleted"] = State(17, "/root/deleted", self)
+        
+        # add children
+        self.states[""].addChild(self.states["/root"])
+        self.states["/root"].addChild(self.states["/root/waiting"])
+        self.states["/root"].addChild(self.states["/root/creating_window"])
+        self.states["/root"].addChild(self.states["/root/creating_canvas"])
+        self.states["/root"].addChild(self.states["/root/creating_button"])
+        self.states["/root"].addChild(self.states["/root/running"])
+        self.states["/root"].addChild(self.states["/root/deleting"])
+        self.states["/root"].addChild(self.states["/root/deleted"])
+        self.states["/root/running"].addChild(self.states["/root/running/main_behaviour"])
+        self.states["/root/running"].addChild(self.states["/root/running/deleting_behaviour"])
+        self.states["/root/running"].addChild(self.states["/root/running/child_behaviour"])
+        self.states["/root/running"].addChild(self.states["/root/running/deleting_balls_behaviour"])
+        self.states["/root/running/main_behaviour"].addChild(self.states["/root/running/main_behaviour/running"])
+        self.states["/root/running/main_behaviour"].addChild(self.states["/root/running/main_behaviour/creating_ball"])
+        self.states["/root/running/deleting_behaviour"].addChild(self.states["/root/running/deleting_behaviour/running"])
+        self.states["/root/running/child_behaviour"].addChild(self.states["/root/running/child_behaviour/listening"])
+        self.states["/root/running/deleting_balls_behaviour"].addChild(self.states["/root/running/deleting_balls_behaviour/listening"])
+        self.states[""].fixTree()
+        self.states[""].default_state = self.states["/root"]
+        self.states["/root"].default_state = self.states["/root/waiting"]
+        self.states["/root/running/main_behaviour"].default_state = self.states["/root/running/main_behaviour/running"]
+        self.states["/root/running/deleting_behaviour"].default_state = self.states["/root/running/deleting_behaviour/running"]
+        self.states["/root/running/child_behaviour"].default_state = self.states["/root/running/child_behaviour/listening"]
+        self.states["/root/running/deleting_balls_behaviour"].default_state = self.states["/root/running/deleting_balls_behaviour/listening"]
+        
+        # transition /root/waiting
+        _root_waiting_0 = Transition(self, self.states["/root/waiting"], [self.states["/root/creating_window"]])
+        _root_waiting_0.setAction(self._root_waiting_0_exec)
+        _root_waiting_0.setTrigger(Event("set_association_name", None))
+        self.states["/root/waiting"].addTransition(_root_waiting_0)
+        
+        # transition /root/creating_window
+        _root_creating_window_0 = Transition(self, self.states["/root/creating_window"], [self.states["/root/creating_canvas"]])
+        _root_creating_window_0.setAction(self._root_creating_window_0_exec)
+        _root_creating_window_0.setTrigger(Event("window_created", None))
+        self.states["/root/creating_window"].addTransition(_root_creating_window_0)
+        
+        # transition /root/creating_canvas
+        _root_creating_canvas_0 = Transition(self, self.states["/root/creating_canvas"], [self.states["/root/creating_button"]])
+        _root_creating_canvas_0.setAction(self._root_creating_canvas_0_exec)
+        _root_creating_canvas_0.setTrigger(Event("canvas_created", None))
+        self.states["/root/creating_canvas"].addTransition(_root_creating_canvas_0)
+        
+        # transition /root/creating_button
+        _root_creating_button_0 = Transition(self, self.states["/root/creating_button"], [self.states["/root/running"]])
+        _root_creating_button_0.setAction(self._root_creating_button_0_exec)
+        _root_creating_button_0.setTrigger(Event("instance_created", None))
+        self.states["/root/creating_button"].addTransition(_root_creating_button_0)
+        
+        # transition /root/running/main_behaviour/running
+        _root_running_main_behaviour_running_0 = Transition(self, self.states["/root/running/main_behaviour/running"], [self.states["/root/running/main_behaviour/creating_ball"]])
+        _root_running_main_behaviour_running_0.setAction(self._root_running_main_behaviour_running_0_exec)
+        _root_running_main_behaviour_running_0.setTrigger(Event("right_click", self.getInPortName("field_ui")))
+        self.states["/root/running/main_behaviour/running"].addTransition(_root_running_main_behaviour_running_0)
+        
+        # transition /root/running/main_behaviour/creating_ball
+        _root_running_main_behaviour_creating_ball_0 = Transition(self, self.states["/root/running/main_behaviour/creating_ball"], [self.states["/root/running/main_behaviour/running"]])
+        _root_running_main_behaviour_creating_ball_0.setAction(self._root_running_main_behaviour_creating_ball_0_exec)
+        _root_running_main_behaviour_creating_ball_0.setTrigger(Event("instance_created", None))
+        self.states["/root/running/main_behaviour/creating_ball"].addTransition(_root_running_main_behaviour_creating_ball_0)
+        
+        # transition /root/running/deleting_behaviour/running
+        _root_running_deleting_behaviour_running_0 = Transition(self, self.states["/root/running/deleting_behaviour/running"], [self.states["/root/running/deleting_behaviour/running"]])
+        _root_running_deleting_behaviour_running_0.setAction(self._root_running_deleting_behaviour_running_0_exec)
+        _root_running_deleting_behaviour_running_0.setTrigger(Event("delete_ball", None))
+        self.states["/root/running/deleting_behaviour/running"].addTransition(_root_running_deleting_behaviour_running_0)
+        
+        # transition /root/running/child_behaviour/listening
+        _root_running_child_behaviour_listening_0 = Transition(self, self.states["/root/running/child_behaviour/listening"], [self.states["/root/running/child_behaviour/listening"]])
+        _root_running_child_behaviour_listening_0.setAction(self._root_running_child_behaviour_listening_0_exec)
+        _root_running_child_behaviour_listening_0.setTrigger(Event("button_pressed", None))
+        self.states["/root/running/child_behaviour/listening"].addTransition(_root_running_child_behaviour_listening_0)
+        
+        # transition /root/running/deleting_balls_behaviour/listening
+        _root_running_deleting_balls_behaviour_listening_0 = Transition(self, self.states["/root/running/deleting_balls_behaviour/listening"], [self.states["/root/running/deleting_balls_behaviour/listening"]])
+        _root_running_deleting_balls_behaviour_listening_0.setAction(self._root_running_deleting_balls_behaviour_listening_0_exec)
+        _root_running_deleting_balls_behaviour_listening_0.setTrigger(Event("key_press", self.getInPortName("field_ui")))
+        _root_running_deleting_balls_behaviour_listening_0.setGuard(self._root_running_deleting_balls_behaviour_listening_0_guard)
+        self.states["/root/running/deleting_balls_behaviour/listening"].addTransition(_root_running_deleting_balls_behaviour_listening_0)
+        
+        # transition /root/deleting
+        _root_deleting_0 = Transition(self, self.states["/root/deleting"], [self.states["/root/deleted"]])
+        _root_deleting_0.setAction(self._root_deleting_0_exec)
+        _root_deleting_0.setTrigger(None)
+        self.states["/root/deleting"].addTransition(_root_deleting_0)
+        
+        # transition /root/running
+        _root_running_0 = Transition(self, self.states["/root/running"], [self.states["/root/deleting"]])
+        _root_running_0.setAction(self._root_running_0_exec)
+        _root_running_0.setTrigger(Event("window_close", self.getInPortName("field_ui")))
+        self.states["/root/running"].addTransition(_root_running_0)
+    
+    def _root_creating_window_enter(self):
+        self.big_step.outputEvent(Event("create_window", self.getOutPortName("ui"), [800, 600, "BouncingBalls", self.inports['field_ui']]))
+    
+    def _root_creating_canvas_enter(self):
+        self.big_step.outputEvent(Event("create_canvas", self.getOutPortName("ui"), [self.window_id, CANVAS_DIMS[0], CANVAS_DIMS[1], {'background':'#eee'}, self.inports['field_ui']]))
+    
+    def _root_creating_button_enter(self):
+        self.big_step.outputEventOM(Event("create_instance", None, [self, "buttons", "Button", self.window_id, 'create_new_field', 'Spawn New Window']))
+    
+    def _root_running_0_exec(self, parameters):
+        self.big_step.outputEventOM(Event("delete_instance", None, [self, "buttons"]))
+        self.big_step.outputEventOM(Event("delete_instance", None, [self, "balls"]))
+    
+    def _root_waiting_0_exec(self, parameters):
+        association_name = parameters[0]
+        self.association_name = association_name
+    
+    def _root_creating_window_0_exec(self, parameters):
+        window_id = parameters[0]
+        self.window_id = window_id
+        self.big_step.outputEvent(Event("bind_event", self.getOutPortName("ui"), [window_id, ui.EVENTS.WINDOW_CLOSE, 'window_close', self.inports['field_ui']]))
+        self.big_step.outputEvent(Event("bind_event", self.getOutPortName("ui"), [window_id, ui.EVENTS.KEY_PRESS, 'key_press', self.inports['field_ui']]))
+    
+    def _root_creating_canvas_0_exec(self, parameters):
+        canvas_id = parameters[0]
+        self.canvas_id = canvas_id
+        self.big_step.outputEvent(Event("bind_event", self.getOutPortName("ui"), [canvas_id, ui.EVENTS.MOUSE_RIGHT_CLICK, 'right_click', self.inports['field_ui']]))
+        self.big_step.outputEvent(Event("bind_event", self.getOutPortName("ui"), [canvas_id, ui.EVENTS.MOUSE_MOVE, 'mouse_move', self.inports['field_ui']]))
+        self.big_step.outputEvent(Event("bind_event", self.getOutPortName("ui"), [canvas_id, ui.EVENTS.MOUSE_RELEASE, 'mouse_release', self.inports['field_ui']]))
+    
+    def _root_creating_button_0_exec(self, parameters):
+        association_name = parameters[0]
+        self.big_step.outputEventOM(Event("start_instance", None, [self, association_name]))
+    
+    def _root_running_main_behaviour_running_0_exec(self, parameters):
+        x = parameters[0]
+        y = parameters[1]
+        button = parameters[2]
+        self.big_step.outputEventOM(Event("create_instance", None, [self, "balls", "Ball", self.canvas_id, x, y]))
+    
+    def _root_running_main_behaviour_creating_ball_0_exec(self, parameters):
+        association_name = parameters[0]
+        self.big_step.outputEventOM(Event("start_instance", None, [self, association_name]))
+        self.big_step.outputEventOM(Event("narrow_cast", None, [self, association_name, Event("set_association_name", None, [association_name])]))
+    
+    def _root_running_deleting_behaviour_running_0_exec(self, parameters):
+        association_name = parameters[0]
+        self.big_step.outputEventOM(Event("delete_instance", None, [self, association_name]))
+    
+    def _root_running_child_behaviour_listening_0_exec(self, parameters):
+        event_name = parameters[0]
+        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent', Event("button_pressed", None, [event_name])]))
+    
+    def _root_running_deleting_balls_behaviour_listening_0_exec(self, parameters):
+        key = parameters[0]
+        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'balls', Event("delete_self", None, [])]))
+    
+    def _root_running_deleting_balls_behaviour_listening_0_guard(self, parameters):
+        key = parameters[0]
+        return key == ui.KEYCODES.DELETE
+    
+    def _root_deleting_0_exec(self, parameters):
+        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent', Event("delete_field", None, [self.association_name])]))
+        self.big_step.outputEvent(Event("destroy_window", self.getOutPortName("ui"), [self.window_id]))
+    
+    def initializeStatechart(self):
+        # enter default state
+        self.default_targets = self.states["/root"].getEffectiveTargetStates()
+        RuntimeClassBase.initializeStatechart(self)
+
+class Field(ClassBase):
+    def __init__(self, name):
+        ClassBase.__init__(self, name)
+        self.input = self.addInPort("input")
+        self.glob_outputs["ui"] = self.addOutPort("ui")
+        self.outputs["balls"] = self.addOutPort("balls")
+        self.outputs["buttons"] = self.addOutPort("buttons")
+        self.outputs["parent"] = self.addOutPort("parent")
+        self.field_ui = self.addInPort("field_ui")
+    
+    def constructObject(self, id, start_port_id, parameters):
+        new_instance = FieldInstance(self, id, start_port_id)
+        return new_instance
+
+class ButtonInstance(RuntimeClassBase):
+    def __init__(self, atomdevs, id, start_port_id, window_id, event_name, button_text):
+        RuntimeClassBase.__init__(self, atomdevs, id)
+        self.associations = {}
+        self.associations["parent"] = Association("Field", 1, 1)
+        
+        self.semantics.big_step_maximality = StatechartSemantics.TakeMany
+        self.semantics.internal_event_lifeline = StatechartSemantics.Queue
+        self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
+        self.semantics.priority = StatechartSemantics.SourceParent
+        self.semantics.concurrency = StatechartSemantics.Single
+        
+        # build Statechart structure
+        self.build_statechart_structure()
+        
+        # user defined attributes
+        self.window_id = None
+        self.event_name = None
+        self.button_id = None
+        
+        # call user defined constructor
+        ButtonInstance.user_defined_constructor(self, window_id, event_name, button_text)
+        port_name = addInputPort("ui", start_port_id, True)
+        atomdevs.state.port_mappings[port_name] = id
+        port_name = addInputPort("<narrow_cast>", start_port_id)
+        atomdevs.state.port_mappings[port_name] = id
+        port_name = addInputPort("button_ui", start_port_id)
+        atomdevs.state.port_mappings[port_name] = id
+        self.inports["button_ui"] = port_name
+    
+    def user_defined_constructor(self, window_id, event_name, button_text):
+        self.window_id = window_id;
+        self.event_name = event_name;
+    
+    def user_defined_destructor(self):
+        pass
+    
+    
+    # builds Statechart structure
+    def build_statechart_structure(self):
+        
+        # state <root>
+        self.states[""] = State(0, "", self)
+        
+        # state /creating_button
+        self.states["/creating_button"] = State(1, "/creating_button", self)
+        self.states["/creating_button"].setEnter(self._creating_button_enter)
+        
+        # state /running
+        self.states["/running"] = State(2, "/running", self)
+        
+        # add children
+        self.states[""].addChild(self.states["/creating_button"])
+        self.states[""].addChild(self.states["/running"])
+        self.states[""].fixTree()
+        self.states[""].default_state = self.states["/creating_button"]
+        
+        # transition /creating_button
+        _creating_button_0 = Transition(self, self.states["/creating_button"], [self.states["/running"]])
+        _creating_button_0.setAction(self._creating_button_0_exec)
+        _creating_button_0.setTrigger(Event("button_created", None))
+        self.states["/creating_button"].addTransition(_creating_button_0)
+        
+        # transition /running
+        _running_0 = Transition(self, self.states["/running"], [self.states["/running"]])
+        _running_0.setAction(self._running_0_exec)
+        _running_0.setTrigger(Event("mouse_click", self.getInPortName("button_ui")))
+        _running_0.setGuard(self._running_0_guard)
+        self.states["/running"].addTransition(_running_0)
+    
+    def _creating_button_enter(self):
+        self.big_step.outputEvent(Event("create_button", self.getOutPortName("ui"), [self.window_id, self.event_name, self.inports['button_ui']]))
+    
+    def _creating_button_0_exec(self, parameters):
+        button_id = parameters[0]
+        self.button_id = button_id
+        self.big_step.outputEvent(Event("bind_event", self.getOutPortName("ui"), [button_id, ui.EVENTS.MOUSE_CLICK, "mouse_click", self.inports['button_ui']]))
+    
+    def _running_0_exec(self, parameters):
+        x = parameters[0]
+        y = parameters[1]
+        button = parameters[2]
+        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent', Event("button_pressed", None, [self.event_name])]))
+    
+    def _running_0_guard(self, parameters):
+        x = parameters[0]
+        y = parameters[1]
+        button = parameters[2]
+        return button == ui.MOUSE_BUTTONS.LEFT
+    
+    def initializeStatechart(self):
+        # enter default state
+        self.default_targets = self.states["/creating_button"].getEffectiveTargetStates()
+        RuntimeClassBase.initializeStatechart(self)
+
+class Button(ClassBase):
+    def __init__(self, name):
+        ClassBase.__init__(self, name)
+        self.input = self.addInPort("input")
+        self.glob_outputs["ui"] = self.addOutPort("ui")
+        self.outputs["parent"] = self.addOutPort("parent")
+        self.button_ui = self.addInPort("button_ui")
+    
+    def constructObject(self, id, start_port_id, parameters):
+        new_instance = ButtonInstance(self, id, start_port_id, parameters[1], parameters[2], parameters[3])
+        return new_instance
+
+class BallInstance(RuntimeClassBase):
+    def __init__(self, atomdevs, id, start_port_id, canvas_id, x, y):
+        RuntimeClassBase.__init__(self, atomdevs, id)
+        self.associations = {}
+        self.associations["parent"] = Association("Field", 1, 1)
+        
+        self.semantics.big_step_maximality = StatechartSemantics.TakeMany
+        self.semantics.internal_event_lifeline = StatechartSemantics.Queue
+        self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
+        self.semantics.priority = StatechartSemantics.SourceParent
+        self.semantics.concurrency = StatechartSemantics.Single
+        
+        # build Statechart structure
+        self.build_statechart_structure()
+        
+        # user defined attributes
+        self.canvas_id = None
+        self.pos = None
+        
+        # call user defined constructor
+        BallInstance.user_defined_constructor(self, canvas_id, x, y)
+        port_name = addInputPort("ui", start_port_id, True)
+        atomdevs.state.port_mappings[port_name] = id
+        port_name = addInputPort("<narrow_cast>", start_port_id)
+        atomdevs.state.port_mappings[port_name] = id
+        port_name = addInputPort("ball_ui", start_port_id)
+        atomdevs.state.port_mappings[port_name] = id
+        self.inports["ball_ui"] = port_name
+    
+    def user_defined_constructor(self, canvas_id, x, y):
+        self.canvas_id = canvas_id;
+        self.r = 20.0;
+        self.vel = {'x': random.uniform(-5.0, 5.0), 'y': random.uniform(-5.0, 5.0)};
+        self.pos = {'x': x, 'y': y};
+        self.smooth = 0.6; # value between 0 and 1
+    
+    def user_defined_destructor(self):
+        pass
+    
+    
+    # builds Statechart structure
+    def build_statechart_structure(self):
+        
+        # state <root>
+        self.states[""] = State(0, "", self)
+        
+        # state /main_behaviour
+        self.states["/main_behaviour"] = State(1, "/main_behaviour", self)
+        
+        # state /main_behaviour/initializing
+        self.states["/main_behaviour/initializing"] = State(2, "/main_behaviour/initializing", self)
+        
+        # state /main_behaviour/creating_circle
+        self.states["/main_behaviour/creating_circle"] = State(3, "/main_behaviour/creating_circle", self)
+        self.states["/main_behaviour/creating_circle"].setEnter(self._main_behaviour_creating_circle_enter)
+        
+        # state /main_behaviour/bouncing
+        self.states["/main_behaviour/bouncing"] = State(4, "/main_behaviour/bouncing", self)
+        self.states["/main_behaviour/bouncing"].setEnter(self._main_behaviour_bouncing_enter)
+        self.states["/main_behaviour/bouncing"].setExit(self._main_behaviour_bouncing_exit)
+        
+        # state /main_behaviour/dragging
+        self.states["/main_behaviour/dragging"] = State(5, "/main_behaviour/dragging", self)
+        
+        # state /main_behaviour/selected
+        self.states["/main_behaviour/selected"] = State(6, "/main_behaviour/selected", self)
+        
+        # state /deleted
+        self.states["/deleted"] = State(7, "/deleted", self)
+        
+        # add children
+        self.states[""].addChild(self.states["/main_behaviour"])
+        self.states[""].addChild(self.states["/deleted"])
+        self.states["/main_behaviour"].addChild(self.states["/main_behaviour/initializing"])
+        self.states["/main_behaviour"].addChild(self.states["/main_behaviour/creating_circle"])
+        self.states["/main_behaviour"].addChild(self.states["/main_behaviour/bouncing"])
+        self.states["/main_behaviour"].addChild(self.states["/main_behaviour/dragging"])
+        self.states["/main_behaviour"].addChild(self.states["/main_behaviour/selected"])
+        self.states[""].fixTree()
+        self.states[""].default_state = self.states["/main_behaviour"]
+        self.states["/main_behaviour"].default_state = self.states["/main_behaviour/initializing"]
+        
+        # transition /main_behaviour/initializing
+        _main_behaviour_initializing_0 = Transition(self, self.states["/main_behaviour/initializing"], [self.states["/main_behaviour/creating_circle"]])
+        _main_behaviour_initializing_0.setAction(self._main_behaviour_initializing_0_exec)
+        _main_behaviour_initializing_0.setTrigger(Event("set_association_name", None))
+        self.states["/main_behaviour/initializing"].addTransition(_main_behaviour_initializing_0)
+        
+        # transition /main_behaviour/creating_circle
+        _main_behaviour_creating_circle_0 = Transition(self, self.states["/main_behaviour/creating_circle"], [self.states["/main_behaviour/bouncing"]])
+        _main_behaviour_creating_circle_0.setAction(self._main_behaviour_creating_circle_0_exec)
+        _main_behaviour_creating_circle_0.setTrigger(Event("circle_created", None))
+        self.states["/main_behaviour/creating_circle"].addTransition(_main_behaviour_creating_circle_0)
+        
+        # transition /main_behaviour/bouncing
+        _main_behaviour_bouncing_0 = Transition(self, self.states["/main_behaviour/bouncing"], [self.states["/main_behaviour/bouncing"]])
+        _main_behaviour_bouncing_0.setAction(self._main_behaviour_bouncing_0_exec)
+        _main_behaviour_bouncing_0.setTrigger(Event("_0after"))
+        self.states["/main_behaviour/bouncing"].addTransition(_main_behaviour_bouncing_0)
+        _main_behaviour_bouncing_1 = Transition(self, self.states["/main_behaviour/bouncing"], [self.states["/main_behaviour/selected"]])
+        _main_behaviour_bouncing_1.setAction(self._main_behaviour_bouncing_1_exec)
+        _main_behaviour_bouncing_1.setTrigger(Event("mouse_press", self.getInPortName("ball_ui")))
+        _main_behaviour_bouncing_1.setGuard(self._main_behaviour_bouncing_1_guard)
+        self.states["/main_behaviour/bouncing"].addTransition(_main_behaviour_bouncing_1)
+        
+        # transition /main_behaviour/dragging
+        _main_behaviour_dragging_0 = Transition(self, self.states["/main_behaviour/dragging"], [self.states["/main_behaviour/dragging"]])
+        _main_behaviour_dragging_0.setAction(self._main_behaviour_dragging_0_exec)
+        _main_behaviour_dragging_0.setTrigger(Event("mouse_move", self.getInPortName("ball_ui")))
+        self.states["/main_behaviour/dragging"].addTransition(_main_behaviour_dragging_0)
+        _main_behaviour_dragging_1 = Transition(self, self.states["/main_behaviour/dragging"], [self.states["/main_behaviour/bouncing"]])
+        _main_behaviour_dragging_1.setAction(self._main_behaviour_dragging_1_exec)
+        _main_behaviour_dragging_1.setTrigger(Event("mouse_release", self.getInPortName("ball_ui")))
+        self.states["/main_behaviour/dragging"].addTransition(_main_behaviour_dragging_1)
+        
+        # transition /main_behaviour/selected
+        _main_behaviour_selected_0 = Transition(self, self.states["/main_behaviour/selected"], [self.states["/main_behaviour/dragging"]])
+        _main_behaviour_selected_0.setAction(self._main_behaviour_selected_0_exec)
+        _main_behaviour_selected_0.setTrigger(Event("mouse_press", self.getInPortName("ball_ui")))
+        _main_behaviour_selected_0.setGuard(self._main_behaviour_selected_0_guard)
+        self.states["/main_behaviour/selected"].addTransition(_main_behaviour_selected_0)
+        _main_behaviour_selected_1 = Transition(self, self.states["/main_behaviour/selected"], [self.states["/deleted"]])
+        _main_behaviour_selected_1.setAction(self._main_behaviour_selected_1_exec)
+        _main_behaviour_selected_1.setTrigger(Event("delete_self", None))
+        self.states["/main_behaviour/selected"].addTransition(_main_behaviour_selected_1)
+    
+    def _main_behaviour_creating_circle_enter(self):
+        self.big_step.outputEvent(Event("create_circle", self.getOutPortName("ui"), [self.canvas_id, self.pos['x'], self.pos['y'], self.r, {'fill':'#000'}, self.inports['ball_ui']]))
+    
+    def _main_behaviour_bouncing_enter(self):
+        self.addTimer(0, 0.02)
+    
+    def _main_behaviour_bouncing_exit(self):
+        self.removeTimer(0)
+    
+    def _main_behaviour_initializing_0_exec(self, parameters):
+        association_name = parameters[0]
+        self.association_name = association_name
+    
+    def _main_behaviour_creating_circle_0_exec(self, parameters):
+        canvas_id = parameters[0]
+        circle_id = parameters[1]
+        self.circle_id = circle_id
+        self.big_step.outputEvent(Event("bind_canvas_event", self.getOutPortName("ui"), [self.canvas_id, circle_id, ui.EVENTS.MOUSE_PRESS, 'mouse_press', self.inports['ball_ui']]))
+        self.big_step.outputEvent(Event("bind_canvas_event", self.getOutPortName("ui"), [self.canvas_id, circle_id, ui.EVENTS.MOUSE_MOVE, 'mouse_move', self.inports['ball_ui']]))
+        self.big_step.outputEvent(Event("bind_canvas_event", self.getOutPortName("ui"), [self.canvas_id, circle_id, ui.EVENTS.MOUSE_RELEASE, 'mouse_release', self.inports['ball_ui']]))
+    
+    def _main_behaviour_bouncing_0_exec(self, parameters):
+        # Invert velocity when colliding with canvas border:
+        if self.pos['x']-self.r <= 0 or self.pos['x']+self.r >= CANVAS_DIMS[0]:
+            self.vel['x'] = -self.vel['x'];
+        if self.pos['y']-self.r <= 0 or self.pos['y']+self.r >= CANVAS_DIMS[1]:
+            self.vel['y'] = -self.vel['y'];
+        self.big_step.outputEvent(Event("move_element", self.getOutPortName("ui"), [self.canvas_id, self.circle_id, self.vel['x'], self.vel['y']]))
+        self.pos['x'] += self.vel['x']
+        self.pos['y'] += self.vel['y']
+    
+    def _main_behaviour_bouncing_1_exec(self, parameters):
+        x = parameters[0]
+        y = parameters[1]
+        button = parameters[2]
+        self.big_step.outputEvent(Event("set_element_color", self.getOutPortName("ui"), [self.canvas_id, self.circle_id, '#ff0']))
+    
+    def _main_behaviour_bouncing_1_guard(self, parameters):
+        x = parameters[0]
+        y = parameters[1]
+        button = parameters[2]
+        return button == ui.MOUSE_BUTTONS.LEFT
+    
+    def _main_behaviour_dragging_0_exec(self, parameters):
+        x = parameters[0]
+        y = parameters[1]
+        button = parameters[2]
+        # Always keep ball within canvas:
+        x = min(max(0+self.r, x), CANVAS_DIMS[0]-self.r)
+        y = min(max(0+self.r, y), CANVAS_DIMS[1]-self.r)
+        
+        dx = x - self.pos['x']
+        dy = y - self.pos['y']
+        
+        self.vel = {
+            'x': (1-self.smooth)*dx + self.smooth*self.vel['x'],
+            'y': (1-self.smooth)*dy + self.smooth*self.vel['y']
+        }
+        
+        self.pos = {'x': x, 'y': y}
+        self.big_step.outputEvent(Event("set_element_pos", self.getOutPortName("ui"), [self.canvas_id, self.circle_id, x-self.r, y-self.r]))
+    
+    def _main_behaviour_dragging_1_exec(self, parameters):
+        x = parameters[0]
+        y = parameters[1]
+        self.big_step.outputEvent(Event("set_element_color", self.getOutPortName("ui"), [self.canvas_id, self.circle_id, '#f00']))
+    
+    def _main_behaviour_selected_0_exec(self, parameters):
+        x = parameters[0]
+        y = parameters[1]
+        button = parameters[2]
+        self.mouse_pos = {'x':x, 'y':y};
+    
+    def _main_behaviour_selected_0_guard(self, parameters):
+        x = parameters[0]
+        y = parameters[1]
+        button = parameters[2]
+        return button == ui.MOUSE_BUTTONS.LEFT
+    
+    def _main_behaviour_selected_1_exec(self, parameters):
+        self.big_step.outputEventOM(Event("narrow_cast", None, [self, 'parent', Event("delete_ball", None, [self.association_name])]))
+        self.big_step.outputEvent(Event("destroy_element", self.getOutPortName("ui"), [self.canvas_id, self.element_id]))
+    
+    def initializeStatechart(self):
+        # enter default state
+        self.default_targets = self.states["/main_behaviour"].getEffectiveTargetStates()
+        RuntimeClassBase.initializeStatechart(self)
+
+class Ball(ClassBase):
+    def __init__(self, name):
+        ClassBase.__init__(self, name)
+        self.input = self.addInPort("input")
+        self.glob_outputs["ui"] = self.addOutPort("ui")
+        self.outputs["parent"] = self.addOutPort("parent")
+        self.ball_ui = self.addInPort("ball_ui")
+    
+    def constructObject(self, id, start_port_id, parameters):
+        new_instance = BallInstance(self, id, start_port_id, parameters[1], parameters[2], parameters[3])
+        return new_instance
+
+#class Dummy(ObjectManagerState):
+    #def __init__(self):
+        #ObjectManagerState.__init__(self)
+    
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["fields"] = Association("Field", 0, -1)
+    elif class_name == "Field":
+        self.narrow_cast_id = self.narrow_cast_id + 1
+        instance["associations"] = {}
+        instance["associations"]["balls"] = Association("Ball", 0, -1)
+        instance["associations"]["buttons"] = Association("Button", 0, -1)
+        instance["associations"]["parent"] = Association("MainApp", 1, 1)
+    elif class_name == "Button":
+        self.narrow_cast_id = self.narrow_cast_id + 1
+        instance["associations"] = {}
+        instance["associations"]["parent"] = Association("Field", 1, 1)
+    elif class_name == "Ball":
+        self.narrow_cast_id = self.narrow_cast_id + 1
+        instance["associations"] = {}
+        instance["associations"]["parent"] = Association("Field", 1, 1)
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+
+ObjectManagerState.instantiate = instantiate
+
+class ObjectManager(ObjectManagerBase):
+    def __init__(self, name):
+        ObjectManagerBase.__init__(self, name)
+        # TODO: changed
+        self.state = ObjectManagerState()
+        self.input = self.addInPort("input")
+        self.output["MainApp"] = self.addOutPort()
+        self.output["Field"] = self.addOutPort()
+        self.output["Button"] = self.addOutPort()
+        self.output["Ball"] = self.addOutPort()
+        self.state.createInstance("MainApp", [])
+        self.state.to_send.append((("MainApp", 0), ("MainApp", 0), Event("start_instance", None, ["MainApp[0]"])))
+
+class Controller(CoupledDEVS):
+    def __init__(self, name):
+        CoupledDEVS.__init__(self, name)
+        self.in_ui = self.addInPort("ui")
+        self.out_ui = self.addOutPort("ui")
+        self.objectmanager = self.addSubModel(ObjectManager("ObjectManager"))
+        self.atomics = []
+        self.atomics.append(self.addSubModel(MainApp("MainApp")))
+        self.atomics.append(self.addSubModel(Field("Field")))
+        self.atomics.append(self.addSubModel(Button("Button")))
+        self.atomics.append(self.addSubModel(Ball("Ball")))
+        self.connectPorts(self.atomics[0].obj_manager_out, self.objectmanager.input)
+        self.connectPorts(self.objectmanager.output["MainApp"], self.atomics[0].obj_manager_in)
+        self.connectPorts(self.atomics[0].outputs["fields"], self.atomics[1].input)
+        self.connectPorts(self.atomics[1].obj_manager_out, self.objectmanager.input)
+        self.connectPorts(self.objectmanager.output["Field"], self.atomics[1].obj_manager_in)
+        self.connectPorts(self.atomics[1].outputs["balls"], self.atomics[3].input)
+        self.connectPorts(self.atomics[1].outputs["buttons"], self.atomics[2].input)
+        self.connectPorts(self.atomics[1].outputs["parent"], self.atomics[0].input)
+        self.connectPorts(self.atomics[2].obj_manager_out, self.objectmanager.input)
+        self.connectPorts(self.objectmanager.output["Button"], self.atomics[2].obj_manager_in)
+        self.connectPorts(self.atomics[2].outputs["parent"], self.atomics[1].input)
+        self.connectPorts(self.atomics[3].obj_manager_out, self.objectmanager.input)
+        self.connectPorts(self.objectmanager.output["Ball"], self.atomics[3].obj_manager_in)
+        self.connectPorts(self.atomics[3].outputs["parent"], self.atomics[1].input)
+        self.connectPorts(self.atomics[0].glob_outputs["ui"], self.out_ui)
+        self.connectPorts(self.in_ui, self.atomics[0].input)
+        self.connectPorts(self.atomics[1].glob_outputs["ui"], self.out_ui)
+        self.connectPorts(self.in_ui, self.atomics[1].input)
+        self.connectPorts(self.atomics[2].glob_outputs["ui"], self.out_ui)
+        self.connectPorts(self.in_ui, self.atomics[2].input)
+        self.connectPorts(self.atomics[3].glob_outputs["ui"], self.out_ui)
+        self.connectPorts(self.in_ui, self.atomics[3].input)

examples/BouncingBallsCollision/PyDEVS/runner.py

@@ -1,7 +1,7 @@
 import tkinter as tk
 import target as target
 from sccd.runtime.libs.ui_v2 import UI
-from sccd.runtime.DEVS_loop import DEVSSimulator
+from sccd.runtime.DEVSSimulatorWrapper import DEVSSimulator
 
 class OutputListener:
 	def __init__(self, ui):

examples/BouncingBallsCollision/PyDEVS/target.py

@@ -33,8 +33,9 @@ class MainAppInstance(RuntimeClassBase):
         
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
+        port_name = addInputPort("ui", start_port_id, True)
+        atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -235,11 +236,11 @@ class FieldInstance(RuntimeClassBase):
         
         # call user defined constructor
         FieldInstance.user_defined_constructor(self)
+        port_name = addInputPort("ui", start_port_id, True)
+        atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("field_ui", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         self.inports["field_ui"] = port_name
     
@@ -597,11 +598,11 @@ class ButtonInstance(RuntimeClassBase):
         
         # call user defined constructor
         ButtonInstance.user_defined_constructor(self, window_id, event_name, button_text)
+        port_name = addInputPort("ui", start_port_id, True)
+        atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("button_ui", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         self.inports["button_ui"] = port_name
     
@@ -703,11 +704,11 @@ class BallInstance(RuntimeClassBase):
         
         # call user defined constructor
         BallInstance.user_defined_constructor(self, canvas_id, x, y)
+        port_name = addInputPort("ui", start_port_id, True)
+        atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("ball_ui", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         self.inports["ball_ui"] = port_name
     
@@ -938,11 +939,11 @@ class CollisionPhysicsInstance(RuntimeClassBase):
         
         # call user defined constructor
         CollisionPhysicsInstance.user_defined_constructor(self, ball1_id, ball2_id, ball1_info, ball2_info)
+        port_name = addInputPort("ui", start_port_id, True)
+        atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("physics_ui", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         self.inports["physics_ui"] = port_name
     

examples/BrokenDeletion/PyDEVS/runner.py

@@ -1,5 +1,5 @@
 import target as target
-from sccd.runtime.DEVS_loop import DEVSSimulator
+from sccd.runtime.DEVSSimulatorWrapper import DEVSSimulator
 from sccd.runtime.statecharts_core import Event
 
 class OutputListener:

examples/ElevatorBalls/PyDEVS/runner.py

@@ -1,7 +1,7 @@
 import tkinter as tk
 import target as target
 from sccd.runtime.libs.ui_v2 import UI
-from sccd.runtime.DEVS_loop import DEVSSimulator
+from sccd.runtime.DEVSSimulatorWrapper import DEVSSimulator
 
 class OutputListener:
 	def __init__(self, ui):

examples/TimerEventloop/PyDEVS/runner.py

@@ -1,7 +1,7 @@
 import tkinter as tk
 import target as target
 from sccd.runtime.libs.ui_v2 import UI
-from sccd.runtime.DEVS_loop import DEVSSimulator
+from sccd.runtime.DEVSSimulatorWrapper import DEVSSimulator
 
 
 

examples/TrafficLight/PyDEVS/runner.py

@@ -1,7 +1,7 @@
 import tkinter as tk
 import examples.TrafficLight.PyDEVS.target as target
 from sccd.runtime.libs.ui_v2 import UI
-from sccd.runtime.DEVS_loop import DEVSSimulator
+from sccd.runtime.DEVSSimulatorWrapper import DEVSSimulator
 
 
 class OutputListener:

pypdevs/basesimulator.py

@@ -1127,22 +1127,22 @@ class BaseSimulator(Solver):
                 tn = time_diff / self.realtime_scale
 
                 # TODO: SAM right now i think 
-                for p in event_port.outline:
-                    z = event_port.z_functions[p]
+                #for p in event_port.outline:
+                #    z = event_port.z_functions[p]
 
+                ##    ev = event_value if z is None else z(event_value)
+                 #   msg = {p: [ev]}
+                 #   p.host_DEVS.my_input = msg
+                 #   self.transitioning[p.host_DEVS] = 2
+                 #   self.model.time_next = (tn, 1)
+
+                for p, z in event_port.routing_outline:
                     ev = event_value if z is None else z(event_value)
                     msg = {p: [ev]}
                     p.host_DEVS.my_input = msg
                     self.transitioning[p.host_DEVS] = 2
                     self.model.time_next = (tn, 1)
 
-                #for p, z in event_port.routing_outline:
-                #    ev = event_value if z is None else z(event_value)
-                #    msg = {p: [ev]}
-                #    p.host_DEVS.my_input = msg
-                #    self.transitioning[p.host_DEVS] = 2
-                #    self.model.time_next = (tn, 1)
-
 
             # Transition
             return False

sccd/compiler/DEVS_generator.py

@@ -46,36 +46,15 @@ class DEVSGenerator(Visitor):
 
         self.writer.beginPackage(class_diagram.name)
 
-        # visit children
+        ################################
+        # Visit children (Classes)
+        ################################
         for c in class_diagram.classes:
             c.accept(self)
 
-
         ################################
-        # Object Manager State
+        # Object Manager State (instantiate function)
         ################################
-        #self.writer.beginClass("ObjectManagerState")
-        #self.writer.beginConstructor()
-        #self.writer.beginMethodBody()
-
-        #self.writer.addAssignment(GLC.SelfProperty("to_send"), f"[(\"{class_diagram.default_class.name}\", \"{class_diagram.default_class.name}\", Event(\"start_instance\", None, [\"{class_diagram.default_class.name}[0]\"], 0))]")
-
-        #self.writer.endMethodBody()
-        #self.writer.endConstructor()
-        #self.writer.endClass()
-
-        self.writer.beginClass(f"Dummy", ["ObjectManagerState"])
-        self.writer.beginConstructor()
-        self.writer.beginMethodBody()
-        self.writer.beginSuperClassConstructorCall("ObjectManagerState")
-        self.writer.endSuperClassConstructorCall()
-
-        #self.writer.addAssignment(GLC.SelfProperty("to_send"), f"[(\"{class_diagram.default_class.name}\", \"{class_diagram.default_class.name}\", Event(\"start_instance\", None, [\"{class_diagram.default_class.name}[0]\"], 0))]")
-
-        self.writer.endMethodBody()
-        self.writer.endConstructor()
-
-
         self.writer.beginMethod("instantiate")
         self.writer.addFormalParameter("class_name")
         self.writer.addFormalParameter("construct_params")
@@ -109,8 +88,7 @@ class DEVSGenerator(Visitor):
         self.writer.endMethodBody()
         self.writer.endMethod()
 
-
-        self.writer.endClass()
+        self.writer.addStaticAttribute("ObjectManagerState.instantiate", "instantiate")
 
         ################################
         # Object Manager
@@ -123,7 +101,8 @@ class DEVSGenerator(Visitor):
         self.writer.addActualParameter("name")
         self.writer.endSuperClassConstructorCall()
 
-        self.writer.addAssignment(GLC.SelfProperty("state"), GLC.FunctionCall("Dummy"))
+        self.writer.addAssignment(GLC.SelfProperty("state"), GLC.FunctionCall("ObjectManagerState"))
+
         self.writer.addAssignment(GLC.SelfProperty("input"),
                                   GLC.FunctionCall(GLC.SelfProperty("addInPort"), [GLC.String("input")]))
 
@@ -172,13 +151,6 @@ class DEVSGenerator(Visitor):
                                                                                                                [
                                                                                                                    GLC.String(
                                                                                                                        class_name)]))]))])))
-        #for (i, class_name) in enumerate(class_diagram.class_names):
-        #    self.writer.addAssignment(GLC.SelfProperty(f"atomic{i}"),
-        #                              (GLC.FunctionCall(GLC.SelfProperty("addSubModel"), [GLC.FunctionCall(class_name,
-        #                                                                                                   GLC.ActualParameters(
-        #                                                                                                       [
-        #                                                                                                           GLC.String(
-        #                                                                                                               class_name)]))])))
 
         # Add links between the models
         for (i, the_class) in enumerate(class_diagram.classes):
@@ -204,11 +176,7 @@ class DEVSGenerator(Visitor):
 
             for inp in class_diagram.inports:
                 self.writer.add(GLC.FunctionCall(GLC.SelfProperty("connectPorts"), [GLC.SelfProperty(f"in_{inp}"), GLC.SelfProperty(f"atomics[{i}].input")]))
-        
 
-        # TODO: What to do with "actual_parameters"?
-        # actual_parameters = [p.getIdent() for p in class_diagram.default_class.constructors[0].parameters]
-        # self.writer.add(GLC.FunctionCall(GLC.Property(GLC.SelfProperty("object_manager"), "createInstance"), [GLC.String(class_diagram.default_class.name), GLC.ArrayExpression(actual_parameters)]))
         self.writer.endMethodBody()
         self.writer.endConstructor()
         self.writer.endClass()
@@ -231,15 +199,11 @@ class DEVSGenerator(Visitor):
                 super_classes.append("RuntimeClassBase")
         if class_node.super_classes:
             for super_class in class_node.super_classes:
-                # Check if this is always the case (that the superclass is an instance)
                 super_classes.append(super_class + "Instance")
 
         ################################
         # State Instance (statechart)
         ################################
-
-        # TODO: RuntimeClassBase only if there are no superclasses, if there are then append the superclasses
-
         self.writer.beginClass(f"{class_node.name}Instance", super_classes)
         self.writer.beginConstructor()
         self.writer.addFormalParameter("atomdevs")
@@ -256,13 +220,6 @@ class DEVSGenerator(Visitor):
         self.writer.addActualParameter("id")
         self.writer.endSuperClassConstructorCall()
 
-        self.writer.addAssignment(GLC.SelfProperty("associations"), "{}")
-        for association in class_node.associations:
-            self.writer.addAssignment(
-                GLC.SelfProperty(f"associations[\"{association.name}\"]"),
-                GLC.FunctionCall("Association",
-                                 [GLC.String(association.to_class), f"{association.min}", f"{association.max}"]))
-            
         # TODO: Switch instance to write in constructor instead of the atomic devs because corresponds better
         constructor = class_node.constructors[0]
         if class_node.statechart:
@@ -320,19 +277,15 @@ class DEVSGenerator(Visitor):
 
         for inp in class_node.class_diagram.inports:
             self.writer.addAssignment("port_name", GLC.FunctionCall("addInputPort", [GLC.String(inp), "start_port_id", "True"]))
-            self.writer.add(GLC.FunctionCall("atomdevs.addInPort", ["port_name"]))
             self.writer.addAssignment("atomdevs.state.port_mappings[port_name]", "id")
 
 
 
         self.writer.addAssignment("port_name", GLC.FunctionCall("addInputPort", [GLC.String("<narrow_cast>"), "start_port_id"]))
-        self.writer.add(GLC.FunctionCall("atomdevs.addInPort", ["port_name"]))
         self.writer.addAssignment("atomdevs.state.port_mappings[port_name]", "id")
 
-        for inp in class_node.inports:
-            #self.writer.addAssignment(GLC.SelfProperty(f"inports[\"{inp}\"]"), f"(\'{inp}\', atomdevs.next_instance)")
-            self.writer.addAssignment("port_name", GLC.FunctionCall("addInputPort", [GLC.String(inp), "start_port_id"]))
-            self.writer.add(GLC.FunctionCall("atomdevs.addInPort", ["port_name"]))
+        for index, inp in enumerate(class_node.inports):
+            self.writer.addAssignment("port_name", GLC.FunctionCall("addInputPort", [GLC.String(inp), f"start_port_id + {index + 1}"]))
             self.writer.addAssignment("atomdevs.state.port_mappings[port_name]", "id")
             self.writer.addAssignment(f"self.inports[\"{inp}\"]", "port_name")
 
@@ -341,7 +294,7 @@ class DEVSGenerator(Visitor):
         self.writer.endConstructor()
 
         # visit constructor
-                # user defined constructor
+        # user defined constructor
         self.writer.beginMethod("user_defined_constructor")
         for p in constructor.getParams():
             p.accept(self)
@@ -353,7 +306,6 @@ class DEVSGenerator(Visitor):
             if super_class in constructor.parent_class.super_class_objs:
                 self.writer.beginSuperClassMethodCall(super_class + "Instance", "user_defined_constructor")
             else:
-                # TODO: How to get in this? 
                 self.writer.beginSuperClassConstructorCall(super_class)
             # write actual parameters
             if super_class in constructor.super_class_parameters:
@@ -409,7 +361,7 @@ class DEVSGenerator(Visitor):
         self.writer.endClass()
 
         ################################
-        # State Object (keeps list of all instances of that object + controller operations)
+        # Class (Type) 
         ################################
         self.writer.beginClass(class_node.name, ["ClassBase"])
 
@@ -448,10 +400,8 @@ class DEVSGenerator(Visitor):
         self.writer.addActualParameter("name")
         self.writer.endSuperClassConstructorCall()
 
-        # TODO: ceck here also
         self.writer.addAssignment(GLC.SelfProperty("input"), GLC.FunctionCall(GLC.SelfProperty("addInPort"), [GLC.String("input")]))
 
-        # TODO: output shuold have the same name as the real port
         for global_outport in constructor.parent_class.class_diagram.outports:
             self.writer.addAssignment(GLC.SelfProperty(f"glob_outputs[\"{global_outport}\"]"), GLC.FunctionCall(GLC.SelfProperty("addOutPort"), [GLC.String(global_outport)]))
 
@@ -473,8 +423,6 @@ class DEVSGenerator(Visitor):
         if constructor.parent_class.name == constructor.parent_class.class_diagram.default_class.name:
             self.writer.addAssignment("new_instance", "self.constructObject(0, 0, [])")
             self.writer.addAssignment("self.state.instances[new_instance.instance_id]", "new_instance")
-            #self.writer.addAssignment("self.state.instances[self.state.next_instance]", f"{constructor.parent_class.name}Instance(self)")
-            self.writer.addAssignment("self.state.next_instance", "self.state.next_instance + 1")
 
         self.writer.endMethodBody()
         self.writer.endConstructor()
@@ -499,9 +447,6 @@ class DEVSGenerator(Visitor):
                     self.writer.beginSuperClassDestructorCall(super_class)
                     self.writer.endSuperClassDestructorCall()
                     pass
-
-                # self.writer.beginSuperClassMethodCall(super_class, "user_defined_destructor")
-                # self.writer.endSuperClassMethodCall()
         self.writer.endMethodBody()
         self.writer.endMethod()
 

sccd/compiler/generic_generator.py

@@ -13,7 +13,7 @@ from sccd.compiler.sccd_constructs import FormalParameter
 from sccd.compiler.stateful_writer import StatefulWriter
 import sccd.compiler.generic_language_constructs as GLC
 
-Platforms = Enum("Threads","GameLoop","EventLoop", "PypDEVS") 
+Platforms = Enum("Threads","GameLoop","EventLoop", "classicDEVS") 
 
 class GenericGenerator(Visitor):
     

sccd/compiler/sccdc.py

@@ -60,7 +60,7 @@ def sccdToDEVS(sccd, platform):
 	generator = DEVSGenerator(platform)
 	sccd.accept(generator)
 	generic = generator.get()
-	Logger.showInfo("Classes <" + ", ".join(sccd.class_names) + "> have been converted to DEVS language constructs.")
+	Logger.showInfo("Classes <" + ", ".join(sccd.class_names) + "> have been converted to generic DEVS constructs.")
 	return generic
 
 def genericToTarget(generic, target_language, output_file):
@@ -70,8 +70,6 @@ def genericToTarget(generic, target_language, output_file):
 			writer = JavascriptWriter(f)
 		elif target_language == "python":
 			writer = PythonWriter(f)
-		elif target_language == "pypDEVS":
-			writer = PythonWriter(f)
 		else:
 			raise Exception("Language not supported")
 		generic.accept(writer)
@@ -124,11 +122,14 @@ def main():
 			platform = Platforms.GameLoop
 		elif args['platform'] == "eventloop" :
 			platform = Platforms.EventLoop
-		elif args['platform'] == "pypdevs":
-			platform = Platforms.PypDEVS
+		elif args['platform'] == "classicdevs":
+			if target_language == "" or target_language == "python":
+				platform = Platforms.classicDEVS
+			else:
+				Logger.showError("DEVS currently only supports python.")
 		else :
 			Logger.showError("Invalid platform.")
-			return		  
+			return	
 	else :
 		platform = Platforms.EventLoop
 		

sccd/runtime/DEVS_loop.py

@@ -16,9 +16,7 @@ class DEVSSimulator(Simulator):
 		super().__init__(model)
 		self.setClassicDEVS()
 
-		# TODO: Add the input ports here so it works without manually adding them
-		inputs ={}
-
+		inputs = {}
 		# Add global inports
 		for global_in in model.IPorts:
 			inputs[global_in.name] = global_in

sccd/runtime/DEVS_statecharts_core old.py

@@ -1,940 +0,0 @@
-# TODO: The associations are sometimes getting pushed differently, fix this
-
-import sys
-import re
-from sccd.runtime.event_queue import EventQueue
-from pypdevs.infinity import INFINITY
-from pypdevs.DEVS import *
-
-from sccd.runtime.statecharts_core import StatechartSemantics, BigStepState, ComboStepState, SmallStepState
-from sccd.runtime.statecharts_core import State, HistoryState, ShallowHistoryState, DeepHistoryState, ParallelState
-from sccd.runtime.statecharts_core import RuntimeException, AssociationException,AssociationReferenceException, ParameterException, InputException
-from sccd.runtime.statecharts_core import ELSE_GUARD, Association, Event
-
-
-from heapq import heappush, heappop, heapify
-import threading
-
-def get_private_port(text):
-    match = re.search(r'private_\d+_(\w+)', text)
-
-    if match:
-        result = match.group(1)
-        return result
-    
-class Transition:
-    def __init__(self, obj, source, targets):
-        self.guard = None
-        self.action = None
-        self.trigger = None
-        self.source = source
-        self.targets = targets
-        self.obj = obj
-        self.enabled_event = None  # the event that enabled this transition
-        self.optimize()
-
-    def isEnabled(self, events, enabled_transitions):
-        if self.trigger is None:
-            self.enabled_event = None
-            return (self.guard is None) or (self.guard == ELSE_GUARD and not enabled_transitions) or self.guard([])
-        else:
-            for event in events:
-                if (self.trigger.name == event.name and (
-                        not self.trigger.port or self.trigger.port == event.port)) and (
-                        (self.guard is None) or (self.guard == ELSE_GUARD and not enabled_transitions) or self.guard(
-                        event.parameters)):
-                    self.enabled_event = event
-                    return True
-
-    # @profile
-    def fire(self, statechart):
-        # exit states...
-        exit_set = self.__exitSet()
-        for s in exit_set:
-            # remember which state(s) we were in if a history state is present
-            for h in s.history:
-                f = lambda s0: s0.ancestors and s0.parent == s
-                if isinstance(h, DeepHistoryState):
-                    f = lambda s0: not s0.descendants and s0 in s.descendants
-                self.obj.history_values[h.state_id] = list(filter(f, self.obj.configuration))
-        for s in exit_set:
-            #########################################
-            # TODO, here trace for exit state
-            statechart.text += "\n"
-            statechart.text += "\t\t\tEXIT STATE in model <%s>\n" % statechart.name
-            statechart.text += f"\t\t\tState: {str(s)} (name: {s.name})\n"
-            #########################################
-
-            self.obj.eventless_states -= s.has_eventless_transitions
-            # execute exit action(s)
-            if s.exit:
-                s.exit()
-            self.obj.configuration_bitmap &= ~2 ** s.state_id
-
-        # combo state changed area
-        self.obj.combo_step.changed_bitmap |= 2 ** self.lca.state_id
-        self.obj.combo_step.changed_bitmap |= self.lca.descendant_bitmap
-
-        #########################################
-         # TODO, here trace for fired transition
-        statechart.text += "\n"
-        statechart.text += "\t\t\tTRANSITION FIRED in model <%s>\n" % statechart.name
-        statechart.text += "\t\t\t%s\n" % str(self)
-        #########################################
-        # execute transition action(s)
-        if self.action:
-            self.action(self.enabled_event.parameters if self.enabled_event else [])
-
-        # enter states...
-        targets = self.__getEffectiveTargetStates()
-        enter_set = self.__enterSet(targets)
-        for s in enter_set:
-            #########################################
-            # TODO, here trace for enter state
-            statechart.text += "\n"
-            statechart.text += "\t\t\tENTER STATE in model <%s>\n" % statechart.name
-            statechart.text += f"\t\t\tState: {str(s)} (name: {s.name})\n"
-            #########################################
-
-            self.obj.eventless_states += s.has_eventless_transitions
-            self.obj.configuration_bitmap |= 2 ** s.state_id
-            # execute enter action(s)
-            if s.enter:
-                s.enter()
-
-        if self.obj.eventless_states:
-            self.obj.controller.state.eventless.add(self.obj)
-        else:
-            self.obj.controller.state.eventless.discard(self.obj)
-
-        try:
-            self.obj.configuration = self.obj.config_mem[self.obj.configuration_bitmap]
-        except:
-            self.obj.configuration = self.obj.config_mem[self.obj.configuration_bitmap] = sorted(
-                [s for s in list(self.obj.states.values()) if 2 ** s.state_id & self.obj.configuration_bitmap],
-                key=lambda s: s.state_id)
-        self.enabled_event = None
-
-    def __getEffectiveTargetStates(self):
-        targets = []
-        for target in self.targets:
-            for e_t in target.getEffectiveTargetStates():
-                if not e_t in targets:
-                    targets.append(e_t)
-        return targets
-
-    def __exitSet(self):
-        return [s for s in reversed(self.lca.descendants) if (s in self.obj.configuration)]
-
-    def __enterSet(self, targets):
-        target = targets[0]
-        for a in reversed(target.ancestors):
-            if a in self.source.ancestors:
-                continue
-            else:
-                yield a
-        for target in targets:
-            yield target
-
-    def setGuard(self, guard):
-        self.guard = guard
-
-    def setAction(self, action):
-        self.action = action
-
-    def setTrigger(self, trigger):
-        self.trigger = trigger
-        if self.trigger is None:
-            self.source.has_eventless_transitions = True
-
-    def optimize(self):
-        # the least-common ancestor can be computed statically
-        if self.source in self.targets[0].ancestors:
-            self.lca = self.source
-        else:
-            self.lca = self.source.parent
-            target = self.targets[0]
-            if self.source.parent != target.parent:  # external
-                for a in self.source.ancestors:
-                    if a in target.ancestors:
-                        self.lca = a
-                        break
-
-    def __repr__(self):
-        return "Transition(%s -> %s)" % (self.source.name, self.targets[0].name)
-
-
-class RuntimeClassBase(object):
-    def __init__(self, controller, id):
-        self.events = EventQueue()
-
-        self.active = False
-
-        # Instead of controller, do the class for which the instanced 
-        self.controller = controller
-        self.instance_id = id
-
-        self.__set_stable(True)
-        self.inports = {}
-        self.outports = {}
-        self.timers = {}
-        self.states = {}
-        self.eventless_states = 0
-        self.configuration_bitmap = 0
-        self.transition_mem = {}
-        self.config_mem = {}
-
-        self.semantics = StatechartSemantics()
-
-    # to break ties in the heap, compare by number of events in the list
-    def __lt__(self, other):
-        return len(self.events.event_list) < len(other.events.event_list)
-
-    def getChildren(self, link_name):
-        pass
-
-    def getSingleChild(self, link_name):
-        return self.getChildren(link_name)[0]  # assume this will return a single child...
-
-    def getOutPortName(self, port_name):
-        return self.outports[port_name] if port_name in self.outports else port_name
-
-    def getInPortName(self, port_name):
-        return self.inports[port_name] if port_name in self.inports else port_name
-
-    def start(self):
-        self.configuration = []
-
-        self.active = True
-
-        self.current_state = {}
-        self.history_values = {}
-        self.timers = {}
-        self.timers_to_add = {}
-
-        self.big_step = BigStepState()
-        self.combo_step = ComboStepState()
-        self.small_step = SmallStepState()
-
-        self.__set_stable(False)
-
-        self.initializeStatechart()
-        self.processBigStepOutput()
-
-    def stop(self):
-        self.active = False
-        self.__set_stable(True)
-
-    def updateConfiguration(self, states):
-        self.configuration.extend(states)
-        self.configuration_bitmap = sum([2 ** s.state_id for s in states])
-
-    def getSimulatedTime(self):
-        return self.controller.state.simulated_time * 1000
-
-    def addTimer(self, index, timeout):
-        self.timers_to_add[index] = (self.controller.state.simulated_time + timeout, Event("_%iafter" % index))
-
-    def removeTimer(self, index):
-        if index in self.timers_to_add:
-            del self.timers_to_add[index]
-        if index in self.timers:
-            self.events.remove(self.timers[index])
-            del self.timers[index]
-        self.earliest_event_time = self.events.getEarliestTime()
-
-    def addEvent(self, event_list, time_offset=0):
-        event_time = self.controller.state.simulated_time + time_offset
-        if not (event_time, self) in self.controller.state.instance_times:
-            heappush(self.controller.state.instance_times, (event_time, self))
-        if event_time < self.earliest_event_time:
-            self.earliest_event_time = event_time
-        if not isinstance(event_list, list):
-            event_list = [event_list]
-        for e in event_list:
-            self.events.add(event_time, e)
-
-    def processBigStepOutput(self):
-        for e in self.big_step.output_events_port:
-            self.controller.state.outputEvent(e)
-        for e in self.big_step.output_events_om:
-            self.controller.state.addEvent(e)
-    def __set_stable(self, is_stable):
-        self.is_stable = is_stable
-        # self.earliest_event_time keeps track of the earliest time this instance will execute a transition
-        if not is_stable:
-            self.earliest_event_time = self.controller.state.simulated_time
-        
-        elif not self.active:
-            self.earliest_event_time = INFINITY
-        else:
-            self.earliest_event_time = self.events.getEarliestTime()
-        if self.earliest_event_time != INFINITY:
-            if not (self.earliest_event_time, self) in self.controller.state.instance_times:
-                heappush(self.controller.state.instance_times, (self.earliest_event_time, self))
-
-    def step(self):
-        is_stable = False
-        while not is_stable:
-            due = []
-            if self.events.getEarliestTime() <= self.controller.state.simulated_time:
-                due = [self.events.pop()]
-            is_stable = not self.bigStep(due)
-            self.processBigStepOutput()
-        for index, entry in list(self.timers_to_add.items()):
-            self.timers[index] = self.events.add(*entry)
-        self.timers_to_add = {}
-        self.__set_stable(True)
-
-    def inState(self, state_strings):
-        state_ids = [self.states[state_string].state_id for state_string in state_strings]
-        for state_id in state_ids:
-            for s in self.configuration:
-                if s.state_id == state_id:
-                    break
-            else:
-                return False
-        return True
-
-    def bigStep(self, input_events):
-        self.big_step.next(input_events)
-        self.small_step.reset()
-        self.combo_step.reset()
-        while self.comboStep():
-            self.big_step.has_stepped = True
-            if self.semantics.big_step_maximality == StatechartSemantics.TakeOne:
-                break  # Take One -> only one combo step allowed
-        return self.big_step.has_stepped
-
-    def comboStep(self):
-        self.combo_step.next()
-        while self.smallStep():
-            self.combo_step.has_stepped = True
-        return self.combo_step.has_stepped
-
-    # generate transition candidates for current small step
-    # @profile
-    def generateCandidates(self):
-        changed_bitmap = self.combo_step.changed_bitmap
-        key = (self.configuration_bitmap, changed_bitmap)
-        try:
-            transitions = self.transition_mem[key]
-        except:
-            self.transition_mem[key] = transitions = [t for s in self.configuration if
-                                                      not (2 ** s.state_id & changed_bitmap) for t in s.transitions]
-
-        enabledEvents = self.getEnabledEvents()
-        enabledTransitions = []
-        for t in transitions:
-            if t.isEnabled(enabledEvents, enabledTransitions):
-                enabledTransitions.append(t)
-        return enabledTransitions
-
-    # @profile
-    def smallStep(self):
-        def __younger_than(x, y):
-            if x.source in y.source.ancestors:
-                return 1
-            elif y.source in x.source.ancestors:
-                return -1
-            else:
-                return 0
-
-        if self.small_step.has_stepped:
-            self.small_step.next()
-        candidates = self.generateCandidates()
-        if candidates:
-            to_skip = set()
-            conflicting = []
-            for c1 in candidates:
-                if c1 not in to_skip:
-                    conflict = [c1]
-                    for c2 in candidates[candidates.index(c1):]:
-                        if c2.source in c1.source.ancestors or c1.source in c2.source.ancestors:
-                            conflict.append(c2)
-                            to_skip.add(c2)
-
-                    if sys.version_info[0] < 3:
-                        conflicting.append(sorted(conflict, cmp=__younger_than))
-                    else:
-                        import functools
-                        conflicting.append(sorted(conflict, key=functools.cmp_to_key(__younger_than)))
-
-            if self.semantics.concurrency == StatechartSemantics.Single:
-                candidate = conflicting[0]
-                if self.semantics.priority == StatechartSemantics.SourceParent:
-                    candidate[-1].fire(self.controller.state)
-                else:
-                    candidate[0].fire(self.controller.state)
-            elif self.semantics.concurrency == StatechartSemantics.Many:
-                pass  # TODO: implement
-            self.small_step.has_stepped = True
-        return self.small_step.has_stepped
-
-    # @profile
-    def getEnabledEvents(self):
-        result = self.small_step.current_events + self.combo_step.current_events
-        if self.semantics.input_event_lifeline == StatechartSemantics.Whole or (
-                not self.big_step.has_stepped and
-                (self.semantics.input_event_lifeline == StatechartSemantics.FirstComboStep or (
-                        not self.combo_step.has_stepped and
-                        self.semantics.input_event_lifeline == StatechartSemantics.FirstSmallStep))):
-            result += self.big_step.input_events
-        return result
-
-    def raiseInternalEvent(self, event):
-        if self.semantics.internal_event_lifeline == StatechartSemantics.NextSmallStep:
-            self.small_step.addNextEvent(event)
-        elif self.semantics.internal_event_lifeline == StatechartSemantics.NextComboStep:
-            self.combo_step.addNextEvent(event)
-        elif self.semantics.internal_event_lifeline == StatechartSemantics.Queue:
-            self.addEvent(event)
-
-    def initializeStatechart(self):
-        self.updateConfiguration(self.default_targets)
-        for state in self.default_targets:
-            self.eventless_states += state.has_eventless_transitions
-            if state.enter:
-                state.enter()
-        if self.eventless_states:
-            pass
-            # TODO: Check (untill now no problems)
-            #self.controller.object_manager.eventless.add(self)
-    
-class ClassState():
-    def __init__(self, name) -> None:
-        self.name = name
-        self.next_time = INFINITY
-        
-        self.port_mappings = {}
-        
-        self.input_queue = EventQueue()
-        self.simulated_time = 0
-        self.to_send = []
-
-        self.events = EventQueue()
-        self.instances = {}
-        self.next_instance = 0
-        self.instance_times = []
-        self.eventless = set()
-
-        #self.lock = threading.Condition()
-
-        self.text = ""
-
-    def __str__(self) -> str:
-        return self.text
-
-    def getEarliestEventTime(self):
-        #with self.lock:
-        while self.instance_times and self.instance_times[0][0] < self.instance_times[0][1].earliest_event_time:
-            heappop(self.instance_times)
-        return min(INFINITY if not self.instance_times else self.instance_times[0][0], self.events.getEarliestTime())
-        
-    def addEvent(self, event, time_offset = 0):
-        self.events.add(self.simulated_time + time_offset, event)
-        
-    # broadcast an event to all instances
-    def broadcast(self, source, new_event, time_offset = 0):
-        for i in self.instances:
-            if self.instances[i] != source:
-                self.instances[i].addEvent(new_event, time_offset)
-        
-    def stepAll(self):
-        self.step()
-        self.to_step = set()
-        if len(self.instance_times) > (4 * len(self.instances)):
-            new_instance_times = []
-            for it in self.instances:
-                if it.earliest_event_time != INFINITY:
-                    new_instance_times.append((it.earliest_event_time, it))
-            self.instance_times = new_instance_times
-            heapify(self.instance_times)
-        while self.instance_times and self.instance_times[0][0] <= self.simulated_time:
-            self.to_step.add(heappop(self.instance_times)[1])
-        for i in self.to_step | self.eventless:
-            if i.active and (i.earliest_event_time <= self.simulated_time or i.eventless_states):
-                i.step()
-
-    def step(self):
-        while self.events.getEarliestTime() <= self.simulated_time:
-            if self.events:
-                self.handleEvent(self.events.pop())
-               
-    def start(self):
-        for i in self.instances:
-            i.start()
-
-    def handleInput(self):
-        while not self.input_queue.isEmpty():
-            event_time = self.input_queue.getEarliestTime()
-            e = self.input_queue.pop()
-
-            target_instance = None
-            if e.getPort():
-                target_instance = self.port_mappings[e.getPort()]
-                if target_instance is not None:
-                    target_instance = self.instances[target_instance] 
-                    e.port = get_private_port(e.port)
-            if target_instance == None:
-                self.broadcast(None,e, event_time - self.simulated_time)
-            else:
-                target_instance.addEvent(e, event_time - self.simulated_time)
-        
-
-    def addInput(self, input_event_list, time_offset = 0):
-        if not isinstance(input_event_list, list):
-            input_event_list = [input_event_list]
-
-        for e in input_event_list:
-            if e.getName() == "":
-                raise InputException("Input event can't have an empty name.")
-            
-            #if e.getPort() not in self.IPorts:
-            #    raise InputException("Input port mismatch, no such port: " + e.getPort() + ".")
-                
-            self.input_queue.add((0 if self.simulated_time is None else 0) + time_offset, e)
-
-
-    def handleEvent(self, e):
-        parameters = e.parameters
-        source = parameters[0]
-        parameters[0] = source.instance_id
-        self.to_send.append(((self.name, source.instance_id), None, e))
-
-
-    def outputEvent(self, event):
-        self.to_send.append(event)
-
-
-class ClassBase(AtomicDEVS):    
-    def __init__(self, name):
-        AtomicDEVS.__init__(self, name)
-        self.glob_outputs = {}
-        self.outputs = {}
-        self.state = ClassState(name)
-        self.obj_manager_in = self.addInPort("obj_manager_in")
-        self.obj_manager_out = self.addOutPort("obj_manager_out")
-
-    def constructObject(self, id, parameters):
-        raise "Something went wrong "
-
-    def extTransition(self, inputs):
-        # Update simulated time
-        self.state.simulated_time += self.elapsed
-        self.state.next_time = 0
-        self.state.text = ""
-
-        # Collect all inputs
-        all_inputs = [input for input_list in inputs.values() for input in input_list]
-        for input in all_inputs:
-            if isinstance(input, str):
-                tem = eval(input)
-                instance = self.state.port_mappings.setdefault(tem.port, None)
-                self.state.addInput(tem)
-            elif input[2].name == "create_instance":
-                new_instance = self.constructObject(input[1][1], input[2].parameters[2:])
-                self.state.instances[new_instance.instance_id] = new_instance
-                ev = Event("instance_created", None, [input[2].parameters[1]])
-                self.state.to_send.append((input[1], input[0], ev))
-                self.state.next_instance += 1
-            elif input[2].name == "broad_cast":
-                # Handle when in the instance atomicDEVS
-                if input[0][0] == self.name:
-                    source = self.state.instances[input[0][1]]
-                    self.state.broadcast(source, input[2].parameters[1])
-                self.state.broadcast(None, input[2].parameters[1])
-            elif input[2].name == "start_instance":
-                instance = self.state.instances[input[1][1]]
-                instance.start()
-                ev = Event("instance_started", None, [input[2].parameters[0]])
-                self.state.to_send.append((input[1], input[0], ev))
-            elif input[2].name == "delete_instance":   
-                instance_ids =  input[2].parameters[0]
-                for id in instance_ids:
-                    instance = self.state.instances[id]  
-                    self.state.port_mappings = {k: v for k, v in self.state.port_mappings.items() if v != id}
-                    del self.state.instances[instance.instance_id]
-                    self.state.eventless.discard(instance.instance_id)
-                    instance.user_defined_destructor()
-                    instance.stop()
-                    del instance
-                ev = Event("instance_deleted", None, [input[2].parameters[1]])
-                self.state.to_send.append((input[1], input[0], ev))
-            elif input[2].name == "associate_instance":
-                ev = Event("instance_associated", None, input[2].parameters)
-                self.state.to_send.append((input[1], input[0], ev))
-            elif input[2].name == "disassociate_instance":
-                ev = Event("instance_disassociated", None, input[2].parameters)
-                self.state.to_send.append((input[1], input[0], ev))
-            elif input[2].name == "instance_created":
-                instance = self.state.instances[input[1][1]]
-                instance.addEvent(input[2])
-            elif input[2].name == "instance_started":
-                instance = self.state.instances[input[1][1]]
-                instance.addEvent(input[2])
-            elif input[2].name == "instance_deleted":
-                instance = self.state.instances[input[1][1]]
-                instance.addEvent(input[2])
-            elif input[2].name == "instance_associated":
-                instance = self.state.instances[input[1][1]]
-                instance.addEvent(input[2])
-            elif input[2].name == "instance_disassociated":
-                instance = self.state.instances[input[1][1]]
-                instance.addEvent(input[2])
-            else:
-                ev = input[2]
-
-                new_port = None
-                for key, value in self.state.port_mappings.items():
-                    if value == ev.port[1]:
-                        new_port = key
-                        break
-                
-                if new_port is None:
-                    new_port = 0
-                ev.port = new_port
-                self.state.addInput(ev)
-        return self.state
-    
-    def intTransition(self):
-        self.state.to_send = self.state.to_send[1:]
-        self.state.text = ""
-
-        if len(self.state.to_send) == 0:
-            # Update simulated time and clear previous messages 
-            self.state.simulated_time += self.state.next_time
-            # Calculate the next event time, clamp to ensure non-negative result
-            self.state.next_time = min(self.state.getEarliestEventTime(), self.state.simulated_time + self.state.input_queue.getEarliestTime())
-            self.state.next_time -= self.state.simulated_time
-            self.state.next_time = max(self.state.next_time, 0.0)
-            # Handle incoming inputs and do a step in all statecharts
-            self.state.handleInput()
-            self.state.stepAll()
-        else:
-            self.state.next_time = 0
-        return self.state
-
-    def outputFnc(self):
-        to_dict = {}
-        if not len(self.state.to_send) == 0:
-            sending = self.state.to_send[0]
-            if isinstance(sending, tuple) and sending[2].port == None:
-                to_dict[self.obj_manager_out] = sending
-            else:
-                the_port = next((port for port in self.OPorts if port.name == sending.port), None)
-                to_dict[the_port] = sending
-        return to_dict
-    
-    def timeAdvance(self):
-        return self.state.next_time
-
-class ObjectManagerState():
-    def __init__(self):
-        self.to_send = []
-        self.instances = []
-
-        self.regex_pattern = re.compile("^([a-zA-Z_]\w*)(?:\[(\d+)\])?$")
-        self.handlers = {
-                    "broad_cast": self.handleBroadCastEvent,
-                    "narrow_cast": self.handleNarrowCastEvent,
-                    "create_instance": self.handleCreateEvent,
-                    "associate_instance": self.handleAssociateEvent,
-                    "start_instance": self.handleStartEvent,
-                    "delete_instance": self.handleDeleteEvent,
-                    "disassociate_instance": self.handleDisassociateEvent,
-                    }
-
-    def handleEvent(self, e):
-        self.handlers[e[2].getName()](e)
-    
-    def processAssociationReference(self, input_string):
-        if len(input_string) == 0:
-            raise AssociationReferenceException("Empty association reference.")
-        path_string =  input_string.split("/")
-        result = []
-        for piece in path_string:
-            match = self.regex_pattern.match(piece)
-            if match:
-                name = match.group(1)
-                index = match.group(2)
-                if index is None:
-                    index = -1
-                result.append((name,int(index)))
-            else:
-                raise AssociationReferenceException("Invalid entry in association reference. Input string: " + input_string)
-        return result
-
-    def getInstances(self, source, traversal_list):
-        currents = [{
-            "instance": source,
-            "ref": None,
-            "assoc_name": None,
-            "assoc_index": None,
-            "path": ""
-        }]
-        # currents = [source]
-        for (name, index) in traversal_list:
-            nexts = []
-            for current in currents:
-                instance = current["instance"][1]
-
-                association = self.instances[instance]["associations"][name]
-                if (index >= 0 ):
-                    try:
-                        nexts.append({
-                            "class": association.to_class,
-                            "instance": (association.to_class, association.instances[index]),
-                            "ref": current["instance"],
-                            "assoc_name": name,
-                            "assoc_index": index,
-                            "path": current["path"] + ("" if current["path"] == "" else "/") + name + "[" + str(index) + "]"
-                        })
-                    except KeyError:
-                        # Entry was removed, so ignore this request
-                        pass
-                elif (index == -1):
-                    for i in association.instances:
-                        nexts.append({
-                            "class": association.to_class,
-                            "instance": (association.to_class, association.instances[i]),
-                            "ref": current["instance"],
-                            "assoc_name": name,
-                            "assoc_index": index,
-                            "path": current["path"] + ("" if current["path"] == "" else "/") + name + "[" + str(index) + "]"
-                        })
-                else:
-                    raise AssociationReferenceException("Incorrect index in association reference.")
-            currents = nexts
-        return currents
-
-    def handleNarrowCastEvent(self, parameters):
-        if len(parameters[2].parameters) != 3:
-            raise ParameterException("The narrow_cast event needs 3 parameters.")
-        else:
-            source = parameters[0]
-            
-            parameters = parameters[2].parameters
-            if not isinstance(parameters[1], list):
-                targets = [parameters[1]]
-            else:
-                targets = parameters[1]
-
-            for target in targets:
-                traversal_list = self.processAssociationReference(target)
-                cast_event = parameters[2]
-                for i in self.getInstances(source, traversal_list):
-                    to_send_event = Event(cast_event.name, i["instance"], cast_event.parameters)
-                    self.to_send.append((source,  i["instance"], to_send_event))
-
-    def handleBroadCastEvent(self, parameters):
-        if len(parameters[2].parameters) != 2:
-            raise ParameterException("The broadcast event needs 2 parameters (source of event and event name).")
-        
-        ev = Event('broad_cast', None, parameters[2].parameters)
-        # Extract unique names
-        unique_classes = {entry["name"] for entry in self.instances}
-        for aclass in unique_classes:
-            # The index of target does not matter as it gets broadcasted to every instance
-            self.to_send.append((parameters[0], (aclass, 0), ev))
-
-    def handleCreateEvent(self, parameters):
-        if len(parameters[2].parameters) < 2:
-            raise ParameterException("The create event needs at least 2 parameters.")
-        else:
-            source = parameters[0]
-
-            association_name = parameters[2].parameters[1]
-            
-            traversal_list = self.processAssociationReference(association_name)
-            instances = self.getInstances(source, traversal_list)
-            
-            association = self.instances[source[1]]["associations"][association_name]
-
-            if association.allowedToAdd():
-                ''' allow subclasses to be instantiated '''
-                class_name = association.to_class if len(parameters[2].parameters) == 2 else parameters[2].parameters[2]
-                new_instance = self.createInstance(class_name, parameters[2].parameters[3:])
-
-                #  Work on index instead of the instance
-                new_instance_index = len(self.instances) - 1
-
-                if not new_instance:
-                    raise ParameterException("Creating instance: no such class: " + class_name)
-                try:
-                    index = association.addInstance(new_instance_index)
-                except AssociationException as exception:
-                    raise RuntimeException("Error adding instance to association '" + association_name + "': " + str(exception))
-                p = new_instance["associations"].get("parent")
-                if p:
-                    p.addInstance(source[1])
-                
-                parameters[2].parameters[1] = f"{association_name}[{index}]"
-                ev = Event('create_instance', None, parameters[2].parameters)
-                self.to_send.append((parameters[0], (class_name, new_instance_index), ev))
-                return [source, association_name+"["+str(index)+"]"]
-            else:
-                #source.addEvent(Event("instance_creation_error", None, [association_name]))
-                return []
-    
-    def handleStartEvent(self, parameters):
-        if len(parameters[2].parameters) != 2:
-            raise ParameterException("The start instance event needs 2 parameters.")  
-        else:
-            source = parameters[0]
-            traversal_list = self.processAssociationReference(parameters[2].parameters[1])
-
-            # TODO: it is possible that we need to get the right index here because not needed now
-            to_class = None
-            for i in self.getInstances(source, traversal_list):
-                to_class = i["instance"]
-            self.to_send.append((source, to_class, Event('start_instance', None, parameters[2].parameters[1:])))
-        
-    def createInstance(self, to_class, construct_params = []):
-        instance = self.instantiate(to_class, construct_params)
-        self.instances.append(instance)
-        return instance
-    
-    def handleAssociateEvent(self, parameters):
-        if len(parameters[2].parameters) != 3:
-            raise ParameterException("The associate_instance event needs 3 parameters.")
-        else:
-            source = parameters[0]
-            to_copy_list = self.getInstances(source, self.processAssociationReference(parameters[2].parameters[1]))
-            if len(to_copy_list) != 1:
-                raise AssociationReferenceException("Invalid source association reference.")
-            wrapped_to_copy_instance = to_copy_list[0]["instance"][1]
-            dest_list = self.processAssociationReference(parameters[2].parameters[2])
-            if len(dest_list) == 0:
-                raise AssociationReferenceException("Invalid destination association reference.")
-            last = dest_list.pop()
-            if last[1] != -1:
-                raise AssociationReferenceException("Last association name in association reference should not be accompanied by an index.")
-                
-            added_links = []
-            to_class = None
-            for i in self.getInstances(source, dest_list):
-                to_class = i["instance"]
-                association = self.instances[i["instance"][1]]["associations"][last[0]]
-                if association.allowedToAdd():
-                    index = association.addInstance(wrapped_to_copy_instance)
-                    added_links.append(i["path"] + ("" if i["path"] == "" else "/") + last[0] + "[" + str(index) + "]")
-
-            self.to_send.append((source, to_class, Event('associate_instance', None, [added_links])))  
-
-    def handleDisassociateEvent(self, parameters):
-        if len(parameters[2].parameters) < 2:
-            raise ParameterException("The disassociate_instance event needs at least 2 parameters.")
-        else:
-            source = parameters[0]
-            association_name = parameters[2].parameters[1]
-            if not isinstance(association_name, list):
-                association_name = [association_name]
-            deleted_links = []
-            
-            to_class = None
-            for a_n in association_name:
-                traversal_list = self.processAssociationReference(a_n)
-                instances = self.getInstances(source, traversal_list)
-                
-                for i in instances:
-                    try:
-                        to_class = i["instance"]
-                        instance = self.instances[i['ref'][1]]
-                        association = instance['associations'][i['assoc_name']]
-
-                        index = association.removeInstance(i["instance"][1])
-                        #index = i['ref'].associations[i['assoc_name']].removeInstance(i["instance"])
-                        deleted_links.append(a_n +  "[" + str(index) + "]")
-                    except AssociationException as exception:
-                        raise RuntimeException("Error disassociating '" + a_n + "': " + str(exception))
-                
-            self.to_send.append((None, source, Event('instance_disassociated', None, [deleted_links])))  
-
-    def handleDeleteEvent(self, parameters):
-        if len(parameters) < 2:
-            raise ParameterException("The delete event needs at least 2 parameters.")
-        else:
-            source = parameters[0]
-            association_name = parameters[2].parameters[1]
-            
-            traversal_list = self.processAssociationReference(association_name)
-            instances = self.getInstances(source, traversal_list)
-
-            association = self.instances[source[1]]["associations"][traversal_list[0][0]]
-            
-            # TODO: THis to class only for when there are no instance
-            to_class = (association.to_class, 0)
-            to_remove = []
-            for i in instances:
-                to_class = i["instance"]
-                to_remove.append(i["instance"][1])
-                try:
-                    for assoc_name in self.instances[i["instance"][1]]["associations"]:
-                        if assoc_name != 'parent':
-                            traversal_list = self.processAssociationReference(assoc_name)
-                            instances = self.getInstances(to_class, traversal_list)
-                            if len(instances) > 0:
-                                raise RuntimeException("Error removing instance from association %s, still %i children left connected with association %s" % (association_name, len(instances), assoc_name))
-                    association.removeInstance(i["instance"][1])
-                except AssociationException as exception:
-                    raise RuntimeException("Error removing instance from association '" + association_name + "': " + str(exception))
-            parameters[2].parameters[0] = to_remove
-            self.to_send.append((source, to_class, Event('delete_instance', None, parameters[2].parameters)))
-            #source.addEvent(Event("delete_instance", parameters = [parameters[1]]))
-
-class ObjectManagerBase(AtomicDEVS):
-    def __init__(self, name):
-        AtomicDEVS.__init__(self, name)
-        self.output = {}
-
-        self.to_propagate = ["instance_created", "instance_started", "instance_associated", "instance_disassociated", "instance_deleted"]
-
-    def extTransition(self, inputs):
-        all_inputs = inputs[self.input]
-        if all_inputs[2].name in self.to_propagate:
-            self.state.to_send.append(all_inputs)
-        else:
-            self.state.handleEvent(all_inputs)
-        
-        return self.state
-    
-    def intTransition(self):
-        self.state.to_send.clear()
-        return self.state
-    
-    def outputFnc(self):
-        out_dict = {}
-        for source, target, message in self.state.to_send:
-            out_dict.setdefault(self.output.get(target[0]), []).append((source, target, message))
-        return out_dict
-    
-    def timeAdvance(self):
-        return 0 if self.state.to_send else INFINITY
-    
-# TODO: port class as wrapper to define the in and out ports the same as in SCCD
-class Ports:
-    private_port_counter = 0
-
-    inports = {}
-    outports = {}
-
-    @classmethod
-    def addOutputPort(self, virtual_name, instance=None):
-        if instance == None:
-            port_name = virtual_name
-        else:
-            port_name = "private_" + str(self.private_port_counter) + "_" + virtual_name
-            self.outports[port_name] = instance
-            self.private_port_counter += 1
-        return port_name
-
-    @classmethod
-    def addInputPort(self, virtual_name, instance=None):
-        if instance == None:
-            port_name = virtual_name
-        else:
-            port_name = "private_" + str(self.private_port_counter) + "_" + virtual_name
-            self.inports[port_name] = instance
-            self.private_port_counter += 1
-        return port_name

sccd/runtime/DEVS_statecharts_core.py

@@ -1,5 +1,3 @@
-# TODO: The associations are sometimes getting pushed differently, fix this
-
 import sys
 import re
 from sccd.runtime.event_queue import EventQueue
@@ -59,7 +57,7 @@ class Transition:
                 self.obj.history_values[h.state_id] = list(filter(f, self.obj.configuration))
         for s in exit_set:
             #########################################
-            # TODO, here trace for exit state
+            # Trace for exit state
             statechart.text += "\n"
             statechart.text += "\t\t\tEXIT STATE in model <%s>\n" % statechart.name
             statechart.text += f"\t\t\tState: {str(s)} (name: {s.name})\n"
@@ -76,7 +74,7 @@ class Transition:
         self.obj.combo_step.changed_bitmap |= self.lca.descendant_bitmap
 
         #########################################
-         # TODO, here trace for fired transition
+         # Trace for fired transition
         statechart.text += "\n"
         statechart.text += "\t\t\tTRANSITION FIRED in model <%s>\n" % statechart.name
         statechart.text += "\t\t\t%s\n" % str(self)
@@ -90,7 +88,7 @@ class Transition:
         enter_set = self.__enterSet(targets)
         for s in enter_set:
             #########################################
-            # TODO, here trace for enter state
+            # Trace for enter state
             statechart.text += "\n"
             statechart.text += "\t\t\tENTER STATE in model <%s>\n" % statechart.name
             statechart.text += f"\t\t\tState: {str(s)} (name: {s.name})\n"
@@ -414,13 +412,14 @@ class ClassState():
 
         self.events = EventQueue()
         self.instances = {}
-        self.next_instance = 0
         self.instance_times = []
         self.eventless = set()
 
         #self.lock = threading.Condition()
 
         self.text = ""
+        
+        self.to_add = ["instance_created", "instance_started", "instance_associated", "instance_disassociated", "instance_deleted"]
 
     def __str__(self) -> str:
         return self.text
@@ -445,7 +444,7 @@ class ClassState():
         self.to_step = set()
         if len(self.instance_times) > (4 * len(self.instances)):
             new_instance_times = []
-            for it in self.instances:
+            for it in self.instances.values():
                 if it.earliest_event_time != INFINITY:
                     new_instance_times.append((it.earliest_event_time, it))
             self.instance_times = new_instance_times
@@ -491,19 +490,16 @@ class ClassState():
                 raise InputException("Input event can't have an empty name.")
             
             if e.getPort() not in self.port_mappings:
-            #if e.getPort() not in self.IPorts:
                 raise InputException("Input port mismatch, no such port: " + e.getPort() + ".")
                 
             self.input_queue.add((0 if self.simulated_time is None else 0) + time_offset, e)
 
-
     def handleEvent(self, e):
         parameters = e.parameters
         source = parameters[0]
         parameters[0] = source.instance_id
         self.to_send.append(((self.name, source.instance_id), None, e))
 
-
     def outputEvent(self, event):
         self.to_send.append(event)
 
@@ -517,8 +513,55 @@ class ClassBase(AtomicDEVS):
         self.obj_manager_in = self.addInPort("obj_manager_in")
         self.obj_manager_out = self.addOutPort("obj_manager_out")
 
+        self.handlers = {
+            "create_instance": self.handleCreateEvent,
+            "broad_cast": self.handleBroadCastEvent,
+            "narrow_cast": self.handleNarrowCastEvent,
+            "associate_instance": self.handleAssociateEvent,
+            "start_instance": self.handleStartEvent,
+            "delete_instance": self.handleDeleteEvent,
+            "disassociate_instance": self.handleDisassociateEvent,
+            }
+
     def constructObject(self, id, parameters):
-        raise "Something went wrong "
+        raise "Something went wrong"
+    
+    def handleBroadCastEvent(self, input):
+        # Handle when in the instance atomicDEVS
+        if input[0][0] == self.name:
+            source = self.state.instances[input[0][1]]
+            self.state.broadcast(source, input[2].parameters[1])
+        self.state.broadcast(None, input[2].parameters[1])
+    def handleNarrowCastEvent(self, input):
+        pass
+    def handleCreateEvent(self, input):
+        new_instance = self.constructObject(input[1][1], input[2].parameters[1], input[2].parameters[3:])
+        self.state.instances[new_instance.instance_id] = new_instance
+        ev = Event("instance_created", None, [input[2].parameters[2]])
+        self.state.to_send.append((input[1], input[0], ev))
+    def handleAssociateEvent(self, input):
+        ev = Event("instance_associated", None, input[2].parameters)
+        self.state.to_send.append((input[1], input[0], ev))
+    def handleStartEvent(self, input):
+        instance = self.state.instances[input[1][1]]
+        instance.start()
+        ev = Event("instance_started", None, [input[2].parameters[0]])
+        self.state.to_send.append((input[1], input[0], ev))
+    def handleDeleteEvent(self, input):
+        instance_ids =  input[2].parameters[0]
+        for id in instance_ids:
+            instance = self.state.instances[id]  
+            self.state.port_mappings = {k: v for k, v in self.state.port_mappings.items() if v != id}
+            del self.state.instances[instance.instance_id]
+            self.state.eventless.discard(instance.instance_id)
+            instance.user_defined_destructor()
+            instance.stop()
+            del instance
+        ev = Event("instance_deleted", None, [input[2].parameters[1]])
+        self.state.to_send.append((input[1], input[0], ev))
+    def handleDisassociateEvent(self, input):
+        ev = Event("instance_disassociated", None, input[2].parameters)
+        self.state.to_send.append((input[1], input[0], ev))
 
     def extTransition(self, inputs):
         # Update simulated time
@@ -527,60 +570,14 @@ class ClassBase(AtomicDEVS):
         self.state.text = ""
 
         # Collect all inputs
-        all_inputs = [input for input_list in inputs.values() for input in input_list]
+        # all_inputs = [input for input_list in inputs.values() for input in input_list]
+        all_inputs = [item for input_list in inputs.values() for item in (input_list if isinstance(input_list, (tuple, list)) else [input_list])]
         for input in all_inputs:
-            # TODO, this should be translated somewhere else
             if isinstance(input, str):
                 input = (None, None, eval(input))
-            if input[2].name == "create_instance":
-                new_instance = self.constructObject(input[1][1], input[2].parameters[1], input[2].parameters[3:])
-                # new_instance = self.constructObject(input[1][1], input[2].parameters[2:])
-                self.state.instances[new_instance.instance_id] = new_instance
-                ev = Event("instance_created", None, [input[2].parameters[2]])
-                self.state.to_send.append((input[1], input[0], ev))
-                self.state.next_instance += 1
-            elif input[2].name == "broad_cast":
-                # Handle when in the instance atomicDEVS
-                if input[0][0] == self.name:
-                    source = self.state.instances[input[0][1]]
-                    self.state.broadcast(source, input[2].parameters[1])
-                self.state.broadcast(None, input[2].parameters[1])
-            elif input[2].name == "start_instance":
-                instance = self.state.instances[input[1][1]]
-                instance.start()
-                ev = Event("instance_started", None, [input[2].parameters[0]])
-                self.state.to_send.append((input[1], input[0], ev))
-            elif input[2].name == "delete_instance":   
-                instance_ids =  input[2].parameters[0]
-                for id in instance_ids:
-                    instance = self.state.instances[id]  
-                    self.state.port_mappings = {k: v for k, v in self.state.port_mappings.items() if v != id}
-                    del self.state.instances[instance.instance_id]
-                    self.state.eventless.discard(instance.instance_id)
-                    instance.user_defined_destructor()
-                    instance.stop()
-                    del instance
-                ev = Event("instance_deleted", None, [input[2].parameters[1]])
-                self.state.to_send.append((input[1], input[0], ev))
-            elif input[2].name == "associate_instance":
-                ev = Event("instance_associated", None, input[2].parameters)
-                self.state.to_send.append((input[1], input[0], ev))
-            elif input[2].name == "disassociate_instance":
-                ev = Event("instance_disassociated", None, input[2].parameters)
-                self.state.to_send.append((input[1], input[0], ev))
-            elif input[2].name == "instance_created":
-                instance = self.state.instances[input[1][1]]
-                instance.addEvent(input[2])
-            elif input[2].name == "instance_started":
-                instance = self.state.instances[input[1][1]]
-                instance.addEvent(input[2])
-            elif input[2].name == "instance_deleted":
-                instance = self.state.instances[input[1][1]]
-                instance.addEvent(input[2])
-            elif input[2].name == "instance_associated":
-                instance = self.state.instances[input[1][1]]
-                instance.addEvent(input[2])
-            elif input[2].name == "instance_disassociated":
+            if input[2].getName() in self.handlers:
+                self.handlers[input[2].getName()](input)
+            elif input[2].name in self.state.to_add:
                 instance = self.state.instances[input[1][1]]
                 instance.addEvent(input[2])
             else:
@@ -804,7 +801,6 @@ class ObjectManagerState():
         else:
             port_name = "private_" + str(self.narrow_cast_id) + "_" + virtual_name
             self.narrow_cast_id += 1
-        #self.input_ports[port_name] = InputPortEntry(virtual_name, instance)
         return port_name
         
     def createInstance(self, to_class, construct_params = []):
@@ -865,7 +861,6 @@ class ObjectManagerState():
                         association = instance['associations'][i['assoc_name']]
 
                         index = association.removeInstance(i["instance"][1])
-                        #index = i['ref'].associations[i['assoc_name']].removeInstance(i["instance"])
                         deleted_links.append(a_n +  "[" + str(index) + "]")
                     except AssociationException as exception:
                         raise RuntimeException("Error disassociating '" + a_n + "': " + str(exception))
@@ -884,7 +879,6 @@ class ObjectManagerState():
 
             association = self.instances[source[1]]["associations"][traversal_list[0][0]]
             
-            # TODO: THis to class only for when there are no instance
             to_class = (association.to_class, 0)
             to_remove = []
             for i in instances:
@@ -896,8 +890,8 @@ class ObjectManagerState():
                             traversal_list = self.processAssociationReference(assoc_name)
                             instances = self.getInstances(to_class, traversal_list)
                             if len(instances) > 0:
-                                pass
-                                #raise RuntimeException("Error removing instance from association %s, still %i children left connected with association %s" % (association_name, len(instances), assoc_name))
+                                #pass
+                                raise RuntimeException("Error removing instance from association %s, still %i children left connected with association %s" % (association_name, len(instances), assoc_name))
                     
                     del self.narrow_cast_ports[i["instance"][1]]
 
@@ -906,7 +900,6 @@ class ObjectManagerState():
                     raise RuntimeException("Error removing instance from association '" + association_name + "': " + str(exception))
             parameters[2].parameters[0] = to_remove
             self.to_send.append((source, to_class, Event('delete_instance', None, parameters[2].parameters)))
-            #source.addEvent(Event("delete_instance", parameters = [parameters[1]]))
 
 class ObjectManagerBase(AtomicDEVS):
     def __init__(self, name):
@@ -921,7 +914,6 @@ class ObjectManagerBase(AtomicDEVS):
             self.state.to_send.append(all_inputs)
         else:
             self.state.handleEvent(all_inputs)
-        
         return self.state
     
     def intTransition(self):
@@ -937,12 +929,6 @@ class ObjectManagerBase(AtomicDEVS):
     def timeAdvance(self):
         return 0 if self.state.to_send else INFINITY
 
-"""  
-def addInputPort(virtual_name, private_port_id):
-        port_name = "private_" + str(private_port_id) + "_" + virtual_name
-        return port_name
-"""
-
 def addInputPort(virtual_name, private_port_id, is_global = False):
     if is_global:
         port_name = virtual_name

sccd/runtime/statecharts_core.py

@@ -146,6 +146,7 @@ class ObjectManagerBase(object):
         
     def addEvent(self, event, time_offset = 0):
         self.events.add(self.controller.simulated_time + time_offset, event)
+        self.controller.tracers.tracesInternalOutput(event)
         
     # broadcast an event to all instances
     def broadcast(self, source, new_event, time_offset = 0):
@@ -1168,7 +1169,8 @@ class RuntimeClassBase(object):
         if not isinstance(event_list, list):
             event_list = [event_list]
         for e in event_list:
-            self.events.add(event_time, e)
+            self.controller.tracers.tracesInternalInput(e)
+            self.events.add(event_time, e)           
 
     def processBigStepOutput(self):
         for e in self.big_step.output_events_port:

sccd/runtime/tracers/tracer.py

@@ -106,12 +106,15 @@ class Tracers(object):
         for tracer in self.tracers:
             tracer.traceTransition(StateChartName, Transition)
 
+    def tracesInternalOutput(self, event):
+        for tracer in self.tracers:
+            tracer.traceInternalOutput(event)
+    
+    def tracesInternalInput(self, event):
+        for tracer in self.tracers:
+            tracer.traceInternalInput(event)
+
     def tracesOutput(self, event):
-        """
-        Perform all tracing actions for an external transition
-        
-        :param aDEVS: the model that transitioned
-        """
         for tracer in self.tracers:
             tracer.traceOutput(event)
 

sccd/runtime/tracers/tracerBase.py

@@ -36,6 +36,12 @@ class BaseTracer:
 	
 	def traceEnterState(self, StateChart, State):
 		pass
+
+	def traceInternalInput(self, event):
+		pass
+
+	def traceInternalOutput(self, event):
+		pass
 	
 	def traceOutput(self, event):
 		pass 

sccd/runtime/tracers/tracerVerbose.py

@@ -1,5 +1,6 @@
 from sccd.runtime.tracers.tracerBase import BaseTracer
 import sys
+import copy
 
 class TracerVerbose(BaseTracer):
     """
@@ -78,6 +79,18 @@ class TracerVerbose(BaseTracer):
         self.text += "\n"
         self.text += "TRANSITION FIRED in model <%s>\n" % StateChart
         self.text += "\t\t%s\n" % str(Transition)
+
+    def traceInternalInput(self, event):
+        self.text += "\n"
+        self.text += "INPUT EVENT from <ObjectManager>\n"
+        self.text += "\t\Type: cd\n"
+        self.text += "\t\Event: %s\n" % str(event)
+
+    def traceInternalOutput(self, event):
+        self.text += "\n"
+        self.text += "OUTPUT EVENT to <ObjectManager>\n"
+
+        self.text += "\t\Event: %s\n" % str(event)
     
     def traceOutput(self, event):
         self.text += "\n"

tests/0) copy/PyDEVS/log.txt

@@ -0,0 +1,121 @@
+
+__  Current Time:   0.000000 __________________________________________ 
+
+
+	INITIAL CONDITIONS in model <Controller.MainApp>
+		Initial State: 
+		Next scheduled internal transition at time inf
+
+
+	INITIAL CONDITIONS in model <Controller.ObjectManager>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x101f8ac00>
+		Next scheduled internal transition at time 0.000000
+
+
+	INITIAL CONDITIONS in model <Controller.Tester>
+		Initial State: None
+		Next scheduled internal transition at time 0.000000
+
+
+__  Current Time:   0.000000 __________________________________________ 
+
+
+	EXTERNAL TRANSITION in model <Controller.MainApp>
+		Input Port Configuration:
+			port <obj_manager_in>:
+				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
+			port <input>:
+		New State: 
+		Next scheduled internal transition at time 0.000000
+
+
+	INTERNAL TRANSITION in model <Controller.ObjectManager>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x101f8ac00>
+		Output Port Configuration:
+			port <port1>:
+				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
+		Next scheduled internal transition at time inf
+
+
+__  Current Time:   0.000000 __________________________________________ 
+
+
+	EXTERNAL TRANSITION in model <Controller.ObjectManager>
+		Input Port Configuration:
+			port <input>:
+				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x101f8ac00>
+		Next scheduled internal transition at time 0.000000
+
+
+	INTERNAL TRANSITION in model <Controller.MainApp>
+		New State: 
+		Output Port Configuration:
+			port <obj_manager_out>:
+				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
+			port <ui>:
+		Next scheduled internal transition at time 0.000000
+
+
+__  Current Time:   0.000000 __________________________________________ 
+
+
+	INTERNAL TRANSITION in model <Controller.MainApp>
+		New State: 
+		Output Port Configuration:
+			port <obj_manager_out>:
+			port <ui>:
+		Next scheduled internal transition at time inf
+
+
+__  Current Time:   0.000000 __________________________________________ 
+
+
+	EXTERNAL TRANSITION in model <Controller.MainApp>
+		Input Port Configuration:
+			port <obj_manager_in>:
+				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
+			port <input>:
+		New State: 
+		Next scheduled internal transition at time 0.000000
+
+
+	INTERNAL TRANSITION in model <Controller.ObjectManager>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x101f8ac00>
+		Output Port Configuration:
+			port <port1>:
+				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
+		Next scheduled internal transition at time inf
+
+
+__  Current Time:   0.000000 __________________________________________ 
+
+
+	INTERNAL TRANSITION in model <Controller.MainApp>
+		New State: 
+		Output Port Configuration:
+			port <obj_manager_out>:
+			port <ui>:
+		Next scheduled internal transition at time 0.000000
+
+
+__  Current Time:   0.000000 __________________________________________ 
+
+
+	INTERNAL TRANSITION in model <Controller.MainApp>
+		New State: 
+		Output Port Configuration:
+			port <obj_manager_out>:
+			port <ui>:
+		Next scheduled internal transition at time inf
+
+
+__  Current Time:   0.000000 __________________________________________ 
+
+
+	INTERNAL TRANSITION in model <Controller.Tester>
+		New State: None
+		Output Port Configuration:
+			port <Test_ui>:
+		Next scheduled internal transition at time inf
+

tests/0) copy/PyDEVS/target.py

@@ -0,0 +1,109 @@
+"""
+Generated by Statechart compiler by Glenn De Jonghe, Joeri Exelmans, Simon Van Mierlo, and Yentl Van Tendeloo (for the inspiration) and Sam Pieters (DEVS)
+
+Model author: Sam Pieters
+Model name:   GlobalData
+Model description:
+Test X: check if global data can be changed
+"""
+
+from sccd.runtime.DEVS_statecharts_core import *
+GLOBAL_INT = 0
+
+# package "GlobalData"
+
+class MainAppInstance(RuntimeClassBase):
+    def __init__(self, atomdevs, id, start_port_id):
+        RuntimeClassBase.__init__(self, atomdevs, id)
+        
+        self.semantics.big_step_maximality = StatechartSemantics.TakeMany
+        self.semantics.internal_event_lifeline = StatechartSemantics.Queue
+        self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
+        self.semantics.priority = StatechartSemantics.SourceParent
+        self.semantics.concurrency = StatechartSemantics.Single
+        
+        # build Statechart structure
+        self.build_statechart_structure()
+        
+        # call user defined constructor
+        MainAppInstance.user_defined_constructor(self)
+        port_name = addInputPort("ui", start_port_id, True)
+        atomdevs.state.port_mappings[port_name] = id
+        port_name = addInputPort("<narrow_cast>", start_port_id)
+        atomdevs.state.port_mappings[port_name] = id
+    
+    def user_defined_constructor(self):
+        pass
+    
+    def user_defined_destructor(self):
+        pass
+    
+    
+    # builds Statechart structure
+    def build_statechart_structure(self):
+        
+        # state <root>
+        self.states[""] = State(0, "", self)
+        
+        # state /state1
+        self.states["/state1"] = State(1, "/state1", self)
+        self.states["/state1"].setEnter(self._state1_enter)
+        
+        # add children
+        self.states[""].addChild(self.states["/state1"])
+        self.states[""].fixTree()
+        self.states[""].default_state = self.states["/state1"]
+    
+    def _state1_enter(self):
+        print(GLOBAL_INT)
+    
+    def initializeStatechart(self):
+        # enter default state
+        self.default_targets = self.states["/state1"].getEffectiveTargetStates()
+        RuntimeClassBase.initializeStatechart(self)
+
+class MainApp(ClassBase):
+    def __init__(self, name):
+        ClassBase.__init__(self, name)
+        self.input = self.addInPort("input")
+        self.glob_outputs["ui"] = self.addOutPort("ui")
+        new_instance = self.constructObject(0, 0, [])
+        self.state.instances[new_instance.instance_id] = new_instance
+        self.state.next_instance = self.state.next_instance + 1
+    
+    def constructObject(self, id, start_port_id, parameters):
+        new_instance = MainAppInstance(self, id, start_port_id)
+        return new_instance
+
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
+
+class ObjectManager(ObjectManagerBase):
+    def __init__(self, name):
+        ObjectManagerBase.__init__(self, name)
+        self.state = ObjectManagerState()
+        self.input = self.addInPort("input")
+        self.output["MainApp"] = self.addOutPort()
+        self.state.createInstance("MainApp", [])
+        self.state.to_send.append((("MainApp", 0), ("MainApp", 0), Event("start_instance", None, ["MainApp[0]"])))
+
+class Controller(CoupledDEVS):
+    def __init__(self, name):
+        CoupledDEVS.__init__(self, name)
+        self.in_ui = self.addInPort("ui")
+        self.out_ui = self.addOutPort("ui")
+        self.objectmanager = self.addSubModel(ObjectManager("ObjectManager"))
+        self.atomics = []
+        self.atomics.append(self.addSubModel(MainApp("MainApp")))
+        self.connectPorts(self.atomics[0].obj_manager_out, self.objectmanager.input)
+        self.connectPorts(self.objectmanager.output["MainApp"], self.atomics[0].obj_manager_in)
+        self.connectPorts(self.atomics[0].glob_outputs["ui"], self.out_ui)
+        self.connectPorts(self.in_ui, self.atomics[0].input)

tests/0) copy/Python/log.txt

@@ -0,0 +1,2 @@
+__  Current Time:   0.000000 __________________________________________ 
+

tests/0) copy/Python/target.py

@@ -0,0 +1,81 @@
+"""
+Generated by Statechart compiler by Glenn De Jonghe, Joeri Exelmans, Simon Van Mierlo, and Yentl Van Tendeloo (for the inspiration)
+
+Model author: Sam Pieters
+Model name:   GlobalData
+Model description:
+Test X: check if global data can be changed
+"""
+
+from sccd.runtime.statecharts_core import *
+GLOBAL_INT = 0
+
+# package "GlobalData"
+
+class MainApp(RuntimeClassBase):
+    def __init__(self, controller):
+        RuntimeClassBase.__init__(self, controller)
+        
+        
+        self.semantics.big_step_maximality = StatechartSemantics.TakeMany
+        self.semantics.internal_event_lifeline = StatechartSemantics.Queue
+        self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
+        self.semantics.priority = StatechartSemantics.SourceParent
+        self.semantics.concurrency = StatechartSemantics.Single
+        
+        # build Statechart structure
+        self.build_statechart_structure()
+        
+        # call user defined constructor
+        MainApp.user_defined_constructor(self)
+    
+    def user_defined_constructor(self):
+        pass
+    
+    def user_defined_destructor(self):
+        pass
+    
+    
+    # builds Statechart structure
+    def build_statechart_structure(self):
+        
+        # state <root>
+        self.states[""] = State(0, "", self)
+        
+        # state /state1
+        self.states["/state1"] = State(1, "/state1", self)
+        self.states["/state1"].setEnter(self._state1_enter)
+        
+        # add children
+        self.states[""].addChild(self.states["/state1"])
+        self.states[""].fixTree()
+        self.states[""].default_state = self.states["/state1"]
+    
+    def _state1_enter(self):
+        print(GLOBAL_INT)
+    
+    def initializeStatechart(self):
+        # enter default state
+        self.default_targets = self.states["/state1"].getEffectiveTargetStates()
+        RuntimeClassBase.initializeStatechart(self)
+
+class ObjectManager(ObjectManagerBase):
+    def __init__(self, controller):
+        ObjectManagerBase.__init__(self, controller)
+    
+    def instantiate(self, class_name, construct_params):
+        if class_name == "MainApp":
+            instance = MainApp(self.controller)
+            instance.associations = {}
+        else:
+            raise Exception("Cannot instantiate class " + class_name)
+        return instance
+
+class Controller(ThreadsControllerBase):
+    def __init__(self, keep_running = None, behind_schedule_callback = None):
+        if keep_running == None: keep_running = True
+        if behind_schedule_callback == None: behind_schedule_callback = None
+        ThreadsControllerBase.__init__(self, ObjectManager(self), keep_running, behind_schedule_callback)
+        self.addInputPort("ui")
+        self.addOutputPort("ui")
+        self.object_manager.createInstance("MainApp", [])

tests/0) copy/sccd.xml

@@ -0,0 +1,22 @@
+<?xml version="1.1" ?>
+<diagram author="Sam Pieters" name="GlobalData">
+    <description>
+        Test X: check if global data can be changed
+    </description>
+    <top>
+        GLOBAL_INT = 0
+    </top>
+    <inport name="ui"/>
+    <outport name="ui"/>
+    <class name="MainApp" default="true">
+        <scxml initial="state1">
+            <state id="state1">
+                <onentry>
+                    <script>
+                        print(GLOBAL_INT)
+                    </script>
+                </onentry>
+            </state>
+        </scxml>
+    </class>
+</diagram>

tests/0) AssociateInstance/PyDEVS/faulty_log.txt

@@ -0,0 +1,34 @@
+0.00 (event name: start_instance; port: None; parameters: ['MainApp[0]'])
+0.00 (event name: instance_started; port: None; parameters: ['MainApp[0]'])
+0.00 (event name: create_instance; port: None; parameters: [0, 'linkA', 'A'])
+0.00 (event name: create_instance; port: None; parameters: [0, 1, 'linkA[0]', 'A'])
+0.00 (event name: instance_started; port: None; parameters: ['MainApp[0]'])
+0.00 (event name: instance_created; port: None; parameters: ['linkA[0]'])
+0.00 (event name: instance_created; port: None; parameters: ['linkA[0]'])
+0.00 (event name: instance_created_succesfully; port: ui; parameters: ['linkA[0]'])
+0.00 (event name: start_instance; port: None; parameters: [0, 'linkA[0]'])
+0.00 (event name: start_instance; port: None; parameters: ['linkA[0]'])
+0.00 (event name: statechart_started_succesfully; port: ui)
+0.00 (event name: instance_started; port: None; parameters: ['linkA[0]'])
+0.00 (event name: instance_started; port: None; parameters: ['linkA[0]'])
+0.00 (event name: instance_started_succesfully; port: ui; parameters: ['linkA[0]'])
+0.00 (event name: create_instance; port: None; parameters: [0, 'linkB', 'B'])
+0.00 (event name: create_instance; port: None; parameters: [0, 2, 'linkB[0]', 'B'])
+0.00 (event name: instance_created; port: None; parameters: ['linkB[0]'])
+0.00 (event name: instance_created; port: None; parameters: ['linkB[0]'])
+0.00 (event name: instance_created_succesfully; port: ui; parameters: ['linkB[0]'])
+0.00 (event name: start_instance; port: None; parameters: [0, 'linkB[0]'])
+0.00 (event name: start_instance; port: None; parameters: ['linkB[0]'])
+0.00 (event name: statechart_started_succesfully; port: ui)
+0.00 (event name: instance_started; port: None; parameters: ['linkB[0]'])
+0.00 (event name: instance_started; port: None; parameters: ['linkB[0]'])
+0.00 (event name: instance_started_succesfully; port: ui; parameters: ['linkB[0]'])
+0.00 (event name: associate_instance; port: None; parameters: [0, 'linkB[0]', 'linkA/linkB'])
+0.00 (event name: associate_instance; port: None; parameters: [['linkA[-1]/linkB[0]']])
+0.00 (event name: instance_associated; port: None; parameters: [['linkA[-1]/linkB[0]']])
+0.00 (event name: instance_associated; port: None; parameters: [['linkA[-1]/linkB[0]']])
+0.00 (event name: narrow_cast; port: None; parameters: [0, 'linkA[0]', (event name: test_link; port: None)
+0.00 (event name: test_link; port: private_1_<narrow_cast>)
+0.00 (event name: narrow_cast; port: None; parameters: [1, 'linkB[0]', (event name: test_new_link; port: None)
+0.00 (event name: test_new_link; port: private_2_<narrow_cast>)
+0.00 (event name: associated_succesfully; port: ui)

tests/3.16) AssociateInstance/PyDEVS/log.txt

@@ -18,7 +18,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104c98170>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -35,14 +35,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -58,7 +56,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -80,7 +78,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: create_instance; port: None; parameters: [0, 'linkA[0]', 'A']))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -103,8 +101,6 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: create_instance; port: None; parameters: [0, 1, 'linkA[0]', 'A']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
@@ -114,14 +110,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
@@ -138,7 +132,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -186,14 +180,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
@@ -245,7 +237,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: start_instance; port: None; parameters: [0, 'linkA[0]']))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -268,14 +260,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: start_instance; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -304,7 +294,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -338,14 +328,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))]
@@ -397,7 +385,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: create_instance; port: None; parameters: [0, 'linkB[0]', 'B']))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -420,14 +408,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('B', 2), (event name: create_instance; port: None; parameters: [0, 2, 'linkB[0]', 'B']))]
 			port <input>:
-			port <ui>:
-			port <private_2_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -443,7 +429,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('B', 2), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkB[0]']))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -464,14 +450,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('B', 2), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 				[(('B', 2), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkB[0]']))]
@@ -523,7 +507,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: start_instance; port: None; parameters: [0, 'linkB[0]']))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -546,14 +530,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('B', 2), (event name: start_instance; port: None; parameters: ['linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_2_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -581,7 +563,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('B', 2), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkB[0]']))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -613,14 +595,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('B', 2), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 				[(('B', 2), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkB[0]']))]
@@ -672,7 +652,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: associate_instance; port: None; parameters: [0, 'linkB[0]', 'linkA/linkB']))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -695,14 +675,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: associate_instance; port: None; parameters: [['linkA[-1]/linkB[0]']]))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -718,7 +696,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_associated; port: None; parameters: [['linkA[-1]/linkB[0]']]))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -740,14 +718,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_associated; port: None; parameters: [['linkA[-1]/linkB[0]']]))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_associated; port: None; parameters: [['linkA[-1]/linkB[0]']]))]
@@ -798,7 +774,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: narrow_cast; port: None; parameters: [0, 'linkA[0]', (event name: test_link; port: None)]))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -821,14 +797,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: test_link; port: private_1_<narrow_cast>))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -877,7 +851,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), None, (event name: narrow_cast; port: None; parameters: [1, 'linkB[0]', (event name: test_new_link; port: None)]))
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -899,14 +873,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('B', 2), (event name: test_new_link; port: private_2_<narrow_cast>))]
 			port <input>:
-			port <ui>:
-			port <private_2_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c98170>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x10200ad20>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:

tests/3.16) AssociateInstance/PyDEVS/target.py

@@ -15,9 +15,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["linkA"] = Association("A", 0, -1)
-        self.associations["linkB"] = Association("B", 0, -1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -31,10 +28,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -163,8 +158,6 @@ class MainApp(ClassBase):
 class AInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["linkB"] = Association("B", 0, -1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -178,10 +171,8 @@ class AInstance(RuntimeClassBase):
         # call user defined constructor
         AInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -241,7 +232,6 @@ class A(ClassBase):
 class BInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -255,10 +245,8 @@ class BInstance(RuntimeClassBase):
         # call user defined constructor
         BInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -314,33 +302,30 @@ class B(ClassBase):
         new_instance = BInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-            instance["associations"]["linkA"] = Association("A", 0, -1)
-            instance["associations"]["linkB"] = Association("B", 0, -1)
-        elif class_name == "A":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-            instance["associations"]["linkB"] = Association("B", 0, -1)
-        elif class_name == "B":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["linkA"] = Association("A", 0, -1)
+        instance["associations"]["linkB"] = Association("B", 0, -1)
+    elif class_name == "A":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["linkB"] = Association("B", 0, -1)
+    elif class_name == "B":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.output["A"] = self.addOutPort()

tests/0) AssociateInstance/Python/faulty_log.txt

@@ -0,0 +1,14 @@
+0.00 (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x1020803b0>, 'linkA', 'A'])
+0.00 (event name: instance_created; port: None; parameters: ['linkA[0]'])
+0.00 (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x1020803b0>, 'linkA[0]'])
+0.00 (event name: instance_started; port: ; parameters: ['linkA[0]'])
+0.00 (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x1020803b0>, 'linkB', 'B'])
+0.00 (event name: instance_created; port: None; parameters: ['linkB[0]'])
+0.00 (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x1020803b0>, 'linkB[0]'])
+0.00 (event name: instance_started; port: ; parameters: ['linkB[0]'])
+0.00 (event name: associate_instance; port: None; parameters: [<target.MainApp object at 0x1020803b0>, 'linkB[0]', 'linkA/linkB'])
+0.00 (event name: instance_associated; port: ; parameters: [['linkA[-1]/linkB[0]']])
+0.00 (event name: narrow_cast; port: None; parameters: [<target.MainApp object at 0x1020803b0>, 'linkA[0]', (event name: test_link; port: None)])
+0.00 (event name: test_link; port: private_1_<narrow_cast>)
+0.00 (event name: narrow_cast; port: None; parameters: [<target.A object at 0x102080920>, 'linkB[0]', (event name: test_new_link; port: None)])
+0.00 (event name: test_new_link; port: private_2_<narrow_cast>)

tests/3.16) AssociateInstance/Python/log.txt

@@ -1,5 +1,12 @@
 __  Current Time:   0.000000 __________________________________________ 
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x1020803b0>, 'linkA', 'A'])
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_created; port: None; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state1
 
@@ -12,10 +19,17 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_created_succesfully; port: ui; parameters: ['linkA[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x1020803b0>, 'linkA[0]'])
+
 
 OUTPUT EVENT to port <ui>
 	\Event: (event name: statechart_started_succesfully; port: ui)
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_started; port: ; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state2
 
@@ -28,6 +42,13 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_started_succesfully; port: ui; parameters: ['linkA[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x1020803b0>, 'linkB', 'B'])
+
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_created; port: None; parameters: ['linkB[0]'])
 
 EXIT STATE in model <MainApp>
 		State: /state3
@@ -41,10 +62,17 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_created_succesfully; port: ui; parameters: ['linkB[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x1020803b0>, 'linkB[0]'])
+
 
 OUTPUT EVENT to port <ui>
 	\Event: (event name: statechart_started_succesfully; port: ui)
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_started; port: ; parameters: ['linkB[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state4
 
@@ -57,6 +85,13 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_started_succesfully; port: ui; parameters: ['linkB[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: associate_instance; port: None; parameters: [<target.MainApp object at 0x1020803b0>, 'linkB[0]', 'linkA/linkB'])
+
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_associated; port: ; parameters: [['linkA[-1]/linkB[0]']])
 
 EXIT STATE in model <MainApp>
 		State: /state5
@@ -67,7 +102,14 @@ TRANSITION FIRED in model <MainApp>
 ENTER STATE in model <MainApp>
 		State: /state6
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: narrow_cast; port: None; parameters: [<target.MainApp object at 0x1020803b0>, 'linkA[0]', (event name: test_link; port: None)])
+
+
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: test_link; port: private_1_<narrow_cast>)
 
 INPUT EVENT from port <private_1_<narrow_cast>>
 	\Type: <narrow_cast>
@@ -82,8 +124,15 @@ TRANSITION FIRED in model <A>
 ENTER STATE in model <A>
 		State: /state2
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: narrow_cast; port: None; parameters: [<target.A object at 0x102080920>, 'linkB[0]', (event name: test_new_link; port: None)])
+
 
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: test_new_link; port: private_2_<narrow_cast>)
+
 INPUT EVENT from port <private_2_<narrow_cast>>
 	\Type: <narrow_cast>
 	\Event: (event name: test_new_link; port: private_2_<narrow_cast>)

tests/0) AssociateInstance/config.json

@@ -0,0 +1,3 @@
+{
+    "trace": ["internal"]
+}

tests/1.0) EventlessTransitionTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x1049b2810>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1016317f0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049b2810>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1016317f0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -45,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x1049b2810>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1016317f0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -84,13 +83,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049b2810>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1016317f0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/1.0) EventlessTransitionTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,7 +27,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -82,24 +80,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/1.1) AfterTransitionTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a7cef0>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102082960>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7cef0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102082960>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -45,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a7cef0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102082960>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -75,13 +74,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7cef0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102082960>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/1.1) AfterTransitionTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,7 +27,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -90,24 +88,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/1.10) DeepHistoryTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x1049eb830>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102061c40>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049eb830>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102061c40>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -45,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x1049eb830>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102061c40>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -75,13 +74,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049eb830>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102061c40>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/1.10) DeepHistoryTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,7 +27,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -69,24 +67,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/1.11) AllStatechartTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x1049e9a60>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021a8f80>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049e9a60>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021a8f80>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -45,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x1049e9a60>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021a8f80>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -75,13 +74,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049e9a60>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021a8f80>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/1.11) AllStatechartTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,7 +27,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -69,24 +67,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/1.2) GuardConditionTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a7d880>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020812b0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7d880>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020812b0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -45,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a7d880>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020812b0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -84,13 +83,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7d880>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020812b0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/1.2) GuardConditionTest/PyDEVS/target.py

@@ -15,7 +15,6 @@ VALUE = 5
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -29,7 +28,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -94,24 +92,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/1.3) TransitionToItselfTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x1047f5910>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020321b0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1047f5910>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020321b0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -45,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x1047f5910>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020321b0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -93,13 +92,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1047f5910>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020321b0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/1.3) TransitionToItselfTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,7 +27,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -93,24 +91,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/1.4) ScriptTransitionTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a7ccb0>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020605f0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7ccb0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020605f0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -45,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a7ccb0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020605f0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -75,13 +74,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7ccb0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020605f0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/1.4) ScriptTransitionTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,7 +27,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -97,24 +95,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/1.5) ScriptEntryTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a7e450>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102062150>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7e450>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102062150>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -45,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a7e450>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102062150>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -93,13 +92,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7e450>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102062150>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/1.5) ScriptEntryTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,7 +27,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -93,24 +91,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/1.6) ScriptExitTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a7cb90>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021dc080>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7cb90>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021dc080>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -45,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a7cb90>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021dc080>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -129,13 +128,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7cb90>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021dc080>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/1.6) ScriptExitTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,7 +27,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -93,24 +91,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/1.7) CompositeStateTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a7f080>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021de2d0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7f080>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021de2d0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -45,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a7f080>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021de2d0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -96,13 +95,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7f080>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021de2d0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/1.7) CompositeStateTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,7 +27,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -101,24 +99,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/1.8) ParallelStateTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x1049e9940>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020619a0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049e9940>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020619a0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -45,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x1049e9940>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020619a0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -75,13 +74,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049e9940>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020619a0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/1.8) ParallelStateTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,7 +27,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -87,24 +85,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/1.9) ShallowHistoryTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x1049eaf00>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021df5f0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049eaf00>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021df5f0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -45,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x1049eaf00>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021df5f0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -75,13 +74,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049eaf00>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021df5f0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/1.9) ShallowHistoryTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,7 +27,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -69,24 +67,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/2.0) GlobalInputTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x1049e9940>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa300>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,14 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049e9940>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa300>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -46,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x1049e9940>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa300>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -76,14 +74,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049e9940>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa300>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
@@ -128,8 +124,6 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 			port <input>:
 				['Event("input_event","ui",[\'0.00\'])']
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 

tests/2.0) GlobalInputTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,10 +27,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -81,24 +78,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/2.0) GlobalInputTest/Python/log.txt

@@ -1,5 +1,9 @@
 __  Current Time:   0.000000 __________________________________________ 
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: input_event; port: ui; parameters: ['0.00'])
+
 INPUT EVENT from port <ui>
 	\Type: ui
 	\Event: (event name: input_event; port: ui; parameters: ['0.00'])

tests/2.1) GlobalOutputTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a4f260>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021a9d60>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,13 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a4f260>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021a9d60>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -57,7 +56,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a4f260>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021a9d60>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -89,13 +88,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a4f260>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021a9d60>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/2.1) GlobalOutputTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,7 +27,6 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -74,24 +72,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/2.2) GlobalIOTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a9caa0>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021abaa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,14 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <Inport>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9caa0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021abaa0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -46,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a9caa0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021abaa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -78,14 +76,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <Inport>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9caa0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021abaa0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
@@ -132,8 +128,6 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 			port <input>:
 				['Event("input_event","Inport",[])']
-			port <Inport>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 

tests/2.2) GlobalIOTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,10 +27,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("Inport", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -86,24 +83,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/2.2) GlobalIOTest/Python/log.txt

@@ -1,5 +1,9 @@
 __  Current Time:   0.000000 __________________________________________ 
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: input_event; port: Inport; parameters: [])
+
 INPUT EVENT from port <Inport>
 	\Type: Inport
 	\Event: (event name: input_event; port: Inport; parameters: [])

tests/2.3) TimedOutputTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a9e870>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9c0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,14 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e870>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9c0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -46,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a9e870>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9c0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -78,14 +76,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e870>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9c0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/2.3) TimedOutputTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,10 +27,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -94,24 +91,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/2.5) MultipleOutputTest/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104aa0a10>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021a9b50>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,14 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104aa0a10>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021a9b50>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -46,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104aa0a10>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021a9b50>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -78,14 +76,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104aa0a10>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021a9b50>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/2.5) MultipleOutputTest/PyDEVS/target.py

@@ -14,7 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -28,10 +27,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -118,24 +115,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/3.0) ClassCreation/PyDEVS/log.txt

@@ -13,7 +13,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a9c8c0>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aba40>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -30,14 +30,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9c8c0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aba40>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -52,7 +50,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a9c8c0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aba40>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -73,7 +71,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: create_instance; port: None; parameters: [0, 'linkA[0]', 'A']))
-		New State: <target.Dummy object at 0x104a9c8c0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aba40>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -95,8 +93,6 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: create_instance; port: None; parameters: [0, 1, 'linkA[0]', 'A']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
@@ -106,14 +102,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9c8c0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aba40>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
@@ -129,7 +123,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104a9c8c0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aba40>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -174,14 +168,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9c8c0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aba40>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]

tests/3.0) ClassCreation/PyDEVS/target.py

@@ -14,8 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["linkA"] = Association("A", 0, -1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -29,10 +27,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -96,7 +92,6 @@ class MainApp(ClassBase):
 class AInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -110,10 +105,8 @@ class AInstance(RuntimeClassBase):
         # call user defined constructor
         AInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -156,28 +149,25 @@ class A(ClassBase):
         new_instance = AInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-            instance["associations"]["linkA"] = Association("A", 0, -1)
-        elif class_name == "A":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["linkA"] = Association("A", 0, -1)
+    elif class_name == "A":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.output["A"] = self.addOutPort()

tests/3.0) ClassCreation/Python/log.txt

@@ -1,5 +1,12 @@
 __  Current Time:   0.000000 __________________________________________ 
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x1021def30>, 'linkA', 'A'])
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_created; port: None; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state1
 

tests/3.1) ClassInitialization/PyDEVS/log.txt

@@ -13,7 +13,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a4e390>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9f0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -30,14 +30,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a4e390>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9f0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -52,7 +50,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a4e390>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9f0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -73,7 +71,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: create_instance; port: None; parameters: [0, 'linkA[0]', 'A']))
-		New State: <target.Dummy object at 0x104a4e390>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9f0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -95,8 +93,6 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: create_instance; port: None; parameters: [0, 1, 'linkA[0]', 'A']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
@@ -106,14 +102,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a4e390>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9f0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
@@ -129,7 +123,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104a4e390>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9f0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -174,14 +168,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a4e390>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9f0>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
@@ -230,7 +222,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: start_instance; port: None; parameters: [0, 'linkA[0]']))
-		New State: <target.Dummy object at 0x104a4e390>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9f0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -252,14 +244,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: start_instance; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a4e390>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9f0>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -286,7 +276,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104a4e390>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9f0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -318,14 +308,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a4e390>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa9f0>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))]

tests/3.1) ClassInitialization/PyDEVS/target.py

@@ -14,8 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["linkA"] = Association("A", 0, -1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -29,10 +27,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -107,7 +103,6 @@ class MainApp(ClassBase):
 class AInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -121,10 +116,8 @@ class AInstance(RuntimeClassBase):
         # call user defined constructor
         AInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -167,28 +160,25 @@ class A(ClassBase):
         new_instance = AInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-            instance["associations"]["linkA"] = Association("A", 0, -1)
-        elif class_name == "A":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["linkA"] = Association("A", 0, -1)
+    elif class_name == "A":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.output["A"] = self.addOutPort()

tests/3.1) ClassInitialization/Python/log.txt

@@ -1,5 +1,12 @@
 __  Current Time:   0.000000 __________________________________________ 
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x1021df260>, 'linkA', 'A'])
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_created; port: None; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state1
 
@@ -12,10 +19,17 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_created_succesfully; port: ui; parameters: ['0.00', 'linkA[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x1021df260>, 'linkA[0]'])
+
 
 OUTPUT EVENT to port <ui>
 	\Event: (event name: statechart_started_succesfully; port: ui; parameters: ['0.00'])
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_started; port: ; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state2
 

tests/3.10) DeleteBadFromNonParent/PyDEVS/log.txt

@@ -18,7 +18,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x1049c2b70>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -35,14 +35,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -58,7 +56,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -80,7 +78,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: create_instance; port: None; parameters: [0, 'linkA[0]', 'A']))
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -103,8 +101,6 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: create_instance; port: None; parameters: [0, 1, 'linkA[0]', 'A']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
@@ -114,14 +110,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
@@ -138,7 +132,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -186,14 +180,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
@@ -245,7 +237,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: start_instance; port: None; parameters: [0, 'linkA[0]']))
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -268,14 +260,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: start_instance; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -304,7 +294,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -338,14 +328,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))]
@@ -397,7 +385,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: create_instance; port: None; parameters: [0, 'linkB[0]', 'B']))
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -420,14 +408,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('B', 2), (event name: create_instance; port: None; parameters: [0, 2, 'linkB[0]', 'B']))]
 			port <input>:
-			port <ui>:
-			port <private_2_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -443,7 +429,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('B', 2), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkB[0]']))
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -464,14 +450,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('B', 2), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Output Port Configuration:
 			port <port1>:
 				[(('B', 2), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkB[0]']))]
@@ -523,7 +507,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: start_instance; port: None; parameters: [0, 'linkB[0]']))
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -546,14 +530,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('B', 2), (event name: start_instance; port: None; parameters: ['linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_2_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -581,7 +563,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('B', 2), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkB[0]']))
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -613,14 +595,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('B', 2), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Output Port Configuration:
 			port <port1>:
 				[(('B', 2), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkB[0]']))]
@@ -672,7 +652,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: narrow_cast; port: None; parameters: [0, 'linkA[0]', (event name: remove; port: None)]))
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -695,14 +675,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: remove; port: private_1_<narrow_cast>))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -751,7 +729,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), None, (event name: delete_instance; port: None; parameters: [[], 'linkB[0]']))
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -773,14 +751,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('B', 0), (event name: delete_instance; port: None; parameters: [[], 'linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_2_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -796,7 +772,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('B', 0), ('A', 1), (event name: instance_deleted; port: None; parameters: ['linkB[0]']))
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -817,14 +793,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('B', 0), ('A', 1), (event name: instance_deleted; port: None; parameters: ['linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x1049c2b70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102320aa0>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:

tests/3.10) DeleteBadFromNonParent/PyDEVS/target.py

@@ -15,9 +15,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["linkA"] = Association("A", 0, -1)
-        self.associations["linkB"] = Association("B", 0, -1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -31,10 +28,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -149,8 +144,6 @@ class MainApp(ClassBase):
 class AInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["linkB"] = Association("B", 0, -1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -164,10 +157,8 @@ class AInstance(RuntimeClassBase):
         # call user defined constructor
         AInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -227,7 +218,6 @@ class A(ClassBase):
 class BInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -241,10 +231,8 @@ class BInstance(RuntimeClassBase):
         # call user defined constructor
         BInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -287,33 +275,30 @@ class B(ClassBase):
         new_instance = BInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-            instance["associations"]["linkA"] = Association("A", 0, -1)
-            instance["associations"]["linkB"] = Association("B", 0, -1)
-        elif class_name == "A":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-            instance["associations"]["linkB"] = Association("B", 0, -1)
-        elif class_name == "B":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["linkA"] = Association("A", 0, -1)
+        instance["associations"]["linkB"] = Association("B", 0, -1)
+    elif class_name == "A":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["linkB"] = Association("B", 0, -1)
+    elif class_name == "B":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.output["A"] = self.addOutPort()

tests/3.10) DeleteBadFromNonParent/Python/log.txt

@@ -1,5 +1,12 @@
 __  Current Time:   0.000000 __________________________________________ 
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x1021aba40>, 'linkA', 'A'])
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_created; port: None; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state1
 
@@ -12,10 +19,17 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_created_succesfully; port: ui; parameters: ['linkA[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x1021aba40>, 'linkA[0]'])
+
 
 OUTPUT EVENT to port <ui>
 	\Event: (event name: statechart_started_succesfully; port: ui)
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_started; port: ; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state2
 
@@ -28,6 +42,13 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_started_succesfully; port: ui; parameters: ['linkA[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x1021aba40>, 'linkB', 'B'])
+
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_created; port: None; parameters: ['linkB[0]'])
 
 EXIT STATE in model <MainApp>
 		State: /state3
@@ -41,10 +62,17 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_created_succesfully; port: ui; parameters: ['linkB[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x1021aba40>, 'linkB[0]'])
+
 
 OUTPUT EVENT to port <ui>
 	\Event: (event name: statechart_started_succesfully; port: ui)
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_started; port: ; parameters: ['linkB[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state4
 
@@ -57,7 +85,14 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_started_succesfully; port: ui; parameters: ['linkB[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: narrow_cast; port: None; parameters: [<target.MainApp object at 0x1021aba40>, 'linkA[0]', (event name: remove; port: None)])
+
+
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: remove; port: private_1_<narrow_cast>)
 
 INPUT EVENT from port <private_1_<narrow_cast>>
 	\Type: <narrow_cast>
@@ -72,4 +107,11 @@ TRANSITION FIRED in model <A>
 ENTER STATE in model <A>
 		State: /state2
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: delete_instance; port: None; parameters: [<target.A object at 0x1023211f0>, 'linkB[0]'])
+
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_deleted; port: ; parameters: ['linkB[0]'])
 

tests/3.11) DeleteGoodFromNonParent/PyDEVS/log.txt

@@ -18,7 +18,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a9e2d0>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -35,14 +35,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -58,7 +56,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -80,7 +78,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: create_instance; port: None; parameters: [0, 'linkA[0]', 'A']))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -103,8 +101,6 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: create_instance; port: None; parameters: [0, 1, 'linkA[0]', 'A']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
@@ -114,14 +110,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
@@ -138,7 +132,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -186,14 +180,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
@@ -245,7 +237,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: start_instance; port: None; parameters: [0, 'linkA[0]']))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -268,14 +260,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: start_instance; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -304,7 +294,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -338,14 +328,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))]
@@ -397,7 +385,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: create_instance; port: None; parameters: [0, 'linkB[0]', 'B']))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -420,14 +408,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('B', 2), (event name: create_instance; port: None; parameters: [0, 2, 'linkB[0]', 'B']))]
 			port <input>:
-			port <ui>:
-			port <private_2_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -443,7 +429,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('B', 2), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkB[0]']))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -464,14 +450,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('B', 2), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 				[(('B', 2), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkB[0]']))]
@@ -523,7 +507,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: start_instance; port: None; parameters: [0, 'linkB[0]']))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -546,14 +530,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('B', 2), (event name: start_instance; port: None; parameters: ['linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_2_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -581,7 +563,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('B', 2), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkB[0]']))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -613,14 +595,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('B', 2), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 				[(('B', 2), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkB[0]']))]
@@ -672,7 +652,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: associate_instance; port: None; parameters: [0, 'linkB[0]', 'linkA/linkB']))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -695,14 +675,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: associate_instance; port: None; parameters: [['linkA[-1]/linkB[0]']]))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -718,7 +696,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_associated; port: None; parameters: [['linkA[-1]/linkB[0]']]))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -740,14 +718,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_associated; port: None; parameters: [['linkA[-1]/linkB[0]']]))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_associated; port: None; parameters: [['linkA[-1]/linkB[0]']]))]
@@ -798,7 +774,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: narrow_cast; port: None; parameters: [0, 'linkA[0]', (event name: remove; port: None)]))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -821,14 +797,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: remove; port: private_1_<narrow_cast>))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -877,7 +851,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), None, (event name: delete_instance; port: None; parameters: [[2], 'linkB[0]']))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -899,14 +873,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('B', 2), (event name: delete_instance; port: None; parameters: [[2], 'linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_2_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -922,7 +894,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('B', 2), ('A', 1), (event name: instance_deleted; port: None; parameters: ['linkB[0]']))
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -943,14 +915,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('B', 2), ('A', 1), (event name: instance_deleted; port: None; parameters: ['linkB[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9e2d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102505550>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:

tests/3.11) DeleteGoodFromNonParent/PyDEVS/target.py

@@ -15,9 +15,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["linkA"] = Association("A", 0, -1)
-        self.associations["linkB"] = Association("B", 0, -1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -31,10 +28,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -162,8 +157,6 @@ class MainApp(ClassBase):
 class AInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["linkB"] = Association("B", 0, -1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -177,10 +170,8 @@ class AInstance(RuntimeClassBase):
         # call user defined constructor
         AInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -250,7 +241,6 @@ class A(ClassBase):
 class BInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -264,10 +254,8 @@ class BInstance(RuntimeClassBase):
         # call user defined constructor
         BInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -310,33 +298,30 @@ class B(ClassBase):
         new_instance = BInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-            instance["associations"]["linkA"] = Association("A", 0, -1)
-            instance["associations"]["linkB"] = Association("B", 0, -1)
-        elif class_name == "A":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-            instance["associations"]["linkB"] = Association("B", 0, -1)
-        elif class_name == "B":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["linkA"] = Association("A", 0, -1)
+        instance["associations"]["linkB"] = Association("B", 0, -1)
+    elif class_name == "A":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["linkB"] = Association("B", 0, -1)
+    elif class_name == "B":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.output["A"] = self.addOutPort()

tests/3.11) DeleteGoodFromNonParent/Python/log.txt

@@ -1,5 +1,12 @@
 __  Current Time:   0.000000 __________________________________________ 
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x102321550>, 'linkA', 'A'])
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_created; port: None; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state1
 
@@ -12,10 +19,17 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_created_succesfully; port: ui; parameters: ['linkA[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x102321550>, 'linkA[0]'])
+
 
 OUTPUT EVENT to port <ui>
 	\Event: (event name: statechart_started_succesfully; port: ui)
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_started; port: ; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state2
 
@@ -28,6 +42,13 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_started_succesfully; port: ui; parameters: ['linkA[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x102321550>, 'linkB', 'B'])
+
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_created; port: None; parameters: ['linkB[0]'])
 
 EXIT STATE in model <MainApp>
 		State: /state3
@@ -41,10 +62,17 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_created_succesfully; port: ui; parameters: ['linkB[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x102321550>, 'linkB[0]'])
+
 
 OUTPUT EVENT to port <ui>
 	\Event: (event name: statechart_started_succesfully; port: ui)
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_started; port: ; parameters: ['linkB[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state4
 
@@ -57,6 +85,13 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_started_succesfully; port: ui; parameters: ['linkB[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: associate_instance; port: None; parameters: [<target.MainApp object at 0x102321550>, 'linkB[0]', 'linkA/linkB'])
+
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_associated; port: ; parameters: [['linkA[-1]/linkB[0]']])
 
 EXIT STATE in model <MainApp>
 		State: /state5
@@ -67,8 +102,15 @@ TRANSITION FIRED in model <MainApp>
 ENTER STATE in model <MainApp>
 		State: /state6
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: narrow_cast; port: None; parameters: [<target.MainApp object at 0x102321550>, 'linkA[0]', (event name: remove; port: None)])
 
 
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: remove; port: private_1_<narrow_cast>)
+
 INPUT EVENT from port <private_1_<narrow_cast>>
 	\Type: <narrow_cast>
 	\Event: (event name: remove; port: private_1_<narrow_cast>)
@@ -82,6 +124,13 @@ TRANSITION FIRED in model <A>
 ENTER STATE in model <A>
 		State: /state2
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: delete_instance; port: None; parameters: [<target.A object at 0x102504f20>, 'linkB[0]'])
+
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_deleted; port: ; parameters: ['linkB[0]'])
 
 EXIT STATE in model <A>
 		State: /state2

tests/3.16) AssociateInstance/PyDEVS/faulty_log.txt

@@ -1,6 +0,0 @@
-0.00 (event name: instance_created_succesfully; port: ui; parameters: ['linkA[0]'])
-0.00 (event name: statechart_started_succesfully; port: ui)
-0.00 (event name: instance_started_succesfully; port: ui; parameters: ['linkA[0]'])
-0.00 (event name: instance_created_succesfully; port: ui; parameters: ['linkB[0]'])
-0.00 (event name: statechart_started_succesfully; port: ui)
-0.00 (event name: instance_started_succesfully; port: ui; parameters: ['linkB[0]'])

tests/3.16) AssociateInstance/Python/faulty_log.txt

@@ -1,9 +0,0 @@
-0.00 (event name: instance_created_succesfully; port: ui; parameters: ['linkA[0]'])
-0.00 (event name: statechart_started_succesfully; port: ui)
-0.00 (event name: instance_started_succesfully; port: ui; parameters: ['linkA[0]'])
-0.00 (event name: instance_created_succesfully; port: ui; parameters: ['linkB[0]'])
-0.00 (event name: statechart_started_succesfully; port: ui)
-0.00 (event name: instance_started_succesfully; port: ui; parameters: ['linkB[0]'])
-0.00 (event name: test_link; port: private_1_<narrow_cast>)
-0.00 (event name: test_new_link; port: private_2_<narrow_cast>)
-0.00 (event name: associated_succesfully; port: ui)

tests/3.17) DissasociateInstance/PyDEVS/log.txt

@@ -13,7 +13,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104c4bec0>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -30,14 +30,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -52,7 +50,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -73,7 +71,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: create_instance; port: None; parameters: [0, 'linkA[0]', 'A']))
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -95,8 +93,6 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: create_instance; port: None; parameters: [0, 1, 'linkA[0]', 'A']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
@@ -106,14 +102,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
@@ -129,7 +123,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -174,14 +168,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
@@ -230,7 +222,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: start_instance; port: None; parameters: [0, 'linkA[0]']))
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -252,14 +244,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: start_instance; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -286,7 +276,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -327,14 +317,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))]
@@ -383,7 +371,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: narrow_cast; port: None; parameters: [0, 'linkA[0]', (event name: link_check; port: None; parameters: ['linkA[0]'])]))
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -404,7 +392,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: disassociate_instance; port: None; parameters: [0, 'linkA']))
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -426,8 +414,6 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: link_check; port: private_1_<narrow_cast>; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
@@ -437,14 +423,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(None, ('MainApp', 0), (event name: instance_disassociated; port: None; parameters: [['linkA[0]']]))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Output Port Configuration:
 			port <port1>:
 				[(None, ('MainApp', 0), (event name: instance_disassociated; port: None; parameters: [['linkA[0]']]))]
@@ -526,7 +510,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: narrow_cast; port: None; parameters: [0, 'linkA[0]', (event name: sanity_check; port: None)]))
-		New State: <target.Dummy object at 0x104c4bec0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1021aa510>
 		Next scheduled internal transition at time inf
 
 

tests/3.17) DissasociateInstance/PyDEVS/target.py

@@ -14,8 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["linkA"] = Association("A", 0, -1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -29,10 +27,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -135,7 +131,6 @@ class MainApp(ClassBase):
 class AInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -149,10 +144,8 @@ class AInstance(RuntimeClassBase):
         # call user defined constructor
         AInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -221,28 +214,25 @@ class A(ClassBase):
         new_instance = AInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-            instance["associations"]["linkA"] = Association("A", 0, -1)
-        elif class_name == "A":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["linkA"] = Association("A", 0, -1)
+    elif class_name == "A":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.output["A"] = self.addOutPort()

tests/3.17) DissasociateInstance/Python/log.txt

@@ -1,5 +1,12 @@
 __  Current Time:   0.000000 __________________________________________ 
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x1021df3b0>, 'linkA', 'A'])
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_created; port: None; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state1
 
@@ -12,10 +19,17 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_created_succesfully; port: ui; parameters: ['0.00', 'linkA[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x1021df3b0>, 'linkA[0]'])
+
 
 OUTPUT EVENT to port <ui>
 	\Event: (event name: statechart_started_succesfully; port: ui; parameters: ['0.00'])
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_started; port: ; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state2
 
@@ -28,6 +42,12 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_started_succesfully; port: ui; parameters: ['0.00', 'linkA[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: narrow_cast; port: None; parameters: [<target.MainApp object at 0x1021df3b0>, 'linkA[0]', (event name: link_check; port: None; parameters: ['linkA[0]'])])
+
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: disassociate_instance; port: None; parameters: [<target.MainApp object at 0x1021df3b0>, 'linkA'])
+
 EXIT STATE in model <A>
 		State: /state1
 
@@ -38,6 +58,10 @@ ENTER STATE in model <A>
 		State: /state2
 
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_disassociated; port: ; parameters: [['linkA[0]']])
+
 EXIT STATE in model <MainApp>
 		State: /state3
 
@@ -50,6 +74,13 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_disassociated_succesfully; port: ui; parameters: ['0.00', ['linkA[0]']])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: narrow_cast; port: None; parameters: [<target.MainApp object at 0x1021df3b0>, 'linkA[0]', (event name: sanity_check; port: None)])
+
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: link_check; port: private_1_<narrow_cast>; parameters: ['linkA[0]'])
 
 INPUT EVENT from port <private_1_<narrow_cast>>
 	\Type: <narrow_cast>

tests/3.18) DissasociateMultiple/PyDEVS/log.txt

@@ -13,7 +13,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a9cbf0>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -30,14 +30,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -52,7 +50,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -73,7 +71,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: create_instance; port: None; parameters: [0, 'linkA[0]', 'A']))
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -95,8 +93,6 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: create_instance; port: None; parameters: [0, 1, 'linkA[0]', 'A']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
@@ -106,14 +102,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
@@ -129,7 +123,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -174,14 +168,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
@@ -230,7 +222,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: start_instance; port: None; parameters: [0, 'linkA[0]']))
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -251,7 +243,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: create_instance; port: None; parameters: [0, 'linkA[1]', 'A']))
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -273,16 +265,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: start_instance; port: None; parameters: ['linkA[0]'])), (('MainApp', 0), ('A', 2), (event name: create_instance; port: None; parameters: [0, 2, 'linkA[1]', 'A']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
-			port <ui>:
-			port <private_2_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -309,7 +297,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -329,7 +317,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 2), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[1]']))
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -370,14 +358,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]'])), (('A', 2), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[1]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]'])), (('A', 2), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[1]']))]
@@ -438,7 +424,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: start_instance; port: None; parameters: [0, 'linkA[1]']))
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -460,16 +446,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 2), (event name: start_instance; port: None; parameters: ['linkA[1]']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
-			port <ui>:
-			port <private_2_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -496,7 +478,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 2), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[1]']))
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -537,14 +519,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 2), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[1]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 2), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[1]']))]
@@ -593,7 +573,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: narrow_cast; port: None; parameters: [0, 'linkA[1]', (event name: link_check; port: None; parameters: ['linkA[1]'])]))
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -614,7 +594,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: disassociate_instance; port: None; parameters: [0, 'linkA']))
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -636,10 +616,6 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 2), (event name: link_check; port: private_2_<narrow_cast>; parameters: ['linkA[1]']))]
 			port <input>:
-			port <ui>:
-			port <private_1_<narrow_cast>>:
-			port <ui>:
-			port <private_2_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
@@ -649,14 +625,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(None, ('MainApp', 0), (event name: instance_disassociated; port: None; parameters: [['linkA[0]', 'linkA[1]']]))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Output Port Configuration:
 			port <port1>:
 				[(None, ('MainApp', 0), (event name: instance_disassociated; port: None; parameters: [['linkA[0]', 'linkA[1]']]))]
@@ -738,7 +712,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: narrow_cast; port: None; parameters: [0, 'linkA[1]', (event name: sanity_check; port: None)]))
-		New State: <target.Dummy object at 0x104a9cbf0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102079d00>
 		Next scheduled internal transition at time inf
 
 

tests/3.18) DissasociateMultiple/PyDEVS/target.py

@@ -14,8 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["linkA"] = Association("A", 0, -1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -29,10 +27,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -155,7 +151,6 @@ class MainApp(ClassBase):
 class AInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -169,10 +164,8 @@ class AInstance(RuntimeClassBase):
         # call user defined constructor
         AInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -241,28 +234,25 @@ class A(ClassBase):
         new_instance = AInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-            instance["associations"]["linkA"] = Association("A", 0, -1)
-        elif class_name == "A":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["linkA"] = Association("A", 0, -1)
+    elif class_name == "A":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.output["A"] = self.addOutPort()

tests/3.18) DissasociateMultiple/Python/log.txt

@@ -1,5 +1,12 @@
 __  Current Time:   0.000000 __________________________________________ 
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x1021df6b0>, 'linkA', 'A'])
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_created; port: None; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state1
 
@@ -12,10 +19,24 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_created_succesfully; port: ui; parameters: ['0.00', 'linkA[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x1021df6b0>, 'linkA[0]'])
+
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x1021df6b0>, 'linkA', 'A'])
+
 
 OUTPUT EVENT to port <ui>
 	\Event: (event name: statechart_started_succesfully; port: ui; parameters: ['0.00'])
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_started; port: ; parameters: ['linkA[0]'])
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_created; port: None; parameters: ['linkA[1]'])
+
 EXIT STATE in model <A>
 		State: /state1
 
@@ -38,18 +59,16 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_created_succesfully; port: ui; parameters: ['0.00', 'linkA[1]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x1021df6b0>, 'linkA[1]'])
+
 
 OUTPUT EVENT to port <ui>
 	\Event: (event name: statechart_started_succesfully; port: ui; parameters: ['0.00'])
 
-EXIT STATE in model <A>
-		State: /state1
-
-TRANSITION FIRED in model <A>
-		Transition(/state1 -> /state2)
-
-ENTER STATE in model <A>
-		State: /state2
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_started; port: ; parameters: ['linkA[1]'])
 
 EXIT STATE in model <MainApp>
 		State: /state3
@@ -63,6 +82,25 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_started_succesfully; port: ui; parameters: ['0.00', 'linkA[1]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: narrow_cast; port: None; parameters: [<target.MainApp object at 0x1021df6b0>, 'linkA[1]', (event name: link_check; port: None; parameters: ['linkA[1]'])])
+
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: disassociate_instance; port: None; parameters: [<target.MainApp object at 0x1021df6b0>, 'linkA'])
+
+EXIT STATE in model <A>
+		State: /state1
+
+TRANSITION FIRED in model <A>
+		Transition(/state1 -> /state2)
+
+ENTER STATE in model <A>
+		State: /state2
+
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_disassociated; port: ; parameters: [['linkA[0]', 'linkA[1]']])
 
 EXIT STATE in model <MainApp>
 		State: /state4
@@ -76,6 +114,13 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <ui>
 	\Event: (event name: instance_disassociated_succesfully; port: ui; parameters: ['0.00', ['linkA[0]', 'linkA[1]']])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: narrow_cast; port: None; parameters: [<target.MainApp object at 0x1021df6b0>, 'linkA[1]', (event name: sanity_check; port: None)])
+
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: link_check; port: private_2_<narrow_cast>; parameters: ['linkA[1]'])
 
 INPUT EVENT from port <private_2_<narrow_cast>>
 	\Type: <narrow_cast>

tests/3.19) (Diss)asociateFromParent/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104aa1f40>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102080b30>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,14 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104aa1f40>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102080b30>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -46,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104aa1f40>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102080b30>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -78,14 +76,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104aa1f40>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102080b30>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/3.19) (Diss)asociateFromParent/PyDEVS/target.py

@@ -15,7 +15,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -29,10 +28,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -74,24 +71,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])

tests/3.2) ClassParameterInitialization/PyDEVS/log.txt

@@ -13,7 +13,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a4c7d0>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020613d0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -30,14 +30,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <Inport>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a4c7d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020613d0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -52,7 +50,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a4c7d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020613d0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -73,7 +71,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: create_instance; port: None; parameters: [0, 'linkA[0]', 'A', 1, 3.14, 'test', [1, 2, 3], {'1': 1, '2': 2, '3': 3}]))
-		New State: <target.Dummy object at 0x104a4c7d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020613d0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -95,8 +93,6 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: create_instance; port: None; parameters: [0, 1, 'linkA[0]', 'A', 1, 3.14, 'test', [1, 2, 3], {'1': 1, '2': 2, '3': 3}]))]
 			port <input>:
-			port <Inport>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
@@ -106,14 +102,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <Inport>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a4c7d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020613d0>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
@@ -129,7 +123,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104a4c7d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020613d0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -174,14 +168,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <Inport>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a4c7d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020613d0>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_created; port: None; parameters: ['linkA[0]']))]
@@ -230,7 +222,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), None, (event name: start_instance; port: None; parameters: [0, 'linkA[0]']))
-		New State: <target.Dummy object at 0x104a4c7d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020613d0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -252,14 +244,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('A', 1), (event name: start_instance; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <Inport>:
-			port <private_1_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a4c7d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020613d0>
 		Output Port Configuration:
 			port <port1>:
 			port <port2>:
@@ -298,7 +288,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))
-		New State: <target.Dummy object at 0x104a4c7d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020613d0>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -330,14 +320,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))]
 			port <input>:
-			port <Inport>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a4c7d0>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x1020613d0>
 		Output Port Configuration:
 			port <port1>:
 				[(('A', 1), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['linkA[0]']))]

tests/3.2) ClassParameterInitialization/PyDEVS/target.py

@@ -14,8 +14,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
-        self.associations["linkA"] = Association("A", 0, -1)
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -29,10 +27,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("Inport", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -107,7 +103,6 @@ class MainApp(ClassBase):
 class AInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id, integer, floating_point, astring, alist, adict):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -121,10 +116,8 @@ class AInstance(RuntimeClassBase):
         # call user defined constructor
         AInstance.user_defined_constructor(self, integer, floating_point, astring, alist, adict)
         port_name = addInputPort("Inport", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self, integer, floating_point, astring, alist, adict):
@@ -172,28 +165,25 @@ class A(ClassBase):
         new_instance = AInstance(self, id, start_port_id, parameters[1], parameters[2], parameters[3], parameters[4], parameters[5])
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-            instance["associations"]["linkA"] = Association("A", 0, -1)
-        elif class_name == "A":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+        instance["associations"]["linkA"] = Association("A", 0, -1)
+    elif class_name == "A":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.output["A"] = self.addOutPort()

tests/3.2) ClassParameterInitialization/Python/log.txt

@@ -1,5 +1,12 @@
 __  Current Time:   0.000000 __________________________________________ 
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: create_instance; port: None; parameters: [<target.MainApp object at 0x1020630b0>, 'linkA', 'A', 1, 3.14, 'test', [1, 2, 3], {'1': 1, '2': 2, '3': 3}])
+
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_created; port: None; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state1
 
@@ -12,6 +19,9 @@ ENTER STATE in model <MainApp>
 OUTPUT EVENT to port <Outport>
 	\Event: (event name: instance_created_succesfully; port: Outport; parameters: ['0.00', 'linkA[0]'])
 
+OUTPUT EVENT to <ObjectManager>
+	\Event: (event name: start_instance; port: None; parameters: [<target.MainApp object at 0x1020630b0>, 'linkA[0]'])
+
 
 OUTPUT EVENT to port <Outport>
 	\Event: (event name: statechart_started_succesfully; port: Outport; parameters: ['0.00'])
@@ -19,6 +29,10 @@ OUTPUT EVENT to port <Outport>
 OUTPUT EVENT to port <Outport>
 	\Event: (event name: constructor_initialized_succesfully; port: Outport; parameters: ['0.00', 1, 3.14, 'test', [1, 2, 3], {'1': 1, '2': 2, '3': 3}])
 
+INPUT EVENT from <ObjectManager>
+	\Type: cd
+	\Event: (event name: instance_started; port: ; parameters: ['linkA[0]'])
+
 EXIT STATE in model <MainApp>
 		State: /state2
 

tests/3.20) (Diss)asociateFromOther/PyDEVS/log.txt

@@ -8,7 +8,7 @@ __  Current Time:   0.000000 __________________________________________
 
 
 	INITIAL CONDITIONS in model <Controller.ObjectManager>
-		Initial State: <target.Dummy object at 0x104a7eb70>
+		Initial State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102341880>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -25,14 +25,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7eb70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102341880>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: start_instance; port: None; parameters: ['MainApp[0]']))]
@@ -46,7 +44,7 @@ __  Current Time:   0.000000 __________________________________________
 		Input Port Configuration:
 			port <input>:
 				(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))
-		New State: <target.Dummy object at 0x104a7eb70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102341880>
 		Next scheduled internal transition at time 0.000000
 
 
@@ -78,14 +76,12 @@ __  Current Time:   0.000000 __________________________________________
 			port <obj_manager_in>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]
 			port <input>:
-			port <ui>:
-			port <private_0_<narrow_cast>>:
 		New State: 
 		Next scheduled internal transition at time 0.000000
 
 
 	INTERNAL TRANSITION in model <Controller.ObjectManager>
-		New State: <target.Dummy object at 0x104a7eb70>
+		New State: <sccd.runtime.DEVS_statecharts_core.ObjectManagerState object at 0x102341880>
 		Output Port Configuration:
 			port <port1>:
 				[(('MainApp', 0), ('MainApp', 0), (event name: instance_started; port: None; parameters: ['MainApp[0]']))]

tests/3.20) (Diss)asociateFromOther/PyDEVS/target.py

@@ -15,7 +15,6 @@ from sccd.runtime.DEVS_statecharts_core import *
 class MainAppInstance(RuntimeClassBase):
     def __init__(self, atomdevs, id, start_port_id):
         RuntimeClassBase.__init__(self, atomdevs, id)
-        self.associations = {}
         
         self.semantics.big_step_maximality = StatechartSemantics.TakeMany
         self.semantics.internal_event_lifeline = StatechartSemantics.Queue
@@ -29,10 +28,8 @@ class MainAppInstance(RuntimeClassBase):
         # call user defined constructor
         MainAppInstance.user_defined_constructor(self)
         port_name = addInputPort("ui", start_port_id, True)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
         port_name = addInputPort("<narrow_cast>", start_port_id)
-        atomdevs.addInPort(port_name)
         atomdevs.state.port_mappings[port_name] = id
     
     def user_defined_constructor(self):
@@ -74,24 +71,21 @@ class MainApp(ClassBase):
         new_instance = MainAppInstance(self, id, start_port_id)
         return new_instance
 
-class Dummy(ObjectManagerState):
-    def __init__(self):
-        ObjectManagerState.__init__(self)
-    
-    def instantiate(self, class_name, construct_params):
-        instance = {}
-        instance["name"] = class_name
-        if class_name == "MainApp":
-            self.narrow_cast_id = self.narrow_cast_id + 0
-            instance["associations"] = {}
-        else:
-            raise Exception("Cannot instantiate class " + class_name)
-        return instance
+def instantiate(self, class_name, construct_params):
+    instance = {}
+    instance["name"] = class_name
+    if class_name == "MainApp":
+        self.narrow_cast_id = self.narrow_cast_id + 0
+        instance["associations"] = {}
+    else:
+        raise Exception("Cannot instantiate class " + class_name)
+    return instance
+ObjectManagerState.instantiate = instantiate
 
 class ObjectManager(ObjectManagerBase):
     def __init__(self, name):
         ObjectManagerBase.__init__(self, name)
-        self.state = Dummy()
+        self.state = ObjectManagerState()
         self.input = self.addInPort("input")
         self.output["MainApp"] = self.addOutPort()
         self.state.createInstance("MainApp", [])