104 lines
4.3 KiB
Python
104 lines
4.3 KiB
Python
from state.base import INTEGER, FLOAT, BOOLEAN, STRING, TYPE, State
|
|
from core.element import Element, String
|
|
|
|
|
|
class Bottom:
|
|
def __init__(self, state: State):
|
|
self.state = state
|
|
|
|
def create_model(self, name: String) -> Element:
|
|
bottom = self.state.create_nodevalue(name.value)
|
|
self.state.create_dict(bottom, "Model", self.state.create_node())
|
|
return Element(id=bottom)
|
|
|
|
def add_node(self, model: Element, name: String):
|
|
model_root = self.state.read_dict(model.id, "Model")
|
|
# create model element
|
|
element = self.state.create_node()
|
|
# connect to model root
|
|
self.state.create_dict(model_root, name.value, element)
|
|
# confirm that element has been added to the model
|
|
element = self.state.read_dict(model_root, name.value)
|
|
if element is None:
|
|
self.state.delete_node(element)
|
|
print(f"Warning: Invalid name {name.value}, element not created.")
|
|
return
|
|
|
|
def add_value(self, model: Element, name: String, value: Element):
|
|
model_root = self.state.read_dict(model.id, "Model")
|
|
# create model element
|
|
element = self.state.create_nodevalue(value.value)
|
|
if element is None:
|
|
print("Warning: Invalid value, value node not created.")
|
|
return
|
|
# connect to model root
|
|
self.state.create_dict(model_root, name.value, element)
|
|
# confirm that element has been added to the model
|
|
element_found = self.state.read_dict(model_root, name.value)
|
|
if element_found is None:
|
|
self.state.delete_node(element)
|
|
print(f"Warning: Invalid name {name.value}, element not created.")
|
|
return
|
|
|
|
def add_edge(self, model: Element, name: String, source: String, target: String):
|
|
model_root = self.state.read_dict(model.id, "Model")
|
|
source_element = self.state.read_dict(model_root, source.value)
|
|
if source_element is None:
|
|
print(f"Warning: Unknown source element {source.value}, edge not created.")
|
|
return
|
|
target_element = self.state.read_dict(model_root, target.value)
|
|
if target_element is None:
|
|
print(f"Warning: Unknown target element {target.value}, edge not created.")
|
|
return
|
|
# create model element
|
|
element = self.state.create_edge(source_element, target_element)
|
|
# connect to model root
|
|
self.state.create_dict(model_root, name.value, element)
|
|
# confirm that element has been added to the model
|
|
element = self.state.read_dict(model_root, name.value)
|
|
if element is None:
|
|
self.state.delete_edge(element)
|
|
print(f"Warning: Invalid name {name.value}, element not created.")
|
|
|
|
def delete_element(self, model: Element, name: String):
|
|
model_root = self.state.read_dict(model.id, "Model")
|
|
element = self.state.read_dict(model_root, name.value)
|
|
# could be both a node or an edge
|
|
self.state.delete_node(element)
|
|
self.state.delete_edge(element)
|
|
|
|
def list_elements(self, model: Element):
|
|
def is_edge(elem: Element) -> bool:
|
|
edge = self.state.read_edge(elem.id)
|
|
return edge is not None
|
|
def value_type(value) -> str:
|
|
map = {
|
|
int: INTEGER,
|
|
float: FLOAT,
|
|
str: STRING,
|
|
bool: BOOLEAN,
|
|
tuple: TYPE
|
|
}
|
|
return map[type(value)][0]
|
|
|
|
unsorted = []
|
|
model_root = self.state.read_dict(model.id, "Model")
|
|
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)
|
|
# find element bottom type
|
|
_, elem = self.state.read_edge(elem_edge)
|
|
if is_edge(elem):
|
|
bottom_type = "Edge"
|
|
else:
|
|
# is_node
|
|
elem_value = self.state.read_value(elem)
|
|
if elem_value is None:
|
|
bottom_type = "Node"
|
|
else:
|
|
bottom_type = value_type
|
|
unsorted.append(f"{label} : {bottom_type}")
|
|
for i in sorted(unsorted):
|
|
print(i)
|