module mote2loss;

create LOSS : OUT from MM : IN;

lazy rule ReferenceToLink {
	from
	refName : String,
	source : OclAny
	to
	link : OUT!Link (
		name <- refName,
		referenceTo <- source
	)
}

lazy rule DTecore__EDouble2Prim {
	from
	attrName : String,
	source : IN!"ecore::EDouble" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EDouble'
	)
}

lazy rule DTecore__ECharacterObject2Prim {
	from
	attrName : String,
	source : IN!"ecore::ECharacterObject" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::ECharacterObject'
	)
}

rule CLecore__EOperation2Complex {
	from
	source : IN!"ecore::EOperation" in MM (source.oclIsTypeOf(IN!"ecore::EOperation"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::EOperation',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EBoolean2Prim('ordered', source.ordered)).including(thisModule.DTecore__EBoolean2Prim('unique', source.unique)).including(thisModule.DTecore__EInt2Prim('lowerBound', source.lowerBound)).including(thisModule.DTecore__EInt2Prim('upperBound', source.upperBound)).including(thisModule.DTecore__EBoolean2Prim('many', source.many)).including(thisModule.DTecore__EBoolean2Prim('required', source.required)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.eType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eType', it)) ).union(Set{source.eGenericType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eGenericType', it)) ).union(Set{source.eContainingClass}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eContainingClass', it)) ).union(source.eTypeParameters->collect(it | thisModule.ReferenceToLink('eTypeParameters', it))).union(source.eParameters->collect(it | thisModule.ReferenceToLink('eParameters', it))).union(source.eExceptions->collect(it | thisModule.ReferenceToLink('eExceptions', it))).union(source.eGenericExceptions->collect(it | thisModule.ReferenceToLink('eGenericExceptions', it)))
	)
}

rule CLmltgg__ModelDomain2Complex {
	from
	source : IN!"mltgg::ModelDomain" in MM (source.oclIsTypeOf(IN!"mltgg::ModelDomain"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'mltgg::ModelDomain',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(source.modelObjects->collect(it | thisModule.ReferenceToLink('modelObjects', it))).union(source.modelLinks->collect(it | thisModule.ReferenceToLink('modelLinks', it)))
	)
}

lazy rule DTecore__ELongObject2Prim {
	from
	attrName : String,
	source : IN!"ecore::ELongObject" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::ELongObject'
	)
}

rule CLecore__ETypeParameter2Complex {
	from
	source : IN!"ecore::ETypeParameter" in MM (source.oclIsTypeOf(IN!"ecore::ETypeParameter"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::ETypeParameter',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(source.eBounds->collect(it | thisModule.ReferenceToLink('eBounds', it)))
	)
}

rule CLecore__EEnumLiteral2Complex {
	from
	source : IN!"ecore::EEnumLiteral" in MM (source.oclIsTypeOf(IN!"ecore::EEnumLiteral"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::EEnumLiteral',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EInt2Prim('value', source.value)).including(thisModule.DTecore__EEnumerator2Prim('instance', source.instance)).including(thisModule.DTecore__EString2Prim('literal', source.literal)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.eEnum}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eEnum', it)) )
	)
}

lazy rule DTmltgg__LinkOrderConstraintEnum2Prim {
	from
	attrName : String,
	source : IN!"mltgg::LinkOrderConstraintEnum" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'mltgg::LinkOrderConstraintEnum'
	)
}

lazy rule DTecore__EFloatObject2Prim {
	from
	attrName : String,
	source : IN!"ecore::EFloatObject" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EFloatObject'
	)
}

lazy rule DTecore__EBooleanObject2Prim {
	from
	attrName : String,
	source : IN!"ecore::EBooleanObject" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EBooleanObject'
	)
}

lazy rule DTecore__EShortObject2Prim {
	from
	attrName : String,
	source : IN!"ecore::EShortObject" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EShortObject'
	)
}

lazy rule DTecore__EEnumerator2Prim {
	from
	attrName : String,
	source : IN!"ecore::EEnumerator" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EEnumerator'
	)
}

lazy rule DTecore__EBigDecimal2Prim {
	from
	attrName : String,
	source : IN!"ecore::EBigDecimal" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EBigDecimal'
	)
}

