--- a
+++ b/eu.opensourceprojects.mondo.benchmarks.itmfactory/transformations/KDMtoUML.atl
@@ -0,0 +1,756 @@
+-- @atlcompiler atl2006 
+-- @nsURI uml=http://www.eclipse.org/uml2/2.1.0/UML
+-- @nsURI kdm=http://www.eclipse.org/MoDisco/kdm
+--authors: Gabriel Barbier, Mia-Software, gbarbier@mia-software.com 
+--Transform KDM Models to UML 2.1 models
+
+module KDMtoUML; 
+create OUT : uml from IN : kdm;
+
+-- specific case to attach all single elements to root model
+entrypoint rule initExternalElementsContainer() {
+--	to externalPackage :uml!Package(
+--		name <- 'detached elements'
+--		,packagedElement <- externalClass
+--	)
+--	,externalClass :uml!Class(
+--		name <- 'detached elements'
+--	)
+--	do {
+--		thisModule.externalPackage <- externalPackage;
+--		thisModule.externalClass <- externalClass;
+--	}
+}
+
+helper def : findExternalPackage() : kdm!CodeModel =
+	kdm!Segment.allInstances()->select(e | e.refImmediateComposite().oclIsUndefined())
+		->collect(e | e.model)->flatten()
+		->select(e | e.name = 'externals')
+		-->collect(e | e.codeElement)->flatten()
+		-->select(e | e.name = 'detached elements')
+		->first();
+
+endpoint rule manageDetachedElements() {
+
+  do {
+  		if (not thisModule->findExternalPackage().oclIsUndefined()) {
+  			thisModule.externalPackage <- thisModule.resolveTemp(thisModule->findExternalPackage(), 'tgt');
+			for (detachedClass in thisModule->findExternalPackage().codeElement) {
+				if (detachedClass.name = 'detached elements') {
+					thisModule.externalClass <- thisModule.resolveTemp(detachedClass, 'tgt');
+				}
+			}
+			for (alone in uml!Element.allInstances()) {
+  				if (not (alone.oclIsTypeOf(uml!Model))) {
+  					if (alone.refImmediateComposite().oclIsUndefined()) {
+  						if (alone.oclIsKindOf(uml!PackageableElement)) {
+  							thisModule.externalPackage.packagedElement <- alone;
+  						} else {
+  							if (not thisModule.externalClass.oclIsUndefined()) {
+  								if (alone.oclIsKindOf(uml!Generalization)) {
+  									thisModule.externalClass.generalization <- alone;
+  								}
+  								if (alone.oclIsKindOf(uml!Operation)) {
+  									thisModule.externalClass.ownedOperation <- alone;
+  								}
+  								if (alone.oclIsKindOf(uml!Property)) {
+	  								thisModule.externalClass.ownedAttribute <- alone;
+  								}
+  							}
+  						}
+  					}
+  				}
+  			}
+  		}  		
+   }
+}
+
+helper def: externalPackage : uml!Package = OclUndefined;
+helper def: externalClass : uml!Class = OclUndefined;
+
+--------------------------Helpers--------------------------------------------------------------------------------------------------
+
+helper context kdm!Element def : getVisibility() : uml!VisibilityKind = 
+	if (self.oclIsTypeOf(kdm!MethodUnit)) then
+		self->getMethodVisibility()
+	else
+		if (self.oclIsTypeOf(kdm!Datatype)) then
+			self->getDatatypeVisibility()
+		else
+			#public
+		endif
+	endif;
+
+helper context kdm!MethodUnit def : getMethodVisibility() : uml!VisibilityKind =
+	if (self.export = #private) then
+		#private
+	else
+		if (self.export = #protected) then
+			#protected
+		else
+			#public
+		endif
+	endif;
+
+helper context kdm!Datatype def : getDatatypeVisibility() : uml!VisibilityKind = 
+	let attribute : kdm!Attribute = self.attribute->select(e | e.tag = 'visibility')->first() in
+		if (attribute.oclIsUndefined()) then
+			#public
+		else
+			let value : String = attribute.value in
+			if (value = 'private') then
+				#private
+			else
+				if (value = 'protected') then
+					#protected
+				else
+					#public
+				endif
+			endif
+		endif;
+
+helper context kdm!DataElement def : getLowerCardinality() : Integer =
+	let attribute : kdm!Attribute = self.attribute->select(e | e.tag = 'inheritance')->first() in
+		if (attribute.oclIsUndefined()) then
+			0
+		else
+			if (attribute.value = 'final') then
+				1
+			else
+				0
+			endif
+		endif;
+
+-- depends on type of DataElement
+helper context kdm!DataElement def : getUpperCardinality() : Integer =
+	if (not self.size.oclIsUndefined()) then
+		self.size
+	else
+		if (not self.type.oclIsUndefined()) then
+			if (self.type.oclIsKindOf(kdm!ArrayType)) then
+				-1
+			else
+				if (self.type.oclIsTypeOf(kdm!TemplateType)) then
+					if (self.type->isCollection() or self.type->isMap()) then
+						-1
+					else
+						1
+					endif
+				else
+					1
+				endif
+		    endif
+		else
+			1
+		endif
+	endif;
+
+helper context kdm!Datatype def : isCollection() : Boolean =
+	if (self.name.oclIsUndefined()) then
+	false
+	else
+	if (self.name->startsWith('Collection')) then
+		true
+	else
+		if (self.oclIsTypeOf(kdm!TemplateType)) then
+			self->getTemplateUnit()->isCollection()
+		else
+			if (self.oclIsTypeOf(kdm!TemplateUnit)) then
+				self->getRealType()->isCollection()
+			else
+				if (self->getInheritanceLinks()->isEmpty()) then
+					false
+				else
+					let parents : Sequence(kdm!AbstractCodeRelationship) = self->getInheritanceLinks() in
+						parents->exists(parent | parent.to->isCollection())
+				endif
+			endif
+		endif
+	endif
+	endif;
+
+helper context kdm!Datatype def : isMap() : Boolean =
+	if (self.name.oclIsUndefined()) then
+	false
+	else
+	if (self.name->startsWith('Map')) then
+		true
+	else
+		if (self.oclIsTypeOf(kdm!TemplateType)) then
+			self->getTemplateUnit()->isMap()
+		else
+			if (self.oclIsTypeOf(kdm!TemplateUnit)) then
+				self->getRealType()->isMap()
+			else
+				if (self->getInheritanceLinks()->isEmpty()) then
+					false
+				else
+					let parents : Sequence(kdm!AbstractCodeRelationship) = self->getInheritanceLinks() in
+						parents->exists(parent | parent.to->isMap())
+				endif
+			endif
+		endif
+	endif
+	endif;
+
+
+helper context kdm!Datatype def : getInheritanceLinks() : Sequence(kdm!AbstractCodeRelationship) = 
+	if ((self.oclIsTypeOf(kdm!EnumeratedType)) or (self.oclIsTypeOf(kdm!ClassUnit))
+			or (self.oclIsTypeOf(kdm!InterfaceUnit)) or (self.oclIsTypeOf(kdm!TemplateUnit))) then
+		self.codeRelation->select(e | e.oclIsTypeOf(kdm!Extends) or e.oclIsTypeOf(kdm!Implements))
+	else
+		Sequence{}
+	endif;
+	
+	
+helper context kdm!TemplateType def : getTemplateUnit() : kdm!Datatype =
+	let link : kdm!InstanceOf = self.codeRelation->select(e | e.oclIsTypeOf(kdm!InstanceOf))->first() in
+	if (link.oclIsUndefined()) then
+		OclUndefined
+	else
+		if (link.to.oclIsUndefined()) then
+			let otherLink : kdm!HasType = self.codeRelation->select(e | e.oclIsTypeOf(kdm!HasType))->first() in
+			if (otherLink.oclIsUndefined()) then
+				OclUndefined
+			else
+				otherLink.to
+			endif
+		else
+			link.to
+		endif
+	endif;
+
+helper context kdm!TemplateUnit def : getRealType() : kdm!CodeItem =
+	self.codeElement->select(e | not e.oclIsTypeOf(kdm!TemplateParameter))->first();
+
+helper context kdm!InterfaceUnit def : getRealType() : kdm!Datatype =
+	self;
+
+helper context kdm!ClassUnit def : getRealType() : kdm!Datatype =
+	self;
+
+helper context kdm!CodeItem def : getPackageContainer() : kdm!Package =
+	if (self.refImmediateComposite().oclIsTypeOf(kdm!Package)) then
+		self.refImmediateComposite()
+	else
+		if (self.refImmediateComposite().oclIsKindOf(kdm!CodeItem)) then
+			self.refImmediateComposite()->getPackageContainer()
+		else
+			thisModule->findExternalPackage()
+		endif
+	endif;
+
+helper context kdm!DataElement def : getDataElementType() : kdm!Datatype =
+	if (self.type.oclIsTypeOf(kdm!TemplateType)) then
+		if (self.type->isCollection() or self.type->isMap()) then
+			self.type->getTemplateTypeBinding()
+		else
+			self.type
+		endif
+	else
+		if (self.type.oclIsTypeOf(kdm!ArrayType)) then
+			self.type.itemUnit.type
+		else
+			self.type
+		endif
+	endif;
+helper context kdm!DataElement def : getDataElementQualifierType() : kdm!Datatype =
+	if (self.type.oclIsTypeOf(kdm!TemplateType)) then
+		if (self.type->isMap()) then
+			self.type.codeRelation->select(e | e.oclIsTypeOf(kdm!ParameterTo))->first().to
+		else
+			OclUndefined
+		endif
+	else
+		OclUndefined
+	endif;
+
+helper context kdm!TemplateType def : getTemplateTypeBinding() : kdm!Datatype =
+	let parameter : kdm!ParameterTo = self.codeRelation->select(e | e.oclIsTypeOf(kdm!ParameterTo))->last() in
+		if (parameter.to.oclIsTypeOf(kdm!TemplateType)) then
+			if (parameter.to->isCollection() or parameter.to->isMap()) then
+				parameter.to->getTemplateTypeBinding()
+			else
+				parameter.to
+			endif
+		else
+			parameter.to
+		endif;
+
+helper context kdm!Datatype def : isPrimitiveType() : Boolean =
+	if (self.oclIsUndefined() or (self.oclIsKindOf(kdm!PrimitiveType))) then
+		true
+	else
+		-- specific case for primitive objects
+		if ((self.name = 'String') or (self.name = 'Integer') 
+				or (self.name = 'Long') or (self.name = 'Short')
+				or (self.name = 'Float') or (self.name = 'Double')
+				or (self.name = 'Boolean') or (self.name = 'Number')) then
+			true
+		else
+			false
+		endif
+	endif;
+	
+--------------------------End-Helpers-----------------------------------------------------------------------------------------------------------------------------------------
+
+
+
+--------------------------Rules-----------------------------------------------------------------------------------------------------------------------------------------------
+
+rule SegmentToRootModel {
+	from src :kdm!Segment
+	to tgt :uml!Model(
+		name<- if (src.name.oclIsUndefined()) then 'root model' else src.name endif
+		,packagedElement<-src.segment
+		,packagedElement<-src.model
+		,packagedElement<-src.extension
+		-- contains external elements
+--		,packagedElement<- if (src.refImmediateComposite().oclIsUndefined()) then
+--								thisModule.externalPackage
+--							else Sequence{} endif
+	)
+}
+
+rule ExtensionFamilyToProfile {
+	from src :kdm!ExtensionFamily
+	to tgt :uml!Profile (
+		name <- src.name
+		,packagedElement <- src.annotation
+		,packagedElement <- src.attribute
+		,packagedElement <- src.stereotype
+	)
+}
+
+rule KDMModelToModel {
+	from src :kdm!KDMModel
+	to tgt :uml!Model (
+		name <- src.name
+		,packagedElement <- src.extension
+		,packagedElement <- src.ownedElement
+	)
+}
+
+--------------------------------End-Rules------------------------------------
+
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+
+-- Specific rules for source package in KDM metamodel------------------------
+
+rule InventoryModelToModel extends KDMModelToModel {
+	from src :kdm!InventoryModel
+	to tgt :uml!Model (
+		packagedElement <- src.inventoryElement
+	)
+}
+
+--rule SourceFileToArtifact extends KDMEntityToNamedElement {
+--	from src :kdm!SourceFile
+--	to tgt :uml!Artifact (
+--		fileName <- src.path
+--	)
+--}
+
+rule InventoryItemToArtifact extends KDMEntityToNamedElement {
+	from src :kdm!InventoryItem
+	to tgt :uml!Artifact (
+		fileName <- src.path
+	)
+}
+rule InventoryContainerToPackage extends KDMEntityToNamedElement {
+	from src :kdm!InventoryContainer
+	to tgt :uml!Package (
+		packagedElement <- src.inventoryElement
+	)
+}
+--------------------------------End-Rules------------------------------------
+
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+
+---Specific rules for code package in KDM metamodel--------------------------
+
+rule CodeModelToModel extends KDMModelToModel {
+	from src :kdm!CodeModel
+	to tgt :uml!Model (
+		packagedElement <- src.codeElement
+	)
+}
+
+abstract rule KDMEntityToNamedElement {
+	from src :kdm!KDMEntity
+	to tgt :uml!NamedElement (
+		name <- src.name
+		,visibility <- src->getVisibility()
+	)
+}
+
+-- to manage LanguageUnit and Package
+rule ModuleToPackage extends KDMEntityToNamedElement {
+	from src :kdm!Module
+	to tgt :uml!Package (
+		packagedElement <- src.codeElement
+	)
+}
+
+-- to manage all primitive types (Boolean, Integer, Void, ...)
+rule PrimitiveTypeToPrimitiveType extends KDMEntityToNamedElement {
+	from src :kdm!PrimitiveType
+	to tgt :uml!PrimitiveType ()
+}
+
+-- we have to filter dummy class only needed in kdm to manage behaviour element in StorableUnit
+rule ClassUnitToClass extends KDMEntityToNamedElement {
+	from src :kdm!ClassUnit (
+		not src.refImmediateComposite().oclIsTypeOf(kdm!TemplateUnit)
+		and not (src.refImmediateComposite().oclIsTypeOf(kdm!StorableUnit))
+		
+	)
+	to tgt :uml!Class (
+		isAbstract <- src.isAbstract
+		-- specific case to manage templated methods (encapsulated in a TemplateUnit)
+		,nestedClassifier <- src.codeElement->select(e | e.oclIsKindOf(kdm!Datatype))
+				->select(e | if (e.oclIsTypeOf(kdm!TemplateUnit)) then not (e->getRealType().oclIsTypeOf(kdm!MethodUnit)) else true endif)
+		,generalization <- src.codeRelation->select(e | e.oclIsTypeOf(kdm!Extends))
+		,interfaceRealization <- src.codeRelation->select(e | e.oclIsTypeOf(kdm!Implements))
+		,ownedOperation <- src.codeElement->select(e | e.oclIsTypeOf(kdm!MethodUnit))
+		,ownedAttribute <- src.codeElement->select(e | e.oclIsKindOf(kdm!DataElement))
+	)
+}
+
+rule InterfaceUnitToInterface extends KDMEntityToNamedElement {
+	from src :kdm!InterfaceUnit (not src.refImmediateComposite().oclIsTypeOf(kdm!TemplateUnit))
+	to tgt :uml!Interface (
+		-- specific case to manage templated methods (encapsulated in a TemplateUnit)
+		nestedClassifier <- src.codeElement->select(e | e.oclIsKindOf(kdm!Datatype))
+				->select(e | if (e.oclIsTypeOf(kdm!TemplateUnit)) then not (e->getRealType().oclIsTypeOf(kdm!MethodUnit)) else true endif)
+		,generalization <- src.codeRelation->select(e | e.oclIsTypeOf(kdm!Extends))
+		,ownedOperation <- src.codeElement->select(e | e.oclIsTypeOf(kdm!MethodUnit))
+		,ownedAttribute <- src.codeElement->select(e | e.oclIsKindOf(kdm!DataElement))
+	)
+}
+
+rule EnumeratedTypeToEnumeration extends KDMEntityToNamedElement {
+	from src :kdm!EnumeratedType
+	to tgt :uml!Enumeration (
+		ownedLiteral <- src.value
+	)
+}
+
+
+abstract rule TemplateUnitToTemplateableElement {
+	from src :kdm!TemplateUnit
+--	to tgt :uml!TemplateableElement (
+--		ownedTemplateSignature <- signature
+--	)
+	to signature :uml!RedefinableTemplateSignature (
+		name <- src.name
+		,ownedParameter <- src.codeElement->select(e | e.oclIsTypeOf(kdm!TemplateParameter))
+								->collect(parameter | thisModule->TemplateParameterToClassifierTemplateParameter(parameter))
+	)
+}
+
+lazy rule TemplateParameterToClassifierTemplateParameter {
+	from src :kdm!TemplateParameter
+	to tgt :uml!ClassifierTemplateParameter (
+		-- name is not managed in UML
+		ownedParameteredElement <- parameter
+	)
+	, parameter :uml!Class (
+		name <- src.name
+	)
+}
+
+rule TemplateUnitToClass extends TemplateUnitToTemplateableElement {
+	from src :kdm!TemplateUnit (
+		src->getRealType().oclIsTypeOf(kdm!ClassUnit)
+		)
+	using {
+		realType :kdm!Datatype = src->getRealType();
+	}
+	to tgt :uml!Class (
+		name <- realType.name
+		,isAbstract <- realType.isAbstract
+		-- specific case to manage templated methods (encapsulated in a TemplateUnit)
+		,nestedClassifier <- realType.codeElement->select(e | e.oclIsKindOf(kdm!Datatype))
+				->select(e | if (e.oclIsTypeOf(kdm!TemplateUnit)) then not (e->getRealType().oclIsTypeOf(kdm!MethodUnit)) else true endif)
+		,generalization <- realType.codeRelation->select(e | e.oclIsTypeOf(kdm!Extends))
+		,interfaceRealization <- realType.codeRelation->select(e | e.oclIsTypeOf(kdm!Implements))
+		,ownedOperation <- realType.codeElement->select(e | e.oclIsTypeOf(kdm!MethodUnit))
+		,ownedAttribute <- realType.codeElement->select(e | e.oclIsKindOf(kdm!DataElement))
+	)
+}
+
+rule TemplateUnitToInterface extends TemplateUnitToTemplateableElement {
+	from src :kdm!TemplateUnit (
+		src->getRealType().oclIsTypeOf(kdm!InterfaceUnit)
+		)
+	using {
+		realType :kdm!Datatype = src->getRealType();
+	}
+	to tgt :uml!Interface (
+		name <- realType.name
+		-- specific case to manage templated methods (encapsulated in a TemplateUnit)
+		,nestedClassifier <- realType.codeElement->select(e | e.oclIsKindOf(kdm!Datatype))
+				->select(e | if (e.oclIsTypeOf(kdm!TemplateUnit)) then not (e->getRealType().oclIsTypeOf(kdm!MethodUnit)) else true endif)
+		,generalization <- realType.codeRelation->select(e | e.oclIsTypeOf(kdm!Extends))
+		,ownedOperation <- realType.codeElement->select(e | e.oclIsTypeOf(kdm!MethodUnit))
+		,ownedAttribute <- realType.codeElement->select(e | e.oclIsKindOf(kdm!DataElement))
+	)
+}
+
+rule ExtendsToGeneralization {
+	from src :kdm!Extends
+	to tgt :uml!Generalization (
+		general <- src.to
+	)
+}
+
+rule ImplementsToInterfaceRealization {
+	from src :kdm!Implements
+	to tgt :uml!InterfaceRealization (
+		contract <- if (src.to.oclIsTypeOf(kdm!ClassUnit)) then OclUndefined else src.to endif
+	)
+	do {
+		if (src.to.oclIsTypeOf(kdm!ClassUnit)) {
+			src.from->debug('Invalid implements, from ');
+			src.to->debug('to ');
+		}
+	}
+}
+
+rule ImportsToDependency {
+	from src :kdm!Imports
+	to tgt :uml!Dependency (
+		client <- src.from
+		,supplier <- src.to
+	)
+	do {
+		-- store the created dependency in first parent package of client element
+		thisModule.resolveTemp(src.from->getPackageContainer(), 'tgt').packagedElement <- tgt;
+	}
+}
+
+rule TemplateTypeToInterface {
+	from src : kdm ! TemplateType (
+		if (src->getTemplateUnit() = OclUndefined) then
+			false
+		else
+			src->getTemplateUnit()->getRealType().oclIsTypeOf(kdm!InterfaceUnit)
+		endif
+	)
+	to tgt :uml!Interface(
+		name<-src.name
+		,templateBinding <- src.codeRelation->select(e | e.oclIsTypeOf(kdm!ParameterTo))
+	)
+	do {
+		thisModule.resolveTemp(src->getTemplateUnit()->getPackageContainer(), 'tgt').packagedElement <- tgt;
+	}
+}
+
+rule TemplateTypeToClass {
+	from src : kdm ! TemplateType (
+		if (src->getTemplateUnit() = OclUndefined) then
+			false
+		else
+			not src->getTemplateUnit()->getRealType().oclIsTypeOf(kdm!InterfaceUnit)
+		endif		
+	)
+	to tgt :uml!Class(
+		name<-src.name
+		,templateBinding <- src.codeRelation->select(e | e.oclIsTypeOf(kdm!ParameterTo))
+	)
+	do {
+		thisModule.resolveTemp(src->getTemplateUnit()->getPackageContainer(), 'tgt').packagedElement <- tgt;
+	}
+}
+
+rule ParameterToToTemplateBinding {
+	from src :kdm!ParameterTo (src.from->getTemplateUnit().oclIsTypeOf(kdm!TemplateUnit))
+	to tgt :uml!TemplateBinding (
+		signature <- thisModule.resolveTemp(src.from->getTemplateUnit(), 'signature')
+		,parameterSubstitution <- substitution
+	)
+	, substitution :uml!TemplateParameterSubstitution (
+--		actual <- src.to
+		--,formal <- src.from->getTemplateUnit().codeElement->at(src.from.codeRelation->indexOf(src))
+	)
+	do {
+		substitution.formal <- tgt.signature.ownedParameter->at(src.from.codeRelation->indexOf(src));
+	}
+}
+--------------------------------End-Rules------------------------------------
+
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+-- ##########################################################################
+
+---Specific rules for code package in KDM metamodel, dedicated to members----
+
+rule ValueToEnumerationLiteral {
+	from src :kdm!Value (src.refImmediateComposite().oclIsTypeOf(kdm!EnumeratedType))
+	to tgt :uml!EnumerationLiteral (
+		name <- src.name
+	)
+}
+
+-- we have to filter dummy operations (needed in KDM to store behaviour)
+rule MethodUnitToOperation extends KDMEntityToNamedElement {
+	from src :kdm!MethodUnit (
+		not src.refImmediateComposite().oclIsTypeOf(kdm!TemplateUnit)
+		and not (src.type.oclIsUndefined())
+		and not (src.refImmediateComposite().oclIsTypeOf(kdm!CodeModel)) -- Unresolved items
+	)
+	to tgt :uml!Operation (
+		ownedParameter <- src.type.parameterUnit
+	)
+}
+
+rule TemplateUnitToOperation extends TemplateUnitToTemplateableElement {
+	from src :kdm!TemplateUnit (
+		src->getRealType().oclIsTypeOf(kdm!MethodUnit)
+	)
+	using {
+		realType :kdm!MethodUnit = src->getRealType();
+	}
+	to tgt :uml!Operation (
+		name <- realType.name
+		,visibility <- src->getVisibility()
+		,ownedParameter <- realType.type.parameterUnit
+	)
+}
+
+rule ParameterUnitToParameter extends KDMEntityToNamedElement {
+	from src :kdm!ParameterUnit
+	to tgt :uml!Parameter (
+		direction <- if (src.kind = #return) then #return else OclUndefined endif
+--		,type <- src->getDataElementType()
+		,lowerValue <- lower
+		,upperValue <- upper
+	)
+	, lower : uml!LiteralInteger (
+		value <- src.getLowerCardinality()
+	)
+	, upper : uml! LiteralUnlimitedNatural (
+		value <- src.getUpperCardinality()
+	)
+}
+
+rule MemberUnitToProperty extends KDMEntityToNamedElement {
+	from src :kdm!MemberUnit
+	to tgt :uml!Property (
+		type <- src->getDataElementType()
+		,lowerValue <- lower
+		,upperValue <- upper
+	)
+	, lower : uml!LiteralInteger (
+		value <- src.getLowerCardinality()
+	)
+	, upper : uml! LiteralUnlimitedNatural (
+		value <- src.getUpperCardinality()
+	)
+	do {
+		if (not (src->getDataElementType().oclIsUndefined())) {
+			if (not (src->getDataElementType()->isPrimitiveType())) {
+				thisModule->DataElementToAssociation(src);
+			}
+			if (not (src->getDataElementQualifierType().oclIsUndefined())) {
+				tgt.qualifier <- thisModule.DatatypeToProperty(src->getDataElementQualifierType());
+			}
+		}
+	}
+}
+
+rule StorableUnitToProperty extends KDMEntityToNamedElement {
+	from src :kdm!StorableUnit (not (src.kind = #local)
+		and not (src.refImmediateComposite().oclIsTypeOf(kdm!CodeModel))) -- Unresolved items
+	to tgt :uml!Property (
+--		type <- src->getDataElementType(),
+		isStatic <- if (src.kind = #static) then true else false endif
+		,lowerValue <- lower
+		,upperValue <- upper
+	)
+	, lower : uml!LiteralInteger (
+		value <- src.getLowerCardinality()
+	)
+	, upper : uml! LiteralUnlimitedNatural (
+		value <- src.getUpperCardinality()
+	)
+	do {
+		if (not (src->getDataElementType().oclIsUndefined())) {
+			if (not (src->getDataElementType()->isPrimitiveType())) {
+				thisModule->DataElementToAssociation(src);
+			}
+			if (not (src->getDataElementQualifierType().oclIsUndefined())) {
+				tgt.qualifier <- thisModule.DatatypeToProperty(src->getDataElementQualifierType());
+			}
+		}
+	}
+}
+
+lazy rule DataElementToAssociation {
+	from src :kdm!DataElement
+	to tgt :uml!Association (
+		memberEnd<- src
+		,memberEnd <- targetProperty
+		,ownedEnd <- targetProperty
+	)
+	, targetProperty :uml!Property (
+--		type <- src.refImmediateComposite()
+	)
+	do {
+		thisModule.resolveTemp(src->getPackageContainer(), 'tgt').packagedElement <- tgt;
+	}
+}
+
+-- to create qualifier for a parent property
+lazy rule DatatypeToProperty {
+	from src :kdm!Datatype
+	to tgt :uml!Property (
+		name <- 'qualifier'
+		,type <- src
+	)
+}
+--------------------------------End-Rules------------------------------------