modelverse/bootstrap/model_management.alc

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

Element function model_fuse(models : Element):
	Element new_model
	Element tagged_model
	String model_name
	Element model
	Element keys
	Element second_keys
	String key
	Element selected_MM
	String type
	Element reverse

	// Read out some data first
	tagged_model = set_pop(models)
	set_add(models, tagged_model)
	new_model = instantiate_model(tagged_model[1]["metamodel"])

	// Do the iteration
	while (read_nr_out(models) > 0):
		tagged_model = set_pop(models)
		model_name = string_join(list_read(tagged_model, 0), "/")
		model = list_read(tagged_model, 1)

		reverse = make_reverse_dictionary(model["model"])

		// Add all elements from 'model', but prepend it with the 'model_name'
		keys = dict_keys(model["model"])
		second_keys = create_node()

		while (read_nr_out(keys) > 0):
			key = set_pop(keys)
			type = read_type(model, key)

			if (is_edge(model["model"][key])):
				String src
				String dst
				src = string_join(model_name, reverse[cast_id2s(read_edge_src(model["model"][key]))])
				dst = string_join(model_name, reverse[cast_id2s(read_edge_dst(model["model"][key]))])
				if (bool_and(dict_in(new_model["model"], src), dict_in(new_model["model"], dst))):
					instantiate_link(new_model, type, model_name + key, src, dst)
				else:
					set_add(second_keys, key)
			elif (has_value(model["model"][key])):
				instantiate_value(new_model, type, model_name + key, model["model"][key])
			else:
				instantiate_node(new_model, type, model_name + key)

			if (read_nr_out(keys) == 0):
				keys = second_keys
				second_keys = create_node()

	return new_model!

Element function model_copy(src_model : Element):
	Element dst_model
	Element name
	Element keys
	Element second_keys
	String type

	Element reverse
	reverse = make_reverse_dictionary(src_model["model"])

	dst_model = instantiate_model(src_model["metamodel"])
	keys = dict_keys(src_model["model"])
	second_keys = create_node()

	while (read_nr_out(keys) > 0):
		name = set_pop(keys)

		if (is_edge(src_model["model"][name])):
			// Is an edge, so potentially queue it
			String src
			String dst

			src = reverse[cast_id2s(read_edge_src(src_model["model"][name]))]
			dst = reverse[cast_id2s(read_edge_dst(src_model["model"][name]))]

			type = read_type(src_model, name)

			if (bool_and(dict_in(dst_model["model"], src), dict_in(dst_model["model"], dst))):
				// All present, so create the link between them
				instantiate_link(dst_model, type, name, src, dst)
			else:
				set_add(second_keys, name)

		elif (has_value(src_model["model"][name])):
			// Has a value, so copy that as well
			type = read_type(src_model, name)
			instantiate_value(dst_model, type, name, src_model["model"][name])

		else:
			// Is a node
			type = read_type(src_model, name)
			instantiate_node(dst_model, type, name)

		if (read_nr_out(keys) == 0):
			keys = second_keys
			second_keys = create_node()

	return dst_model!

Element function model_retype_on_name(model : Element, new_MM : Element, operation : String, name : String):
	String key
	String type
	Element keys
	Integer length

	keys = dict_keys(model["model"])
	length = string_len(name)

	while (read_nr_out(keys) > 0):
		key = set_pop(keys)
		if (dict_in(model["model"], key)):
			// Check if the element is still there, as a delete of a node might remove all attached links automatically
			type = read_type(model, key)

			if (operation == "+"):
				// Keep all, but augment typename
				dict_delete(model["type_mapping"], key)
				dict_add_fast(model["type_mapping"], key, name + type)
			elif (operation == "-"):
				// Keep only if typename beginning matches and remove from typename
				if (string_startswith(type, name)):
					dict_delete(model["type_mapping"], key)
					dict_add_fast(model["type_mapping"], key, string_substr(type, length, string_len(type)))
				else:
					model_delete_element(model, key)

	dict_delete(model, "metamodel")
	dict_add_fast(model, "metamodel", new_MM)

	return model!

Void function model_join(dst_model : Element, src_model : Element, retyping_key : String):
	Element keys
	Element second_keys
	Element mapping
	String name
	String type
	String src
	String dst
	Element elem

	mapping = create_node()

	second_keys = create_node()

	Element reverse
	reverse = make_reverse_dictionary(src_model["model"])

	keys = dict_keys(src_model["model"])
	while (read_nr_out(keys) > 0):
		name = set_pop(keys)
		elem = src_model["model"][name]
		type = read_type(src_model, name)

		if (is_edge(elem)):
			// Is an edge, so potentially queue it
			String src
			String dst

			src = reverse[cast_id2s(read_edge_src(elem))]
			dst = reverse[cast_id2s(read_edge_dst(elem))]

			if (bool_and(dict_in(mapping, src), dict_in(mapping, dst))):
				// All present, so create the link between them
				dict_add_fast(mapping, name, instantiate_link(dst_model, retyping_key + type, "", mapping[src], mapping[dst]))
			else:
				set_add(second_keys, name)

		elif (has_value(elem)):
			// Has a value, so copy that as well
			dict_add_fast(mapping, name, instantiate_value(dst_model, retyping_key + type, "", elem))

		else:
			// Is a node
			dict_add_fast(mapping, name, instantiate_node(dst_model, retyping_key + type, ""))

		if (read_nr_out(keys) == 0):
			keys = second_keys
			second_keys = create_node()

	return!
	
Element function model_split(src_model : Element, target_metamodel : Element, retyping_key : String):
	Element dst_model

	dst_model = instantiate_model(target_metamodel)

	Element keys
	Element second_keys
	Element mapping
	String name
	String type
	String src
	String dst
	Integer length
	String new_type
	Element elem

	mapping = create_node()
	length = string_len(retyping_key)

	second_keys = create_node()

	Element reverse
	reverse = make_reverse_dictionary(src_model["model"])

	keys = dict_keys(src_model["model"])
	while (read_nr_out(keys) > 0):
		name = set_pop(keys)
		elem = src_model["model"][name]

		type = read_type(src_model, name)
		if (string_startswith(type, retyping_key)):
			new_type = string_substr(type, length, string_len(type))
			if (is_edge(elem)):
				// Is an edge, so potentially queue it
				String src
				String dst

				src = reverse[cast_id2s(read_edge_src(elem))]
				dst = reverse[cast_id2s(read_edge_dst(elem))]

				if (bool_and(dict_in(mapping, src), dict_in(mapping, dst))):
					// All present, so create the link between them
					dict_add_fast(mapping, name, instantiate_link(dst_model, new_type, "", mapping[src], mapping[dst]))
				elif (bool_not(bool_or(set_in(keys, src), set_in(keys, dst)))):
					// Source/target not in the queue, but we need it to split!
					// This is an error as it indicates problems with links crossing different formalisms
					log("ERROR: source/target of link to be included is not included!")
					log("Source: " + src)
					log("  type: " + read_type(src_model, src))
					log("Destination: " + dst)
					log("  type: " + read_type(src_model, dst))
					log("For link: " + name)
					log("  type: " + type)
					return create_node()!
				else:
					// Still source or destination in the queue, so we wait for that
					set_add(second_keys, name)

			elif (has_value(elem)):
				// Has a value, so copy that as well
				dict_add_fast(mapping, name, instantiate_value(dst_model, new_type, "", elem))

			else:
				// Is a node
				dict_add_fast(mapping, name, instantiate_node(dst_model, new_type, ""))

		if (read_nr_out(keys) == 0):
			keys = second_keys
			second_keys = create_node()

	return dst_model!