tests/org.eclipse.m2m.tests.qvt.oml/unparserTestData/sources/mapDisjuncts/mapDisjuncts.qvto

modeltype ECORE uses 'http://www.eclipse.org/emf/2002/Ecore';

transformation mapDisjuncts(in inModel : ECORE, out outModel : ECORE);
 
main() {
	var root := object EPackage { name := 'root' };

	var a := object EAttribute {  name := 'aSrc'; };
	var aResult := a.map disjunctMapping('aSrc_disjunctMapping');	
	-- trace records for disjuncting mappings explicitly enabled for bug 377882 	
	assert fatal (null <> a.resolveoneIn(ENamedElement::disjunctMapping, ETypedElement));
	assert fatal (null <> a.resolveoneIn(EAttribute::disjunctedMapping1, ETypedElement));	
		
	var p := object EParameter {  name := 'pSrc'; };
	var pResult := p.map disjunctMapping('pSrc_disjunctMapping');
	-- trace records for disjuncting mappings explicitly enabled for bug 377882
	assert fatal (null <> p.resolveoneIn(ENamedElement::disjunctMapping, ETypedElement));	
	assert fatal (null <> p.resolveoneIn(EParameter::disjunctedMapping2, ETypedElement));
	
	var container := object EAnnotation {
		source := 'testResult';
		contents += a.oclAsType(EObject);
		contents += aResult.oclAsType(EObject);	
		contents += p.oclAsType(EObject);
		contents += pResult.oclAsType(EObject);
	};	
	root.eAnnotations += container;
	
	var a1 := a.map chainedDisjunctMapping('a1_chained');
	assert fatal (a1.oclIsKindOf(EAttribute)); 
	container.contents += a1.oclAsType(EObject);
	
	var p1 := p.map chainedDisjunctMapping('p1_chained');
	assert fatal (p1.oclIsKindOf(EParameter));
	container.contents += p1.oclAsType(EObject);
	
	var c1Src := object EClass { name := 'c1Src'; };
	container.contents += c1Src.oclAsType(EObject);
	var c1 := c1Src.map chainedDisjunctMapping('c1_chained');
 	assert fatal (c1.oclIsKindOf(EReference));
 	container.contents += c1.oclAsType(EObject);
 	
	-- trace fetch should work too
 	assert fatal (c1 = c1Src.map chainedDisjunctMapping('c1_chained'));
 	
 	-- check failed pre-condition (when clause)
	var wrongSrc := object EClass { 
		name := null; -- causing precondition to fail 
	};
	container.contents += wrongSrc.oclAsType(EObject);			 	
	var redirectedMappingResult := wrongSrc.map chainedDisjunctMapping('c1_chained');
	assert fatal (redirectedMappingResult.oclIsKindOf(EAnnotation));
	container.contents += redirectedMappingResult.oclAsType(EObject);
	-- just correcting the precondition should make it work	
	-- check succeeded pre-condition (when clause)
	wrongSrc := object EClass { 
		name := 'x'; -- causing precondition to succeed 
	};
	container.contents += wrongSrc.oclAsType(EObject);
	var wrongSrcCorrectedResult := wrongSrc.map chainedDisjunctMapping('c1_chained');
	assert fatal (wrongSrcCorrectedResult <> null);
	wrongSrc.eStructuralFeatures += wrongSrcCorrectedResult.oclAsType(EReference);

	-- hides toEClass as the first mapping is type conformant, but
	-- when called the no disjunct is applicable and returns null
	var annotResult := c1Src.map chainedDisjunctMappingHideToEReference('$');
	assert fatal(annotResult.oclIsKindOf(EAnnotation));
	container.contents += annotResult.oclAsType(EObject);

	var pp := p1.invresolveone(EParameter).map chainedDisjunctMappingHideToEReference('$');	
	assert fatal(pp.oclIsKindOf(EParameter));
	container.contents += pp.oclAsType(EObject);
	
	-- test self with inout 
	c1Src._abstract := false; 
	var inoutResult := c1Src.map inoutSimpleDisjunct();
	assert fatal (null = inoutResult and not c1Src.containsAnnotation('EClass::inoutWithConditionDisjuncted'));

	c1Src._abstract := true;
	inoutResult := c1Src.map inoutSimpleDisjunct();	
	assert fatal (inoutResult = null and c1Src.containsAnnotation('EClass::inoutWithConditionDisjuncted'));
	
	
	assert fatal (null = root.map fooDisjuncting(null));
	assert fatal (root.map fooDisjuncting(root).oclIsTypeOf(EPackage));	
}


mapping inout EModelElement::fooDisjuncting(inout p : EPackage) : EPackage
	disjuncts EPackage::fooDisjuncted when { p <> null } 
{
	name := 'EObject::fooDisjuncting'; -- not executed
}

mapping inout EPackage::fooDisjuncted(inout p_Renamed : EPackage) : EPackage {
	init {
		assert fatal (p_Renamed <> null) with log('never execute here for p=', p_Renamed);
	}
	population {
		object result: {
			name := 'EObject::fooDisjuncting'; -- not executed
		};
		object p_Renamed: {
			eSubpackages += result;
		}
	}
}

 

abstract mapping EModelElement::chainedDisjunctMapping(in strPar1 : String) : EModelElement
	disjuncts EClass::toEReference, EClass::toEAnnotation, ENamedElement::disjunctMapping 
{} 
    
-- can't call toEClass(), the first mapping allways satisfies the call
abstract mapping EModelElement::chainedDisjunctMappingHideToEReference(in strPar1 : String) : EModelElement 
	disjuncts EClass::toEAnnotation, EClass::toEReference, ENamedElement::disjunctMapping 
{} 

mapping EClass::toEAnnotation(in sourceSuffix : String) : EAnnotation
when { true } {
	source := self.name + '_EClass::toEAnnotation_' + sourceSuffix;
}

mapping EClass::toEReference(in xx : String) : EReference 
when { self.name <> null } {
	name := self.name + '_' + xx;
}

abstract mapping ENamedElement::disjunctMapping(in strPar1 : String) : ETypedElement
	disjuncts EAttribute::disjunctedMapping1, EParameter::disjunctedMapping2
{
 
}

mapping EAttribute::disjunctedMappingDummy(in par1 : EClass) : EAttribute {
	name := self.name + '_' + par1.name;	
}


mapping EAttribute::disjunctedMapping1(in strPar1 : String) : EAttribute {
	name := self.name + '_' + strPar1;	
}

mapping EParameter::disjunctedMapping2(in strPar1 : String) : EParameter {
	name := self.name + '_' + strPar1;
}

mapping inout EClass::inoutSimpleDisjunct()
	disjuncts EClass::inoutWithConditionDisjuncted
{}

mapping inout EClass::inoutWithConditionDisjuncted() when { self._abstract } { 
	eAnnotations += object EAnnotation {
		source := 'EClass::inoutWithConditionDisjuncted';
	};	
}

query EModelElement::containsAnnotation(in sourceStr : String) : Boolean {
	return self.eAnnotations->one(source = sourceStr);
}