rule CLmltgg__ModelElement2Complex {
	from
	source : IN!"mltgg::ModelElement" in MM (source.oclIsTypeOf(IN!"mltgg::ModelElement"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'mltgg::ModelElement',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).including(thisModule.DTmltgg__TGGModifierEnum2Prim('modifier', source.modifier)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(Set{source.incomingCorrespondenceLink}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('incomingCorrespondenceLink', it)) )
	)
}

rule CLmltgg__TGGRule2Complex {
	from
	source : IN!"mltgg::TGGRule" in MM (source.oclIsTypeOf(IN!"mltgg::TGGRule"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'mltgg::TGGRule',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EString2Prim('description', source.description)).including(thisModule.DTecore__EString2Prim('displayName', source.displayName)).including(thisModule.DTecore__EString2Prim('ruleID', source.ruleID)).including(thisModule.DTecore__EBoolean2Prim('enabled', source.enabled)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(Set{source.leftModelDomain}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('leftModelDomain', it)) ).union(Set{source.rightModelDomain}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('rightModelDomain', it)) ).union(Set{source.correspondenceDomain}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('correspondenceDomain', it)) ).union(source.attributeFormulas->collect(it | thisModule.ReferenceToLink('attributeFormulas', it))).union(source.ruleParameters->collect(it | thisModule.ReferenceToLink('ruleParameters', it))).union(Set{source.ruleGroup}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('ruleGroup', it)) ).union(source.leftInputElements->collect(it | thisModule.ReferenceToLink('leftInputElements', it))).union(source.rightInputElements->collect(it | thisModule.ReferenceToLink('rightInputElements', it)))
	)
}

lazy rule DTecore__EJavaClass2Prim {
	from
	attrName : String,
	source : IN!"ecore::EJavaClass" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EJavaClass'
	)
}

rule CLmltgg__TGGRuleGroup2Complex {
	from
	source : IN!"mltgg::TGGRuleGroup" in MM (source.oclIsTypeOf(IN!"mltgg::TGGRuleGroup"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'mltgg::TGGRuleGroup',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EString2Prim('description', source.description)).including(thisModule.DTecore__EString2Prim('displayName', source.displayName)).including(thisModule.DTecore__EString2Prim('ruleGroupID', source.ruleGroupID)).including(thisModule.DTecore__EBoolean2Prim('isAxiom', source.isAxiom)).including(thisModule.DTecore__EBoolean2Prim('enabled', source.enabled)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(Set{source.tgg}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('tgg', it)) ).union(source.rules->collect(it | thisModule.ReferenceToLink('rules', it)))
	)
}

rule CLecore__EModelElement2Complex {
	from
	source : IN!"ecore::EModelElement" in MM (source.oclIsTypeOf(IN!"ecore::EModelElement"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'ecore::EModelElement',
		primitives <- Set{}.union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it)))
	)
}

lazy rule DTecore__EBigInteger2Prim {
	from
	attrName : String,
	source : IN!"ecore::EBigInteger" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EBigInteger'
	)
}

lazy rule DTmltgg__TGGModifierEnum2Prim {
	from
	attrName : String,
	source : IN!"mltgg::TGGModifierEnum" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'mltgg::TGGModifierEnum'
	)
}

lazy rule DTecore__EInt2Prim {
	from
	attrName : String,
	source : IN!"ecore::EInt" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EInt'
	)
}

lazy rule DTecore__EIntegerObject2Prim {
	from
	attrName : String,
	source : IN!"ecore::EIntegerObject" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EIntegerObject'
	)
}

lazy rule DTecore__ELong2Prim {
	from
	attrName : String,
	source : IN!"ecore::ELong" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::ELong'
	)
}

lazy rule DTecore__EResource2Prim {
	from
	attrName : String,
	source : IN!"ecore::EResource" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EResource'
	)
}

lazy rule DTecore__EChar2Prim {
	from
	attrName : String,
	source : IN!"ecore::EChar" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EChar'
	)
}

lazy rule DTecore__EFloat2Prim {
	from
	attrName : String,
	source : IN!"ecore::EFloat" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EFloat'
	)
}

rule CLmltgg__RuleElement2Complex {
	from
	source : IN!"mltgg::RuleElement" in MM (source.oclIsTypeOf(IN!"mltgg::RuleElement"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'mltgg::RuleElement',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).including(thisModule.DTmltgg__TGGModifierEnum2Prim('modifier', source.modifier)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it)))
	)
}

