-- @atlcompiler atl2006

module Create_propagation; 
create OUT : AMW from IN: AMW, left : MOF, right : MOF;


helper def: amwModel : AMW!MatchModel = OclUndefined;

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

helper def: methodName : String = 'Propagation weaving model';


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

helper context MOF!EModelElement def : isLeftME() : Boolean =
	MOF!EModelElement.allInstancesFrom('left')->exists(e | e = self);

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

helper context MOF!EModelElement def : isRight() : Boolean =
	if self.oclIsTypeOf(MOF!EClass) then
		MOF!EClass.allInstancesFrom('right')->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 context AMW!WElementRef def : getInstance (model : String): MOF!EModelElement =
	MOF!EModelElement.getInstanceById(model, self.ref);
	
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------


rule attribute_relationship {
	from --class to attribute links
		class_link : AMW!Equivalent,			
	    attr_link : AMW!Equivalent (	    	
	    	if class_link.left.element.getInstance('left').oclIsTypeOf(MOF!EClass) and
			   class_link.right.element.getInstance('right').oclIsTypeOf(MOF!EClass) and 			
	    	   attr_link.left.element.getInstance('left').oclIsTypeOf(MOF!EAttribute) and
	    	   attr_link.right.element.getInstance('right').oclIsTypeOf(MOF!EAttribute) then
			   if 
				 attr_link.left.element.getInstance('left').eContainingClass = class_link.left.element.getInstance('left') and
		  	     attr_link.right.element.getInstance('right').eContainingClass = class_link.right.element.getInstance('right') then
				    true
			   else
			   	 false
			   endif
			else
				false
			endif
			
	   )	
	using {
    	l_class : MOF!EModelElement = class_link.left.element.getInstance('left');
    	r_class : MOF!EModelElement = class_link.right.element.getInstance('right');
    	l_attribute : MOF!EModelElement = attr_link.left.element.getInstance('left');
    	r_attribute : MOF!EModelElement = attr_link.right.element.getInstance('right');	
   }
	to
	   out : AMW!PropagationEdge ( --class to attribute
	   	    propagation <- 	
			     1 / ( 
   			        r_class.eStructuralFeatures->size() *
 			        l_class.eStructuralFeatures->size()
				 ),				
	   		name <- '_CONTAINER_ATR_' + l_class.name+','+ r_class.name +'_'+ l_attribute.name +','+ r_attribute.name,
	   		outgoingLink <- class_link,
			incomingLink <- attr_link,
			model <- class_link.model
	   ) ,
	   out2 : AMW!PropagationEdge ( -- attribute to class
	   	    propagation <- 1.0,
	   		name <- '_OWNED_ATR_' +  l_attribute.name +','+ r_attribute.name + '_'+ l_class.name+','+ r_class.name ,
	   		incomingLink <- class_link,
			outgoingLink <- attr_link,
			model <- class_link.model
	   )
}

--rule reference_attribute_relationship {
--	from --class to attribute edtes
--	   l_class : MOF!EClass, l_reference : MOF!EReference,
--	   r_class : MOF!EClass, r_attribute : MOF!EAttribute (	   	
--	   		l_class.isLeft and r_class.isRight and
--			l_reference.isLeft and r_attribute.isRight and 
--			
--		   	l_reference.eContainingClass = l_class	and r_attribute.eContainingClass = r_class
--		)
--	to
--	   out : prop_g!Edge ( --class to attribute
--	   	    propagation <- 							
--   			       1/ 
--   			       (r_class.eStructuralFeatures->size() *
-- 			       l_class.eStructuralFeatures->size() ),	
--	   		name <- '_CONTAINER_' + l_class.name+','+ r_class.name +'_'+ l_reference.name +','+ r_attribute.name,
--	   		outgoingNode <-
--				thisModule.resolveTemp(
--					Tuple { left = l_class, right = r_class} ,'anode'),
--			incomingNode <- thisModule.resolveTemp(
--					Tuple { left = l_reference, right = r_attribute} ,'anode')				
--				   
--	   ) ,
--	   out2 : prop_g!Edge ( -- attribute to class
--	   	    propagation <- 1.0,
--	   		name <- '_OWNED_' +  l_reference.name +','+ r_attribute.name + '_'+ l_class.name+','+ r_class.name ,
--	   		incomingNode <- thisModule.resolveTemp(
--					Tuple { left = l_class, right = r_class} ,'anode'),
--			outgoingNode <- thisModule.resolveTemp(
--					Tuple { left = l_reference, right = r_attribute} ,'anode')
--	   )
--}
--
--
--rule attribute_reference_relationship {
--	from --class to attribute edtes
--	   l_class : MOF!EClass, l_attribute : MOF!EAttribute,
--	   r_class : MOF!EClass, r_reference : MOF!EReference (	   		
--	   		l_class.isLeft and r_class.isRight and
--			l_attribute.isLeft and r_reference.isRight and 			
--		   	l_attribute.eContainingClass  = l_class	and r_reference.eContainingClass = r_class
--		)
--	to
--	   out : prop_g!Edge ( --class to attribute
--	   	    propagation <- 				
--			     1 / ( 
--   			       r_class.eStructuralFeatures->size() *
-- 			       l_class.eStructuralFeatures->size() ),				     		
--			name <- '_CONTAINER_' + l_class.name+','+ r_class.name +'_'+ l_attribute.name +','+ r_reference.name,
--	   		outgoingNode <-
--				thisModule.resolveTemp(
--					Tuple { left = l_class, right = r_class} ,'anode'),
--			incomingNode <- thisModule.resolveTemp(
--					Tuple { left = l_attribute, right = r_reference} ,'anode')								   
--	   )  ,
--	   out2 : prop_g!Edge ( -- attribute to class
--	   	    propagation <- 1.0,
--	   		name <- '_OWNED_' +  l_attribute.name +','+ r_reference.name + '_'+ l_class.name+','+ r_class.name ,
--	   		incomingNode <- thisModule.resolveTemp(
--					Tuple { left = l_class, right = r_class} ,'anode'),
--			outgoingNode <- thisModule.resolveTemp(
--					Tuple { left = l_attribute, right = r_reference} ,'anode')
--	   )
--}
--
--

