Fixed visualization in GUI

bootstrap/conformance_finding.alc

@@ -33,6 +33,8 @@ Boolean function find_type_mapping(model : Element):
 	// TODO this must be expanded for other things than trivial metamodels!
 	if (dict_len(model["model"]) > dict_len(tm)):
 		log("Model is incompletely typed!")
+		log("Model has: " + set_to_string(dict_keys(model["model"])))
+		log("Type mapping has: " + set_to_string(dict_keys(tm)))
 		log("Difference: " + set_to_string(set_difference(dict_keys(model["model"]), dict_keys(tm))))
 
 		// TODO for now, this only returns something for a simple case, where the MM has one edge, and one node

bootstrap/core_algorithm.alc

@@ -395,6 +395,9 @@ String function export_typing(model : Element, name : String):
 	instance_of = instantiate_link(core, "instanceOf", "", result, get_entry_id("formalisms/TypeMapping"))
 	instantiate_link(core, "semantics", "", instance_of, get_entry_id("models/conformance_mv"))
 
+	log("Created type mapping " + result)
+	log("   for " + name)
+
 	return result!
 
 Void function model_create(model : Element, name : String, type_id : String, kind : String):
@@ -456,6 +459,61 @@ Void function model_overwrite(model : Element, model_id : String, metamodel_id :
 
 	return!
 
+Void function model_overwrite2(model : Element, model_id : String, metamodel_id : String):
+	// TODO this should be more elegant than just hiding the old elements
+
+	String location
+	String instanceOf_link
+
+	log("Rendering1: " + cast_id2s(get_full_model(get_entry_id("rendered/formalisms/MM_render"), get_entry_id("formalisms/MM_render"))))
+	location = "models/" + cast_id2s(model)
+	export_node(location, model["model"])
+	log("Rendering2: " + cast_id2s(get_full_model(get_entry_id("rendered/formalisms/MM_render"), get_entry_id("formalisms/MM_render"))))
+
+	// Change location in meta-data
+	unset_attribute(core, model_id, "location")
+	instantiate_attribute(core, model_id, "location", location)
+	log("Changed location of model to " + location)
+	log("Changing model " + model_id)
+	log("With name: " + cast_v2s(read_attribute(core, model_id, "name")))
+	log("Rendering3: " + cast_id2s(get_full_model(get_entry_id("rendered/formalisms/MM_render"), get_entry_id("formalisms/MM_render"))))
+
+	// Update the instanceOf relation of the context in which we are working
+	String choice
+	choice = get_instanceOf_link(model_id, metamodel_id)
+	log("Rendering4: " + cast_id2s(get_full_model(get_entry_id("rendered/formalisms/MM_render"), get_entry_id("formalisms/MM_render"))))
+	if (element_neq(choice, read_root())):
+		// There was a link, so we remove it
+
+		// First remove the type mapping it referred to
+		Element tl
+		tl = allAssociationDestinations(core, choice, "typing")
+		String e
+		log("Rendering5: " + cast_id2s(get_full_model(get_entry_id("rendered/formalisms/MM_render"), get_entry_id("formalisms/MM_render"))))
+		while (set_len(tl) > 0):
+			e = set_pop(tl)
+			model_delete_element(core, e)
+			log("Deleting type mapping... " + cast_id2s(e))
+		log("Rendering6: " + cast_id2s(get_full_model(get_entry_id("rendered/formalisms/MM_render"), get_entry_id("formalisms/MM_render"))))
+
+		// Now delete the element itself
+		model_delete_element(core, choice)
+		log("Deleting choice itself " + choice)
+		log("Rendering7: " + cast_id2s(get_full_model(get_entry_id("rendered/formalisms/MM_render"), get_entry_id("formalisms/MM_render"))))
+
+	// Create a new instanceOf relation now
+	String instance_of
+	log("Created new link")
+	log("Rendering8: " + cast_id2s(get_full_model(get_entry_id("rendered/formalisms/MM_render"), get_entry_id("formalisms/MM_render"))))
+	instance_of = instantiate_link(core, "instanceOf", "", model_id, metamodel_id)
+	instantiate_link(core, "semantics", "", instance_of, get_entry_id("models/conformance_mv"))
+	log("Update semantics")
+	instantiate_link(core, "typing", "", instance_of, export_typing(model, full_name(model_id)))
+	log("Rendering9: " + cast_id2s(get_full_model(get_entry_id("rendered/formalisms/MM_render"), get_entry_id("formalisms/MM_render"))))
+	log("Update typing")
+
+	return!
+
 Boolean function check_conformance(model_id : String):
 	// TODO check if it actually conforms, considering that instanceOf link
 	//    --> in-depth check
@@ -1088,8 +1146,8 @@ String function cmd_model_render(model_name : String, mapper_name : String):
 				if (allow_read(current_user_id, mapper_ID)):
 					// Everything is fine; start the actual operation
 					// Find metamodel to render to
-					rendered_name = ("rendered/" + model_name) + mapper_name
-					tracability_name = ("tracability/" + model_name) + mapper_name
+					rendered_name = "rendered/" + model_name
+					tracability_name = "tracability/" + model_name
 
 					// Take the abstract syntax model and the previously rendered model
 					inputs = dict_create()
@@ -1108,7 +1166,7 @@ String function cmd_model_render(model_name : String, mapper_name : String):
 						Element rendered
 						rendered = get_full_model(get_entry_id(output_map["rendered"]), get_entry_id("formalisms/SimpleClassDiagrams"))
 						if (element_eq(rendered, read_root())):
-							return "Rendered metamodel cannot conform to formalisms/SimpleClassDiagrams"!
+							return "Rendered metamodel doesn't conform to formalisms/SimpleClassDiagrams"!
 
 						rendered_model = instantiate_model(rendered)
 
@@ -1125,11 +1183,22 @@ String function cmd_model_render(model_name : String, mapper_name : String):
 							return "Tracability model not typed by Tracability metamodel: " + tracability_name!
 
 					// Do the operation itself!
+					log("PERCEPTUALIZING...")
 					result = execute_operation(mapper_ID, inputs, tracability_model)
+					log("Generated perceptualized model")
 
 					// Overwrite the previous rendered model
+					log("RENDERED:")
+					log("Model name: " + rendered_name)
+					log("Entry_id: " + get_entry_id(rendered_name))
 					model_overwrite(result["rendered"], get_entry_id(rendered_name), get_entry_id(output_map["rendered"]))
-					model_overwrite(result["abstract"], get_entry_id(model_name), get_entry_id(output_map["abstract"]))
+					// TODO the following line causes rendering to fail:
+					// nonetheless, it is necessary to allow the GUI to link back to the AS elements
+					log("ABSTRACT:")
+					log("Model name: " + model_name)
+					log("Entry_id: " + get_entry_id(model_name))
+					//model_overwrite2(result["abstract"], get_entry_id(model_name), get_entry_id(output_map["abstract"]))
+					log("Overwrite OK")
 
 					// Tracability updated in-place
 					model_overwrite(tracability_model, get_entry_id(tracability_name), get_entry_id("formalisms/Tracability"))

bootstrap/model_management.alc

@@ -128,11 +128,15 @@ Element function model_join(models : Element, metamodel : Element, tracability_m
 	new_model = instantiate_model(metamodel)
 	elem_map = dict_create()
 
+	Element retyping_keys
+	retyping_keys = set_create()
+
 	// Do the iteration
 	while (set_len(models) > 0):
 		tagged_model = set_pop(models)
 		retyping_key = string_join(list_read(tagged_model, 0), "/")
 		model = list_read(tagged_model, 1)
+		set_add(retyping_keys, retyping_key)
 
 		// Add all elements from 'model'
 		keys = dict_keys(model["model"])
@@ -174,25 +178,40 @@ Element function model_join(models : Element, metamodel : Element, tracability_m
 		String tracability_link
 		String new_name_src
 		String new_name_dst
+		String src_name
+		String dst_name
+		Element src_models
+		String src_model
+		Element dst_models
+		String dst_model
 
 		tracability_links = allInstances(tracability_model, "TracabilityLink")
 
 		while (set_len(tracability_links) > 0):
 			tracability_link = set_pop(tracability_links)
 
-			// Get necessary information from the tracability link
-
-			new_name_src = elem_map[cast_id2s(read_edge_src(tracability_model["model"][tracability_link]))]
-			new_name_dst = elem_map[cast_id2s(read_edge_dst(tracability_model["model"][tracability_link]))]
-
+			src_name = read_attribute(tracability_model, readAssociationSource(tracability_model, tracability_link), "name")
+			dst_name = read_attribute(tracability_model, readAssociationDestination(tracability_model, tracability_link), "name")
 			type = read_attribute(tracability_model, tracability_link, "type")
 
-			// Connect the two with the info we have
-			new_name = instantiate_link(new_model, type, "", new_name_src, new_name_dst)
+			// Now try to find all possible combinations
+			// that is, find all models for which src_name exists, and all models for which dst_name exists, and connect them
+			src_models = set_copy(retyping_keys)
+			while (set_len(src_models) > 0):
+				src_model = set_pop(src_models)
 
-			if (new_name == ""):
-				log("ERROR: could not create a tracability link; ignoring")
+				if (dict_in(new_model["model"], src_model + src_name)):
+					// This element exists for this source model
+					dst_models = set_copy(retyping_keys)
 
+					while (set_len(dst_models) > 0):
+						dst_model = set_pop(dst_models)
+
+						if (dict_in(new_model["model"], dst_model + dst_name)):
+							// Found a match for source and target, so create a link
+							new_name = instantiate_link(new_model, type, "", src_model + src_name, dst_model + dst_name)
+							if (new_name == ""):
+								log("ERROR: could not create a tracability link; ignoring")
 	return new_model!
 	
 Element function model_split(merged_model : Element, models : Element, tracability : Boolean):
@@ -253,27 +272,21 @@ Element function model_split(merged_model : Element, models : Element, tracabili
 				src = reverse[cast_id2s(read_edge_src(elem))]
 				dst = reverse[cast_id2s(read_edge_dst(elem))]
 
-				src_name = list_read(string_split(read_type(merged_model, src), "/"), 0)
-				dst_name = list_read(string_split(read_type(merged_model, dst), "/"), 0)
-
-				// Check if we actually keep both models around, as otherwise it is useless anyway
-				if (bool_and(dict_in(result, src_name), dict_in(result, dst_name))):
-					if (bool_and(dict_in(mapping, src), dict_in(mapping, dst))):
-						// All present, so create the link between them
-						Element src_model
-						Element dst_model
-
-						src_model = result[src_name]
-						dst_model = result[dst_name]
+				if (bool_and(dict_in(mapping, src), dict_in(mapping, dst))):
+					// All present, so create the link between them
+					src_name = list_pop_final(string_split(src, "/"))
+					dst_name = list_pop_final(string_split(dst, "/"))
 
-						source = reuse_element(tracability_model, "Reference", "", src_model["model"][mapping[src]])
-						target = reuse_element(tracability_model, "Reference", "", dst_model["model"][mapping[dst]])
+					source = instantiate_node(tracability_model, "Reference", "")
+					target = instantiate_node(tracability_model, "Reference", "")
+					instantiate_attribute(tracability_model, source, "name", src_name)
+					instantiate_attribute(tracability_model, target, "name", dst_name)
 
-						link = instantiate_link(tracability_model, "TracabilityLink", "", source, target)
-						instantiate_attribute(tracability_model, link, "type", type)
-					else:
-						// Not yet available!
-						set_add(second_keys, key)
+					link = instantiate_link(tracability_model, "TracabilityLink", "", source, target)
+					instantiate_attribute(tracability_model, link, "type", type)
+				else:
+					// Not yet available!
+					set_add(second_keys, key)
 		else:
 			retyping_key = splitted[0]
 			if (list_len(string_split(key, "/")) > 1):

bootstrap/tracability.mvc

@@ -6,7 +6,9 @@ include "object_operations.alh"
 SimpleClassDiagrams Tracability {
     SimpleAttribute String {}
 
-    Class Reference {}
+    Class Reference {
+        name : String
+    }
     Association TracabilityLink {
         type : String
     }