rule CLecore__EAttribute2Complex {
	from
	source : IN!"ecore::EAttribute" in MM (source.oclIsTypeOf(IN!"ecore::EAttribute"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::EAttribute',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EBoolean2Prim('ordered', source.ordered)).including(thisModule.DTecore__EBoolean2Prim('unique', source.unique)).including(thisModule.DTecore__EInt2Prim('lowerBound', source.lowerBound)).including(thisModule.DTecore__EInt2Prim('upperBound', source.upperBound)).including(thisModule.DTecore__EBoolean2Prim('many', source.many)).including(thisModule.DTecore__EBoolean2Prim('required', source.required)).including(thisModule.DTecore__EBoolean2Prim('changeable', source.changeable)).including(thisModule.DTecore__EBoolean2Prim('volatile', source.volatile)).including(thisModule.DTecore__EBoolean2Prim('transient', source.transient)).including(thisModule.DTecore__EString2Prim('defaultValueLiteral', source.defaultValueLiteral)).including(thisModule.DTecore__EJavaObject2Prim('defaultValue', source.defaultValue)).including(thisModule.DTecore__EBoolean2Prim('unsettable', source.unsettable)).including(thisModule.DTecore__EBoolean2Prim('derived', source.derived)).including(thisModule.DTecore__EBoolean2Prim('iD', source.iD)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.eType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eType', it)) ).union(Set{source.eGenericType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eGenericType', it)) ).union(Set{source.eContainingClass}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eContainingClass', it)) ).union(Set{source.eAttributeType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eAttributeType', it)) )
	)
}

rule CLecore__EObject2Complex {
	from
	source : IN!"ecore::EObject" in MM (source.oclIsTypeOf(IN!"ecore::EObject"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'ecore::EObject',
		primitives <- Set{}
	)
}

lazy rule DTecore__EJavaObject2Prim {
	from
	attrName : String,
	source : IN!"ecore::EJavaObject" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EJavaObject'
	)
}

rule CLecore__EPackage2Complex {
	from
	source : IN!"ecore::EPackage" in MM (source.oclIsTypeOf(IN!"ecore::EPackage"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::EPackage',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EString2Prim('nsURI', source.nsURI)).including(thisModule.DTecore__EString2Prim('nsPrefix', source.nsPrefix)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.eFactoryInstance}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eFactoryInstance', it)) ).union(source.eClassifiers->collect(it | thisModule.ReferenceToLink('eClassifiers', it))).union(source.eSubpackages->collect(it | thisModule.ReferenceToLink('eSubpackages', it))).union(Set{source.eSuperPackage}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eSuperPackage', it)) )
	)
}

rule CLmltgg__AttributeAssignment2Complex {
	from
	source : IN!"mltgg::AttributeAssignment" in MM (source.oclIsTypeOf(IN!"mltgg::AttributeAssignment"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'mltgg::AttributeAssignment',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).including(thisModule.DTecore__EBoolean2Prim('initOnly', source.initOnly)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(Set{source.modelObject}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('modelObject', it)) ).union(Set{source.assignmentExpression}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('assignmentExpression', it)) ).union(Set{source.feature}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('feature', it)) )
	)
}

rule CLecore__EGenericType2Complex {
	from
	source : IN!"ecore::EGenericType" in MM (source.oclIsTypeOf(IN!"ecore::EGenericType"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'ecore::EGenericType',
		primitives <- Set{}.union(Set{source.eUpperBound}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eUpperBound', it)) ).union(source.eTypeArguments->collect(it | thisModule.ReferenceToLink('eTypeArguments', it))).union(Set{source.eRawType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eRawType', it)) ).union(Set{source.eLowerBound}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eLowerBound', it)) ).union(Set{source.eTypeParameter}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eTypeParameter', it)) ).union(Set{source.eClassifier}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eClassifier', it)) )
	)
}

lazy rule DTecore__EDiagnosticChain2Prim {
	from
	attrName : String,
	source : IN!"ecore::EDiagnosticChain" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EDiagnosticChain'
	)
}

lazy rule DTecore__EFeatureMap2Prim {
	from
	attrName : String,
	source : IN!"ecore::EFeatureMap" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EFeatureMap'
	)
}