helper context MOF!EModelElement def : getLink (right : MOF!EModelElement): AMW!WLink =
	AMW!Equivalent.allInstancesFrom('IN')->
		select ( e | e.left.element.ref = self.__xmiID__ and right.__xmiID__ = e.right.element.ref)->first();

rule Reference_relationship {
	from --class to reference edges
	 	class_link : AMW!Equivalent,			
	    ref_link : AMW!Equivalent (
	    	if class_link.left.element.getInstance('left').oclIsTypeOf(MOF!EClass) and
			   class_link.right.element.getInstance('right').oclIsTypeOf(MOF!EClass) and 			
	    	   ref_link.left.element.getInstance('left').oclIsTypeOf(MOF!EReference) and
	    	   ref_link.right.element.getInstance('right').oclIsTypeOf(MOF!EReference) then
			   if 
				 ref_link.left.element.getInstance('left').eContainingClass = class_link.left.element.getInstance('left') and
		  	     ref_link.right.element.getInstance('right').eContainingClass = class_link.right.element.getInstance('right') then
				    true
			   else
			   	 false
			   endif
			else
				false
			endif			
	   )	
	using {
    	l_class : MOF!EModelElement = class_link.left.element.getInstance('left');
    	r_class : MOF!EModelElement = class_link.right.element.getInstance('right');
    	l_reference : MOF!EModelElement = ref_link.left.element.getInstance('left');
    	r_reference : MOF!EModelElement = ref_link.right.element.getInstance('right');	
		refers_link : AMW!WLink = l_reference.eReferenceType.getLink(r_reference.eReferenceType);
   }
	to	
--		out : AMW!PropagationEdge ( --class to reference  (class to class)
--	   	    propagation <- 					
--			 1 / 
--			  ( MOF!EReference.allInstances()->select (e | e.eReferenceType = r_reference.eReferenceType)->size() *
--  			    MOF!EReference.allInstances()->select (e | e.eReferenceType = l_reference.eReferenceType)->size() ),						
--	   		name <- '_REFERS_' + l_class.name+','+ r_class.name + '_' +
--							l_reference.eReferenceType.name + ',' + r_reference.eReferenceType.name,
--	   		outgoingLink <- class_link,
--			incomingLink <- refers_link,
--			model <- class_link.model			
--	   ),
--	   out2 : AMW!PropagationEdge ( -- reference to class
--	   	    propagation <- 1.0,
--	   		name <- '_REFERRED_' +  l_reference.eReferenceType.name +','+ r_reference.eReferenceType.name + '_'+ l_class.name+','+ r_class.name ,
--	   		incomingLink <- class_link,
--			outgoingLink <- refers_link,
--			model <- class_link.model
--	   ),	   
	   out_ref : AMW!PropagationEdge ( --class to reference
	   	    propagation <- 					
				1 / ( 
   			       r_class.eStructuralFeatures->size()  *
 			       l_class.eStructuralFeatures->size() ),												
	   		name <- '_CONTAINER_' + l_class.name+','+ r_class.name +'_'+ l_reference.name +','+ r_reference.name,
	   		outgoingLink <- class_link,
			incomingLink <- ref_link,
			model <- class_link.model
	   ),
	   out2_ref : AMW!PropagationEdge ( -- reference to class
	   	    propagation <- 1.0,
	   		name <- '_OWNED_' +  l_reference.name +','+ r_reference.name + '_'+ l_class.name+','+ r_class.name ,
	   		incomingLink <- class_link,
			outgoingLink <- ref_link,
			model <- class_link.model
	   ) 
--	   ,	   
--	   out_ref3 : AMW!PropagationEdge ( --reference points to class
--	   	    propagation <- 							
--				1 / ( 
--   			       r_class.eStructuralFeatures->size()  *
-- 			       l_class.eStructuralFeatures->size() ),	
--	   		name <- '_POINTS_' + l_class.name+','+ r_class.name +'_'+ l_reference.name +','+ r_reference.name,
--	   		outgoingLink <- ref_link,
--			incomingLink <- refers_link,
--			model <- class_link.model				   
--	   ),
--	   out3_ref : AMW!PropagationEdge ( -- reference to class
--	   	    propagation <- 1.0,
--	   		name <- '_POINTED_' +  l_reference.name +','+ r_reference.name + '_'+ l_class.name+','+ r_class.name ,
--	   		incomingLink <- ref_link,
--			outgoingLink <- refers_link,
--			model <- class_link.model
--	 )
}


------------------------------copied rules---------------------------------------------------

rule leftElement {
	from
		mmw : AMW!LeftElement
	to
		out : AMW!LeftElement (
			name <- mmw.name,
			element <- mmw.element
		)
}

rule rightElement {
	from
		mmw : AMW!RightElement
	to
		out : AMW!RightElement (
			name <- mmw.name,
			element <- mmw.element
		)
}

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

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 <- thisModule.methodName
		)
}

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 equivalentlink {
	from
		mmw : AMW!Equivalent
	to
		alink : AMW!Equivalent (			
			name <- mmw.name,
			model <- mmw.model,
			left <- mmw.left,
			right <- mmw.right,
			similarity <- mmw.similarity 
			)	
}