Entity: NamedElement 103 30 null * abstract name String 3 false false false Entity: Relationship 549 34 NamedElement * abstract Entity: Feature 6 125 NamedElement * abstract isStatic boolean 3 false false false Entity: Type 261 133 NamedElement * abstract typeId String 3 false true false Operation: isPrimitiveType Type boolean s String static query true ( s = "double" => result = true ) & ( s = "long" => result = true ) & ( s = "String" => result = true ) & ( s = "boolean" => result = true ) & ( s = "int" => result = true ) Operation: mapType Type String query abstract true true Operation: allLeafSubclasses Entity Set(Entity) query true (specialization.size = 0 => result = Set{self}) & (specialization.size > 0 => result = specialization->unionAll(specific.allLeafSubclasses())) Operation: allProperties Entity Set(Property) query true (generalization.size = 0 => result = ownedAttribute) & (generalization.size > 0 => result = ownedAttribute->union(generalization.general.allProperties())) Operation: allOperations Entity Set(BehaviouralFeature) query true oonames = ownedOperation.name & ((generalization.size = 0 => result = ownedOperation) & (generalization.size > 0 => result = ownedOperation->union(generalization.general.allOperations()->select( op | op.name /: oonames ) )) ) Operation: isSingleValued Entity boolean d String query true allProperties()->exists( p | p.name = d & p.lower = 1 & p.upper = 1) => result = true Operation: isSetValued Entity boolean d String query true allProperties()->exists( p | p.name = d & (p.lower /= 1 or p.upper /= 1) & p.isOrdered = false ) => result = true Operation: isSequenceValued Entity boolean d String query true allProperties()->exists( p | p.name = d & (p.lower /= 1 or p.upper /= 1) & p.isOrdered = true ) => result = true Entity: Classifier 275 201 Type * abstract Operation: mapType Classifier String query true result = name Entity: StructuralFeature 26 208 Feature * abstract isReadOnly boolean 3 false false false Entity: DataType 343 143 Classifier * abstract Entity: PrimitiveType 405 196 DataType * Entity: Entity 295 292 Classifier * isAbstract boolean 3 false false false isInterface boolean 3 false false false Entity: Property 27 325 StructuralFeature * lower int 3 false false false upper int 3 false false false isOrdered boolean 3 false false false isUnique boolean 3 false false false isDerived boolean 3 false false false Entity: Association 603 345 Relationship * addOnly boolean 3 false false false aggregation boolean 3 false false false Entity: Generalization 509 248 Relationship * Entity: BehaviouralFeature 8 471 Feature * abstract isAbstract boolean 3 false false false Entity: Operation 8 527 BehaviouralFeature * isQuery boolean 3 false false false isCached boolean 3 false false false Entity: Expression 338 791 null * abstract needsBracket boolean 3 false false false umlKind UMLKind 3 false false false expId String 3 false true false isStatic boolean 3 false false false Operation: tolist Expression String s Sequence(String) query static true ( s.size = 0 => result = "" ) & ( s.size = 1 => result = s->first() ) & ( s.size > 1 => result = s->first() + "," + Expression.tolist(s->tail()) ) Operation: indexstring Expression String aind Set(String) query static true ( aind.size > 0 => result = "[" + aind->any() + "]" ) & ( aind.size = 0 => result = "" ) Operation: parstring Expression String pars Sequence(String) query static true ( pars.size = 1 => result = "(" + pars->first() + ")") & ( pars.size > 1 => result = "(" + pars->first() + pars->tail()->collect( p | ", " + p )->sum() + ")" ) & ( pars.size = 0 => result = "()" ) Operation: addReference Expression Expression x BasicExpression abstract true true Operation: isMathFunction Expression boolean fname String query static true ( fname = "sqrt" or fname = "exp" or fname = "log" or fname = "sin" or fname = "cos" or fname = "tan" or fname = "pow" or fname = "log10" or fname = "cbrt" or fname = "tanh" or fname = "cosh" or fname = "sinh" or fname = "asin" or fname = "acos" or fname = "atan" or fname = "ceil" or fname = "round" or fname = "floor" or fname = "abs" => result = true ) Operation: isComparitor Expression boolean fname String query static true ( fname = "=" or fname = "/=" or fname = "<" or fname = ">" or fname = "<=" or fname = ">=" => result = true ) Operation: isInclusion Expression boolean fname String query static true ( fname = ":" or fname = "->includes" or fname = "<:" or fname = "->includesAll" => result = true ) Operation: isExclusion Expression boolean fname String query static true ( fname = "/:" or fname = "/<:" or fname = "->excludes" or fname = "->excludesAll" => result = true ) Operation: isBooleanOp Expression boolean fname String query static true ( fname = "&" or fname = "or" or fname = "=>" or fname = "->exists" or fname = "->forAll" or fname = "->exists1" => result = true ) Operation: isStringOp Expression boolean fname String query static true ( fname = "->indexOf" or fname = "->count" or fname = "->hasPrefix" or fname = "->hasSuffix" => result = true ) Operation: isUnaryStringOp Expression boolean fname String query static true ( fname = "->size" or fname = "->first" or fname = "->last" or fname = "->front" or fname = "->tail" or fname = "->reverse" or fname = "->display" or fname = "->toUpperCase" or fname = "->toLowerCase" or fname = "->toInteger" or fname = "->toReal" or fname = "->toLong" => result = true ) Operation: isCollectionOp Expression boolean fname String query static true ( fname = "->including" or fname = "->excluding" or fname = "->append" or fname = "->count" or fname = "->indexOf" or fname = "->union" or fname = "->intersection" or fname = "^" or fname = "->isUnique" or fname = "->at" ) => result = true Operation: isDistributedIteratorOp Expression boolean fname String query static true ( fname = "->sortedBy" or fname = "->unionAll" or fname = "->concatenateAll" or fname = "->intersectAll" or fname = "->selectMinimals" or fname = "->selectMaximals" => result = true) Operation: isCollection Expression boolean query true ( type.name = "Set" or type.name = "Sequence" or type.name = "Map" => result = true ) Operation: isNumeric Expression boolean query true ( type.name = "int" or type.name = "long" or type.name = "double" => result = true ) Operation: isString Expression boolean query true ( type.name = "String" => result = true ) Operation: isUnaryCollectionOp Expression boolean fname String query static true ( fname = "->size" or fname = "->any" or fname = "->reverse" or fname = "->front" or fname = "->tail" or fname = "->first" or fname = "->last" or fname = "->sort" or fname = "->asSet" or fname = "->asSequence" ) => result = true Operation: isIteratorOp Expression boolean fname String query static true ( fname = "->collect" or fname = "->select" or fname = "->reject" ) => result = true Operation: isReduceOp Expression boolean fname String query static true ( fname = "->min" or fname = "->max" or fname = "->sum" or fname = "->prd" ) => result = true Entity: UseCase 661 449 Classifier * isGeneric boolean 3 false false false isDerived boolean 3 false false false Entity: CollectionType 398 92 DataType * Operation: mapType CollectionType String query true result = name + "(" + elementType.mapType() + ")" Entity: BinaryExpression 57 960 Expression * operator String 3 false false false variable String 3 false false false Operation: addReference BinaryExpression Expression x BasicExpression x.data /= self.variable BinaryExpression->exists( e | e.expId = expId + "_" + x.data & e.operator = operator & e.variable = variable & e.umlKind = umlKind & e.left = left.addReference(x) & e.right = right.addReference(x) & result = e ) Entity: UnaryExpression 654 912 Expression * operator String 3 false false false Operation: addReference UnaryExpression Expression x BasicExpression true UnaryExpression->exists( e | e.expId = expId + "_" + x.data & e.operator = operator & e.umlKind = umlKind & e.argument = argument.addReference(x) & result = e ) Entity: CollectionExpression 646 838 Expression * isOrdered boolean 3 false false false Operation: addReference CollectionExpression Expression x BasicExpression true CollectionExpression->exists( e | e.expId = expId + "_" + x.data & e.isOrdered = isOrdered & e.umlKind = umlKind & e.elements = elements.addReference(x) & result = e ) Type: UMLKind 789 996 value attribute role variable constant function queryop operation classid Entity: BasicExpression 284 1028 Expression * data String 3 false false false prestate boolean 3 false false false Operation: addReference BasicExpression Expression x BasicExpression true (umlKind = classid => BasicExpression->exists( e | e.expId = expId + "_" + x.data & e.data = data & e.prestate = prestate & e.umlKind = umlKind & e.objectRef = objectRef & e.arrayIndex = arrayIndex.addReference(x) & e.parameters = parameters.addReference(x) & result = e) ) & (objectRef.size = 0 => BasicExpression->exists( e | e.expId = expId + "_" + x.data & e.data = data & e.prestate = prestate & e.umlKind = umlKind & e.objectRef = Set{x} & e.arrayIndex = arrayIndex.addReference(x) & e.parameters = parameters.addReference(x) & result = e) ) & (objectRef.size > 0 & "self" = objectRef->any() + "" => BasicExpression->exists( e | e.expId = expId + "_" + x.data & e.data = data & e.prestate = prestate & e.umlKind = umlKind & e.objectRef = Set{x} & e.arrayIndex = arrayIndex.addReference(x) & e.parameters = parameters.addReference(x) & result = e) ) & (true => BasicExpression->exists( e | e.expId = expId + "_" + x.data & e.data = data & e.prestate = prestate & e.umlKind = umlKind & e.objectRef = objectRef.addReference(x) & e.arrayIndex = arrayIndex.addReference(x) & e.parameters = parameters.addReference(x) & result = e) ) Association: Feature Type 0 210 130 262 140 1 type null Association: Feature Type 0 220 130 272 140 1 elementType null Association: Entity Property 1 300 292 63 326 0 ownedAttribute owner ordered Association: Association Property -1 604 394 248 392 0 memberEnd null ordered Association: Entity Generalization 1 362 293 511 251 0 generalization specific Association: Generalization Entity 0 579 273 523 325 1 general specialization Association: Entity Operation 1 326 346 208 530 0 ownedOperation owner ordered Association: Operation Entity 0 211 509 326 346 0 definers null ordered Association: BehaviouralFeature Property -1 166 474 186 423 0 parameters null ordered Association: UseCase Property -1 664 450 246 421 0 parameters null ordered Association: CollectionType Type 0 394 98 307 133 1 elementType null Association: Expression Type 0 340 791 266 176 1 type null Association: Expression Type 0 345 791 309 178 1 elementType null Association: CollectionExpression Expression 0 647 857 338 798 0 elements null Association: BinaryExpression Expression 0 124 960 338 799 1 left null 125 778 Association: BinaryExpression Expression 0 208 972 338 805 1 right null 221 781 Association: BasicExpression Expression 0 427 1033 350 770 0 parameters null ordered Association: UnaryExpression Expression -1 657 915 413 792 1 argument null Association: BasicExpression Property 0 588 1037 27 359 -1 referredProperty null Association: BasicExpression Entity 0 588 237 297 299 0 context null Association: BasicExpression Expression -1 287 1134 339 1158 -1 arrayIndex null 227 1133 227 1196 307 1197 Association: Property Expression -1 664 678 335 816 1 initialValue null 665 826 514 822 Association: BasicExpression Expression -1 490 953 408 1162 -1 objectRef null 552 953 551 1002 443 1203 Generalisation: NamedElement Feature 53 127 105 67 Generalisation: NamedElement Relationship 552 40 261 35 Generalisation: NamedElement Type 278 135 243 68 Generalisation: Feature StructuralFeature 168 210 167 162 Generalisation: Type Classifier 287 203 287 156 Generalisation: DataType PrimitiveType 414 198 414 165 Generalisation: Classifier Entity 336 296 335 224 Generalisation: Classifier DataType 372 164 334 203 Generalisation: StructuralFeature Property 51 329 52 247 Generalisation: Relationship Association 731 348 650 58 Generalisation: Relationship Generalization 588 247 583 56 Generalisation: Feature BehaviouralFeature 12 472 14 165 Generalisation: BehaviouralFeature Operation 35 528 35 493 Generalisation: Classifier UseCase 777 452 356 220 775 245 Generalisation: DataType CollectionType 420 119 422 145 Generalisation: Expression UnaryExpression 655 939 341 810 Generalisation: Expression BasicExpression 357 1026 347 813 Generalisation: Expression BinaryExpression 57 1018 348 818 23 1019 24 818 288 816 Generalisation: Expression CollectionExpression 722 839 375 837 722 823 474 822 Entity: Statement 366 1118 null * abstract statId String 3 false true false Operation: tab Statement String indent int static query true ( indent <= 0 => result = "" ) & ( indent > 0 => result = " " + Statement.tab(indent - 1) ) Entity: ReturnStatement 272 1175 Statement * Entity: BreakStatement 289 1209 Statement * Entity: OperationCallStatement 248 1366 Statement * assignsTo String 3 false false false Entity: ImplicitCallStatement 305 1413 Statement * assignsTo String 3 false false false Entity: LoopStatement 509 1304 Statement * abstract Entity: BoundedLoopStatement 501 1400 LoopStatement * Entity: UnboundedLoopStatement 543 1354 LoopStatement * Entity: AssignStatement 28 1022 Statement * Entity: SequenceStatement 683 1123 Statement * kind int 3 false false false Entity: ConditionalStatement 135 1063 Statement * Entity: CreationStatement 286 1245 Statement * createsInstanceOf String 3 false false false assignsTo String 3 false false false Association: CreationStatement Type 0 270 1266 27 255 1 type null Association: CreationStatement Type 0 268 1279 108 257 1 elementType null Association: AssignStatement Type 0 27 1066 27 255 -1 type null Association: BehaviouralFeature Statement -1 424 32 430 1116 1 activity null Association: ReturnStatement Expression -1 275 1178 200 185 -1 returnValue null Association: UseCase Statement -1 545 28 448 1122 1 classifierBehaviour null Association: UseCase Type 0 545 28 148 222 1 resultType null Association: OperationCallStatement Expression -1 254 1368 175 209 1 callExp null 201 1309 Association: ImplicitCallStatement Expression -1 309 1434 110 206 1 callExp null 180 1400 Association: LoopStatement Expression -1 510 1315 201 198 1 test null 267 1309 Association: AssignStatement Expression -1 32 1043 106 198 1 left null Association: AssignStatement Expression -1 118 1044 124 180 1 right null Association: ConditionalStatement Expression -1 179 1087 179 177 1 test null Association: ConditionalStatement Statement -1 302 1084 367 1122 1 ifPart null 303 120 Association: ConditionalStatement Statement -1 218 1085 367 1139 -1 elsePart null 217 1139 Association: SequenceStatement Statement -1 687 1159 453 1130 0 statements null ordered Association: LoopStatement Statement -1 627 1305 451 1141 1 body null 625 1175 Generalisation: Statement ReturnStatement 383 1179 380 1140 Generalisation: Statement BreakStatement 417 1213 414 1143 Generalisation: Statement OperationCallStatement 439 1365 429 1143 Generalisation: Statement ImplicitCallStatement 467 1416 439 1144 Generalisation: Statement LoopStatement 515 1307 447 1144 Generalisation: LoopStatement BoundedLoopStatement 522 1404 519 1328 Association: BoundedLoopStatement Expression -1 515 1315 211 198 1 loopRange null Association: BoundedLoopStatement Expression -1 520 1315 221 198 1 loopVar null Generalisation: LoopStatement UnboundedLoopStatement 635 1356 634 1327 Generalisation: Statement SequenceStatement 686 1128 451 1124 Generalisation: Statement ConditionalStatement 312 1068 385 1119 383 1067 Generalisation: Statement AssignStatement 164 1034 408 1120 403 1047 Generalisation: Statement CreationStatement 427 1244 422 1142 Operation: signature Operation String query true ( parameters.size = 1 => result = name + "(" + parameters.first.name + " : " + parameters.first.type.mapType() + ")") & ( pars.size > 1 => result = name + "(" + parameters.first.name + " : " + parameters.first.type.mapType() + parameters->tail()->collect( p | ", " + p.name + " : " + p.type.mapType() )->sum() + ")" ) & ( parameters.size = 0 => result = name + "()" ) Operation: mapExpression Expression String query abstract true true Operation: mapNumericExpression BinaryExpression String ls String rs String query true (needsBracket => result = "(" + ls + " " + operator + " " + rs + ")") & (true => result = ls + " " + operator + " " + rs) Operation: mapStringExpression BinaryExpression String ls String rs String query true (needsBracket => result = "(" + ls + " " + operator + " " + rs + ")") & ( true => result = ls + " " + operator + " " + rs) Operation: mapStringPlus BinaryExpression String ls String rs String query true (needsBracket => result = "(" + ls + " " + operator + " " + rs + ")") & (true => result = ls + " + " + rs ) Operation: mapBooleanExpression BinaryExpression String ls String rs String query true (needsBracket => result = "(" + ls + " " + operator + " " + rs + ")") & ( true => result = ls + " " + operator + " " + rs) Operation: mapBinaryCollectionExpression BinaryExpression String ls String rs String lt String rt String query true ( true => result = ls + operator + "(" + rs + ")") Operation: mapDistributedIteratorExpression BinaryExpression String ls String rs String rexp Expression query true ( true => result = ls + operator + "(" + rs + ")") Operation: mapIteratorExpression BinaryExpression String ls String rs String tn String query true ( true => result = ls + operator + "(" + rs + ")") Operation: mapBinaryExpression BinaryExpression String ls String rs String query true (Expression.isDistributedIteratorOp(operator) => BasicExpression->exists( be | be.data = expId & be.expId = expId + "_variable" & result = mapDistributedIteratorExpression(ls,rs,right.addReference(be)))) & ((left.isNumeric() & right.isNumeric()) => result = mapNumericExpression(ls,rs)) & ((left.isString() & right.isString()) => result = mapStringExpression(ls,rs)) & (Expression.isIteratorOp(operator) => result = mapIteratorExpression(ls,rs,type.name)) & ( Expression.isBooleanOp(operator) => result = mapBooleanExpression(ls,rs)) & (operator = "+" & (left.isString() or right.isString()) => result = mapStringPlus(ls,rs)) & ((left.isCollection() or right.isCollection()) => result = mapBinaryCollectionExpression(ls,rs,left.type.name, right.type.name)) & ( true => result = ls + " " + operator + " " + rs) Operation: mapExpression BinaryExpression String query true result = mapBinaryExpression(left.mapExpression(),right.mapExpression()) Operation: mapNumericExpression UnaryExpression String arg String query true (true => result = arg + operator) Operation: mapStringExpression UnaryExpression String arg String query true (true => result = arg + operator) Operation: mapReduceExpression UnaryExpression String arg String tn String query true (true => result = arg + operator) Operation: mapUnaryCollectionExpression UnaryExpression String arg String tn String query true (true => result = arg + operator) Operation: mapUnaryExpression UnaryExpression String arg String query true ( operator = "-" => result = "-" + arg ) & ( operator = "not" => result = "not " + arg ) & ( argument.isNumeric() => result = mapNumericExpression(arg) ) & ( argument.isString() => result = mapStringExpression(arg) ) & ( Expression.isReduceOp(operator) => result = mapReduceExpression(arg,argument.type.name) ) & ( argument.isCollection() => result = mapUnaryCollectionExpression(arg,argument.type.name) ) & (true => result = arg + operator) Operation: mapExpression UnaryExpression String query true result = mapUnaryExpression(argument.mapExpression()) Operation: mapCollectionExpression CollectionExpression String elems Sequence(String) tn String query true ( tn = "Set" => result = "Set{" + Expression.tolist(elems) + "}" ) & ( tn = "Sequence" => result = "Sequence{" + Expression.tolist(elems) + "}" ) Operation: mapExpression CollectionExpression String query true result = mapCollectionExpression(elements.mapExpression(),type.name) Operation: mapTypeExpression BasicExpression String query true ( true => result = data ) Operation: mapValueExpression BasicExpression String aind Set(String) query true ( aind.size > 0 => result = data + "[" + aind->any() + "]" ) & ( aind.size = 0 => result = data ) Operation: mapVariableExpression BasicExpression String aind Set(String) query true ( aind.size = 0 => result = data ) & ( aind.size > 0 => result = data + "[" + aind->any() + "]" ) Operation: mapAttributeExpression BasicExpression String obs Set(String) aind Set(String) pars Sequence(String) query true ( context.size = 0 & obs.size = 0 => result = data + Expression.indexstring(aind) ) & ( context.size > 0 & obs.size = 0 => result = "self." + data + Expression.indexstring(aind) ) & ( context.size > 0 & obs.size > 0 & objectRef.any.type /: CollectionType => result = obs->any() + "." + data + Expression.indexstring(aind) ) & ( context.size > 0 & obs.size > 0 & objectRef.any.type : CollectionType & type.name = "Sequence" => result = obs->any() + "." + data + Expression.indexstring(aind) ) & ( context.size > 0 & obs.size > 0 & objectRef.any.type : CollectionType & type.name = "Set" => result = obs->any() + data + Expression.indexstring(aind) ) Operation: mapOperationExpression BasicExpression String obs Set(String) aind Set(String) pars Sequence(String) query true ( context.size = 0 & obs.size = 0 => result = data + Expression.parstring(pars) + Expression.indexstring(aind) ) & ( context.size > 0 & obs.size = 0 => result = "self." + data + Expression.parstring(pars) + Expression.indexstring(aind) ) & ( context.size > 0 & obs.size > 0 => result = obs->any() + "." + data + Expression.parstring(pars) + Expression.indexstring(aind) ) Operation: mapFunctionExpression BasicExpression String obs Set(String) aind Set(String) pars Sequence(String) query obs.size > 0 (data = "allInstances" => result = obs->any() + ".allInstances()") & ( "Integer" = obs->any() & "subrange" = data => result = "Integer.subrange(" + pars->first() + ", " + pars->at(2) + ")" ) & ( "Integer" = obs->any() & "sum" = data => result = "Integer.sum(" + pars[1] + ", " + pars[2] + ", " + pars[3] + ", " + pars[4] + ")" ) & ( "Integer" = obs->any() & "prd" = data => result = "Integer.prd(" + pars[1] + ", " + pars[2] + ", " + pars[3] + ", " + pars[4] + ")" ) & ( Expression.isMathFunction(data) => result = data + "(" + obs->any() + ")" ) & ( data = "subrange" => result = obs->any() + ".subrange(" + pars[1] + ", " + pars[2] + ")" ) & ( data = "insertAt" => result = obs->any() + ".insertAt(" + pars[1] + ", " + pars[2] + ")" ) & ( true => result = data + "(" + obs->any() + ")" ) Operation: mapClassExpression BasicExpression String obs Set(String) aind Set(String) pars Sequence(String) query umlKind = classid (arrayIndex.size > 0 => result = elementType.name + "[" + aind->any() + "]" ) & (arrayIndex.size = 0 => result = data + ".allInstances" + "()" ) Operation: mapBasicExpression BasicExpression String ob Set(String) aind Set(String) pars Sequence(String) query true ( Type.isPrimitiveType(data) => result = mapTypeExpression()) & ( umlKind = value => result = mapValueExpression(aind) ) & ( umlKind = variable => result = mapVariableExpression(aind) ) & ( umlKind = attribute or umlKind = role => result = mapAttributeExpression(ob,aind,pars) ) & ( umlKind = operation => result = mapOperationExpression(ob,aind,pars) ) & ( umlKind = function => result = mapFunctionExpression(ob,aind,pars) ) & ( umlKind = classid => result = mapClassExpression(ob,aind,pars) ) Operation: mapExpression BasicExpression String query true result = mapBasicExpression(objectRef.mapExpression(),arrayIndex.mapExpression(),parameters.mapExpression()) Operation: mapStatement Statement String indent int query abstract true true Operation: mapStatement ReturnStatement String indent int query true ( returnValue.size = 0 => result = Statement.tab(indent) + "return" + "\n" ) & ( returnValue.size > 0 => result = Statement.tab(indent) + "return " + returnValue.any.mapExpression() + "\n" ) Operation: mapStatement BreakStatement String indent int query true result = Statement.tab(indent) + "break" + "\n" Operation: mapStatement OperationCallStatement String indent int query true result = Statement.tab(indent) + callExp.mapExpression() + "\n" Operation: mapExpression ImplicitCallStatement String indent int query true result = Statement.tab(indent) + callExp.mapExpression() + "\n" Operation: mapStatement BoundedLoopStatement String indent int query true result = Statement.tab(indent) + "for " + test.mapExpression() + " \n" + Statement.tab(indent) + "do\n" + body.mapStatement(indent + 2) Operation: mapStatement UnboundedLoopStatement String indent int query true result = Statement.tab(indent) + "while " + test.mapExpression() + " \n" + Statement.tab(indent) + "do\n" + body.mapStatement(indent + 2) Operation: mapStatement AssignStatement String indent int query true result = Statement.tab(indent) + left.mapExpression() + " := " + right.mapExpression() + "\n" Operation: mapStatement SequenceStatement String indent int query true ( statements.size = 0 => result = Statement.tab(indent) + "skip\n" ) & ( statements.size = 1 => result = Statement.tab(indent) + statements.first.mapStatement(indent)) & ( statements.size > 1 => result = Statement.tab(indent) + statements.first.mapStatement(indent) + statements->collect( s | " ;\n" + s.mapStatement(indent) )->sum() ) Operation: elsecode ConditionalStatement String indent int query true (elsePart.size = 0 => result = "") & ( elsePart.size > 0 => result = Statement.tab(indent) + "else \n" + elsePart.any.mapStatement(indent + 2)) Operation: mapStatement ConditionalStatement String indent int query true result = Statement.tab(indent) + "if " + test.mapExpression() + " \n" + Statement.tab(indent) + "then\n" + ifPart.mapStatement(indent + 2) + elsecode(indent) Operation: mapStatement CreationStatement String indent int query true result = Statement.tab(indent) + "var " + assignsTo + " : " + createsInstanceOf + "\n" Operation: mapOperation Operation String indent int query true (isStatic = false & isQuery = false => result = Statement.tab(indent) + signature() + "\n" + activity.mapStatement(indent + 2) + "\n") & (isStatic = true & isQuery = false => result = Statement.tab(indent) + "static " + signature() + "\n" + activity.mapStatement(indent + 2) + "\n") Operation: mapUseCase UseCase String query true (classifierBehaviour->oclIsUndefined() = false => result = signature() + "\n" + classifierBehaviour.mapStatement(2) + "\n")