rule CLmltgg__ModelObject2Complex {
	from
	source : IN!"mltgg::ModelObject" in MM (source.oclIsTypeOf(IN!"mltgg::ModelObject"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'mltgg::ModelObject',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).including(thisModule.DTmltgg__TGGModifierEnum2Prim('modifier', source.modifier)).including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EString2Prim('description', source.description)).including(thisModule.DTecore__EString2Prim('displayName', source.displayName)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(Set{source.incomingCorrespondenceLink}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('incomingCorrespondenceLink', it)) ).union(Set{source.type}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('type', it)) ).union(source.outgoingLinks->collect(it | thisModule.ReferenceToLink('outgoingLinks', it))).union(source.incomingLinks->collect(it | thisModule.ReferenceToLink('incomingLinks', it))).union(source.constraints->collect(it | thisModule.ReferenceToLink('constraints', it))).union(source.attributeAssignments->collect(it | thisModule.ReferenceToLink('attributeAssignments', it))).union(Set{source.modelDomain}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('modelDomain', it)) ).union(source.forwardConstraints->collect(it | thisModule.ReferenceToLink('forwardConstraints', it))).union(source.backwardConstraints->collect(it | thisModule.ReferenceToLink('backwardConstraints', it)))
	)
}

rule CLmltgg__CorrespondenceDomain2Complex {
	from
	source : IN!"mltgg::CorrespondenceDomain" in MM (source.oclIsTypeOf(IN!"mltgg::CorrespondenceDomain"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'mltgg::CorrespondenceDomain',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(Set{source.rule}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('rule', it)) ).union(source.correspondenceNodes->collect(it | thisModule.ReferenceToLink('correspondenceNodes', it))).union(source.correspondenceLinks->collect(it | thisModule.ReferenceToLink('correspondenceLinks', it)))
	)
}

rule CLmltgg__CorrespondenceNode2Complex {
	from
	source : IN!"mltgg::CorrespondenceNode" in MM (source.oclIsTypeOf(IN!"mltgg::CorrespondenceNode"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'mltgg::CorrespondenceNode',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).including(thisModule.DTmltgg__TGGModifierEnum2Prim('modifier', source.modifier)).including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EString2Prim('description', source.description)).including(thisModule.DTecore__EString2Prim('displayName', source.displayName)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(Set{source.type}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('type', it)) ).union(source.outgoingLinks->collect(it | thisModule.ReferenceToLink('outgoingLinks', it))).union(Set{source.correspondenceDomain}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('correspondenceDomain', it)) )
	)
}

rule CLecore__EEnum2Complex {
	from
	source : IN!"ecore::EEnum" in MM (source.oclIsTypeOf(IN!"ecore::EEnum"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::EEnum',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EString2Prim('instanceClassName', source.instanceClassName)).including(thisModule.DTecore__EJavaClass2Prim('instanceClass', source.instanceClass)).including(thisModule.DTecore__EJavaObject2Prim('defaultValue', source.defaultValue)).including(thisModule.DTecore__EString2Prim('instanceTypeName', source.instanceTypeName)).including(thisModule.DTecore__EBoolean2Prim('serializable', source.serializable)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.ePackage}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('ePackage', it)) ).union(source.eTypeParameters->collect(it | thisModule.ReferenceToLink('eTypeParameters', it))).union(source.eLiterals->collect(it | thisModule.ReferenceToLink('eLiterals', it)))
	)
}

rule CLmltgg__ModelLink2Complex {
	from
	source : IN!"mltgg::ModelLink" in MM (source.oclIsTypeOf(IN!"mltgg::ModelLink"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'mltgg::ModelLink',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).including(thisModule.DTmltgg__TGGModifierEnum2Prim('modifier', source.modifier)).including(thisModule.DTmltgg__LinkPositionConstraintEnum2Prim('linkPositionConstraint', source.linkPositionConstraint)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(Set{source.incomingCorrespondenceLink}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('incomingCorrespondenceLink', it)) ).union(Set{source.source}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('source', it)) ).union(Set{source.target}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('target', it)) ).union(Set{source.feature}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('feature', it)) ).union(source.outgoingLinkOrderConstraints->collect(it | thisModule.ReferenceToLink('outgoingLinkOrderConstraints', it))).union(source.incomingLinkOrderConstraints->collect(it | thisModule.ReferenceToLink('incomingLinkOrderConstraints', it))).union(Set{source.modelDomain}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('modelDomain', it)) )
	)
}

