diff --git a/experiments/exp_scd.py b/experiments/exp_scd.py index 31f684e..c8e4e10 100644 --- a/experiments/exp_scd.py +++ b/experiments/exp_scd.py @@ -153,12 +153,14 @@ def main(): matcher = MatcherVF2(host, guest, mvs_adapter.RAMCompare(Bottom(state), dsl_m_od)) for m in matcher.match(): print("\nMATCH:\n", m) - name_to_matched = {} + name_mapping = {} + id_mapping = {} for guest_vtx, host_vtx in m.mapping_vtxs.items(): if isinstance(guest_vtx, mvs_adapter.NamedNode) and isinstance(host_vtx, mvs_adapter.NamedNode): - name_to_matched[guest_vtx.name] = host_vtx.name - print(name_to_matched) - rewriter.rewrite(state, lhs_id, rhs_id, ramified_mm_id, name_to_matched, dsl_m_id, dsl_mm_id) + id_mapping[guest_vtx.node_id] = host_vtx.node_id + name_mapping[guest_vtx.name] = host_vtx.name + print(name_mapping) + #rewriter.rewrite(state, lhs_id, rhs_id, ramified_mm_id, name_mapping, dsl_m_id, dsl_mm_id) break print("DONE") @@ -166,7 +168,28 @@ def main(): print("Updated model conforms?", conf5.check_nominal(log=True)) - print(plantuml.render_ramification(state, dsl_mm_id, ramified_mm_id)) + + + # Render original and RAMified meta-models + print(plantuml.render_package("Meta-Model", plantuml.render_class_diagram(state, dsl_mm_id))) + print(plantuml.render_package("RAMified Meta-Model", plantuml.render_class_diagram(state, ramified_mm_id))) + + # Render ramification traceability links + print(plantuml.render_trace_ramifies(state, dsl_mm_id, ramified_mm_id)) + + # Render host graph + print(plantuml.render_package("Model", plantuml.render_object_diagram(state, dsl_m_id, dsl_mm_id))) + + # Render conformance host -> MM + print(plantuml.render_trace_conformance(state, dsl_m_id, dsl_mm_id)) + + # Render pattern + print(plantuml.render_package("LHS", plantuml.render_object_diagram(state, lhs_id, ramified_mm_id))) + + # Render pattern -> RAM-MM + print(plantuml.render_trace_conformance(state, lhs_id, ramified_mm_id)) + + print(plantuml.render_trace_match(state, id_mapping)) if __name__ == "__main__": main() diff --git a/renderer/plantuml.py b/renderer/plantuml.py index 09f61fe..5a10c6a 100644 --- a/renderer/plantuml.py +++ b/renderer/plantuml.py @@ -12,9 +12,9 @@ def render_class_diagram(state, model): # Render classes for name, class_node in model_scd.get_classes().items(): if model_od.read_slot_boolean(class_node, "abstract"): - output += f"\nabstract class {name}" + output += f"\nabstract class \"{name}\" as {make_id(class_node)}" else: - output += f"\nclass {name}" + output += f"\nclass \"{name}\" as {make_id(class_node)}" # Render attributes output += " {" @@ -27,17 +27,24 @@ def render_class_diagram(state, model): # Render inheritance links for inh_node in model_scd.get_inheritances().values(): - src_name = model_scd.get_class_name(bottom.read_edge_source(inh_node)) - tgt_name = model_scd.get_class_name(bottom.read_edge_target(inh_node)) - output += f"\n{tgt_name} <|-- {src_name}" + src_node = bottom.read_edge_source(inh_node) + tgt_node = bottom.read_edge_target(inh_node) + # src_name = model_scd.get_class_name(bottom.read_edge_source(inh_node)) + # tgt_name = model_scd.get_class_name(bottom.read_edge_target(inh_node)) + output += f"\n{make_id(tgt_node)} <|-- {make_id(src_node)}" output += "\n" + # Render associations for assoc_name, assoc_edge in model_scd.get_associations().items(): - src_name = model_scd.get_class_name(bottom.read_edge_source(assoc_edge)) - tgt_name = model_scd.get_class_name(bottom.read_edge_target(assoc_edge)) + src_node = bottom.read_edge_source(assoc_edge) + tgt_node = bottom.read_edge_target(assoc_edge) + # src_name = model_scd.get_class_name(bottom.read_edge_source(assoc_edge)) + # tgt_name = model_scd.get_class_name(bottom.read_edge_target(assoc_edge)) src_lower_card, src_upper_card, tgt_lower_card, tgt_upper_card = model_scd.get_assoc_cardinalities(assoc_edge) + + # default cardinalities if src_lower_card == None: src_lower_card = 0 if src_upper_card == None: @@ -55,7 +62,34 @@ def render_class_diagram(state, model): if tgt_card == "1 .. 1": tgt_card = " " # hide cardinality - output += f'\n{src_name} "{src_card}" --> "{tgt_card}" {tgt_name} : {assoc_name}' + output += f'\n{make_id(src_node)} "{src_card}" --> "{tgt_card}" {make_id(tgt_node)} : {assoc_name}' + + return output + + +def render_object_diagram(state, m, mm): + bottom = Bottom(state) + mm_scd = scd.SCD(mm, state) + m_od = od.OD(mm, m, state) + + output = "" + + # Render objects + for class_name, class_node in mm_scd.get_classes().items(): + for obj_name, obj_node in m_od.get_objects(class_node).items(): + output += f"\nobject \"{obj_name} : {class_name}\" as {make_id(obj_node)}" + + output += '\n' + + # Render links + for assoc_name, assoc_edge in mm_scd.get_associations().items(): + for link_name, link_edge in m_od.get_objects(assoc_edge).items(): + src_obj = bottom.read_edge_source(link_edge) + tgt_obj = bottom.read_edge_target(link_edge) + src_name = m_od.get_object_name(src_obj) + tgt_name = m_od.get_object_name(tgt_obj) + + output += f"\n{make_id(src_obj)} -> {make_id(tgt_obj)} : {assoc_name}" return output @@ -66,23 +100,57 @@ def render_package(name, contents): output += '\n}' return output -def render_ramification(state, mm, ramified_mm): +def render_trace_ramifies(state, mm, ramified_mm): bottom = Bottom(state) - output = ( - render_package("original", render_class_diagram(state, mm)) - + '\n' - + render_package("RAMified", render_class_diagram(state, ramified_mm)) - ) - mm_scd = scd.SCD(mm, state) ramified_mm_scd = scd.SCD(ramified_mm, state) - output += "\n" + # output = ( + # render_package("original", render_class_diagram(state, mm)) + # + '\n' + # + render_package("RAMified", render_class_diagram(state, ramified_mm)) + # ) + + output = "" + + # output += "\n" for ram_name, ram_class_node in ramified_mm_scd.get_classes().items(): original_class, = bottom.read_outgoing_elements(ram_class_node, ramify.RAMIFIES_LABEL) original_name = mm_scd.get_class_name(original_class) - output += f"\n{ram_name} ..> {original_name} : RAMifies" + output += f"\n{make_id(ram_class_node)} ..> {make_id(original_class)} #line:green;text:green : RAMifies " - return output \ No newline at end of file + return output + + +def render_trace_conformance(state, m, mm): + bottom = Bottom(state) + mm_scd = scd.SCD(mm, state) + m_od = od.OD(mm, m, state) + + output = "" + + # Render objects + for class_name, class_node in mm_scd.get_classes().items(): + for obj_name, obj_node in m_od.get_objects(class_node).items(): + output += f"\n{make_id(obj_node)} ..> {make_id(class_node)} #line:blue;text:blue : instanceOf" + + output += '\n' + + return output + +def render_trace_match(state, mapping): + bottom = Bottom(state) + + output = "" + + for pattern_el, host_el in mapping.items(): + # only render 'match'-edges between objects (= those elements where the type of the type is 'Class'): + if od.get_type(bottom, od.get_type(bottom, pattern_el)) == od.get_scd_mm_class_node(bottom): + output += f"\n{make_id(pattern_el)} ..> {make_id(host_el)} #line:grey;text:grey : matchedWith" + + return output + +def make_id(uuid) -> str: + return (str(uuid).replace('-','_')) \ No newline at end of file diff --git a/services/od.py b/services/od.py index c7d20fe..624ad95 100644 --- a/services/od.py +++ b/services/od.py @@ -139,6 +139,15 @@ class OD: self.bottom.create_edge(link_edge, type_edge, "Morphism") return link_edge + def get_objects(self, class_node): + return get_typed_by(self.bottom, self.model, class_node) + + def get_object_name(self, obj: UUID): + for key in self.bottom.read_keys(self.model): + for el in self.bottom.read_outgoing_elements(self.model, key): + if el == obj: + return key + def get_types(bottom: Bottom, obj: UUID): return bottom.read_outgoing_elements(obj, "Morphism") @@ -155,6 +164,16 @@ def is_typed_by(bottom, el: UUID, typ: UUID): return True return False +def get_typed_by(bottom, model, type_node: UUID): + name_to_instance = {} + for key in bottom.read_keys(model): + element, = bottom.read_outgoing_elements(model, key) + element_types = bottom.read_outgoing_elements(element, "Morphism") + if type_node in element_types: + name_to_instance[key] = element + # mapping from instance name to UUID + return name_to_instance + def get_scd_mm(bottom): scd_metamodel_id = bottom.state.read_dict(bottom.state.read_root(), "SCD") scd_metamodel = UUID(bottom.state.read_value(scd_metamodel_id))