modelverse/core/mini_modify.alc

include "primitives.alh"
include "constructors.alh"
include "object_operations.alh"
include "library.alh"
include "conformance_scd.alh"
include "io.alh"
include "metamodels.alh"
include "modelling.alh"
include "compilation_manager.alh"

String function pretty_print(model : Element):
	Element keys_m
	String type
	String v_m
	Element attr_list
	Element attr_keys
	String attr_key
	String result

	result = ""
	keys_m = dict_keys(model["model"])

	while (read_nr_out(keys_m) > 0):
		v_m = set_pop(keys_m)
		type = read_type(model["metamodel"], read_type(model, v_m))

		if (bool_or(type == "Class", type == "Association")):
			result = result + ((("  " + v_m) + " : ") + read_type(model, v_m))
			result = result + "\n"
			if (type == "Association"):
				result = result + ((("    " + reverseKeyLookup(model["model"], read_edge_src(model["model"][v_m]))) + " --> ") + reverseKeyLookup(model["model"], read_edge_dst(model["model"][v_m])))
				result = result + "\n"

			// Defines attributes
			attr_list = getInstantiatableAttributes(model, v_m)
			attr_keys = dict_keys(attr_list)
			while (0 < read_nr_out(attr_keys)):
				attr_key = set_pop(attr_keys)
				result = result + (((("      " + attr_key) + " : ") + cast_v2s(attr_list[attr_key])))
				result = result + "\n"

			// Has attributes
			attr_list = getAttributeList(model, v_m)
			attr_keys = dict_keys(attr_list)
			while (0 < read_nr_out(attr_keys)):
				attr_key = set_pop(attr_keys)
				if (element_eq(read_attribute(model, v_m, attr_key), read_root())):
					result = result + (((("      " + cast_v2s(attr_key)) + " : ") + cast_v2s(attr_list[attr_key])) + " = (undefined)")
				else:
					result = result + ((((("      " + cast_v2s(attr_key)) + " : ") + cast_v2s(attr_list[attr_key])) + " = ") + cast_v2s(read_attribute(model, v_m, attr_key)))
				result = result + "\n"
	return result!

