/*****************************************************************************
 * Copyright (c) 2016 CEA LIST.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *  Vincent Lorenzo (CEA LIST) vincent.lorenzo@cea.fr - Initial API and implementation
 *****************************************************************************/
 
import org.eclipse.papyrus.migration.rhapsody.blackboxes.uml.AssociationOwnerHelper;
import org.eclipse.papyrus.migration.rhapsody.blackboxes.rhapsody.RhapsodyHelper;
import RhapsodyToPapyrusUtils;
import SysMLRhapsodyUtils;

modeltype uml "strict" uses 'http://www.eclipse.org/uml2/5.0.0/UML';
modeltype ecore "strict" uses 'http://www.eclipse.org/emf/2002/Ecore';
modeltype umlrhapsody "strict" uses 'http://www.eclipse.org/Papyrus/UMLRhapsody/1.0.0';
modeltype notation "strict" uses 'http://www.eclipse.org/gmf/runtime/1.0.2/notation';
modeltype UMLPrimitivesTypes "strict" uses 'http://www.eclipse.org/uml2/5.0.0/Types' ;
//add syml profile
modeltype sysml11 "strict" uses 'http://www.eclipse.org/papyrus/0.7.0/SysML';
	
/**
*	Transformation rules for importing a Rhapsody Semantic model into a UML model 
*/
transformation Rhapsody2PapyrusSemanticElements(in inModel:umlrhapsody, out outModel:uml, in primitives:UMLPrimitivesTypes);

property events : Set(IEvent) = null;

/**This variable is used to reference the types created outside of all contexts. (bug 510869)*/
property userTypeDeclaration: Set(Type);

/**
* Maunch the semantic transformation
*/
main() {
	log('Start UML Semantic QVTo Transfo');
		inModel.rootObjects()[IProject]->map iProjectToPapyrusModel();
		setAssociationOwnerAndClear();
	log('Finish UML Semantic QVTO Transfo');
}

/**
*
* Create a Model from the IProject
*/
mapping umlrhapsody::IProject::iProjectToPapyrusModel() : uml::Model {
	name:=self.name.replaceAll("\"","");
	eAnnotations+=inModel.rootObjects()->selectByType(IProject)![IProject].createEAnnotationForVersioning();

	//managing the rhapsodyType, importing them in the user model
	var rhapsodyLibraries:Sequence(uml::Package):=getISubsystemsFromRhapsodyLibraries(self).map importRhapsodyTypeLibrary();

	//we map the packaged elements
	packagedElement+=self.Subsystems.map iDefaultSubsystemTypeToPackage();

	//we add the rhapsody library at the end
	packagedElement+=rhapsodyLibraries;//we add them add the end of the list. it is a kind of feature, to show firstly in the model the user elements 
		
	//import uml basic primitives Types by default
	var importedPackages: Set(PackageImport);
	var models : Set(Model) := primitives.objectsOfType(Model);
	models->forEach(package){
		var packageImport:=object PackageImport{
			importedPackage:=package;
		};
		importedPackages+=packageImport;
	};

	packageImport+=importedPackages;
	
	if(userTypeDeclaration->notEmpty()){
		packagedElement+= object Package{
			name:="UserTypesDeclaration";
			packagedElement+=userTypeDeclaration;
		}
	}
}

/**
*
* dedicated method to import only types from Rhapsody Library
*/
mapping umlrhapsody::ISubsystem::importRhapsodyTypeLibrary():uml::Package{
	name:=self.name;
	packagedElement += self.Types->selectByType(IType)->selectByKind(EObject).map generalMappingToUMLElement().oclAsType(uml::PackageableElement);
}

/**
* Create packages from DefaultSubsystemType
*/
mapping umlrhapsody::DefaultSubsystemType::iDefaultSubsystemTypeToPackage():uml::Package when{self.oclIsKindOf(ISubsystem)}{
	var iSubSystem:ISubsystem:=self.oclAsType(ISubsystem);
	name:=iSubSystem.name;
	
	//no idea about this code coming from the initial prototype
	if(iSubSystem.SignalEvents()[IEvent].oclAsSet()->notEmpty()){
		var SignalsPackage := object Package{
			name:= "Signals";
			packagedElement:= iSubSystem.SignalEvents()->selectByKind(EObject).map generalMappingToUMLElement().oclAsType(PackageableElement);
		};
		nestedPackage+=SignalsPackage;
	};
	
	//no idea about this code coming from the initial prototype
	if(iSubSystem.SignalEvents()[IEvent].oclAsSet()->notEmpty()){
		var SignalEventPackage := object Package{
			name:= "Signal Events";
			packagedElement:= iSubSystem.SignalEvents()[IEvent].map toSignalEvents();
		};
		nestedPackage+=SignalEventPackage;
	};
	
	packagedElement+=iSubSystem.Events->selectByType(IEvent)->selectByKind(EObject).map generalMappingToUMLElement().oclAsType(PackageableElement);
	
	packagedElement+= iSubSystem.Classes->selectByType(IClass)->any(name="TopLevel").Attrs->selectByKind(IAttribute).oclAsType(EObject).map generalMappingToUMLElement().oclAsType(PackageableElement);
	//TODO probably more check are required to remove TopLevel without problems (check with MARTE...)
	packagedElement+= iSubSystem.Classes->selectByType(IClass)->select(curr | curr.name<>"TopLevel")->selectByKind(EObject).map generalMappingToUMLElement().oclAsType(uml::PackageableElement);
	packagedElement += iSubSystem.Classes[IClass].Associations[IAssociationEnd]->select(assoEnd: IAssociationEnd |not (assoEnd.oclAsType(IAssociationEnd).inverse.oclIsUndefined()))->any(true).map toAssociationswithoutProp();
	packagedElement += iSubSystem.Types->selectByType(IType)->selectByKind(EObject).map generalMappingToUMLElement().oclAsType(uml::PackageableElement);
	packagedElement += iSubSystem.Actors->selectByKind(IActor)->oclAsType(EObject).map generalMappingToUMLElement().oclAsType(uml::PackageableElement);
	packagedElement +=iSubSystem.Declaratives[DefaultSubsystemType].oclAsSet().map iDefaultSubsystemTypeToPackage();
	ownedComment += iSubSystem.Annotations->select(a | (a.oclIsTypeOf(IAnnotation) or a.oclIsTypeOf(IComment)))->oclAsType(EObject).map generalMappingToUMLElement().oclAsType(uml::Comment);
	var localComment:Comment:=iSubSystem.description.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(uml::Comment);
	localComment.annotatedElement:=result;
	ownedComment+=localComment;
}