rule CLecore__EStructuralFeature2Complex {
	from
	source : IN!"ecore::EStructuralFeature" in MM (source.oclIsTypeOf(IN!"ecore::EStructuralFeature"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::EStructuralFeature',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EBoolean2Prim('ordered', source.ordered)).including(thisModule.DTecore__EBoolean2Prim('unique', source.unique)).including(thisModule.DTecore__EInt2Prim('lowerBound', source.lowerBound)).including(thisModule.DTecore__EInt2Prim('upperBound', source.upperBound)).including(thisModule.DTecore__EBoolean2Prim('many', source.many)).including(thisModule.DTecore__EBoolean2Prim('required', source.required)).including(thisModule.DTecore__EBoolean2Prim('changeable', source.changeable)).including(thisModule.DTecore__EBoolean2Prim('volatile', source.volatile)).including(thisModule.DTecore__EBoolean2Prim('transient', source.transient)).including(thisModule.DTecore__EString2Prim('defaultValueLiteral', source.defaultValueLiteral)).including(thisModule.DTecore__EJavaObject2Prim('defaultValue', source.defaultValue)).including(thisModule.DTecore__EBoolean2Prim('unsettable', source.unsettable)).including(thisModule.DTecore__EBoolean2Prim('derived', source.derived)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.eType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eType', it)) ).union(Set{source.eGenericType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eGenericType', it)) ).union(Set{source.eContainingClass}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eContainingClass', it)) )
	)
}

rule CLmltgg__LinkOrderConstraint2Complex {
	from
	source : IN!"mltgg::LinkOrderConstraint" in MM (source.oclIsTypeOf(IN!"mltgg::LinkOrderConstraint"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'mltgg::LinkOrderConstraint',
		primitives <- Set{}.including(thisModule.DTmltgg__LinkOrderConstraintEnum2Prim('kind', source.kind)).union(Set{source.predecessorLink}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('predecessorLink', it)) ).union(Set{source.successorLink}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('successorLink', it)) )
	)
}

rule CLecore__EDataType2Complex {
	from
	source : IN!"ecore::EDataType" in MM (source.oclIsTypeOf(IN!"ecore::EDataType"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::EDataType',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EString2Prim('instanceClassName', source.instanceClassName)).including(thisModule.DTecore__EJavaClass2Prim('instanceClass', source.instanceClass)).including(thisModule.DTecore__EJavaObject2Prim('defaultValue', source.defaultValue)).including(thisModule.DTecore__EString2Prim('instanceTypeName', source.instanceTypeName)).including(thisModule.DTecore__EBoolean2Prim('serializable', source.serializable)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.ePackage}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('ePackage', it)) ).union(source.eTypeParameters->collect(it | thisModule.ReferenceToLink('eTypeParameters', it)))
	)
}

lazy rule DTecore__EByteObject2Prim {
	from
	attrName : String,
	source : IN!"ecore::EByteObject" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EByteObject'
	)
}

rule CLecore__EParameter2Complex {
	from
	source : IN!"ecore::EParameter" in MM (source.oclIsTypeOf(IN!"ecore::EParameter"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::EParameter',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EBoolean2Prim('ordered', source.ordered)).including(thisModule.DTecore__EBoolean2Prim('unique', source.unique)).including(thisModule.DTecore__EInt2Prim('lowerBound', source.lowerBound)).including(thisModule.DTecore__EInt2Prim('upperBound', source.upperBound)).including(thisModule.DTecore__EBoolean2Prim('many', source.many)).including(thisModule.DTecore__EBoolean2Prim('required', source.required)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.eType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eType', it)) ).union(Set{source.eGenericType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eGenericType', it)) ).union(Set{source.eOperation}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eOperation', it)) )
	)
}

rule CLmltgg__RightModelDomain2Complex {
	from
	source : IN!"mltgg::RightModelDomain" in MM (source.oclIsTypeOf(IN!"mltgg::RightModelDomain"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'mltgg::RightModelDomain',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(source.modelObjects->collect(it | thisModule.ReferenceToLink('modelObjects', it))).union(source.modelLinks->collect(it | thisModule.ReferenceToLink('modelLinks', it))).union(Set{source.rule}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('rule', it)) )
	)
}

