muMLE/core/context/generic.py

from core.element import Element, String, Boolean
from state.base import State
from core.context.base import Context
from core.context.bottom import BottomContext


class GenericContext(Context):

    def __init__(self, state: State, model: Element, metamodel: Element):
        super().__init__(state, model, metamodel)
        self.bottom = BottomContext(state, model)

    def __enter__(self):
        pass

    def __exit__(self):
        pass

    def exposed_methods(self):
        yield from [
            self.instantiate,
            self.instantiate_value,
            self.instantiate_link,
            self.retype_element,
            self.delete_element,
            self.list_elements,
            self.list_types,
            self.verify,
        ]

    def _type_exists(self, type_name: String, instantiate_link: bool) -> bool:
        metamodel_root = self.state.read_dict(self.metamodel.id, "Model")
        type_element = self.state.read_dict(metamodel_root, type_name.value)
        if type_element is None:
            return False
        else:
            element_is_edge = self.state.read_edge(type_element) != (None, None)
            return element_is_edge == instantiate_link

    def instantiate(self, type_name: String, name: String):
        if not self._type_exists(type_name, instantiate_link=False):
            print(f"Attempting to instantiate element with invalid type: {type_name.value}")
        else:
            self.bottom.add_node(name)
            self.retype_element(name, type_name)

    def instantiate_value(self, type_name: String, name: String, value: Element):
        if not self._type_exists(type_name, instantiate_link=False):
            print(f"Attempting to instantiate element with invalid type: {type_name.value}")
        else:
            self.bottom.add_value(name, value)
            self.retype_element(name, type_name)

    def instantiate_link(self, type_name: String, name: String, source: String, target: String):
        if not self._type_exists(type_name, instantiate_link=True):
            print(f"Attempting to instantiate link with invalid type: {type_name.value}")
        else:
            self.bottom.add_edge(name, source, target)
            self.retype_element(name, type_name)

    def delete_element(self, name: String):
        self.bottom.delete_element(name)

    def verify(self):
        pass  # TODO: implement conformance check

    def list_elements(self):
        model_root = self.state.read_dict(self.model.id, "Model")
        unsorted = []
        for elem_edge in self.state.read_outgoing(model_root):
            # get element name
            label_edge, = self.state.read_outgoing(elem_edge)
            _, label_node = self.state.read_edge(label_edge)
            label = self.state.read_value(label_node)
            type_node = self.state.read_dict(label_node, "Type")
            type_name = self.state.read_value(type_node)
            unsorted.append(f"{label} : {type_name}")
        for i in sorted(unsorted):
            print(i)

    def retype_element(self, name: String, type_name: String):
        model_root = self.state.read_dict(self.model.id, "Model")
        element_edge = self.state.read_dict_edge(model_root, name.value)
        if element_edge is None:
            print(f"Error: Element with name {name.value} not found.")
            return
        label_node_edge, = self.state.read_outgoing(element_edge)
        _, label_node = self.state.read_edge(label_node_edge)
        # create type name node
        type_name_node = self.state.create_nodevalue(type_name.value)
        if type_name_node is None:
            print("Error: Invalid type name, element not retyped.")
        # remove any existing type node
        existing = self.state.read_dict(label_node, "Type")
        if existing is not None:
            self.state.delete_node(existing)
        # create new type node
        self.state.create_dict(label_node, "Type", type_name_node)