New matching transformation that creates a propagation model.
diff --git a/examples/amwExamples.xml b/examples/amwExamples.xml
index a83d3bb..d44b803 100644
--- a/examples/amwExamples.xml
+++ b/examples/amwExamples.xml
@@ -33,6 +33,18 @@
</amwExample>
<amwExample>
+ <shortName>Propagation model</shortName>
+ <name>Propagation model</name>
+ <sourceLink>libray/CreatePropagation.atl</sourceLink>
+ <description>
+ This transformation creates a propagation model that enables to execute the similarity flooding
+ algorithm. The propagation model defines the way the similarities are propagated, for example using
+ containment relationships or the inheritance tree.
+ </description>
+ <pubDate>19/10/2006</pubDate>
+ </amwExample>
+
+ <amwExample>
<shortName>Cardinality</shortName>
<name>Cardinality</name>
<docLink></docLink>
diff --git a/examples/library/CreatePropagation.atl b/examples/library/CreatePropagation.atl
new file mode 100644
index 0000000..ac81974
--- /dev/null
+++ b/examples/library/CreatePropagation.atl
@@ -0,0 +1,328 @@
+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
+ )
+}