/**
*
* This method has been created to be the common entry point for all the semantic transformations from the Rhapsody Model to the UML Model
* TODO : rewrite all transformations in order to use me everywhere  
*/
mapping ecore::EObject::generalMappingToUMLElement():uml::Element disjuncts
	ecore::EObject::iActorToUMLActor,
	ecore::EObject::iCommentToUMLComment,
	ecore::EObject::iDescriptionToUMLComment,
	ecore::EObject::iAttributeToUMLInstanceSpecification,
	ecore::EObject::iClassToUMLInterface, 
 	ecore::EObject::iClassToUMLClass,
 	ecore::EObject::iEventToUMLSignal,
 	ecore::EObject::iTypeToUMLDatatype,
 	ecore::EObject::iTypeToUMLInstanceSpecification, 
 	ecore::EObject::iTypeToUMLEnumeration,
 	ecore::EObject::iTypeToUMLClass, //TODO : merge me with the existing other way to create a class
 	ecore::EObject::iTypeToDefault
{}

/**
* This mapping convert an IActor into a UML Actor
*/
mapping EObject::iActorToUMLActor():uml::Actor when {self.oclIsTypeOf(umlrhapsody::IActor)}{
	var actor:IActor:=self.oclAsType(IActor);
	name:=actor.name;
	ownedComment += actor.Annotations->selectByType(IComment).oclAsType(EObject).map generalMappingToUMLElement().oclAsType(uml::Comment);
}

/**
*
* This mapping convert a IComment into a UML Comment
*/
mapping EObject::iCommentToUMLComment(): uml::Comment when {self.oclIsTypeOf(IComment)}{
	var comment:IComment:=self.oclAsType(IComment);
	body:=comment.body;
	if(body=null or body.size()=0){
		body:=comment.description.text;
		if(body=null or body.size()=0){
			body:=comment.description.textRTF.getTextWithoutMarkers();
		}
	};
	comment.Anchors->forEach(anchor){
		var rpyAnnotatedElement:EObject:=anchor.dependsOn.oclAsType(EObject);
		//this is the generic method to call to create/find mapped element
		var resolvedContext:Element:=rpyAnnotatedElement.map generalMappingToUMLElement();
		
		//TODO : the code of the transformation should be refactored to use the previous one, nevertheless, waiting for this refactoring, we use this code
		if(resolvedContext=null){
			var metaClassName:String:= rpyAnnotatedElement.metaClassName();
			annotatedElement+=switch{
				case (metaClassName="IPart") rpyAnnotatedElement.oclAsType(umlrhapsody::IPart).map iPartToUMLElement().oclAsType(uml::Element);
				case (metaClassName="IAttribute") rpyAnnotatedElement.oclAsType(umlrhapsody::IAttribute).map iVariableToUMLElement().oclAsType(uml::Element);
			};
		}else{
			annotatedElement+=resolvedContext;
		}
	}
}

/**
*
* This mapping convert a IDescription into a UML Comment
*/
mapping EObject::iDescriptionToUMLComment(): uml::Comment when {self.oclIsTypeOf(IDescription)}{
	var description:IDescription:=self.oclAsType(IDescription);
	body:=description.text;
	if(body=null or body.size()=0){
		body:=description.textRTF.getTextWithoutMarkers();
	};
	if(self.eContainer().oclIsKindOf(Element)){
		annotatedElement+=self.eContainer().oclAsType(Element);
	}
}

/**
* This method remove all markers in the string
*/ 
helper String::getTextWithoutMarkers():String{
	//this code seems me quite specific to my examples, but I don't have better idea
	var res:String:=self.replaceAll("\\\\[a-zA-Z0-9]*", ""); //to remove all formatting information
	
	//we remove the end of the string
	var lastIndex:Integer:=res.lastIndexOf("\n}");
	if(lastIndex<>-1){
		res:=res.substring(1,lastIndex-1);
	};
			
	var t:="}\n "; //} + carriage return + white space
	
	//we remove the beginning of the string
	lastIndex:=res.lastIndexOf(t);
	if(lastIndex<>-1){
		res:=res.substring(lastIndex+t.length(),res.length());
	};
	
	return res;
}

/**
*
* return true if the IClass is representing an interface
*/
mapping ecore::EObject::iClassToUMLInterface() : uml::Interface when {self.oclIsTypeOf(umlrhapsody::IClass) and self.oclAsType(umlrhapsody::IClass).isInterface() /*self.isSysMLFlowSpecification()*/}{
	var localIClass:umlrhapsody::IClass:=self.oclAsType(umlrhapsody::IClass);
	name:= localIClass.name.replaceAll("\"","");
	ownedAttribute+= localIClass.Attrs[IAttribute].map iVariableToUMLElement();
//	ownedAttribute+= self.Associations[IAssociationEnd].map toAssociationsEnd();
//	ownedOperation := self.Operations [IPrimitiveOperation].map toOperations();
//	ownedReception:= self.Operations[IReception].map toReceptions();
//	generalization:= self.Inheritances [IGeneralization].map toPapyrusGeneralization();
}



/**
*
* When we match any condition, we create a uml::DataType. 
* We can be here in case of bug, when an existing type has not been resolved
* or when the user use the C type declaration in Rhapsody (declaring a type with a string, see bug 510869)
*/
mapping ecore::EObject::iTypeToDefault():uml::DataType when{self.oclIsTypeOf(IType)}{
	var localIType:IType:=self.oclAsType(IType);	

	if(localIType.name=null or localIType.name.oclIsInvalid()){
		if(localIType.declaration<>null){
			name:=localIType.declaration;
		}
	}else{
		name:=localIType.name.replaceAll("\"","");
	};
}


/**
* This method allows to map a RhapsodyType on an other type
*/
query umlrhapsody::IType::mapToBasicType(inout templateableElement:TemplateableElement){
	//we assurme here that the UML PrimitiveTypes are already imported
	var baseType:IUnit := self.typedefBaseType;
	if(not(baseType.oclIsUndefined()) and baseType.oclIsTypeOf(IType)){
//			var name:String:=baseType.metaClassName();
			var umlType:uml::Type :=baseType.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
			if(not(umlType.oclIsUndefined())){//should never appends
						var templateBinding := object uml::TemplateBinding{
					
						};
//						var redefinableTemplateSignature:=object uml::RedefinableTemplateSignature {
//					
//						};
						var templateParameterSubstitution:= object TemplateParameterSubstitution{
					
						};
//						var classifierTemplateParameter:= object ClassifierTemplateParameter{
//					
//						};
	
						templateableElement.templateBinding+=templateBinding;
						templateBinding.boundElement:=templateableElement;
//						//templateBinding.source:=templatableElement; //read only
//						//templateBinding.target:=templateParameterSubstitution; //read only
//						templateBinding.signature:=redefinableTemplateSignature;
						templateBinding.parameterSubstitution+=templateParameterSubstitution;		
						templateParameterSubstitution.actual:=umlType;	
			};
	};
//	return templateableElement;
}


