modelverse/bootstrap/conformance_scd.alc

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

Element function set_copy(a : Element):
	Element b
	Integer i
	Integer count

	b = create_node()
	i = 0
	count = read_nr_out(a)

	while (i < count):
		set_add(b, read_edge_dst(read_out(a, i)))
		i = i + 1

	return b

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

Boolean function is_nominal_instance(model : Element, instance : String, type : String):
	if (bool_not(dict_in(model["metamodel"]["model"], type))):
		// type is not even in the specified metamodel, so this will never work
		return False

	if (bool_and(is_edge(model["metamodel"]["model"][type]), bool_not(is_edge(model["model"][instance])))):
		// type is an edge, but we aren't
		return False

	if (bool_not(dict_in_node(model["type_mapping"], model["model"][instance]))):
		// doesn't even have a type
		return False

	return is_nominal_subtype(model["metamodel"], reverseKeyLookup(model["metamodel"]["model"], dict_read_node(model["type_mapping"], model["model"][instance])), type)

Boolean function is_nominal_subtype(metamodel : Element, subclass : String, superclass : String):
	if (element_eq(metamodel["model"][subclass], metamodel["model"][superclass])):
		return True

	if (bool_not(dict_in(metamodel["model"], subclass))):
		return False

	if (bool_not(dict_in(metamodel["model"], superclass))):
		return False

	return set_in(get_superclasses(metamodel, subclass), superclass)

Element function precompute_cardinalities(model : Element):
	Integer slc
	Integer suc
	Integer tlc
	Integer tuc
	String key
	Element tmp_dict
	Element cardinalities
	Element keys
	Element metamodel

	metamodel = model["metamodel"]
	keys = allInstances(metamodel, "Association")

	cardinalities = create_node()
	while (0 < list_len(keys)):
		key = set_pop(keys)
		tmp_dict = create_node()
		slc = read_attribute(metamodel, key, "source_lower_cardinality")
		suc = read_attribute(metamodel, key, "source_upper_cardinality")
		tlc = read_attribute(metamodel, key, "target_lower_cardinality")
		tuc = read_attribute(metamodel, key, "target_upper_cardinality")

		if (element_neq(slc, read_root())):
			dict_add(tmp_dict, "slc", slc)
		if (element_neq(suc, read_root())):
			dict_add(tmp_dict, "suc", suc)
		if (element_neq(tlc, read_root())):
			dict_add(tmp_dict, "tlc", tlc)
		if (element_neq(tuc, read_root())):
			dict_add(tmp_dict, "tuc", tuc)

		if (list_len(tmp_dict) > 0):
			dict_add(cardinalities, key, tmp_dict)

	return cardinalities

