modelverse/bootstrap/object_operations.alc

include "primitives.alh"
include "conformance_scd.alh"
include "constructors.alh"

Element function allInstances(model_ai : Element, type_ai : Element):
	Element type_mapping_ai
	Element result_ai

	type_mapping_ai = dict_read(model_ai, "type_mapping")
	result_ai = create_node()

	Integer counter_ai
	counter_ai = 0

	Integer length_ai
	length_ai = read_nr_out(type_mapping_ai)

	Element edge_ai
	while (integer_lt(counter_ai, length_ai)):
		edge_ai = read_out(type_mapping_ai, counter_ai)
		if (element_eq(read_edge_dst(edge_ai), type_ai)):
			// Found an element of the specified type
			set_add(result_ai, read_edge_dst(read_out(edge_ai, 0)))
		counter_ai = integer_addition(counter_ai, 1)
	
	return result_ai

Element function allOutgoingAssociationInstances(model_aoai : Element, source_aoai : Element, assoc_aoai : Element):
	// Read out all outgoing edges of the model and select those that are typed by the specified association
	// TODO for some reason this crashes if allInstances is used!
	Integer length_aoai
	length_aoai = read_nr_out(source_aoai)

	Integer counter_aoai
	counter_aoai = 0

	Element result_aoai
	result_aoai = create_node()

	Element edge_aoai
	while (integer_lt(counter_aoai, length_aoai)):
		edge_aoai = read_out(source_aoai, counter_aoai)
		if (element_eq(dict_read_node(dict_read(model_aoai, "type_mapping"), edge_aoai), assoc_aoai)):
			set_add(result_aoai, edge_aoai)
		counter_aoai = integer_addition(counter_aoai, 1)
	return result_aoai

Element function allIncomingAssociationInstances(model_aiai : Element, source_aiai : Element, assoc_aiai : Element):
	// Read out all outgoing edges of the model and select those that are typed by the specified association
	Element result_aiai
	result_aiai = create_node()
	Element allinsts_aiai
	allinsts_aiai = allInstances(model_aiai, assoc_aiai)

	Element understudy_aiai
	while (integer_lt(0, read_nr_out(allinsts_aiai))):
		understudy_aiai = set_pop(allinsts_aiai)
		if (element_eq(read_edge_dst(understudy_aiai), source_aiai)):
			set_add(result_aiai, understudy_aiai)
	return result_aiai

Element function readElementByName(model_rebn : Element, name_rebn : String):
	return dict_read(dict_read(model_rebn, "model"), name_rebn)

Element function findAttribute(source_fa : Element, attr_name_fa : Element, types_fa : Element, inheritance_link_fa : Element):
	if (dict_in(source_fa, attr_name_fa)):
		return dict_read_edge(source_fa, attr_name_fa)
	else:
		Integer counter_fa
		Integer i_fa
		Element edge_fa
		counter_fa = read_nr_out(source_fa)
		i_fa = 0
		while (integer_lt(i_fa, counter_fa)):
			edge_fa = read_out(source_fa, i_fa)
			if (element_eq(dict_read_node(types_fa, edge_fa), inheritance_link_fa)):
				return find_attribute(read_edge_dst(edge_fa), attr_name_fa, types_fa, inheritance_link_fa)
			i_fa = integer_addition(i_fa, 1)
		// No return at the moment, as this crashes the MvK
		log("ERROR: could not find attribute")

Element function readAttribute(model_ra : Element, source_ra : Element, attr_name_ra : String):
	// Read out the edge we are talking about
	Element edge_ra
	edge_ra = findAttribute(dict_read_node(dict_read(model_ra, "type_mapping"), source_ra), attr_name_ra, dict_read(model_ra, "type_mapping"), dict_read(model_ra, "inheritance"))

	return read_edge_dst(set_pop(allOutgoingAssociationInstances(model_ra, source_ra, edge_ra)))