/**
* Return true if the object must be converted into a UML DataType
*
* For JUnit SysML test1: 
* 		must be converted into UML Datatype : 
*    MyBool : kind = Typedef and stereotype = DataType
*    MyArrayOfInt : kind = Typedef and stereotype DataType
*    MyPrimitivesTypes : kind = Language and stereotype = DataType
*    MySpeed : kind = kind = Typedef and ValueType 
*    IType defined in Rhapsody Library (like PredefinedTypes) must be imported as DatType
*/
query umlrhapsody::IType::isUMLDataType(): Boolean {
	var res:=self.isSysMLValueType() and not self.isKindEnumeration();
	if(not res){
		res:=(self.isRhapsodyDataType() or self.isRhapsodyLibraryType()) and  (self.isKindLanguage() or self.isKindTypedef());
    };
	return res;
}


/**
* Return true if the IType is kind Typedef
*/
query umlrhapsody::IType::isKindTypedef(): Boolean{
	return self.kind="Typedef";
}

/**
* Return true if the IType is kind Enumeration
*/
query umlrhapsody::IType::isKindEnumeration(): Boolean{
	return self.kind="Enumeration";
}

/**
* Return true if the IType is kind Enumeration
*/
query umlrhapsody::IType::isKindStructure(): Boolean{
	return self.kind="Structure";
}

/**
* Return true if the IType has kind Language
*/
query umlrhapsody::IType::isKindLanguage(): Boolean {
	return self.kind="Language";
}

query umlrhapsody::IType::isUMLClass(): Boolean{
	return self.isKindStructure() and (self.isRhapsodyDataType() or self.isSysMLValueType());
}

query umlrhapsody::IType::isUMLEnumeration():Boolean{
	return self.isKindEnumeration() and ((self.isRhapsodyDataType() or self.isSysMLValueType()) //TODO to check : is it required to check isDatatYpe and isSysmlValueType ? 
	or self.isRhapsodyLibraryType()); //to create Enumeration for Type defined ni RhapsodyLibrary
}

query umlrhapsody::IType::isUMLInstanceSpecification(): Boolean {
	return self.isKindLanguage() and (self.isSysMLDimension() or self.isSysMLUnit());
}






mapping umlrhapsody::IAssociationEnd::toAssociationswithoutProp(): uml::Association {
	var assoEnd:Set(umlrhapsody::IAssociationEnd) =inModel.rootObjects()[IProject].defaultSubsystem[ISubsystem].Classes[IClass].Associations[IAssociationEnd]->select(assoEnd: IAssociationEnd |not (assoEnd.oclAsType(IAssociationEnd).inverse.oclIsUndefined()))->asSet();
	memberEnd:=assoEnd.map toAssociationsEnd();
}

mapping umlrhapsody::IAssociationEnd::toAssociationswithProp(): uml::Association {			
	//please keep this order (O source and 1 target) -> if we change this property we broke the BDD of test2
	var localMemberEnd:=self.map toAssociationsEnd();
	memberEnd+= localMemberEnd; 
	var localOwnedEnd:=self.map toOwnedAssociationEnd();
	ownedEnd+= localOwnedEnd;
	name:=localOwnedEnd.type.name  + " refers to " + localMemberEnd.type.name + " as " + localMemberEnd.name;
			
}

mapping umlrhapsody::IAssociationEnd::toOwnedAssociationEnd(): uml::Property{
	type:= self.container().oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
	var type : uml::Class = type.oclAsType(Class);
}

mapping ecore::EObject::iTypeToUMLDatatype() : uml::DataType when {self.oclIsTypeOf(IType) and self.oclAsType(IType).isUMLDataType()}{
	var localIType:IType:=self.oclAsType(IType);		
	name:= localIType.name.replaceAll("\"","");
	ownedAttribute+=localIType.Attrs[IAttribute].map iVariableToUMLElement();
	localIType.mapToBasicType(result.oclAsType(uml::TemplateableElement));
}

mapping ecore::EObject::iTypeToUMLEnumeration() : uml::Enumeration when {self.oclIsTypeOf(IType) and self.oclAsType(IType).isUMLEnumeration()}{
	var localIType:IType:=self.oclAsType(IType);
	name:= localIType.name.replaceAll("\"","");
	ownedLiteral+=localIType.Literals[IEnumerationLiteral].map toUMLEnumerationLiteral();
	localIType.mapToBasicType(result.oclAsType(uml::TemplateableElement));
}

mapping umlrhapsody::IEnumerationLiteral::toUMLEnumerationLiteral() : uml::EnumerationLiteral {
	name:= self.name.replaceAll("\"","");
}

mapping ecore::EObject::iTypeToUMLInstanceSpecification() : uml::InstanceSpecification when {self.oclIsTypeOf(IType) and self.oclAsType(IType).isUMLInstanceSpecification()}{
	var localIType:IType:=self.oclAsType(IType);	
	name:= localIType.name.replaceAll("\"","");
}

//TODO : refactore me, there is at least 2 method to create a class, on efrom an IType and an other one from a IClass
mapping ecore::EObject::iTypeToUMLClass() : uml::Class when {self.oclIsTypeOf(IType) and self.oclAsType(IType).isUMLClass()}{//stereotype Block is added later in the process
	var localIType:IType:=self.oclAsType(IType);
	name:= localIType.name.replaceAll("\"","");
	ownedAttribute+=localIType.Attrs[IAttribute].map iVariableToUMLElement();
	localIType.mapToBasicType(result.oclAsType(uml::TemplateableElement));
}


