modelverse/bootstrap/conformance_scd.alc

include "primitives.alh"
include "library.alh"
include "object_operations.alh"
include "constructors.alh"

Element function set_copy(elem_to_copy : Element):
	Element result
	Integer i
	Integer max

	result = create_node()

	// Expand the provided list by including all elements that need to be checked
	i = 0
	max = read_nr_out(elem_to_copy)
	while (i < max):
		set_add(result, read_edge_dst(read_out(elem_to_copy, i)))
		i = i + 1

	return result

Boolean function is_direct_instance(model : Element, instance : Element, type : Element):
	// Just check whether or not the type mapping specifies the type as the type of the instance
	return dict_read_node(model["type_mapping"], instance) == type

Boolean function is_nominal_instance(model : Element, instance : Element, type : Element):
	return is_nominal_subtype(type, dict_read_node(model["type_mapping"], instance), model["metamodel"]["type_mapping"], model["inheritance"])

Boolean function is_nominal_subtype(superclass : Element, subclass : Element, types : Element, inheritance_link : Element):
	Integer counter
	Integer i
	Element edge
	Element destination

	// End of recursion
	if (superclass == subclass):
		return True

	// Iterate over all superclasses of the found class
	counter = read_nr_out(subclass)
	i = 0
	while (i < counter):
		edge = read_out(subclass, i)
		// Check if it even has a type (to prevent errors)
		if (dict_in_node(types, edge)):
			// Check whether it is an inheritance edge, as there is no other distinction between them
			if (dict_read_node(types, edge) == inheritance_link):
				// It is an inheritance edge, so follow it to its destination
				destination = read_edge_dst(edge)
				// Found a new superclass to test
				if (is_nominal_subtype(superclass, destination, types, inheritance_link)):
					return True
		i = i + 1
	
	// No link seems to have been found, so it is False
	return False

Boolean function is_structural_instance(model : Element, instance : Element, type : Element):
	return is_structural_subtype(dict_read_node(model["type_mapping"], instance), type)
	
Boolean function is_structural_subtype(subtype : Element, supertype : Element):
	// Determine whether it is just the exact type or not
	if (subtype == supertype):
		return True

	// Find all links that are required (name and type) from the specified type
	Element required_keys
	required_keys = dict_keys(supertype)
	Integer required_keys_len
	required_keys_len = dict_len(required_keys)

	String key
	Element equivalent
	Integer i
	i = 0

	// Go over all keys that we require
	while (i < required_keys_len):
		key = set_pop(required_keys)
		// Check whether they exist in the instance
		if (dict_in(subtype, key)):
			// Normally, we should still check whether they don't violate the constraints imposed on the class (i.e., are actually present)
			// For now, we ignore this and simply require that it is always there in the metamodel (not necessarily in the instance)
			// TODO

			// Still check whether the types match
			if (bool_not(is_structural_subtype(subtype[key], supertype[key]))):
				return False

			// All clear, so pass on to the next attribute
			i = i + 1
		else:
			return False

	// No violations found, so OK
	return True

String function conformance_scd(model : Element):
	// Initialization
	Element work_node
	Element model_src
	Element metamodel_src
	Element model_dst
	Element metamodel_dst
	Element models
	Element metamodels
	models = set_copy(model["model"])

	Element typing
	typing = model["type_mapping"]
	metamodels = set_copy(model["metamodel"]["model"])
	Element inheritance
	inheritance = model["metamodel"]["inheritance"]
	Element metamodel_typing
	metamodel_typing = model["metamodel"]["type_mapping"]

	// Iterate over all model elements and check if they are typed (in "typing") and their type is in the metamodel
	while (dict_len(models) > 0):
		work_node = set_pop(models)
		// Basic check: does the element have a type
		if (bool_not(dict_in_node(typing, work_node))):
			return "Model has no type specified: " + getName(model, work_node)

		// Basic check: is the type of the element part of the metamodel
		if (bool_not(set_in_node(metamodels, dict_read_node(typing, work_node)))):
			return "Type of element not in specified metamodel: " + getName(model, work_node)

		// For edges only: check whether the source is typed according to the metamodel
		if (is_edge(work_node)):
			model_src = read_edge_src(work_node)
			metamodel_src = read_edge_src(dict_read_node(typing, work_node))
			if (bool_not(is_nominal_instance(model, model_src, metamodel_src))):
				return "Source of model edge not typed by source of type: " + getName(model, work_node)

		// For edges only: check whether the destination is typed according to the metamodel
		if (is_edge(work_node)):
			model_dst = read_edge_dst(work_node)
			metamodel_dst = read_edge_dst(dict_read_node(typing, work_node))
			if (bool_not(is_nominal_instance(model, model_dst, metamodel_dst))):
				return "Destination of model edge not typed by destination of type: " + getName(model, work_node)

	// Structure seems fine, now do static semantics
	if (dict_in(model["metamodel"], "constraints")):
		Element constraint_function
		constraint_function = model["metamodel"]["constraints"]
		return constraint_function(model)
	else:
		return "OK"