String function conformance_scd(model : Element):
	// Initialization
	Element keys
	Element metamodel
	Element typing
	String model_name
	String src_model
	String dst_model
	String src_metamodel
	String dst_metamodel
	Element element
	Element check_list
	String check_type
	Element cardinalities
	Element scd
	Integer instances
	String type_name
	Element spo_cache
	Element spi_cache

	spo_cache = create_node()
	spi_cache = create_node()

	// Load in variables
	scd = import_node("models/SimpleClassDiagrams")
	metamodel = model["metamodel"]
	typing = model["type_mapping"]


	// Create dictionary with all associations and allowed cardinalities
	if (list_len(model["model"]) > 0):
		cardinalities = precompute_cardinalities(model)

		// Iterate over each element of the model, finding out whether everything is fine
		keys = dict_keys(model["model"])
		while (0 < list_len(keys)):
			model_name = set_pop(keys)
			element = model["model"][model_name]
			type_name = reverseKeyLookup(metamodel["model"], dict_read_node(typing, element))
			log((("Check " + model_name) + " : ") + type_name)

			if (bool_not(dict_in_node(typing, element))):
				return "Model has no type specified: " + model_name

			if (bool_not(set_in_node(metamodel["model"], dict_read_node(typing, element)))):
				return "Type of element not in specified metamodel: " + model_name

			// This is true by definition of is_nominal_instance
			//if (bool_not(is_nominal_instance(model, model_name, type_name))):
			//	return "Element is not an instance of its specified type: " + model_name

			if (is_edge(element)):
				src_model = reverseKeyLookup(model["model"], read_edge_src(element))
				dst_model = reverseKeyLookup(model["model"], read_edge_dst(element))
				src_metamodel = reverseKeyLookup(metamodel["model"], read_edge_src(dict_read_node(typing, element)))
				dst_metamodel = reverseKeyLookup(metamodel["model"], read_edge_dst(dict_read_node(typing, element)))

				if (bool_not(is_nominal_instance(model, src_model, src_metamodel))):
					return "Source of model edge not typed by source of type: " + model_name

				if (bool_not(is_nominal_instance(model, dst_model, dst_metamodel))):
					return "Destination of model edge not typed by source of type: " + model_name

			// Check cardinality for all of our edges
			//
			//      SLC..SUC     TLC..TUC
			//   A  ---------------------> B
			//
			// First the incoming, so we are at B in the above figure
			if (bool_not(dict_in(spo_cache, type_name))):
				log("Fill SPO cache")
				dict_add(spo_cache, type_name, selectPossibleOutgoing(metamodel, type_name, dict_keys(cardinalities)))
				log("Filled SPO cache")

			check_list = set_copy(spo_cache[type_name])
			while (0 < list_len(check_list)):
				check_type = set_pop(check_list)
				if (dict_in(cardinalities, check_type)):
					// Cardinalities defined for this association, so check them
					if (bool_or(dict_in(cardinalities[check_type], "tlc"), dict_in(cardinalities[check_type], "tuc"))):
						instances = list_len(allOutgoingAssociationInstances(model, model_name, check_type))
						if (dict_in(cardinalities[check_type], "tlc")):
							// A lower cardinality was defined at the target
							if (integer_gt(cardinalities[check_type]["tlc"], instances)):
								log("Instances: " + cast_i2s(instances))
								log("Cardinalities: " + cast_i2s(cardinalities[check_type]["tuc"]))
								log("Type: " + check_type)
								return "Lower cardinality violation for outgoing edge at " + model_name
						if (dict_in(cardinalities[check_type], "tuc")):
							// An upper cardinality was defined at the target
							if (integer_lt(cardinalities[check_type]["tuc"], instances)):
								log("Instances: " + cast_i2s(instances))
								log("Cardinalities: " + cast_i2s(cardinalities[check_type]["tuc"]))
								log("Type: " + check_type)
								return "Upper cardinality violation for outgoing edge at " + model_name

			// Identical, but for outgoing, and thus for A in the figure
			if (bool_not(dict_in(spi_cache, type_name))):
				log("Fill SPI cache")
				dict_add(spi_cache, type_name, selectPossibleIncoming(metamodel, type_name, dict_keys(cardinalities)))
				log("Filled SPI cache")

			check_list = set_copy(spi_cache[type_name])
			while (0 < list_len(check_list)):
				check_type = set_pop(check_list)
				if (dict_in(cardinalities, check_type)):
					// Cardinalities defined for this association, so check them
					if (bool_or(dict_in(cardinalities[check_type], "slc"), dict_in(cardinalities[check_type], "suc"))):
						instances = list_len(allIncomingAssociationInstances(model, model_name, check_type))
						if (dict_in(cardinalities[check_type], "slc")):
							// A lower cardinality was defined at the source
							if (integer_gt(cardinalities[check_type]["slc"], instances)):
								log("Instances: " + cast_i2s(instances))
								log("Cardinalities: " + cast_i2s(cardinalities[check_type]["tuc"]))
								log("Type: " + check_type)
								return "Lower cardinality violation for incoming edge at " + model_name
						if (dict_in(cardinalities[check_type], "suc")):
							// An upper cardinality was defined at the source
							if (integer_lt(cardinalities[check_type]["suc"], instances)):
								log("Instances: " + cast_i2s(instances))
								log("Cardinalities: " + cast_i2s(cardinalities[check_type]["tuc"]))
								log("Type: " + check_type)
								return "Upper cardinality violation for incoming edge at " + model_name

			Element constraint_function
			constraint_function = read_attribute(metamodel, reverseKeyLookup(metamodel["model"], dict_read_node(typing, element)), "constraint")
			if (element_neq(constraint_function, read_root())):
				String result
				result = constraint_function(model, model_name)
				if (result != "OK"):
					return result

	// Check multiplicities, if they are defined (optional)
	Element metamodel_keys
	String metamodel_element
	Integer attr_value

	metamodel_keys = dict_keys(metamodel["model"])
	while (0 < list_len(metamodel_keys)):
		metamodel_element = set_pop(metamodel_keys)

		// Lower multiplicities
		attr_value = read_attribute(metamodel, metamodel_element, "lower_cardinality")
		if (element_neq(attr_value, read_root())):
			// We have defined a lower cardinality, so check number of instances!
			if (attr_value > list_len(allInstances(model, metamodel_element))):
				return "Lower cardinality violated for class: " + metamodel_element

		// Upper multiplicities
		attr_value = read_attribute(metamodel, metamodel_element, "upper_cardinality")
		if (element_neq(attr_value, read_root())):
			// We have defined a lower cardinality, so check number of instances!
			if (attr_value < list_len(allInstances(model, metamodel_element))):
				return "Upper cardinality violated for class: " + metamodel_element

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

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 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:
			dict_add(tm, elem, mm["Node"])

	return model