Element function modify(model : Element, write : Boolean):
	String cmd

	Element attr_list_pn
	Element attr_keys_pn
	String attr_key_pn
	Element metamodel_element_pn
	String typename

	output("Model loaded, ready for commands!")
	output("Use 'help' command for a list of possible commands")

	while (True):
		output("Please give your command.")
		cmd = input()
		if (cmd == "help"):
			output("Allowed operations:")
			if (write):
				output(" == READ/WRITE ==")
				output("  instantiate   -- Create a new model element")
				output("  delete        -- Delete an existing element")
				output("  attr_add      -- Add an attribute to an element")
				output("  attr_add_code -- Add a coded attribute to an element")
				output("  attr_del      -- Delete an attribute of an element")
				output("  attr_modify   -- Modify an attribute of an element")
				output("  retype        -- Change the type of an element")
				output("  upload        -- Upload a completely new model")
			else:
				output(" == READ-ONLY ==")
			output("  list          -- Prints the list of elements in the model")
			output("  list_full     -- Prints the list of all elements in the model")
			output("  types         -- Prints the list of elements that can be instantiated")
			output("  read          -- Prints the current state of a model element")
			output("  verify        -- Check whether the model conforms to the metamodel")
			output("  exit          -- Leave the modification interface")
		elif (cmd == "exit"):
			return model!
		elif (cmd == "upload"):
			Element new_model
			output("Waiting for model constructors...")
			new_model = construct_model_raw(model["metamodel"])
			dict_overwrite(model, "model", new_model["model"])
			dict_overwrite(model, "type_mapping", new_model["type_mapping"])
		elif (cmd == "instantiate"):
			if (write):
				String mm_type_name
				output("Type to instantiate?")
				mm_type_name = input()
				if (dict_in(model["metamodel"]["model"], mm_type_name)):
					String element_name
					output("Name of new element?")
					element_name = input()
					if (dict_in(model["model"], element_name)):
						output("Element already exists; aborting")
					else:
						if (is_edge(model["metamodel"]["model"][mm_type_name])):
							output("Source name?")
							String src_name
							src_name = input()
							if (dict_in(model["model"], src_name)):
								output("Destination name?")
								String dst_name
								dst_name = input()
								if (dict_in(model["model"], dst_name)):
									instantiate_link(model, mm_type_name, element_name, src_name, dst_name)
									output("Instantiation successful!")
								else:
									output("Unknown destination; aborting")
							else:
								log("Unknown source!")
								log("SRC: " + src_name)
								log("In set: " + set_to_string(dict_keys(model["model"])))
								output("Unknown source; aborting")
						else:
							instantiate_node(model, mm_type_name, element_name)
							output("Instantiation successful!")
				else:
					output("Unknown type specified; aborting")
			else:
				output("Permission denied")

		elif (cmd == "attr_modify"):
			if (write):
				String model_name
				output("Element to modify?")
				model_name = input()
				if (dict_in(model["model"], model_name)):
					Element attrs
					attrs = getAttributeList(model, model_name)
					String attr_name
					output("Attribute to modify?")
					attr_name = input()
					if (set_in(dict_keys(attrs), attr_name)):
						output("New value?")
						unset_attribute(model, model_name, attr_name)
						instantiate_attribute(model, model_name, attr_name, input())
						output("Modified!")
					else:
						output("No such attribute!")
				else:
					output("No such model!")
			else:
				output("Permission denied")

		elif (cmd == "attr_add"):
			if (write):
				String model_name
				output("Which model do you want to assign an attribute to?")
				model_name = input()
				if (dict_in(model["model"], model_name)):
					Element attrs
					attrs = getAttributeList(model, model_name)
					String attr_name
					output("Which attribute do you wish to assign?")
					attr_name = input()
					if (set_in(dict_keys(attrs), attr_name)):
						output("Value of attribute?")
						instantiate_attribute(model, model_name, attr_name, input())
						output("Added attribute!")
					else:
						output("No such attribute!")
				else:
					output("No such model!")
			else:
				output("Permission denied")

		elif (cmd == "attr_add_code"):
			if (write):
				String model_name
				output("Which model do you want to assign a coded attribute to?")
				model_name = input()
				if (dict_in(model["model"], model_name)):
					Element attrs
					attrs = getAttributeList(model, model_name)
					String attr_name
					output("Which attribute do you wish to assign?")
					attr_name = input()
					if (set_in(dict_keys(attrs), attr_name)):
						output("Waiting for code constructors...")
						instantiate_attribute_code(model, model_name, attr_name, input())
						output("Added attribute!")
					else:
						output("No such attribute!")
				else:
					output("No such model!")
			else:
				output("Permission denied")

		elif (cmd == "attr_del"):
			if (write):
				String model_name
				output("Which model do you want to remove an attribute of?")
				model_name = input()
				if (dict_in(model["model"], model_name)):
					Element attrs
					attrs = getAttributeList(model, model_name)
					String attr_name
					output("Which attribute do you want to delete?")
					attr_name = input()
					if (set_in(dict_keys(attrs), attr_name)):
						unset_attribute(model, model_name, attr_name)
						output("Attribute deleted!")
					else:
						output("No such attribute!")
				else:
					output("No such model!")
			else:
				output("Permission denied")

		elif (cmd == "delete"):
			if (write):
				output("What is the name of the element you want to delete?")
				cmd = input()
				if (dict_in(model["model"], cmd)):
					model_delete_element(model, cmd)
					output("Deleted!")
				else:
					output("No such element; aborting")
			else:
				output("Permission denied")

		elif (cmd == "nice_list"):
			pretty_print(model)

		elif (cmd == "list"):
			Element keys_m
			keys_m = dict_keys(model["model"])
			output("List of all elements:")
			String v_m
			while (read_nr_out(keys_m) > 0):
				v_m = set_pop(keys_m)
				// Filter out anonymous objects
				if (bool_not(string_startswith(v_m, "__"))):
					typename = read_type(model, v_m)
					output((("  " + v_m) + " : ") + typename)

		elif (cmd == "list_full"):
			Element keys_m
			keys_m = dict_keys(model["model"])
			output("List of all elements:")
			String v_m
			while (read_nr_out(keys_m) > 0):
				v_m = set_pop(keys_m)
				// Filter out anonymous objects
				typename = read_type(model, v_m)
				output((("  " + v_m) + " : ") + typename)

		elif (cmd == "read"):
			output("Element to read?")
			cmd = input()
			if (dict_in(model["model"], cmd)):
				output("ID: " + cmd)
				output("Type: " + read_type(model, cmd))
				if (is_edge(model["model"][cmd])):
					output("Source: " + reverseKeyLookup(model["model"], read_edge_src(model["model"][cmd])))
					output("Destination: " + reverseKeyLookup(model["model"], read_edge_dst(model["model"][cmd])))
				if (has_value(model["model"][cmd])):
					output("Value: " + cast_v2s(model["model"][cmd]))
				output("Defines attributes:")
				attr_list_pn = getInstantiatableAttributes(model, cmd)
				attr_keys_pn = dict_keys(attr_list_pn)
				while (0 < read_nr_out(attr_keys_pn)):
					attr_key_pn = set_pop(attr_keys_pn)
					output(((("  " + attr_key_pn) + " : ") + cast_v2s(attr_list_pn[attr_key_pn])))
				output("Attributes:")
				attr_list_pn = getAttributeList(model, cmd)
				attr_keys_pn = dict_keys(attr_list_pn)
				while (0 < read_nr_out(attr_keys_pn)):
					attr_key_pn = set_pop(attr_keys_pn)
					output((((("  " + cast_v2s(attr_key_pn)) + " : ") + cast_v2s(attr_list_pn[attr_key_pn])) + " = ") + cast_v2s(read_attribute(model, cmd, attr_key_pn)))
			else:
				output("Unknown element; aborting")

		elif (cmd == "verify"):
			output(conformance_scd(model))

		elif (cmd == "types"):
			Element keys_t
			keys_t = dict_keys(model["metamodel"]["model"])
			output("List of types:")
			String v_t
			while (read_nr_out(keys_t) > 0):
				v_t = set_pop(keys_t)
				if (bool_not(string_startswith(v_t, "__"))):
					output(string_join(("  " + v_t) + " : ", read_type(model, v_t)))

		elif (cmd == "retype"):
			if (write):
				output("Element to retype?")
				String elementname
				elementname = input()
				if (dict_in(model["model"], elementname)):
					output("New type")
					typename = input()
					if (dict_in(model["metamodel"]["model"], typename)):
						retype(model, elementname, typename)
						output("Retyped!")
					else:
						output("Unknown type; aborting")
				else:
					output("Unknown element; aborting")
			else:
				output("Permission denied")

		else:
			output("Unknown command: " + cast_v2s(cmd))
			output("Use command 'help' to get a list of available commands")

	return model!