mapping ecore::EObject::iClassToUMLClass(): uml::Class when {self.oclIsTypeOf(umlrhapsody::IClass) and not (self.oclAsType(umlrhapsody::IClass).isInterface())}{
	var localIClass:umlrhapsody::IClass:=self.oclAsType(umlrhapsody::IClass);	

	name:= localIClass.name.replaceAll("\"","");
	ownedAttribute+= localIClass.Attrs[IAttribute].map iVariableToUMLElement();
	ownedAttribute+= localIClass.Associations[IPart].map iPartToUMLElement().oclAsType(uml::Property);
	
	var associationsToAdd:=localIClass.Associations[IPart].map iPartToUMLAssociation();
	
	nestedClassifier+= localIClass.Associations[IPart]->select(current | current.implicitClass<>null).implicitClass.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(uml::Classifier);
	nestedClassifier+=localIClass.Declaratives->selectByType(IClass)->selectByKind(EObject).map generalMappingToUMLElement().oclAsType(uml::Classifier);
	
	ownedAttribute+= localIClass.Associations[IAssociationEnd].map toAssociationsEnd();
	associationsToAdd+=localIClass.Associations[IAssociationEnd]->select(assoEnd: IAssociationEnd |assoEnd.oclAsType(IAssociationEnd).inverse.oclIsUndefined()).oclAsSet().map toAssociationswithProp();
	
	
	ownedOperation += localIClass.Operations [IPrimitiveOperation].map toOperations();
	ownedReception += localIClass.Operations[IReception].map toReceptions();
	generalization += localIClass.Inheritances [IGeneralization].map toPapyrusGeneralization();
	ownedBehavior += localIClass.StateCharts[IStateChart].map toStateMachine();

	ownedAttribute+=localIClass.Ports.map iRelationToUMLElement().oclAsType(uml::Property);
	ownedConnector+=localIClass.ObjectLinks[IObjectLink].map iObjectLinkToUMLElement().oclAsType(uml::Connector);
	ownedConnector+=localIClass.Declaratives[IInformationFlow].map iInformationFlowToUMLElement().oclAsType(uml::Connector);
	
	ownedComment+=localIClass.Annotations.oclAsType(IComment).oclAsType(EObject).map generalMappingToUMLElement().oclAsType(uml::Comment);
	
	registerAssociationToStore(result, associationsToAdd);
}


/**
* This method map a IObjectLink with a UML Element
*
*/
mapping umlrhapsody::IInformationFlow::iInformationFlowToUMLElement():uml::Element disjuncts 
	umlrhapsody::IInformationFlow::iInformationFlowToUMLConnector
{}

/**
* This method map a IInformationFlow with a UML Connector
*
*/
mapping umlrhapsody::IInformationFlow::iInformationFlowToUMLConnector():uml::Connector when{self.isUMLConnector() }{
	name:= self.name.replaceAll("\"","");	
	_end+=self.map iInformationFlowSourceToUMLConnectorEnd();
	_end+=self.map iInformationFlowTargetToUMLConnectorEnd();
}

/**
* This method map a IInformationFlow with a UML Connector End used as source
*
*/
mapping umlrhapsody::IInformationFlow::iInformationFlowSourceToUMLConnectorEnd():uml::ConnectorEnd{
	var end1:umlrhapsody::End1_Type:=self.end1_;
	var end1ObjectPort:umlrhapsody::IInstance:=self.end1ObjectPort_;
	
	var mappingEnd1:uml::Element; 	
	var mappingEnd1ObjectPort:uml::Element;
	//1. we manage the end1 property
	if(end1<>null){
		if(end1.oclIsTypeOf(umlrhapsody::IPart)){
			mappingEnd1:=end1.oclAsType(umlrhapsody::IPart).map iPartToUMLElement().oclAsType(uml::Property);
		}elif(end1.oclIsTypeOf(umlrhapsody::IAttribute)){
			mappingEnd1:=end1.oclAsType(IAttribute).map iVariableToUMLElement();
		}elif(end1.oclIsKindOf(umlrhapsody::IRelation)){
			mappingEnd1:=end1.oclAsType(IRelation).map iRelationToUMLElement();
		};
	};
	
	//2. we manage the end1ObjectPort_ property when required
	if(end1ObjectPort<>null and end1ObjectPort.oclIsKindOf(umlrhapsody::IRelation)){
			mappingEnd1ObjectPort:=end1ObjectPort.oclAsType(umlrhapsody::IRelation).map iRelationToUMLElement().oclAsType(uml::Element);
	};
		
	if(mappingEnd1ObjectPort=null){
		if(mappingEnd1.oclIsTypeOf(uml::Property)){
			role:=mappingEnd1.oclAsType(uml::Property);
		}
	}else{
		if(mappingEnd1ObjectPort.oclIsTypeOf(uml::Property)){
			role:=mappingEnd1ObjectPort.oclAsType(uml::Property);
		}elif(mappingEnd1ObjectPort.oclIsTypeOf(uml::Port) and mappingEnd1.oclIsTypeOf(uml::Property)){
			//not sure, not example for this usecase
			role:=mappingEnd1ObjectPort.oclAsType(uml::Property);
			partWithPort:=mappingEnd1.oclAsType(uml::Property);
		};
	
	};
}

/**
* This method map a IInformationFlow with a UML Connector End used as target
*
*/
mapping umlrhapsody::IInformationFlow::iInformationFlowTargetToUMLConnectorEnd():uml::ConnectorEnd{
	var end2:umlrhapsody::End1_Type:=self.end2_;
	var end2ObjectPort:umlrhapsody::IInstance:=self.end2ObjectPort_;
	
	var mappingEnd2:uml::Element; 	
	var mappingEnd2ObjectPort:uml::Element;
	//1. we manage the end2 property
	if(end2<>null){
		if(end2.oclIsTypeOf(umlrhapsody::IPart)){
			mappingEnd2:=end2.oclAsType(umlrhapsody::IPart).map iPartToUMLElement().oclAsType(uml::Property);
		}elif(end2.oclIsTypeOf(umlrhapsody::IAttribute)){
			mappingEnd2:=end2.oclAsType(IAttribute).map iVariableToUMLElement();
		}elif(end2.oclIsKindOf(umlrhapsody::IRelation)){
			mappingEnd2:=end2.oclAsType(IRelation).map iRelationToUMLElement();
		};
	};
	
	//2. we manage the end2ObjectPort_ property when required
	if(end2ObjectPort<>null and end2ObjectPort.oclIsKindOf(umlrhapsody::IRelation)){
			mappingEnd2ObjectPort:=end2ObjectPort.oclAsType(umlrhapsody::IRelation).map iRelationToUMLElement().oclAsType(uml::Element);
	};
	
	if(mappingEnd2ObjectPort=null){
		if(mappingEnd2.oclIsTypeOf(uml::Property)){
			role:=mappingEnd2.oclAsType(uml::Property);
		}
	}else{
		if(mappingEnd2ObjectPort.oclIsTypeOf(uml::Property)){
			role:=mappingEnd2ObjectPort.oclAsType(uml::Property);
		}elif(mappingEnd2ObjectPort.oclIsTypeOf(uml::Port) and mappingEnd2.oclIsTypeOf(uml::Property)){
			//not sure, not example for this usecase 
			role:=mappingEnd2ObjectPort.oclAsType(uml::Property);
			partWithPort:=mappingEnd2.oclAsType(uml::Property);
		};
	};
}

