Added simple code to do callbacks in execute_MANUAL and add_*

wrappers/modelverse.py

@@ -78,28 +78,46 @@ def transformation_between(source, target):
     INPUT("transformation_between", None, [source, target])
     return OUTPUT()
 
-def transformation_add_MT(source_metamodels, target_metamodels, operation_name, code):
+def transformation_add_MT(source_metamodels, target_metamodels, operation_name, code, callback=None):
     INPUT("transformation_add_MT", None, [source_metamodels, target_metamodels, operation_name, code])
+    context = OUTPUT()
+    if callback is not None:
+        callback(context)
+    INPUT("exit", context, [])
     return OUTPUT()
 
-def transformation_add_AL(source_metamodels, target_metamodels, operation_name, code):
+def transformation_add_AL(source_metamodels, target_metamodels, operation_name, code, callback=None):
     INPUT("transformation_add_AL", None, [source_metamodels, target_metamodels, operation_name, code])
+    context = OUTPUT()
+    if callback is not None:
+        callback(context)
+    INPUT("exit", context, [])
     return OUTPUT()
 
-def transformation_add_MANUAL(source_metamodels, target_metamodels, operation_name):
+def transformation_add_MANUAL(source_metamodels, target_metamodels, operation_name, callback=None):
     INPUT("transformation_add_MANUAL", None, [source_metamodels, target_metamodels, operation_name])
+    context = OUTPUT()
+    if callback is not None:
+        callback(context)
+    INPUT("exit", context, [])
     return OUTPUT()
 
 def transformation_execute_MT(operation_name, input_models_dict, output_models_dict):
+    #NOTE callbacks as statechart not supported (yet?)!
     INPUT("transformation_execute_MT", None, [operation_name, input_models_dict, output_models_dict])
     return OUTPUT()
 
 def transformation_execute_AL(operation_name, input_models_dict, output_models_dict):
+    #NOTE callbacks as statechart not supported (yet?)!
     INPUT("transformation_execute_AL", None, [operation_name, input_models_dict, output_models_dict])
     return OUTPUT()
 
-def transformation_execute_MANUAL(operation_name, input_models_dict, output_models_dict):
+def transformation_execute_MANUAL(operation_name, input_models_dict, output_models_dict, callback=None):
     INPUT("transformation_execute_MANUAL", None, [operation_name, input_models_dict, output_models_dict])
+    context = OUTPUT()
+    if callback is not None:
+        callback(context)
+    INPUT("exit", context, [])
     return OUTPUT()
 
 def permission_modify(model_name, permissions):
@@ -166,76 +184,76 @@ def model_types(model_name):
     INPUT("model_types", None, [model_name])
     return OUTPUT()
 
-def element_list(model_name):
-    INPUT("element_list", None, [model_name])
+def element_list(model_name, context=None):
+    INPUT("element_list", context, [model_name])
     return OUTPUT()
 
-def element_list_nice(model_name):
-    INPUT("element_list_nice", None, [model_name])
+def element_list_nice(model_name, context=None):
+    INPUT("element_list_nice", context, [model_name])
     return OUTPUT()
 
-def types(model_name):
-    INPUT("types", None, [model_name])
+def types(model_name, context=None):
+    INPUT("types", context, [model_name])
     return OUTPUT()
 
-def types_full(model_name):
-    INPUT("types_full", None, [model_name])
+def types_full(model_name, context=None):
+    INPUT("types_full", context, [model_name])
     return OUTPUT()
 
-def read_info(model_name, ID):
-    INPUT("read_info", None, [model_name, ID])
+def read_info(model_name, ID, context=None):
+    INPUT("read_info", context, [model_name, ID])
     return OUTPUT()
 
-def read_attrs(model_name, ID):
-    INPUT("read_attrs", None, [model_name, ID])
+def read_attrs(model_name, ID, context=None):
+    INPUT("read_attrs", context, [model_name, ID])
     return OUTPUT()
 
-def instantiate(model_name, typename, edge=None, ID=""):
-    INPUT("instantiate", None, [model_name, typename, edge, ID])
+def instantiate(model_name, typename, edge=None, ID="", context=None):
+    INPUT("instantiate", context, [model_name, typename, edge, ID])
     return OUTPUT()
 
-def delete_element(model_name, ID):
-    INPUT("delete_element", None, [model_name, ID])
+def delete_element(model_name, ID, context=None):
+    INPUT("delete_element", context, [model_name, ID])
     return OUTPUT()
 
-def attr_assign(model_name, ID, attr, value):
-    INPUT("attr_assign", None, [model_name, ID, attr, value])
+def attr_assign(model_name, ID, attr, value, context=None):
+    INPUT("attr_assign", context, [model_name, ID, attr, value])
     return OUTPUT()
 
-def attr_assign_code(model_name, ID, attr, code):
-    INPUT("attr_assign_code", None, [model_name, ID, attr, code])
+def attr_assign_code(model_name, ID, attr, code, context=None):
+    INPUT("attr_assign_code", context, [model_name, ID, attr, code])
     return OUTPUT()
 
-def attr_delete(model_name, ID, attr):
-    INPUT("attr_delete", None, [model_name, ID, attr])
+def attr_delete(model_name, ID, attr, context=None):
+    INPUT("attr_delete", context, [model_name, ID, attr])
     return OUTPUT()
 
-def read_outgoing(model_name, ID, typename):
-    INPUT("read_outgoing", None, [model_name, ID, typename])
+def read_outgoing(model_name, ID, typename, context=None):
+    INPUT("read_outgoing", context, [model_name, ID, typename])
     return OUTPUT()
 
-def read_incoming(model_name, ID, typename):
-    INPUT("read_incoming", None, [model_name, ID, typename])
+def read_incoming(model_name, ID, typename, context=None):
+    INPUT("read_incoming", context, [model_name, ID, typename])
     return OUTPUT()
 
-def read_association_source(model_name, ID):
-    INPUT("read_association_source", None, [model_name, ID])
+def read_association_source(model_name, ID, context=None):
+    INPUT("read_association_source", context, [model_name, ID])
     return OUTPUT()
 
-def read_association_destination(model_name, ID):
-    INPUT("read_association_destination", None, [model_name, ID])
+def read_association_destination(model_name, ID, context=None):
+    INPUT("read_association_destination", context, [model_name, ID])
     return OUTPUT()
 
-def connections_between(model_name, source, target):
-    INPUT("connections_between", None, [model_name, source, target])
+def connections_between(model_name, source, target, context=None):
+    INPUT("connections_between", context, [model_name, source, target])
     return OUTPUT()
 
-def define_attribute(model_name, node, attr_name, attr_type):
-    INPUT("define_attribute", None, [model_name, node, attr_name, attr_type])
+def define_attribute(model_name, node, attr_name, attr_type, context=None):
+    INPUT("define_attribute", context, [model_name, node, attr_name, attr_type])
     return OUTPUT()
 
-def all_instances(model_name, type_name):
-    INPUT("all_instances", None, [model_name, type_name])
+def all_instances(model_name, type_name, context=None):
+    INPUT("all_instances", context, [model_name, type_name])
     return OUTPUT()
 
 import threading