Element function setAttribute(model_sa : Element, source_sa : Element, attr_name_sa : String, value_sa : Element):
	// Read out which edge we are talking about
	Element edge_sa
	edge_sa = deleteAttribute(model_sa, source_sa, attr_name_sa)

	// Now make the element
	Element created_edge_sa
	created_edge_sa = create_edge(source_sa, value_sa)
	dict_add(dict_read(model_sa, "type_mapping"), created_edge_sa, edge_sa)
	dict_add(dict_read(model_sa, "type_mapping"), value_sa, read_edge_dst(edge_sa))
	add_to_model(model_sa, "", value_sa)
	add_to_model(model_sa, "", created_edge_sa)

	return True

Element function deleteAttribute(model_da : Element, source_da : Element, attr_name_da : Element):
	Element edge_da
	edge_da = findAttribute(dict_read_node(dict_read(model_da, "type_mapping"), source_da), attr_name_da, dict_read(model_da, "type_mapping"), dict_read(model_da, "inheritance"))

	Element found_elements_da
	found_elements_da = allOutgoingAssociationInstances(model_da, source_da, edge_da)

	Element rm_element_da
	if (integer_gt(list_len(found_elements_da), 0)):
		rm_element_da = read_edge_dst(set_pop(found_elements_da))
		dict_delete(dict_read(model_da, "type_mapping"), rm_element_da)
		delete_element(rm_element_da)

	return edge_da

Element function getAttributeList(model_gali : Element, mm_gali : Element):
	Element result_gali
	result_gali = create_node()
	// Get all outgoing "dictionary" links
	Element set_gali_own
	set_gali_own = dict_keys(mm_gali)

	// Filter them
	Element e_gali
	while (integer_lt(0, read_nr_out(set_gali_own))):
		e_gali = set_pop(set_gali_own)
		if (type_eq(typeof(e_gali), String)):
			if (type_eq(typeof(dict_read(mm_gali, e_gali)), Type)):
				// This is a primitive type, so add to the list
				dict_add(result_gali, e_gali, dict_read(mm_gali, e_gali))

	// And go up to the possible supertypes
	Element found_elements_gali
	found_elements_gali = allOutgoingAssociationInstances(model_gali, mm_gali, dict_read(model_gali, "inheritance"))
	Element dict_gali_super
	Integer i_gali
	Integer max_gali
	Element set_gali_super
	Element found_key_gali
	while (integer_lt(0, read_nr_out(found_elements_gali))):
		// Now find the destination of these associations, which are the superclasses of this model
		dict_gali_super = getAttributeList(model_gali, read_edge_dst(set_pop(found_elements_gali)))
		set_gali_super = dict_keys(dict_gali_super)
		// Merge the two
		while (integer_lt(0, read_nr_out(set_gali_super))):
			found_key_gali = set_pop(set_gali_super)
			dict_add(result_gali, found_key_gali, dict_read(dict_gali_super, found_key_gali))

	return result_gali

Element function getInstantiatableAttributes(model_gili : Element, element_gili : Element):
	Element result_gili
	result_gili = create_node()
	// Get all outgoing "dictionary" links
	Element set_gili_own
	set_gili_own = dict_keys(element_gili)

	// Filter them
	Element e_gili
	while (integer_lt(0, read_nr_out(set_gili_own))):
		e_gili = set_pop(set_gili_own)
		if (bool_and(type_eq(typeof(e_gili), String), type_eq(typeof(dict_read(element_gili, e_gili)), Type))):
			// This is a primitive type, so add to the list
			dict_add(result_gili, e_gili, dict_read(element_gili, e_gili))

	return result_gili

String function getName(m : Element, e : Element):
	Element element_keys
	Element s
	s = dict_read(m, "model")
	element_keys = dict_keys(s)

	while (integer_lt(0, read_nr_out(element_keys))):
		Element key
		key = set_pop(element_keys)
		if (element_eq(dict_read_node(s, key), e)):
			return key

	return string_join(string_join("(unknown: ", cast_e2s(e)), " )")

String function reverseNameLookup(s_rnl : Element, e_rnl : Element):
	Element element_keys_rnl
	element_keys_rnl = dict_keys(s_rnl)

	while (integer_lt(0, read_nr_out(element_keys_rnl))):
		Element key_rnl
		key_rnl = set_pop(element_keys_rnl)
		if (element_eq(dict_read_node(s_rnl, key_rnl), e_rnl)):
			return key_rnl

	return string_join(string_join("(unknown: ", cast_e2s(e_rnl)), " )")