/**
*
* Returns true of the object is a UML Connector
*/
query umlrhapsody::IInformationFlow::isUMLConnector(): Boolean{
	return self.Stereotypes[IStereotype]->select(ste | ste.name="BindingConnector").oclAsSet()->notEmpty()
}



/**
* This method map a IObjectLink with a UML Element
*
*/
mapping umlrhapsody::IObjectLink::iObjectLinkToUMLElement():uml::Element disjuncts 
	umlrhapsody::IObjectLink::iObjectLinkToUMLConnector
{}

/**
* This method map a IObjectLink with a UML Connector
*
*/
mapping umlrhapsody::IObjectLink::iObjectLinkToUMLConnector():uml::Connector when{self.isUMLConnector() }{ 
	name:= self.name.replaceAll("\"","");	
	_end+=self.map iObjectLinkSourceToUMLConnectorEnd();
	_end+=self.map iObjectLinkTargetToUMLConnectorEnd();
}

/**
* This method map a IObjectLink with a UML Connector End used as source
*
*/
mapping umlrhapsody::IObjectLink::iObjectLinkSourceToUMLConnectorEnd():uml::ConnectorEnd{
	var fromLink:umlrhapsody::FromLinkType:=self.fromLink;
	var fromPort:umlrhapsody::IRelation:=self.fromPort;
	//1. we manage the from link property
	if(fromLink<>null){
		if(fromLink.oclIsTypeOf(umlrhapsody::IPart)){
			partWithPort:=fromLink.oclAsType(umlrhapsody::IPart).map iPartToUMLElement().oclAsType(uml::Property);
		}elif(fromLink.oclIsTypeOf(umlrhapsody::IAssociationEnd)){
			partWithPort:=fromLink.oclAsType(IAssociationEnd).map toAssociationsEnd();
		}elif(fromLink.oclIsKindOf(umlrhapsody::IRelation)){
			role:=fromLink.oclAsType(umlrhapsody::IRelation).map iRelationToUMLElement().oclAsType(uml::Port);
		};
	};
	
	//2. we manage the fromPort property when required
	if(fromPort<>null and fromPort.oclIsKindOf(umlrhapsody::IRelation)){
		if(role=null){
			role:=fromPort.oclAsType(umlrhapsody::IRelation).map iRelationToUMLElement().oclAsType(uml::Port);
		}
		//I don't know what to do in other case!
	};	
}

/**
* This method map a IObjectLink with a UML Connector End used as target
*
*/
mapping umlrhapsody::IObjectLink::iObjectLinkTargetToUMLConnectorEnd():uml::ConnectorEnd{
	var toLink:umlrhapsody::FromLinkType:=self.toLink;
	var toPort:umlrhapsody::IRelation:=self.toPort;
	//1. we manage the from link property
	if(toLink<>null){
		if(toLink.oclIsTypeOf(umlrhapsody::IPart)){
			partWithPort:=toLink.oclAsType(umlrhapsody::IPart).map iPartToUMLElement().oclAsType(uml::Property);
		}elif(toLink.oclIsTypeOf(umlrhapsody::IAssociationEnd)){
			partWithPort:=toLink.oclAsType(IAssociationEnd).map toAssociationsEnd();
		}elif(toLink.oclIsKindOf(umlrhapsody::IRelation)){
			role:=toLink.oclAsType(umlrhapsody::IRelation).map iRelationToUMLElement().oclAsType(uml::Port);
		};
	};
	
	//2. we manage the fromPort property when required
	if(toPort<>null and toPort.oclIsKindOf(umlrhapsody::IRelation)){
		if(role=null){
			role:=toPort.oclAsType(umlrhapsody::IRelation).map iRelationToUMLElement().oclAsType(uml::Port);
		}
		//I don't know what to do in other case!
	};	
}

/**
*
* Returns true of the object is a UML Connector
*/
query umlrhapsody::IObjectLink::isUMLConnector(): Boolean{
	return self.isStereotypedWith("connector");
}

mapping umlrhapsody::IRelation::iRelationToUMLElement():uml::Element disjuncts 
	umlrhapsody::IRelation::iRelationToSysMLPort,
	umlrhapsody::IRelation::iRelationToUMLProperty
{}

/**
*
* This mapping convert a IPart into a uml Element
*/
mapping umlrhapsody::IPart::iPartToUMLElement():uml::Element disjuncts
	umlrhapsody::IPart::iPartToUMLProperty
{}

/**
* This method convert an IPart into a uml Property
*
*/ 
mapping umlrhapsody::IPart::iPartToUMLProperty():uml::Property when {self.oclIsTypeOf(IPart)}{
	name:= self.name.replaceAll("\"","");
	//TODO : manage aggregation kind
	aggregation:=AggregationKind::composite;
	type:=self.otherClass.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(uml::Type);
	if((not self.multiplicity.oclIsUndefined()) and self.multiplicity<>"1"){
		lowerValue:=createLowerMultiplicity(self.multiplicity);
		upperValue:=createUpperMultiplicity(self.multiplicity);
	}
}

mapping umlrhapsody::IPart::iPartToUMLAssociation():uml::Association when {true}{
	var part:uml::Property:=self.resolveoneIn(umlrhapsody::IPart::iPartToUMLProperty); //TODO : replace me with a mapping
	var propOwner:uml::NamedElement:=part.owner.oclAsType(NamedElement);
	var propType:=part.type;
	var initialVal:=propType.invresolveone();//TODO is it a good idea to use unresolve ? 
	var res:Boolean:=false;
	if(initialVal.oclIsTypeOf(umlrhapsody::IClass)){
		//TODO : make a util for this stereotype application
		res:=initialVal.oclAsType(umlrhapsody::IClass).Stereotypes[IStereotype]->select(ste | ste.name="ConstraintBlock")->notEmpty();
	};
	if(res){
		name:=propOwner.name + " has constraint " + propType.name + " applied as " + part.name;
	}elif(part.aggregation.toString()=AggregationKind::composite.toString()){
		name:=propOwner.name + " owns a " + propType.name + " as " + part.name;
	};
	
	
	var ownedEnd2:uml::Property:= object Property{};
	
	ownedEnd2.name:=propOwner.name.toLowerCase();
	ownedEnd2.type:=propOwner.oclAsType(uml::Type);
	memberEnd+=ownedEnd;
	memberEnd+=part;
	ownedEnd+=ownedEnd2;
}


