-- @atlcompiler emftvm
-- @nsURI UML2=http://www.eclipse.org/uml2/3.0.0/UML
-- $Id$
-- Prunes superfluous elements from a CompatibilityReport UML2 model.
--
module UML2CRPrune;

create OUT : UML2		-- The pruned compatibility report model
from IN : UML2; 		-- The input compatibility report model

uses UML2Copy;

-- ======================================================================
-- context helper attributes begin
-- ======================================================================

-- ------------------------ mustCopy ------------------------------------

helper context OclAny def : mustCopy : Boolean =
	let owner : OclAny = self.refImmediateComposite() in
	owner.oclIsUndefined() or owner.mustCopy;

helper context UML2!"uml::Model" def : mustCopy : Boolean =
	true;

helper context UML2!"uml::Package" def : mustCopy : Boolean =
	if self.isMissing or self.isIncompatible or self.hasReferredTypes then 
		true
	else
		false.debug('Pruned ' + self.qualifiedName)
	endif;

helper context UML2!"uml::Classifier" def : mustCopy : Boolean =
	if self.isMissing or self.isIncompatible or self.isReferred or self.hasReferredTypes then
		true
	else
		false.debug('Pruned ' + self.qualifiedName)
	endif;

helper context UML2!"uml::Operation" def : mustCopy : Boolean =
	self.isMissing;

helper context UML2!"uml::Property" def : mustCopy : Boolean =
	self.isMissing;

helper context UML2!"uml::Dependency" def : mustCopy : Boolean =
	self.isMissing;

helper context UML2!"uml::Generalization" def : mustCopy : Boolean =
	self.isMissing;

-- ------------------------ isMissing -----------------------------------

helper context UML2!"uml::Element" def : isMissing : Boolean =
	not self.getAppliedStereotype('CompatibilityReport::Missing').oclIsUndefined();

helper context UML2!"uml::Parameter" def : isMissing : Boolean =
	self.owner.isMissing;

-- ------------------------ isIncompatible ------------------------------

helper context UML2!"uml::Element" def : isIncompatible : Boolean =
	not self.getAppliedStereotype('CompatibilityReport::Incompatible').oclIsUndefined();

-- ------------------------ isReferred ----------------------------------

helper context UML2!"uml::Element" def : isReferred : Boolean =
	false;

helper context UML2!"uml::Classifier" def : isReferred : Boolean =
	thisModule.allElements
	->exists(e | e.isMissing and e.refersToType(self));

-- ------------------------ hasReferredTypes ----------------------------

helper context UML2!"uml::Element" def : hasReferredTypes : Boolean =
	false;

helper context UML2!"uml::Package" def : hasReferredTypes : Boolean =
	self.packagedElement
	->exists(e|e.isReferred or e.hasReferredTypes);

helper context UML2!"uml::Class" def : hasReferredTypes : Boolean =
	self.nestedClassifier
	->exists(e|e.isReferred);

helper context UML2!"uml::Interface" def : hasReferredTypes : Boolean =
	self.nestedClassifier
	->exists(e|e.isReferred);

-- ======================================================================
-- context-free helper attributes begin
-- ======================================================================

helper def : allElements : Set(UML2!"uml::Element") =
	UML2!"uml::Element".allInstancesFrom('IN')->asSet();

-- ======================================================================
-- helper attributes end
-- ======================================================================

-- ======================================================================
-- helper methods begin
-- ======================================================================

-- ------------------------ refersToType --------------------------------

helper context UML2!"uml::Element" def : refersToType(type : UML2!"uml::Type") : Boolean =
	false;

helper context UML2!"uml::Property" def : refersToType(type : UML2!"uml::Type") : Boolean =
	self.type = type;

helper context UML2!"uml::Parameter" def : refersToType(type : UML2!"uml::Type") : Boolean =
	self.type = type;

helper context UML2!"uml::Generalization" def : refersToType(type : UML2!"uml::Type") : Boolean =
	self.general = type;

helper context UML2!"uml::InterfaceRealization" def : refersToType(type : UML2!"uml::Type") : Boolean =
	self.contract = type;

-- ======================================================================
-- helper methods end
-- ======================================================================

-- ======================================================================
-- transformation rules begin
-- ======================================================================

rule Model {
    from s : UML2!"uml::Model" in IN (s.mustCopy)
    to t : UML2!"uml::Model" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        viewpoint <- s.viewpoint,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        packageMerge <- s.packageMerge,
        packagedElement <- s.packagedElement->select(p|p.mustCopy),
        profileApplication <- s.profileApplication)
}

rule Package {
    from s : UML2!"uml::Package" in IN (s.oclIsTypeOf(UML2!"uml::Package") and s.mustCopy)
    to t : UML2!"uml::Package" (
        __xmiID__ <- s.__xmiID__,
        name <- s.name,
        visibility <- s.visibility,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency,
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        packageMerge <- s.packageMerge,
        packagedElement <- s.packagedElement->select(p|p.mustCopy),
        profileApplication <- s.profileApplication)
}

rule Class {
    from s : UML2!"uml::Class" in IN (s.oclIsTypeOf(UML2!"uml::Class") and s.mustCopy)
    to t : UML2!"uml::Class" (
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        isActive <- s.isActive,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency->select(c|c.isMissing),
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute->select(a|a.mustCopy),
        ownedConnector <- s.ownedConnector,
        ownedBehavior <- s.ownedBehavior,
        classifierBehavior <- s.classifierBehavior,
        interfaceRealization <- s.interfaceRealization->select(c|c.isMissing),
        ownedTrigger <- s.ownedTrigger,
        nestedClassifier <- s.nestedClassifier->select(c|c.mustCopy),
        ownedOperation <- s.ownedOperation->select(o|o.mustCopy),
        ownedReception <- s.ownedReception)
}

rule Interface {
    from s : UML2!"uml::Interface" (s.mustCopy)
    to t : UML2!"uml::Interface" (
        name <- s.name,
        visibility <- s.visibility,
        isLeaf <- s.isLeaf,
        isAbstract <- s.isAbstract,
        eAnnotations <- s.eAnnotations,
        ownedComment <- s.ownedComment,
        clientDependency <- s.clientDependency->select(c|c.isMissing),
        nameExpression <- s.nameExpression,
        elementImport <- s.elementImport,
        packageImport <- s.packageImport,
        ownedRule <- s.ownedRule,
        templateParameter <- s.templateParameter,
        templateBinding <- s.templateBinding,
        ownedTemplateSignature <- s.ownedTemplateSignature,
        generalization <- s.generalization,
        powertypeExtent <- s.powertypeExtent,
        redefinedClassifier <- s.redefinedClassifier,
        substitution <- s.substitution,
        representation <- s.representation,
        collaborationUse <- s.collaborationUse,
        ownedUseCase <- s.ownedUseCase,
        useCase <- s.useCase,
        ownedAttribute <- s.ownedAttribute->select(a|a.mustCopy),
        ownedOperation <- s.ownedOperation->select(o|o.mustCopy),
        nestedClassifier <- s.nestedClassifier->select(c|c.mustCopy),
        redefinedInterface <- s.redefinedInterface,
        ownedReception <- s.ownedReception,
        protocol <- s.protocol)
}

endpoint rule Result() {
	do {
		thisModule.allElements
			->select(e|e.oclIsKindOf(UML2!"uml::PackageableElement") and e.mustCopy)
			->reject(p|p.owner.oclIsUndefined())
			->isEmpty().debug('Empty pruned model');
	}
}

-- ======================================================================
-- transformation rules end
-- ======================================================================