MV2/core/manager.py

from state.base import State
from core.element import Element, String


class Manager:
    def __init__(self, state: State):
        self.state = state

    def exposed_methods(self):
        yield from [
            self.new_model,
            self.get_model,
            self.rename_model,
            self.retype_model,
            self.delete_model,
            self.list_models,
        ]

    def new_model(self, name: String, type_model_name: String) -> Element:
        root = self.state.read_root()
        mm_bottom = self.state.read_dict(root, type_model_name.value)
        if mm_bottom is None:
            print(f"Error: Invalid type model name {type_model_name.value}. Model not created.")
            return Element()
        bottom = self.state.create_nodevalue(name.value)
        if bottom is None:
            print(f"Error: Invalid model name {name.value}. Model not created.")
            return Element()
        self.state.create_dict(root, name.value, bottom)
        self.state.create_dict(bottom, "Model", self.state.create_node())
        self.state.create_dict(bottom, "Metamodel", mm_bottom)
        return Element(id=bottom)

    def get_model(self, name: String) -> Element:
        root = self.state.read_root()
        model = self.state.read_dict(root, name.value)
        if model is None:
            print(f"Error: Cannot find model with name {name.value}.")
            return Element()
        return Element(id=model)

    def rename_model(self, name: String, new_name: String):
        root = self.state.read_root()
        name_used = self.state.read_dict_edge(root, new_name.value)
        if name_used:
            print(f"Error: Model with name {new_name.value} already exists. Please use another name.")
            return
        mode_edge = self.state.read_dict_edge(root, name.value)
        if mode_edge is None:
            print(f"Error: Cannot find model with name {name.value}.")
            return
        _,  model_node = self.state.read_edge(mode_edge)
        self.state.create_dict(root, new_name.value, model_node)
        created = self.state.read_dict_edge(root, new_name.value)
        if created is None:
            print(f"Error: Invalid model name {new_name.value}. Model not renamed.")
        else:
            self.state.delete_edge(mode_edge)

    def delete_model(self, name: String):
        root = self.state.read_root()
        model = self.state.read_dict(root, name.value)
        if model is None:
            print(f"Error: No model found for name {name.value}.")
        else:
            self.state.delete_node(model)

    def list_models(self):
        unsorted = []
        for edge in self.state.read_outgoing(self.state.read_root()):
            _, model = self.state.read_edge(edge)
            metamodel = self.state.read_dict(model, "Metamodel")
            unsorted.append(f"{self.state.read_value(model)} : {self.state.read_value(metamodel)}")
        for x in sorted(unsorted):
            print(x)

    def retype_model(self, model_name: String, metamodel_name: String):
        root = self.state.read_root()
        model = self.state.read_dict(root, model_name.value)
        if model is None:
            print(f"Error: Cannot find model with name {model_name.value}.")
        metamodel = self.state.read_dict(root, metamodel_name.value)
        if metamodel is None:
            print(f"Error: Cannot find model with name {metamodel_name.value}.")
        metamodel_edge = self.state.read_dict_edge(model, "Metamodel")
        if metamodel_edge is not None:
            self.state.delete_edge(metamodel_edge)
        self.state.create_dict(model, "Metamodel", metamodel)