/**
* This mapping convert a IRelation instanceof ISysMLPort into a uml Property
*
*/
mapping umlrhapsody::IRelation::iRelationToUMLProperty(): uml::Property when {self.isRhapsodySysMLPortRepresentingUMLProperty()}{
		var sysPort:umlrhapsody::ISysMLPort:=self.oclAsType(ISysMLPort);
		name:= sysPort.name.replaceAll("\"","");
		aggregation:=AggregationKind::composite;
//		if (not sysPort.otherClass.oclIsUndefined()){
//			type := sysPort.otherClass.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
//		}elif(sysPort.otherClass.oclIsKindOf(IClass)){
//				type := sysPort.otherClass.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
//		};
		
		//at this time we don't generate implicite type
		if(sysPort.implicitClass<>sysPort.otherClass){
			type := sysPort.otherClass.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
		};
			//a multiplicity has been defined
		if(not sysPort.multiplicity.oclIsUndefined()){
			lowerValue:= createLowerMultiplicity(sysPort.multiplicity);
			upperValue:= createUpperMultiplicity(sysPort.multiplicity);
		}else{
			lowerValue:= createLowerMultiplicity("1");
			upperValue:= createUpperMultiplicity("1");
		}
}

/**
* This mapping convert a IRelation instanceof ISysMLPort into a uml Port
*
*/
mapping umlrhapsody::IRelation::iRelationToSysMLPort(): uml::Port when {self.isRhapsodySysMLPortRepresentingUMLPort()}{
		var sysPort:umlrhapsody::ISysMLPort:=self.oclAsType(ISysMLPort);
		name:= sysPort.name.replaceAll("\"","");
//		if (not sysPort.otherClass.oclIsUndefined()){
//			if(sysPort.otherClass.oclIsKindOf(IType)){ 
//				type := sysPort.otherClass.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
//			}elif(sysPort.otherClass.oclIsKindOf(IClass)){
//				type := sysPort.otherClass.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
//			}
//		};
		if(sysPort.implicitClass<>sysPort.otherClass){
			type := sysPort.otherClass.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
		};
		aggregation:=AggregationKind::composite;
		isConjugated:=sysPort.isConjugated();
			//a multiplicity has been defined
		if(not sysPort.multiplicity.oclIsUndefined()){
			lowerValue:= createLowerMultiplicity(sysPort.multiplicity);
			upperValue:= createUpperMultiplicity(sysPort.multiplicity);
		}else{
			lowerValue:= createLowerMultiplicity("1");
			upperValue:= createUpperMultiplicity("1");
		}
}


query umlrhapsody::IRelation::isRhapsodySysMLPortRepresentingUMLPort(): Boolean{
	if(self.isRhapsodyPort()){
		return self.oclAsType(ISysMLPort).Stereotypes[IStereotype]->select(ste | ste.name="flowPort")->notEmpty();
		//we could do an additional check, checking that owner is stereotyped by Block?
	};
	return false;
}


query umlrhapsody::IRelation::isRhapsodySysMLPortRepresentingUMLProperty(): Boolean{
	if(self.isRhapsodyPort()){
		return self.oclAsType(ISysMLPort).Stereotypes[IStereotype]->select(ste | ste.name="ConstraintParameter")->notEmpty();
		//we could do an additional check, checking that owner is stereotyped by ConstraintParamater?
	};
	return false;
}

//TODO : merge me with previous one
query umlrhapsody::IRelation::isRhapsodySysMLPortContraintParameter(): Boolean{
	if(self.isRhapsodyPort()){
		return self.oclAsType(ISysMLPort).Stereotypes[IStereotype]->select(ste | ste.name="ConstraintParameter")->notEmpty();
		//we could do an additional check, checking that owner is stereotyped by ConstraintParamater?
	};
	return false;
}


mapping umlrhapsody::IStateChart::toStateMachine(): uml::StateMachine
{
	//get hierarchic states
	var parentStates:Set(IState) :=self.getCompositeStates();
	var allsubStates:Set(IState):= self.getallSubStates();
	name:=self.name.replaceAll("\"","");
	
	// create the default region : for the default ROOT region concept did not exist in rhap
	 region := object Region
   {
   
      name:="Region1";
   	  subvertex += self.States[IState]->select(s|allsubStates->excludes(s) and parentStates->excludes(s)).map toStates();
   	 
   	 var pseudo := object Pseudostate {
		name :="initial";
		kind:= PseudostateKind::initial;	
	};
	
	subvertex+=pseudo;
	
	 //only the first default transition
   	 transition += self.Transitions[IDefaultDrvdTrans]->select(t|parentStates->excludes(t.ofState)).map toInitialTransition(pseudo);
   	 subvertex+= self.States[IState]->select(s|parentStates->includes(s)).map toCompositeStates(self);
   	  // only transitions that its states are in the firest regions
	 transition+=self.Transitions[ITransition]->select(t|((allsubStates->excludes(t.itsTarget.oclAsType(IState))) and (allsubStates->excludes(t.itsSource.oclAsType(IState))))).map toTransitions();	  
   	 // other mix transition (source and target not in the same region)
   	  transition+=self.getMixTransitions(parentStates, allsubStates).map toTransitions();	  
   };
    
   
}

query umlrhapsody::IStateChart::getMixTransitions(parentStates:Set(umlrhapsody::IState), allsubStates:Set(umlrhapsody::IState)): Set(umlrhapsody::ITransition)
{
var mixTrnasitions:Set(umlrhapsody::ITransition);
var outTransitions :=self.Transitions[ITransition]->select(t|((allsubStates->excludes(t.itsTarget.oclAsType(IState))) and (allsubStates->excludes(t.itsSource.oclAsType(IState)))));
var innerTransitions := self.Transitions[ITransition]->select(t|allsubStates->includes(t.itsSource.oclAsType(IState)) and allsubStates->includes(t.itsTarget.oclAsType(IState)));
	mixTrnasitions := self.Transitions[ITransition]->select(t| (innerTransitions->excludes(t) and outTransitions->excludes(t)));
return mixTrnasitions;
} 

query umlrhapsody::IStateChart::getSubStates(parentstate: umlrhapsody::IState ): Set(umlrhapsody::IState)
{
var subStates:Set(umlrhapsody::IState);
	self.States->forEach(state)
	{
		if (state.parent.oclAsType(IState)=parentstate)
		{
			subStates+=state.oclAsType(IState);
		}
	};
	return subStates;
} 
query umlrhapsody::IStateChart::getCompositeStates(): Set(umlrhapsody::IState)
{
var parentStates:Set(umlrhapsody::IState);
	self.States->forEach(state)
	{
	
		if (not(state.parent.oclAsType(IState).name.replaceAll("\"","")="ROOT"))
		{
			parentStates+=state.parent.oclAsType(IState);
		}
	};
	
	return parentStates;
} 