lazy rule DTecore__EShort2Prim {
	from
	attrName : String,
	source : IN!"ecore::EShort" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EShort'
	)
}

rule CLecore__EClass2Complex {
	from
	source : IN!"ecore::EClass" in MM (source.oclIsTypeOf(IN!"ecore::EClass"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::EClass',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EString2Prim('instanceClassName', source.instanceClassName)).including(thisModule.DTecore__EJavaClass2Prim('instanceClass', source.instanceClass)).including(thisModule.DTecore__EJavaObject2Prim('defaultValue', source.defaultValue)).including(thisModule.DTecore__EString2Prim('instanceTypeName', source.instanceTypeName)).including(thisModule.DTecore__EBoolean2Prim('abstract', source.abstract)).including(thisModule.DTecore__EBoolean2Prim('interface', source.interface)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.ePackage}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('ePackage', it)) ).union(source.eTypeParameters->collect(it | thisModule.ReferenceToLink('eTypeParameters', it))).union(source.eSuperTypes->collect(it | thisModule.ReferenceToLink('eSuperTypes', it))).union(source.eOperations->collect(it | thisModule.ReferenceToLink('eOperations', it))).union(source.eAllAttributes->collect(it | thisModule.ReferenceToLink('eAllAttributes', it))).union(source.eAllReferences->collect(it | thisModule.ReferenceToLink('eAllReferences', it))).union(source.eReferences->collect(it | thisModule.ReferenceToLink('eReferences', it))).union(source.eAttributes->collect(it | thisModule.ReferenceToLink('eAttributes', it))).union(source.eAllContainments->collect(it | thisModule.ReferenceToLink('eAllContainments', it))).union(source.eAllOperations->collect(it | thisModule.ReferenceToLink('eAllOperations', it))).union(source.eAllStructuralFeatures->collect(it | thisModule.ReferenceToLink('eAllStructuralFeatures', it))).union(source.eAllSuperTypes->collect(it | thisModule.ReferenceToLink('eAllSuperTypes', it))).union(Set{source.eIDAttribute}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eIDAttribute', it)) ).union(source.eStructuralFeatures->collect(it | thisModule.ReferenceToLink('eStructuralFeatures', it))).union(source.eGenericSuperTypes->collect(it | thisModule.ReferenceToLink('eGenericSuperTypes', it))).union(source.eAllGenericSuperTypes->collect(it | thisModule.ReferenceToLink('eAllGenericSuperTypes', it)))
	)
}

lazy rule DTecore__EInvocationTargetException2Prim {
	from
	attrName : String,
	source : IN!"ecore::EInvocationTargetException" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EInvocationTargetException'
	)
}

rule CLmltgg__TGG2Complex {
	from
	source : IN!"mltgg::TGG" in MM (source.oclIsTypeOf(IN!"mltgg::TGG"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'mltgg::TGG',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EString2Prim('description', source.description)).including(thisModule.DTecore__EString2Prim('displayName', source.displayName)).including(thisModule.DTecore__EString2Prim('tggID', source.tggID)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(source.ruleGroups->collect(it | thisModule.ReferenceToLink('ruleGroups', it)))
	)
}

lazy rule DTmltgg__LinkPositionConstraintEnum2Prim {
	from
	attrName : String,
	source : IN!"mltgg::LinkPositionConstraintEnum" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'mltgg::LinkPositionConstraintEnum'
	)
}

rule CLecore__ENamedElement2Complex {
	from
	source : IN!"ecore::ENamedElement" in MM (source.oclIsTypeOf(IN!"ecore::ENamedElement"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::ENamedElement',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it)))
	)
}

rule CLmltgg__RuleParameter2Complex {
	from
	source : IN!"mltgg::RuleParameter" in MM (source.oclIsTypeOf(IN!"mltgg::RuleParameter"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'mltgg::RuleParameter',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EString2Prim('description', source.description)).including(thisModule.DTecore__EString2Prim('displayName', source.displayName)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(Set{source.type}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('type', it)) ).union(Set{source.forwardCalculationExpression}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('forwardCalculationExpression', it)) ).union(Set{source.backwardCalculationExpression}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('backwardCalculationExpression', it)) ).union(Set{source.rule}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('rule', it)) )
	)
}

