| --/******************************************************************************* |
| -- * Copyright (c) 2015 Vienna University of Technology. |
| -- * 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: |
| -- * Alexander Bergmayr (TU Wien) - initial API and implementation |
| -- * Manuel Wimmer (TU Wien) - initial API and implementation |
| -- * |
| -- * Initially developed in the context of ARTIST EU project www.artist-project.eu |
| -- *******************************************************************************/ |
| |
| -- @nsURI UMLMM=http://www.eclipse.org/uml2/3.0.0/UML |
| -- @path JMM=pathmap://METAMODEL/java.ecore |
| |
| library javaLibrary; |
| |
| helper context JMM!TypeAccess def : getParameterizedType() : UMLMM!Type = |
| -- BUG: TODO : we need to deal with UnresolvedTypeDeclaration! |
| -- if(self.oclIsTypeOf(JMM!UnresolvedTypeDeclaration)) then OclUndefined |
| -- else |
| thisModule.resolveTemp(self.type, 't1'); |
| -- endif; |
| |
| --helper context JMM!TypeAccess def : containedByModelLibrary() : Boolean = |
| -- UMLMM!Type.allInstancesFrom('ML') -> exists(e | e.name = self.type.name and e.refImmediateComposite().name = self.type.refImmediateComposite().name); |
| |
| -- checks if a type is complex |
| helper context JMM!TypeAccess def : isComplexType() : Boolean = |
| if(self.isPrimitiveType() or self.type.oclIsTypeOf(JMM!EnumDeclaration)) then false |
| else |
| if(self.type.oclIsTypeOf(JMM!ArrayType)) then not self.type.isArrayWithNonComplexType |
| else |
| true |
| endif |
| endif; |
| |
| -- ckecks if a type is primitive ... |
| helper context JMM!TypeAccess def : isPrimitiveType() : Boolean = |
| -- if we have a kind of PrimitiveType (int, float, bool, etc.) |
| if (self.type.oclIsKindOf(JMM!PrimitiveType)) then true |
| else |
| -- wrapped primitive types (e.g., ClassDeclaration of type String etc.) |
| if ((self.type.name = 'String') or (self.type.name = 'Integer') |
| or (self.type.name = 'Long') or (self.type.name = 'Short') |
| or (self.type.name = 'Float') or (self.type.name = 'Double') |
| or (self.type.name = 'Boolean') or (self.type.name = 'Number')) then true |
| else |
| -- finally, we have the case of Array's with primitive type |
| -- only in case it is an ArrayType, we check the type of the Array |
| if(not self.type.oclIsTypeOf(JMM!ArrayType)) then false |
| else |
| --if (self.type.elementType.isPrimitiveType() or self.type.elementType.type.oclIsTypeOf(JMM!EnumDeclaration)) then true |
| if(self.type.elementType.isPrimitiveType()) then true |
| else |
| false |
| endif |
| endif |
| endif |
| endif; |
| |
| helper context JMM!TypeAccess def : isParameterizedType : Boolean = |
| self.type.oclIsTypeOf(JMM!ParameterizedType) or self.type.isJavaLangClass(); |
| |
| helper context OclAny def : isJavaLangClass : Boolean = |
| self.refImmediateComposite().getFullyQualifiedPackageName.toString().concat('.').concat(self.name).toString() = 'java.lang.Class' or |
| self.refImmediateComposite().getFullyQualifiedPackageName.toString().concat('.').concat(self.name).toString() = 'java.lang.Class[]'; |
| |
| helper context JMM!ArrayType def : isArrayWithNonComplexType : Boolean = |
| if (self.elementType.isPrimitiveType() or self.elementType.type.oclIsTypeOf(JMM!EnumDeclaration)) then true |
| else false |
| endif; |
| |
| -- TODO: here we could also use a Map |
| -- returns the type for a given type access; required to determine on the return type of |
| -- a method in the annotation type declaration |
| helper context JMM!TypeAccess def : getType() : UMLMM!Type = |
| -- PrimitiveType, String |
| if self.isPrimitiveType() then self.type.getTypeFromPrimitiveType |
| else |
| -- Class / Parameterized Class (can only be java.lang.Class) |
| if (self.type.oclIsTypeOf(JMM!ClassDeclaration) or self.type.oclIsTypeOf(JMM!ParameterizedType)) then self.type.getTypeFromTypeDeclaration |
| else |
| -- EnumType |
| if self.type.oclIsTypeOf(JMM!EnumDeclaration) then self.type.getTypeFromEnumDeclaration() |
| else |
| -- AnnotationType |
| if self.type.oclIsTypeOf(JMM!AnnotationTypeDeclaration) then self.type.getTypeFromAnnotationTypeDeclaration() |
| else |
| -- ArrayType |
| if self.type.oclIsTypeOf(JMM!ArrayType) then self.type.getTypeFromArrayType |
| |
| -- UnresolvedType |
| else thisModule.resolveTemp(self.type, 't1') |
| endif |
| endif |
| endif |
| endif |
| endif; |
| |
| -- return for a given Java |
| -- we should use here Java Primitive Types ... ???? |
| helper context JMM!Type def : getTypeFromPrimitiveType : UMLMM!Type = |
| thisModule.javaPrimitiveType.get(self.name.toString()); |
| |
| -- can only be java.lang.Class |
| helper context OclAny def : getTypeFromTypeDeclaration : UMLMM!Type = |
| UMLMM!Class.allInstancesFrom('MC') -> any(e | e.name = 'Class'); |
| |
| -- return for a given Java parameterized Class the appropriate UML Class |
| helper context JMM!ParameterizedType def : getTypeFromParameterizedType() : UMLMM!Class = |
| UMLMM!Class.allInstancesFrom('MC') -> any(e | e.name = 'Class'); |
| |
| -- return for a given Java Enum Type the appropriate UML instance of this Enum Type |
| helper context JMM!EnumDeclaration def : getTypeFromEnumDeclaration() : UMLMM!Enumeration = |
| thisModule.resolveTemp(self, 't1'); |
| |
| -- return for a given Java Annotation Type the appropriate UML instance of this |
| helper context JMM!AnnotationTypeDeclaration def : getTypeFromAnnotationTypeDeclaration() : UMLMM!Stereotype = |
| thisModule.resolveTemp(self, 't1'); |
| |
| -- return for a given Java Annotation Type the appropriate UML instance of this |
| helper context JMM!UnresolvedTypeDeclaration def : getTypeFromUnresolvedTypeDeclaration() : UMLMM!Class = |
| thisModule.resolveTemp(self, 't1'); |
| |
| -- return for a given Java ArrayType the appropriate UML Type ... here deal only with |
| -- complex types and enumerations |
| helper context JMM!ArrayType def : getTypeFromArrayType : UMLMM!Type = |
| if(self.elementType.type.oclIsTypeOf(JMM!ClassDeclaration) or |
| self.elementType.type.oclIsTypeOf(JMM!InterfaceDeclaration)) then |
| self.elementType.type.getTypeFromTypeDeclaration |
| else |
| if(self.elementType.type.oclIsTypeOf(JMM!ParameterizedType)) then |
| self.elementType.type.getTypeFromParameterizedType() |
| else |
| if(self.elementType.type.oclIsTypeOf(JMM!EnumDeclaration)) then |
| self.elementType.type.getTypeFromEnumDeclaration() |
| else |
| if(self.elementType.type.oclIsTypeOf(JMM!AnnotationTypeDeclaration)) then |
| self.elementType.type.getTypeFromAnnotationTypeDeclaration() |
| else |
| if(self.elementType.type.oclIsTypeOf(JMM!UnresolvedTypeDeclaration)) then |
| self.elementType.type.getTypeFromUnresolvedTypeDeclaration() |
| else |
| -- TODO: check ... but should actually not happen ;) |
| OclUndefined |
| endif |
| endif |
| endif |
| endif |
| endif; |
| |
| -- decide if a class or interface is required for the annotation type declaration |
| --helper context JMM!Type def : isRequiredForAnnotationTypes : Boolean = |
| -- if (JMM!AnnotationTypeMemberDeclaration.allInstances() -> |
| -- select(e | e.type.type.oclIsTypeOf(JMM!ParameterizedType)) -> exists(f | f.type.type.typeArguments -> exists(g | g.type.name = s1.name)) or |
| -- |
| -- |
| -- ) |
| |
| -- get fully qualified package name of a java type |
| helper context OclAny def : getFullyQualifiedPackageName : String = |
| if(self.refImmediateComposite().oclIsTypeOf(JMM!Package)) then |
| self.refImmediateComposite().getFullyQualifiedPackageName.concat('.').concat(self.name) |
| else |
| self.name |
| endif; |
| |
| -- get Java package |
| helper context OclAny def : getJavaPackage() : JMM!Package = |
| if(not self.package.oclIsUndefined()) then |
| self.package |
| else |
| self.refImmediateComposite().getPackage() |
| endif; |
| |
| -- get the package of a PackageableElement |
| helper context UMLMM!PackageableElement def : getPackage() : UMLMM!Package = |
| if(self.refImmediateComposite().oclIsTypeOf(UMLMM!Package)) then |
| self.refImmediateComposite() |
| else |
| self.refImmediateComposite().getPackage() |
| endif; |
| |
| -- only those code elements that are relevant element types / return values of annotation type declarations |
| helper context OclAny def : isRelevantForAnnotationTypes : Boolean = |
| -- maybe the name matching here can be dangerous ... |
| if(self.oclIsKindOf(JMM!Type)) then |
| if ((self.oclIsTypeOf(JMM!AnnotationTypeDeclaration) and self.proxy = false)) or |
| |
| (thisModule.getAnnotationTypeMemberDeclarations -> select(e | not e.type.oclIsUndefined()) |
| -> exists(e | e.type.type = self) or |
| |
| (thisModule.getAnnotationTypeMemberDeclarations -> select(e | not e.type.oclIsUndefined()) |
| -> select(e | e.type.type.oclIsTypeOf(JMM!ArrayType))) |
| -> exists(e | e.type.type.elementType.type = self) or |
| |
| self.hasInnerAnnotationTypeDeclaration() |
| |
| ) then true |
| else false endif |
| else false |
| endif; |
| |
| -- we want to have only packages that serve as container for annotation type declarations |
| helper context JMM!Package def : isAnnotationTypeContainer : Boolean = |
| if self.ownedElements -> exists(e | e.isRelevantForAnnotationTypes) or |
| self.ownedPackages -> exists(e | e.isAnnotationTypeContainer) then true |
| else false |
| endif; |
| |
| helper context JMM!Type def : hasInnerAnnotationTypeDeclaration() : Boolean = |
| if(self.bodyDeclarations -> exists(e | e.oclIsTypeOf(JMM!AnnotationTypeDeclaration)) or |
| self.bodyDeclarations -> select(e | e.oclIsKindOf(JMM!Type)) -> exists(f | f.hasInnerAnnotationTypeDeclaration()) |
| ) then true |
| else false |
| endif; |
| |
| helper context OclAny def : isEnumerationRelevant : Boolean = |
| -- must be an EnumerationType |
| if(not self.oclIsTypeOf(JMM!EnumDeclaration)) then false |
| else |
| |
| -- the Enumeration is the type of an AnnotationTypeMemberDeclaration |
| thisModule.getAnnotationTypeMemberDeclarations -> select(e | not e.type.oclIsUndefined()) -> |
| exists(e | e.type.type = self) or |
| |
| -- the Enumeration is the element type of an Array which is the type of an AnnotationTypeMemberDeclaration |
| thisModule.getAnnotationTypeMemberDeclarations -> select(e | not e.type.oclIsUndefined()) -> |
| select(e | e.type.type.oclIsTypeOf(JMM!ArrayType)) -> |
| exists(f | f.type.type.elementType.type = self) or |
| |
| -- the Enumeration is the parameter of java.lang.Class which is the type of an AnnotationTypeMemberDeclaration |
| thisModule.getAnnotationTypeMemberDeclarations -> select(e | not e.type.oclIsUndefined()) -> |
| select(e | e.type.type.oclIsTypeOf(JMM!ParameterizedType)) -> |
| exists(f | f.type.type.typeArguments -> exists(g | g.type = self)) |
| |
| endif; |
| |
| -- required because the structure of the model differs depending on multi-valued vs. single-valued SingleVariableAccess elements |
| helper context JMM!SingleVariableAccess def : isMultiValuedAnnotationTarget : Boolean = |
| if self.refImmediateComposite().refImmediateComposite().refImmediateComposite().oclIsTypeOf(JMM!Annotation) then |
| self.refImmediateComposite().refImmediateComposite().refImmediateComposite().type.type.name = 'Target' |
| else false |
| endif; |
| |
| -- required because the structure of the model differs depending on multi-valued vs. single-valued SingleVariableAccess elements |
| helper context JMM!SingleVariableAccess def : isSingleValuedAnnotationTarget : Boolean = |
| if self.refImmediateComposite().refImmediateComposite().oclIsTypeOf(JMM!Annotation) then |
| self.refImmediateComposite().refImmediateComposite().type.type.name = 'Target' |
| else false |
| endif; |
| |
| -- mapping between java element type targets and UML targets, i.e., the extended UML element |
| helper def : umlTarget : Map(String, Sequence(UMLMM!Element)) = |
| Map{ |
| ('ANNOTATION_TYPE', Sequence{UMLMM!Type.allInstances() -> select(e | e.name = 'Stereotype').first()}), |
| -- TODO: add constraint |
| ('CONSTRUCTOR', Sequence{UMLMM!Type.allInstances() -> select(e | e.name = 'Operation').first()}), |
| -- maybe we could think also to annotate the association on a model level ... however |
| -- for this prototype we do not consider associations at all .. so it is sufficient to |
| -- have here Property only. |
| ('FIELD', Sequence{UMLMM!Type.allInstances() -> select(e | e.name = 'Property').first(), |
| UMLMM!Type.allInstances() -> select(e | e.name = 'EnumerationLiteral').first()--, |
| -- UMLMM!Type.allInstances() -> select(e | e.name = 'Association').first() |
| }), |
| ('LOCAL_VARIABLE', Sequence{UMLMM!Type.allInstances() -> select(e | e.name = 'Property').first()--, |
| -- UMLMM!Type.allInstances() -> select(e | e.name = 'Association').first() |
| }), |
| ('METHOD', Sequence{UMLMM!Type.allInstances() -> select(e | e.name = 'Operation').first(), |
| UMLMM!Type.allInstances() -> select(e | e.name = 'Property').first() |
| }), |
| ('PACKAGE', Sequence{UMLMM!Type.allInstances() -> select(e | e.name = 'Package').first()}), |
| ('PARAMETER', Sequence{UMLMM!Type.allInstances() -> select(e | e.name = 'Parameter').first()}), |
| -- adaptation required ... Java Type --> Class, Interface, AnnotationType, Enumeration |
| -- TODO: add constraint!! |
| -- Idea: less explicit stereotypes in the profile |
| ('TYPE', Sequence{UMLMM!Type.allInstances() -> select(e | e.name = 'Type').first()})}; |
| |
| -- ensure the use of java primitive types |
| helper def : javaPrimitiveType : Map(String, UMLMM!Element) = Map{('boolean', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'boolean').first()), |
| ('byte', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'byte').first()), |
| ('char', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'char').first()), |
| ('double', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'double').first()), |
| ('float', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'float').first()), |
| ('int', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'int').first()), |
| ('integer', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'int').first()), |
| ('long', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'long').first()), |
| ('short', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'short').first()), |
| -- first letter is capital |
| ('Boolean', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'boolean').first()), |
| ('Byte', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'byte').first()), |
| ('Char', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'char').first()), |
| ('Double', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'double').first()), |
| ('Float', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'float').first()), |
| ('Int', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'int').first()), |
| ('Integer', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'int').first()), |
| ('Long', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'long').first()), |
| ('Short', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'short').first()), |
| -- TODO: maybe we should have here also a Java STRING |
| ('String', UMLMM!Type.allInstancesFrom('UPT') -> select(e | e.name = 'String').first()), |
| -- the array version ... |
| ('boolean[]', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'boolean').first()), |
| ('byte[]', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'byte').first()), |
| ('char[]', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'char').first()), |
| ('double[]', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'double').first()), |
| ('float[]', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'float').first()), |
| ('int[]', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'int').first()), |
| ('long[]', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'long').first()), |
| ('short[]', UMLMM!Type.allInstancesFrom('JPT') -> select(e | e.name = 'short').first()), |
| -- TODO: maybe we should have here also a Java STRING |
| ('java.lang.String[]', UMLMM!Type.allInstancesFrom('UPT') -> select(e | e.name = 'String').first())}; |
| |
| -- get package even though types are declared inside types |
| helper context JMM!AbstractTypeDeclaration def : getPackage() : JMM!Package = |
| if(not self.package.oclIsUndefined()) then self.package |
| -- assumption: the type is declared inside another type |
| else self.refImmediateComposite().getPackage() |
| endif; |
| |
| |
| |
| |
| |
| |
| |
| |
