examples/library/Link_rewriting.atl

-- @atlcompiler atl2006

module Link_rewriting; 
create OUT : AMW from LxR: AMW, left_model : MOF, right_model : MOF;


helper def: amwModel : AMW!MatchModel = OclUndefined;

helper def: listRef : Sequence(AMW!Element) = Sequence{};

---------------------------------------------------------------------------------------------------
---------------------- generic helpers used for auxiliar tasks-----------------------------------------------------------------------------

helper context MOF!EClass def : isLeft() : Boolean =
	MOF!EClass.allInstancesFrom('left_model')->exists(e | e = self);

helper context MOF!EModelElement def : isRight() : Boolean =
	if self.oclIsTypeOf(MOF!EClass) then
		MOF!EClass.allInstancesFrom('right_model')->exists(e | e = self)		
	else
		if self.oclIsKindOf(MOF!EStructuralFeature) then
			self.isRightsf()
		else
			false
		endif
	endif;

helper context MOF!EStructuralFeature def : isLeftsf() : Boolean =
	self.eContainingClass.isLeft();

helper context MOF!EStructuralFeature def : isRightsf() : Boolean =
	self.eContainingClass.isRight();

helper def : maxSim : Real = 0.0;

helper def : targetRef : AMW!Element = OclUndefined;


------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------


helper def : getMax(current : AMW!Equivalent, list : Sequence(AMW!Equivalent), max : AMW!Equivalent) : AMW!Equivalent =
	if current.oclIsUndefined() then
	   max
	else
	   thisModule.getMax(list->first(), list->subSequence(2, list->size()),  
	   	    if max.oclIsUndefined() then
			   current
			else			  	
		   		if current.similarity > max.similarity then
				    current
				else
					max
				endif	   
			endif
	   )		   
	endif;

rule matchmodel {
	from
		mmw: AMW!MatchModel 
	to
		model : AMW!MatchModel (
			name <- mmw.name,
			leftM <- mmw.leftM,
			rightM <- mmw.rightM,
			methods <- mmw.methods->union(Sequence{method})
		),
		method : AMW!Method (
			name <- 'Link rewriting'
		)
	do {
		thisModule.amwModel <- mmw;
	}
		
}

rule method {
	from
		mmw : AMW!Method
	to 
		method : AMW!Method (
			name <- mmw.name			
		)
}

rule modelref {
	from
		mmw : AMW!ModelRef
	to
		out : AMW!ModelRef (
			name <- mmw.name,
			ref <- mmw.ref
		)
}

rule ElementRefs {
	from
		mmw : AMW!ElementRef 		
	to
		out : AMW!ElementRef (			
			name <- mmw.name,
			ref <- mmw.ref,
			modelRef <- mmw.modelRef			
		)
}


rule classElementRef {
	from
		element : MOF!EClass (
			element.isLeft() 
		)
	using {
		links : Sequence(AMW!Equivalent) = AMW!Equivalent.allInstancesFrom('LxR')->select (e | e.left.element.ref = element.__xmiID__);
		link : AMW!Equivalent = thisModule.getMax(  links->first(), links->subSequence(2, links->size()), OclUndefined  );
		targetEl : OclAny = 
			AMW!RightElement.allInstances()->select(e | e.element.ref = link.right.element.ref)->first().element;			
	}				
	to
		left : AMW!Element (
			name <- element.name,
			element <- --out
			AMW!LeftElement.allInstances()->select(e | e.element.ref = element.__xmiID__)->first().element
			--AMW!MatchModel.allInstances()->first().leftM.allInstances()->select
		),
		right : AMW!Element (	
			element <- targetEl,
			name <- targetEl.name
		),
		wlink : AMW!ElementEqual (			
	    	left <- left,
			right <- right,
			model <- thisModule.amwModel,
			similarity <- link.similarity
	    )
}

rule AttributeElementRef {
	from
		element : MOF!EAttribute (element.isLeftsf())
	using {
		links : Sequence(AMW!Equivalent) = AMW!Equivalent.allInstancesFrom('LxR')->		
				select (e | e.left.element.ref = element.__xmiID__);
		link : AMW!Equivalent = thisModule.getMax(  
						links->first(), links->subSequence(2, links->size()), OclUndefined  );
		targetEl : OclAny = 
			AMW!RightElement.allInstances()->select(e | e.element.ref = link.right.element.ref)->first().element;
	}						
	to
		source : AMW!Element (
			name <- element.name,
			element <- 
			AMW!LeftElement.allInstances()->select(e | e.element.ref = element.__xmiID__)->first().element
			--out
		),
		target : AMW!Element (	
			element <- targetEl,
			name <- targetEl.name
		),
		alink : AMW!AttributeEqual (
	    	left <- source,
			right <- target,
			parent <- if thisModule.resolveTemp(element.eContainingClass,'wlink').oclIsUndefined() then
						OclUndefined 
					else
						thisModule.resolveTemp(element.eContainingClass,'wlink')
					endif,
			similarity <- link.similarity
	    )
}

rule ReferenceElementRef {
	from
		element : MOF!EReference (element.isLeftsf())
	using {
		links : Sequence(AMW!Equivalent) = AMW!Equivalent.allInstancesFrom('LxR')->
											select (e | e.left.element.ref = element.__xmiID__);
		link : AMW!Equivalent = thisModule.getMax(  links->first(), links->subSequence(2, links->size()), OclUndefined  );
		targetEl : OclAny = 
			AMW!RightElement.allInstances()->select(e | e.element.ref = link.right.element.ref)->first().element;
	}			
	to
		source : AMW!Element (
			name <- element.name,
			element <- AMW!LeftElement.allInstances()->select(e | e.element.ref = element.__xmiID__)->first().element
			--out
		),
		target : AMW!Element (	
			element <- targetEl,
			name <- targetEl.name
		),
		alink : AMW!ReferenceEqual (			
	    	left <- source,
			right <- target,
			parent <- thisModule.resolveTemp(element.eContainingClass,'wlink'),
			similarity <- link.similarity
	    )
}

endpoint rule NormalizeSimilarity() {
	using {
		max : Real = 0;
		curr : Real = 0;
		list : Sequence (AMW!Equal) = Sequence{};
		first : OclAny = OclUndefined;
	}
	do {
		for(e in AMW!Equal.allInstancesFrom('OUT')) {
			if(e.similarity > max) {
				max <- e.similarity;
			}
		}
		if(max > 0) {
			for(e in AMW!Equal.allInstancesFrom('OUT')) {
				e.similarity <- e.similarity / max;
			}
		}
	}
}