query umlrhapsody::IStateChart::getallSubStates(): Set(umlrhapsody::IState)
{
var allSubStates:Set(umlrhapsody::IState);
	self.States->forEach(state)
	{
		if (not(state.parent.oclAsType(IState).name.replaceAll("\"","")="ROOT"))
		{
			allSubStates+=state.oclAsType(IState);
		}
	};
	return allSubStates;
} 

mapping umlrhapsody::IDefaultDrvdTrans::toInitialTransition(pseudo:uml::Vertex): uml::Transition
{
	
	name:=self.name;
	target:= self.itsTarget[IState].resolveone(State);
	source:=pseudo;
	
	
}

mapping umlrhapsody::IState::toCompositeStates(statechart:umlrhapsody::IStateChart): uml::State
{

var allsubStates:Set(IState):= statechart.getSubStates(self);
		

			name:=self.name.replaceAll("\"","");
			result.oclAsType(State).region:=  object Region
			{
				name:="Region1";
   	  			subvertex += allsubStates.map toStates();
   	  			 var pseudo := object Pseudostate {
   	  
   
					name :="initial";
					kind:= PseudostateKind::initial;
		
		
				};
	
				subvertex+=pseudo;
   	  			transition += statechart.Transitions[IDefaultDrvdTrans]->select(t|t.ofState=self).map toInitialTransition(pseudo);
   	  			transition += statechart.Transitions[ITransition]->select(t|allsubStates->includes(t.itsSource.oclAsType(IState)) and allsubStates->includes(t.itsTarget.oclAsType(IState))).map toTransitions();
   	  				
			}		
}

mapping umlrhapsody::IState::toStates(): uml::State
when {not(self.name.replaceAll("\"","")="ROOT")}
	
{
				name:=self.name.replaceAll("\"","");	
}


mapping umlrhapsody::ITransition::toTransitions(): uml::Transition
{
	
	name:=self.name;
	target:= self.itsTarget[IState].resolveone(State);
	source:=self.itsSource[IState].resolveone(State);
	trigger:=self.itsLabel[ILabel].itsTrigger [IInterfaceItemTrigger].map toTrigger();
	//take the first guard
	guard:=self.itsLabel[ILabel].itsGuard[IGuard]->any(true).map toGuard();
	effect:= self.itsLabel[ILabel].itsAction[IAction]->any(true).map toBehavior();
}


mapping umlrhapsody::IAction::toBehavior(): uml::OpaqueBehavior
{
	
	body:=self.body.trim();
	language:= "C++";
	
	
}

mapping umlrhapsody::IGuard::toGuard(): uml::Constraint
{
	
	result.specification := object  OpaqueExpression
	{
	body:=self.body.trim();
	language:= "C++";
	}
	
}

mapping umlrhapsody::IInterfaceItemTrigger::toTrigger(): uml::Trigger
{
	
	event:= self.itsInterfaceItem.resolveone(SignalEvent);
	
	
}

mapping umlrhapsody::IAssociationEnd::toAssociationsEnd(): uml::Property when{self.oclIsTypeOf(IAssociationEnd)}{
	name:=self.name.replaceAll("\"","");
	type:= self.otherClass.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
	aggregation:=AggregationKind::none;
}

mapping umlrhapsody::IClass::fromClasse2Associations(): uml::Association
{

//TODO FIXME: default subsystem : bad code
var classes : Set(uml::Class) :=inModel.rootObjects()[IProject].defaultSubsystem[ISubsystem].Classes->selectByKind(EObject).map iClassToUMLClass()->asSet();
var  associations: Set(uml::Association);
var i : Integer=0;
classes->forEach(element)
{
var newasso: uml::Association;
	// collect the classes with AssociationEnd and create an association with both classes
	if (not (element.oclAsType(IClass).Associations[IAssociationEnd]->isEmpty()))
	then 
	{
	newasso := object uml::Association
	
	{
		var otherClass : IClass:= element.oclAsType(IClass).Associations[IAssociationEnd].otherClass->any(true).oclAsType(IClass);
		memberEnd+= element.oclAsType(IClass).Associations[IAssociationEnd].map toAssociationsEnd();
		memberEnd+= otherClass.Associations[IAssociationEnd].map toAssociationsEnd();
		memberEnd->asSet();
		
	};
	if (i=0){
	associations+=newasso;
	i:= i+1;
	};
	
	if (not (associations->isEmpty()))
	{
	associations->forEach(asso)
	{
	if( not (asso.memberEnd->includesAll(newasso.memberEnd)))
			associations+=newasso;
			
	}
	}endif;
		
	}endif;

	
	
	};
	
}


mapping umlrhapsody::IGeneralization::toPapyrusGeneralization(): uml::Generalization
{
	general:= self.oclAsType(IGeneralization).dependsOn.oclAsType(IClass).oclAsType(EObject).map iClassToUMLClass();
	
}

mapping umlrhapsody::IReception::toReceptions(): uml::Reception
{
	name:= self.event.name.replaceAll("\"","");
	signal := self.event[IEvent].resolveone(Signal);
	
	
}

mapping umlrhapsody::IPrimitiveOperation::toOperations(): uml::Operation
{
	name:= self.name.replaceAll("\"","");
	// with the return type inside
    ownedParameter:= self.Args[IArgument]->map toArguments();
    if (not self.returnType.oclIsUndefined()){
    	var return_param:= object uml::Parameter {
    		direction:= ParameterDirectionKind::_return;
    		type:= self.returnType.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
    	};
    	ownedParameter+=return_param;
    };
  	var desiredVisibility := getVisibility(self.protection); 
	if (desiredVisibility != VisibilityKind::public) { //to avoid green + in UML editor
		visibility:= desiredVisibility
	};  

   	
}

mapping umlrhapsody::IVariable::iVariableToUMLElement():uml::Property disjuncts
	umlrhapsody::IArgument::iArgumentToUMLElement,
	umlrhapsody::IAttribute::iAttributeToUMLElement
{}



mapping umlrhapsody::IArgument::iArgumentToUMLElement(): uml::Property when {self.oclIsTypeOf(umlrhapsody::IArgument)}{
 	name:= self.oclAsType(IArgument).name.replaceAll("\"","");
	// should add the PtR Stereotpe if the type is a C++ Declaration : i,e: Class *;
	if (self.typeOf.oclIsUndefined()){
		type := self.myTypeOf.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
		userTypeDeclaration+=type;
	}else{
		type := self.typeOf.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
	};
}

/**
* We map IAttribute declared in the TopLevel class as instance specifications
*/
helper umlrhapsody::IAttribute::isInstanceSpecification():Boolean{
	var owner:EObject:=self.oclAsType(EObject).eContainer();
	return owner.oclIsKindOf(IClass) and owner.oclAsType(IClass).name="TopLevel";
}

