| -- @atlcompiler atl2006 |
| |
| module SF; |
| 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 = 'Similarity flooding'; |
| |
| |
| --------------------------------------------------------------------------------------------------- |
| ---------------------- 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); |
| |
| |
| ---------------------------------------------------------------------------------------- |
| ------------------------------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 Edge { |
| from |
| mmw : AMW!PropagationEdge |
| to |
| edge : AMW!PropagationEdge ( |
| name <- mmw.name, |
| model <- mmw.model, |
| incomingLink <- mmw.incomingLink, |
| outgoingLink <- mmw.outgoingLink, |
| propagation <- mmw.propagation |
| ) |
| } |
| |
| --------------------------------end copied rules------------------------------------- |
| ---------------------------------------------------------------------------------------- |
| ---------------------------------------------------------------------------------------- |
| |
| helper def: aTuple : TupleType(value : Real, count : Integer) = Tuple {value = 0, count = 0}; |
| |
| |
| rule PropagationRule { |
| from |
| mmw : AMW!Equivalent |
| to |
| alink : AMW!Equivalent ( |
| name <- mmw.name, |
| model <- mmw.model, |
| left <- mmw.left, |
| right <- mmw.right |
| ) |
| do { |
| -- all the propagation of neighbors nodes |
| thisModule.aTuple <- AMW!PropagationEdge.allInstancesFrom('IN')-> |
| select ( e | Set { e.incomingLink.left, e.incomingLink.right} = |
| Set {mmw.left, mmw.right} )-> |
| iterate (e1; acc : TupleType(value : Real, count : Integer) = Tuple {value = 0, count = 0} | |
| Tuple { |
| value = acc.value + (e1.outgoingLink.similarity * e1.propagation), |
| count = acc.count + 1 |
| } |
| ); |
| if (thisModule.aTuple.count = 0 ) { |
| alink.similarity <- mmw.similarity; |
| }else { |
| alink.similarity <- (mmw.similarity + thisModule.aTuple.value / thisModule.aTuple.count); |
| } |
| } |
| } |