rule CLmltgg__LeftModelDomain2Complex {
	from
	source : IN!"mltgg::LeftModelDomain" in MM (source.oclIsTypeOf(IN!"mltgg::LeftModelDomain"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'mltgg::LeftModelDomain',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(source.modelObjects->collect(it | thisModule.ReferenceToLink('modelObjects', it))).union(source.modelLinks->collect(it | thisModule.ReferenceToLink('modelLinks', it))).union(Set{source.rule}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('rule', it)) )
	)
}

lazy rule DTecore__EByte2Prim {
	from
	attrName : String,
	source : IN!"ecore::EByte" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EByte'
	)
}

rule CLmltgg__CorrespondenceLink2Complex {
	from
	source : IN!"mltgg::CorrespondenceLink" in MM (source.oclIsTypeOf(IN!"mltgg::CorrespondenceLink"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'mltgg::CorrespondenceLink',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).including(thisModule.DTmltgg__TGGModifierEnum2Prim('modifier', source.modifier)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it))).union(Set{source.source}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('source', it)) ).union(Set{source.target}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('target', it)) ).union(Set{source.correspondenceDomain}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('correspondenceDomain', it)) )
	)
}

lazy rule DTecore__EResourceSet2Prim {
	from
	attrName : String,
	source : IN!"ecore::EResourceSet" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EResourceSet'
	)
}

rule CLecore__EReference2Complex {
	from
	source : IN!"ecore::EReference" in MM (source.oclIsTypeOf(IN!"ecore::EReference"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::EReference',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EBoolean2Prim('ordered', source.ordered)).including(thisModule.DTecore__EBoolean2Prim('unique', source.unique)).including(thisModule.DTecore__EInt2Prim('lowerBound', source.lowerBound)).including(thisModule.DTecore__EInt2Prim('upperBound', source.upperBound)).including(thisModule.DTecore__EBoolean2Prim('many', source.many)).including(thisModule.DTecore__EBoolean2Prim('required', source.required)).including(thisModule.DTecore__EBoolean2Prim('changeable', source.changeable)).including(thisModule.DTecore__EBoolean2Prim('volatile', source.volatile)).including(thisModule.DTecore__EBoolean2Prim('transient', source.transient)).including(thisModule.DTecore__EString2Prim('defaultValueLiteral', source.defaultValueLiteral)).including(thisModule.DTecore__EJavaObject2Prim('defaultValue', source.defaultValue)).including(thisModule.DTecore__EBoolean2Prim('unsettable', source.unsettable)).including(thisModule.DTecore__EBoolean2Prim('derived', source.derived)).including(thisModule.DTecore__EBoolean2Prim('containment', source.containment)).including(thisModule.DTecore__EBoolean2Prim('container', source.container)).including(thisModule.DTecore__EBoolean2Prim('resolveProxies', source.resolveProxies)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.eType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eType', it)) ).union(Set{source.eGenericType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eGenericType', it)) ).union(Set{source.eContainingClass}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eContainingClass', it)) ).union(Set{source.eOpposite}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eOpposite', it)) ).union(Set{source.eReferenceType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eReferenceType', it)) ).union(source.eKeys->collect(it | thisModule.ReferenceToLink('eKeys', it)))
	)
}

rule CLmltgg__CorrespondenceElement2Complex {
	from
	source : IN!"mltgg::CorrespondenceElement" in MM (source.oclIsTypeOf(IN!"mltgg::CorrespondenceElement"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'mltgg::CorrespondenceElement',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('uuid', source.uuid)).including(thisModule.DTmltgg__TGGModifierEnum2Prim('modifier', source.modifier)).union(source.annotations->collect(it | thisModule.ReferenceToLink('annotations', it)))
	)
}

lazy rule DTecore__EFeatureMapEntry2Prim {
	from
	attrName : String,
	source : IN!"ecore::EFeatureMapEntry" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EFeatureMapEntry'
	)
}

lazy rule DTecore__ETreeIterator2Prim {
	from
	attrName : String,
	source : IN!"ecore::ETreeIterator" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::ETreeIterator'
	)
}