Element function retype(model : Element, metamodel : Element, inheritance : Element, mapping : Element):
	if (dict_in(model, "type_mapping")):
		// Remove previous type mappings
		dict_delete(model, "type_mapping")
	if (dict_in(model, "metamodel")):
		// Remove the previous metamodel too, as this might change too
		dict_delete(model, "metamodel")
	if (dict_in(model, "inheritance")):
		// Remove the inheritance link too, as, yet again, this can vary
		dict_delete(model, "inheritance")
	
	// Start the new configuration of the metamodel and inheritance link, as well as set the new mapping relation
	dict_add(model, "metamodel", metamodel)
	dict_add(model, "inheritance", inheritance)
	dict_add(model, "type_mapping", mapping)

	return model

Element function add_to_model(model : Element, name : String, element : Element):
	if (name == ""):
		// No name desired
		dict_add(model["model"], "__" + cast_id2s(element), element)
	else:
		dict_add(model["model"], name, element)
	return element

Element function instantiate_bottom_node(model : Element, name : String):
	Element new_element
	new_element = create_node()
	return add_to_model(model, name, new_element)

Element function instantiate_bottom_value(model : Element, name : String, value : Element):
	Element new_element
	new_element = create_value(value)
	return add_to_model(model, name, new_element)

Element function instantiate_bottom_edge(model : Element, name : String, source : Element, target : Element):
	Element new_element
	new_element = create_edge(source, target)
	return add_to_model(model, name, new_element)

Element function set_model_constraints(model : Element, func : Element):
	if (dict_in(model, "constraints")):
		dict_delete(model, "constraints")
	dict_add(model, "constraints", func)
	return model

Element function instantiate_model_lib(model : Element, type : Element, name : String, optionals : Element, attribute_types : Element, attribute_instances : Element):
	Element new_element
	if (is_edge(type)):
		// Create a new edge from "optionals[0]" to "optionals[1]"
		new_element = instantiate_bottom_edge(model, name, list_read(optionals, 0), list_read(optionals, 1))
	else:
		if (typeof(type) == Type):
			new_element = instantiate_bottom_value(model, name, list_read(optionals, 0))
		else:
			new_element = instantiate_bottom_node(model, name)

	// Add it to the type mapping
	dict_add(model["type_mapping"], new_element, type)

	// Add all attribute types at this level
	Integer counter
	Integer max
	Element keys
	keys = dict_keys(attribute_types)
	counter = 0
	max = list_len(keys)

	Element attr_name
	Element attr_type
	Element created_attr
	Element created_edge
	Element metamodel
	metamodel = model["metamodel"]["model"]

	// For all new attributes
	while (counter < max):
		attr_name = set_pop(keys)
		attr_type = attribute_types[attr_name]

		created_attr = create_edge(new_element, attr_type)
		created_edge = create_edge(created_attr, attr_name)
		
		Element m
		Element tm
		m = model["model"]
		tm = model["type_mapping"]

		// Add it to the model
		dict_add(m, "__" + cast_id2s(attr_name), attr_name)
		dict_add(m, "__" + cast_id2s(attr_type), attr_type)
		dict_add(m, "__" + cast_id2s(created_attr), created_attr)
		dict_add(m, "__" + cast_id2s(created_edge), created_edge)

		// And add the typing
		dict_add(tm, attr_name, metamodel["__String"])
		dict_add(tm, attr_type, metamodel["Type"])
		dict_add(tm, created_attr, metamodel["Attribute"])
		dict_add(tm, created_edge, metamodel["__Name"])

		// Increase while loop counter
		counter = counter + 1

	// Similarly for instantiated attributes
	counter = 0
	keys = dict_keys(attribute_instances)
	max = list_len(keys)
	Element attr_definer_class
	Element attr_type_edge
	Element attr_value
	Element attr_edge

	while (counter < max):
		// Look it up
		attr_name = set_pop(keys)
		attr_value = attribute_instances[attr_name]
		attr_definer_class = find_attribute(type, attr_name, model["metamodel"]["type_mapping"], model["inheritance"])
		attr_type = attr_definer_class[attr_name]
		attr_type_edge = dict_read_edge(attr_definer_class, attr_name)
		attr_edge = create_edge(new_element, attr_value)

		// Add to model
		dict_add(model["model"], "__" + cast_id2s(attr_value), attr_value)
		dict_add(model["model"], "__" + cast_id2s(attr_edge), attr_edge)

		// Type the new elements
		dict_add(model["type_mapping"], attr_value, attr_type)
		dict_add(model["type_mapping"], attr_edge, attr_type_edge)

		counter = counter + 1

	return new_element

Element function instantiate_new_model(metamodel : Element, inheritance : Element):
	Element model
	model = create_node()
	dict_add(model, "model", create_node())
	dict_add(model, "type_mapping", create_node())
	dict_add(model, "metamodel", metamodel)
	dict_add(model, "inheritance", inheritance)
	return model

Element function generate_bottom_type_mapping(model : Element):
	Element mm
	mm = model["metamodel"]["model"]
	dict_delete(model, "type_mapping")
	Element tm
	tm = create_node()
	dict_add(model, "type_mapping", tm)
	
	// Iterate over every element
	Element elem_keys
	Element elem
	elem_keys = dict_keys(model["model"])
	while (0 < read_nr_out(elem_keys)):
		elem = model["model"][set_pop(elem_keys)]
		if (is_edge(elem)):
			dict_add(tm, elem, mm["Edge"])
		else:
			if (cast_v2s(elem) != "None"):
				dict_add(tm, elem, mm[cast_v2s(typeof(elem))])
			else:
				dict_add(tm, elem, mm["Node"])

	return model