Swift is the new programming language for Apple platforms such as MacOS and iOS, and it is the basis of the SwiftUI mobile app framework. The language incorporates first-class functions, open classes, and other advanced features. In this paper we describe a tool for translating UML and OCL specifications into fully-functional code in Swift. Translation of OCL extensions (map and function types) are also described.
At a high level, the translation from UML+OCL to Swift can be defined as follows: 1. UML/OCL types are mapped to corresponding Swift types, with the exception that
OclMessage and UnlimitedNatural are not mapped.
2. UML data features are mapped to Swift variables or constants of corresponding type and
scope (instance or class scope).
3. OCL expressions are mapped to corresponding Swift expressions, defined directly in
terms of Swift expression operators, or by using a library Ocl.swift which provides
implementations of OCL operators2. 101 OCL 2.4 library operators are supported by the
translation, out of 181 operators in [
We describe the translation by using the ℒ notation for code-generator specification
[
For example, to map UML/OCL type occurrences to Swift 5, the following rules are used: Type:: int |-->Int32 long |-->Int64 Boolean |-->Bool double |-->Double OclVoid |-->Void OclAny |-->Any Sequence(_1) |-->[_1] Set(_1) |-->Set<_1> No rules for occurrences of enumerations, String or entity types are needed because their syntactic form is identical in OCL and Swift.
The semantics of a ℒ script is based on recursive application of string replacement in
the RHS of rules [
The rules for translating OCL expressions are divided into five groups: (1) Basic expressions, for literal values, variables, feature applications, etc; (2) Unary expressions, for one-argument expression forms not(e), e→size(), etc; (3) Binary expressions, for infix binary and binary → operators: x + y, sq→union(s), etc; (4) collection expressions Set{}, Sequence{x1, x2}, etc; (5) Conditional and let expressions.
The translation of basic expressions is direct, and includes rules such as: null |-->nil _1.allInstances() |-->_1_allInstances For each class E, a global scope sequence var E allInstances : [E] of current E instances is maintained in the Swift implementation.
Prefix unary expressions not(e) and − e also translate directly to !(e′) and − e′ in Swift, where e′ is the translation of e. Postfix unary expressions either translate directly to Swift, or into Ocl.swift calls, eg.: _1->size() |-->_1.count _1->max() |-->Ocl.max(s: _1) _1->sum() |-->Ocl.sum(s: _1)
Likewise, with binary expressions a direct translation is possible in some cases: _1 mod _2 |-->_1 % _2 _1->union(_2) |-->_1.union(_2)<when> _1 Set _1->union(_2) |-->_1 + _2<when> _1 Sequence _1->collect(_2 | _3) |-->_1.map({_2 in _3}) where {x in e} is Swift syntax for the lambda expression x · e.
Some collection operators require specialised implementations: _1->sortedBy(_2|_3) |-->Ocl.sortedBy(s: _1, f: { _2 in _3 }) _1->select(_2 | _3) |-->Ocl.select(s: _1, f: { _2 in _3 }) _1->reject(_2 | _3) |-->Ocl.reject(s: _1, f: { _2 in _3 })
Conditional expressions have a similar implementation in many 3GLs: if _1 then _2 else _3 endif |-->((_1) ? _2 : _3)
To ensure that variables never hold null objects, we use the Default instance pattern, a variant
on the Singleton design pattern: for each class E, a static method defaultInstance() : E is defined,
which returns an existing instance of E if there is any E instance, otherwise it creates a new E
instance and returns it. Generated object variable declarations then have the form
var v : E = E.defaultInstance()
3. Translation of map and function types
Proposals for extending OCL with map types have been made by several researchers [
Map(S, T ) m→at(x) m[x] = y Map{k1 ↦→ v1, ..., kn ↦→ vn} m→size() m1→keys() m1→values() m1→union(m2) m1→intersection(m2) m1 − m2 m→restrict(ks) m→select(x | P) m→collect(x | e)
m applied to x m updated by x ↦→ y Literal map Number of mappings in m Set of keys in m1 Range of m1 m1 overridden by m2 Common mappings of m1, m2 Mappings of m1 not in m2 Mappings of m with key in ks s ↦→ t of m where t |= P Map composition of m and e
m[x]! m[x] = y [k1:v1, ..., kn:vn] m.count Ocl.mapKeys(m: m1) Ocl.mapRange(m: m1) Ocl.unionMap(m1: m1, m2: m2) Ocl.intersectionMap(m1: m1, m2: m2) Ocl.excludeAllMap(m1: m1, m2: m2) Ocl.restrict(m: m, ks: ks) Ocl.selectMap(m: m, f: { x in P }) Ocl.collectMap(m: m, f: { x in e })
We extend the ℒ code generation specification of Section 2 with type and expression rules for maps and functions, eg.: Map(_1,_2) |-->Dictionary<_1,_2> Function(_1,_2) |-->(_1)->_2 _1->keys() |-->Ocl.mapKeys(m: _1) _1->values() |-->Ocl.mapRange(m: _1)
3Functions are immutable values, in contrast to maps. _1 |-> _2 |-->_1:_2 _1->at(_2) |-->_1[_2]!<when> _1 Map _1->union(_2) |-->Ocl.unionMap(m1: _1, m2: _2)<when> _1 Map _1->intersection(_2) |-->Ocl.intersectionMap(m1: _1, m2: _2)<when> _1 Map _1 - _2 |-->Ocl.excludeAllMap(m1: _1, m2: _2)<when> _1 Map _1->restrict(_2) |-->Ocl.restrict(m: _1, ks: _2) _1->collect(_2 | _3) |-->Ocl.collectMap(m: _1, f: {_2 in _3})<when> _1 Map
The default map value is the empty map [:], the default function value of Function(S, T ) is the function that returns the default value of T for each S element.
Lambda expressions are directly implemented by closures: lambda _1 : _2 in _3 |-->{ (_1 : _2) -> _3‘type in _3 } i‘type denotes the translation of the type metafeature of the source expression bound to i.
In the directories oclmapexamples.zip and oclfunctionexamples.zip on [
In this section we evaluate the eficiency of map and function code implementations generated by AgileUML. Two evaluation cases are used: (i) a word-count algorithm using maps; (ii) a numerical optimisation procedure using functions. All Java, C and Python tests were carried out on a Windows 10 i5-6300 dual core laptop with 2.4GHz clock frequency, 8GB RAM + 3MB cache. For Swift we also tested execution on a similar iMac running MacOS 10 (dual core i5, 2.3GHz/8GB RAM/4MB cache). The REM IDE was used for Swift execution on Windows4. 4.1. Maps example: word counts This example stores word counts of the words in an input sequence sq in a result map using assignments result[x] := sq->count(x).
Table 3 shows the execution times of wordCount for inputs of 1000, 10000 and 100000 words, for the Swift, Java, Python and C implementations generated from the example using AgileUML. All times are in seconds, computed as an average of 3 independent executions, using the same datasets. The MacOS implementation of Swift is intermediate in performance between C and Python.
Python Swift (MacOS) Swift (Windows) C 4.2. Functions example: numerical optimisation The test example for functions uses function types and function evaluation as part of a numerical optimisation procedure: class SomeFunctions { static operation secant(rn : double , rminus : double , fminus : double , tol : double , f : Function(double,double) ) : double pre: true post: fn = f(rn) and (if fn->abs() < tol then result = rn else ( result = SomeFunctions.secant(rn
fn * ( ( rn - rminus ) / ( fn - fminus ) ), rn,fn,tol,f) } ) endif); The secant routine is invoked with f instantiated by lambda expressions lambda x : double in x * x + x − 1, lambda x : double in x→pow(x) − 0.7. Table 4 shows the execution time of this example in Java, Python, Swift and C, for 1000 function calls, 10,000 and 100,000. This case has an approximately linear time complexity. Swift on MacOS is faster than both Python and Java, and comparable to C.
Python Swift (MacOS) Swift (Windows) C
Three general approaches for defining mappings from UML and OCL to programming languages are Model-to-model (M2M), Model-to-text (M2T) or Text-to-text (T2T). Table 5 compares examples of the three approaches with regard to their size and scope. T2T solutions are substantially more concise than M2M or M2T solutions, relative to the supported functionality (scope) of the code generator.
We have shown that ℒ can be used to define a practical translation from OCL to Swift.
This translation includes support for OCL map and function extensions and regular expressions.
The translation is used to generate the business tier code of SwiftUI apps [