/**
* This mapping creates InstanceSpecification from IAttribute
*/ 
mapping ecore::EObject::iAttributeToUMLInstanceSpecification(): uml::InstanceSpecification when {self.oclIsKindOf(IAttribute) and self.oclAsType(IAttribute).isInstanceSpecification()}{
	var iAttribute:IAttribute:=self.oclAsType(IAttribute);
	name:=iAttribute.name;
	classifier+=iAttribute.typeOf.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(uml::Classifier);
	var tmp:String:="";
	if(not iAttribute.ValueSpecifications.oclIsUndefined()){
		tmp:=iAttribute.ValueSpecifications.value;
	};
	if(classifier->any(true).oclIsTypeOf(Enumeration)){
		specification:=object InstanceValue{
			name:="InstanceValue1";
			instance:=classifier.oclAsType(Enumeration).member->any(name=tmp).oclAsType(InstanceSpecification);
		}
	}else{
		specification:=object OpaqueExpression{
			body:=tmp;
		}
	}
	
}

mapping umlrhapsody::IAttribute::iAttributeToUMLElement(): uml::Property when {self.oclIsTypeOf(umlrhapsody::IAttribute)}{
	name:= self.name.replaceAll("\"","");
	// should add the PtR Stereotpe if the type is a C++ Declaration : i,e: Class *;
	

	if (self.typeOf.oclIsUndefined()) {
		type := self.myTypeOf.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
		userTypeDeclaration+=type;
	}else{
		type := self.typeOf.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
	};
	var desiredVisibility := getVisibility(self.protection); 
	if (desiredVisibility != VisibilityKind::public) { //to avoid green + in UML editor
		visibility:= desiredVisibility
	};  

	//a multiplicity has been defined
	if(not self.multiplicity.oclIsUndefined()){
		lowerValue:= createLowerMultiplicity(self.multiplicity);
		upperValue:= createUpperMultiplicity(self.multiplicity);
	};
	
	aggregation:=AggregationKind::composite;
}


/**
* Create LiteralInteger to represent the lower multiplicity
*/
helper createLowerMultiplicity(multiplicity:String):LiteralInteger{
	if(multiplicity.oclIsUndefined() or multiplicity.size()=0){
		return null;
	};
	var lower:String;	
	if(multiplicity.indexOf("..")<>0){
		lower:=multiplicity.substringBefore("..");
	}elif(multiplicity.indexOf(",")<>0){
		lower:=multiplicity.substringBefore(",");
	}else{
		lower:=multiplicity;
	};
	var lit:LiteralInteger:= object LiteralInteger{};
	lit.value:=lower.toInteger();
	return lit;
	
	
}

/**
* Create LiteralUnlimitedNatural to represent the upper multiplicity
*/
helper createUpperMultiplicity(multiplicity:String):LiteralUnlimitedNatural{
	if(multiplicity.oclIsUndefined() or multiplicity.size()=0){
		return null;
	};
	var upper:String;
	
	if(multiplicity.indexOf("..")<>0){
		upper:=multiplicity.substringAfter("..");
	}elif(multiplicity.indexOf(",")<>0){
		upper:=multiplicity.substringAfter(",");
	}else{
		upper:=multiplicity;
	};
	
	var lit:LiteralUnlimitedNatural:= object LiteralUnlimitedNatural{};
	if(upper.equalsIgnoreCase("*")){
		lit.value:=-1;
	}else{
		lit.value:=upper.toInteger();
	};
	return lit;	
}


/**
* Return the visibility kind for an IAttribtue or an operation
*/
helper getVisibility(protection:String):uml::VisibilityKind{
	if(protection="iPublic"){
		return VisibilityKind::public;
	}elif(protection="iProtected"){
		return VisibilityKind::protected;
	}elif(protection="iPrivate"){
		return VisibilityKind::private;
	};
	//seems not possible in Rhapsody
	//	elif(self.protection="iPackage"){
	//		return VisibilityKind::package;
	//	};
	return VisibilityKind::public;
}


mapping umlrhapsody::IArgument::toArguments(): uml::Parameter
{
	name:= self.name.replaceAll("\"","");
	direction:=  getDirectionKind(self.argumentDirection);
	// should add the PtR Stereotpe if the type is a C++ Declaration : i,e: Class *;
	if (self.typeOf.oclIsUndefined())
	{
		type := self.myTypeOf.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
		userTypeDeclaration+=type;
	}else
	{
	type := self.typeOf.oclAsType(EObject).map generalMappingToUMLElement().oclAsType(Type);
	}
	
	
}


query getDirectionKind(s:String): uml::ParameterDirectionKind{
var direction: uml::ParameterDirectionKind;
	direction:= switch  {
		case (s="in") ParameterDirectionKind::_in;
		case (s="out") ParameterDirectionKind::_out;
		case (s="inout") ParameterDirectionKind::_inout;
		// there is no return direction in Rhapsody there is a returnType attribute instead, 
	};
	return direction;
}


mapping umlrhapsody::IEvent::toSignalEvents(): uml::SignalEvent
{
	name:= self.name.replaceAll("\"","");
	
	signal:= self[IEvent].resolveone(Signal); //TODO replace me with a mapping
	
}

mapping ecore::EObject::iEventToUMLSignal(): uml::Signal when {self.oclIsTypeOf(IEvent)}{
	var localEvent:IEvent:=self.oclAsType(IEvent);
	name:= localEvent.name.replaceAll("\"","");
	ownedAttribute += localEvent.Args[IVariable]->map iVariableToUMLElement();
}

//collect the call events from the umlrhapsody file

query umlrhapsody::ISubsystem::callEvents() : Set(umlrhapsody::IEvent)
{
	return self.Events.oclAsType(Set(IEvent))->asSet();
	}
	
//collect the signal events from the umlrhapsody file

query umlrhapsody::ISubsystem::SignalEvents() : Set(umlrhapsody::IEvent)
{
var allSignalEvents : Set(umlrhapsody::IEvent);
var classes : Set(umlrhapsody::IClass) :=inModel.rootObjects()[IProject].defaultSubsystem[ISubsystem].Classes[IClass]->asSet();
classes->forEach(classe)
{
	if (not(classe.Operations[IReception]->isEmpty()))
	{
	
	classe.Operations[IReception]->forEach(reception)
	{
	if (not(reception.oclAsType(IReception).event.oclIsUndefined()))
		allSignalEvents+= reception.oclAsType(IReception).event;
	}
		
	}endif;
};
	return allSignalEvents;
	
}