rule CLecore__EFactory2Complex {
	from
	source : IN!"ecore::EFactory" in MM (source.oclIsTypeOf(IN!"ecore::EFactory"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'ecore::EFactory',
		primitives <- Set{}.union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.ePackage}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('ePackage', it)) )
	)
}

rule CLecore__EAnnotation2Complex {
	from
	source : IN!"ecore::EAnnotation" in MM (source.oclIsTypeOf(IN!"ecore::EAnnotation"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'ecore::EAnnotation',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('source', source.source)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(source.details->collect(it | thisModule.ReferenceToLink('details', it))).union(Set{source.eModelElement}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eModelElement', it)) ).union(source.contents->collect(it | thisModule.ReferenceToLink('contents', it))).union(source.references->collect(it | thisModule.ReferenceToLink('references', it)))
	)
}

lazy rule DTecore__EString2Prim {
	from
	attrName : String,
	source : IN!"ecore::EString" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EString'
	)
}

rule CLecore__EClassifier2Complex {
	from
	source : IN!"ecore::EClassifier" in MM (source.oclIsTypeOf(IN!"ecore::EClassifier"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::EClassifier',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EString2Prim('instanceClassName', source.instanceClassName)).including(thisModule.DTecore__EJavaClass2Prim('instanceClass', source.instanceClass)).including(thisModule.DTecore__EJavaObject2Prim('defaultValue', source.defaultValue)).including(thisModule.DTecore__EString2Prim('instanceTypeName', source.instanceTypeName)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.ePackage}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('ePackage', it)) ).union(source.eTypeParameters->collect(it | thisModule.ReferenceToLink('eTypeParameters', it)))
	)
}

lazy rule DTecore__EByteArray2Prim {
	from
	attrName : String,
	source : IN!"ecore::EByteArray" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EByteArray'
	)
}

lazy rule DTecore__EDoubleObject2Prim {
	from
	attrName : String,
	source : IN!"ecore::EDoubleObject" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EDoubleObject'
	)
}

lazy rule DTecore__EMap2Prim {
	from
	attrName : String,
	source : IN!"ecore::EMap" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EMap'
	)
}

rule CLecore__EStringToStringMapEntry2Complex {
	from
	source : IN!"ecore::EStringToStringMapEntry" in MM (source.oclIsTypeOf(IN!"ecore::EStringToStringMapEntry"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- 'NoName',
		className <- 'ecore::EStringToStringMapEntry',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('key', source.key)).including(thisModule.DTecore__EString2Prim('value', source.value))
	)
}

lazy rule DTecore__EBoolean2Prim {
	from
	attrName : String,
	source : IN!"ecore::EBoolean" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EBoolean'
	)
}

rule CLecore__ETypedElement2Complex {
	from
	source : IN!"ecore::ETypedElement" in MM (source.oclIsTypeOf(IN!"ecore::ETypedElement"))
	to
	prim : OUT!Complex (
		reference <- source,
		name <- source.name,
		className <- 'ecore::ETypedElement',
		primitives <- Set{}.including(thisModule.DTecore__EString2Prim('name', source.name)).including(thisModule.DTecore__EBoolean2Prim('ordered', source.ordered)).including(thisModule.DTecore__EBoolean2Prim('unique', source.unique)).including(thisModule.DTecore__EInt2Prim('lowerBound', source.lowerBound)).including(thisModule.DTecore__EInt2Prim('upperBound', source.upperBound)).including(thisModule.DTecore__EBoolean2Prim('many', source.many)).including(thisModule.DTecore__EBoolean2Prim('required', source.required)).union(source.eAnnotations->collect(it | thisModule.ReferenceToLink('eAnnotations', it))).union(Set{source.eType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eType', it)) ).union(Set{source.eGenericType}->select( e | not e.oclIsUndefined())->collect(it | thisModule.ReferenceToLink('eGenericType', it)) )
	)
}

lazy rule DTecore__EEList2Prim {
	from
	attrName : String,
	source : IN!"ecore::EEList" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EEList'
	)
}

lazy rule DTecore__EDate2Prim {
	from
	attrName : String,
	source : IN!"ecore::EDate" in MM
	to
	prim : OUT!Primitive (
		name <- attrName,
		className <- 'ecore::EDate'
	)
}