1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
|
/*******************************************************************************
* «codeGenHelper.getCopyright(' * ')»
*
* This code is 100% auto-generated
* using: org.eclipse.qvtd.codegen.qvti.java.QVTiCodeGenerator
*
* Do not edit it.
********************************************************************************/
package org.eclipse.qvtd.xtext.qvtimperative.tests.Tree2TallTree;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.eclipse.emf.ecore.EcorePackage;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.ocl.pivot.evaluation.Executor;
import org.eclipse.ocl.pivot.ids.ClassId;
import org.eclipse.ocl.pivot.ids.IdManager;
import org.eclipse.ocl.pivot.ids.IdResolver;
import org.eclipse.ocl.pivot.ids.TypeId;
import org.eclipse.ocl.pivot.internal.library.executor.ExecutorSingleIterationManager;
import org.eclipse.ocl.pivot.library.AbstractBinaryOperation;
import org.eclipse.ocl.pivot.library.LibraryIteration;
import org.eclipse.ocl.pivot.library.collection.CollectionAsSetOperation;
import org.eclipse.ocl.pivot.library.collection.CollectionExcludingOperation;
import org.eclipse.ocl.pivot.library.collection.CollectionMaxOperation;
import org.eclipse.ocl.pivot.library.collection.CollectionNotEmptyOperation;
import org.eclipse.ocl.pivot.library.numeric.NumericPlusOperation;
import org.eclipse.ocl.pivot.oclstdlib.OCLstdlibTables;
import org.eclipse.ocl.pivot.utilities.ClassUtil;
import org.eclipse.ocl.pivot.utilities.ValueUtil;
import org.eclipse.ocl.pivot.values.BagValue;
import org.eclipse.ocl.pivot.values.IntegerValue;
import org.eclipse.ocl.pivot.values.InvalidValueException;
import org.eclipse.ocl.pivot.values.OrderedSetValue;
import org.eclipse.ocl.pivot.values.SetValue;
import org.eclipse.qvtd.runtime.evaluation.AbstractInvocation;
import org.eclipse.qvtd.runtime.evaluation.AbstractTransformer;
import org.eclipse.qvtd.runtime.evaluation.Connection;
import org.eclipse.qvtd.runtime.evaluation.Interval;
import org.eclipse.qvtd.runtime.evaluation.InvocationConstructor;
import org.eclipse.qvtd.runtime.evaluation.InvocationManager;
import org.eclipse.qvtd.runtime.evaluation.ObjectManager;
import org.eclipse.qvtd.runtime.evaluation.TransformationExecutor;
import org.eclipse.qvtd.runtime.internal.evaluation.AbstractInvocationConstructor;
import org.eclipse.qvtd.runtime.internal.evaluation.IncrementalInvocationManager;
import org.eclipse.qvtd.runtime.internal.evaluation.IncrementalObjectManager;
import org.eclipse.qvtd.runtime.library.model.ModelObjectsOfKindOperation;
import tree2talltree.talltree.TallNode;
import tree2talltree.talltree.TalltreeFactory;
import tree2talltree.talltree.TalltreePackage;
import tree2talltree.tree.Node;
import tree2talltree.tree.TreePackage;
import tree2talltree.tree2talltree.Node2TallNode;
import tree2talltree.tree2talltree.Tree2talltreeFactory;
import tree2talltree.tree2talltree.Tree2talltreePackage;
/**
* The Tree2TallTreeInstall transformation:
* <p>
* Construct with an evaluator
* <br>
* Populate each input model with {@link addRootObjects(String,List)}
* <br>
* {@link run()}
* <br>
* Extract each output model with {@link getRootObjects(String)}
*/
@SuppressWarnings("nls")
public class Tree2TallTreeInstallManual extends AbstractTransformer
{
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull RootPackageId PACKid_$metamodel$ = IdManager.getRootPackageId("$metamodel$");
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull NsURIPackageId PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore = IdManager.getNsURIPackageId("http://www.eclipse.org/emf/2002/Ecore", null, EcorePackage.eINSTANCE);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull NsURIPackageId PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2015_s_QVTbaseLibrary = IdManager.getNsURIPackageId("http://www.eclipse.org/qvt/2015/QVTbaseLibrary", "qvtbaselib", null);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull NsURIPackageId PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_examples_s_0_1_s_List2List = IdManager.getNsURIPackageId("http://www.eclipse.org/qvt/examples/0.1/List2List", null, Tree2talltreePackage.eINSTANCE);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull NsURIPackageId PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_examples_s_0_1_s_TallTree = IdManager.getNsURIPackageId("http://www.eclipse.org/qvt/examples/0.1/TallTree", null, TalltreePackage.eINSTANCE);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull NsURIPackageId PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_examples_s_0_1_s_Tree = IdManager.getNsURIPackageId("http://www.eclipse.org/qvt/examples/0.1/Tree", null, TreePackage.eINSTANCE);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_Class = PACKid_$metamodel$.getClassId("Class", 0);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_Model = PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_2015_s_QVTbaseLibrary.getClassId("Model", 0);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_Node = PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_examples_s_0_1_s_Tree.getClassId("Node", 0);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_Node2TallNode = PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_examples_s_0_1_s_List2List.getClassId("Node2TallNode", 0);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull ClassId CLSSid_TallNode = PACKid_http_c_s_s_www_eclipse_org_s_qvt_s_examples_s_0_1_s_TallTree.getClassId("TallNode", 0);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull DataTypeId DATAid_EInt = PACKid_http_c_s_s_www_eclipse_org_s_emf_s_2002_s_Ecore.getDataTypeId("EInt", 0);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull IntegerValue INT_0 = ValueUtil.integerValueOf("0");
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull IntegerValue INT_1 = ValueUtil.integerValueOf("1");
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId BAG_CLSSid_TallNode = TypeId.BAG.getSpecializedId(CLSSid_TallNode);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId BAG_DATAid_EInt = TypeId.BAG.getSpecializedId(DATAid_EInt);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId ORD_CLSSid_Node = TypeId.ORDERED_SET.getSpecializedId(CLSSid_Node);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId SEQ_CLSSid_Node2TallNode = TypeId.SEQUENCE.getSpecializedId(CLSSid_Node2TallNode);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId SET_CLSSid_Node = TypeId.SET.getSpecializedId(CLSSid_Node);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId SET_CLSSid_Node2TallNode = TypeId.SET.getSpecializedId(CLSSid_Node2TallNode);
public static final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull CollectionTypeId SET_CLSSid_TallNode = TypeId.SET.getSpecializedId(CLSSid_TallNode);
/*
* Property-source to Property-target unnavigable navigation caches
*/
protected final @NonNull Map<Node,Node2TallNode> OPPOSITE_OF_Node2TallNode_node = new HashMap<Node,Node2TallNode>();
/*
* Array of the ClassIds of each class for which allInstances() may be invoked. Array index is the ClassIndex.
*/
private static final @NonNull ClassId[] classIndex2classId = new @NonNull ClassId[]{
CLSSid_Node // 0 => Node
};
/*
* Mapping from each ClassIndex to all the ClassIndexes to which an object of the outer index
* may contribute results to an allInstances() invocation.
* Non trivial inner arrays arise when one ClassId is a derivation of another and so an
* instance of the derived classId contributes to derived and inherited ClassIndexes.
*/
private final static int @NonNull [] @NonNull [] classIndex2allClassIndexes = new int @NonNull [] @NonNull [] {
{0} // 0 : Node -> {Node}
};
protected final AbstractInvocationConstructor.@NonNull Incremental CTOR_Root;
protected final AbstractInvocationConstructor.@NonNull Incremental CTOR_Node2MiddleNode;
protected final AbstractInvocationConstructor.@NonNull Incremental CTOR_Edge2MiddleEdge;
protected final AbstractInvocationConstructor.@NonNull Incremental CTOR_MiddleNode2TallNode;
protected final @NonNull Interval interval0;
protected final @NonNull Interval interval1;
protected final @NonNull Interval interval2;
protected final @NonNull Interval interval3;
public Tree2TallTreeInstallManual(final @NonNull TransformationExecutor executor) {
super(executor, new @NonNull String[] {"tree", "talltree", "tree2talltree"}, null, classIndex2classId, classIndex2allClassIndexes);
interval0 = invocationManager.createInterval();
interval1 = invocationManager.createInterval();
interval2 = invocationManager.createInterval();
interval3 = invocationManager.createInterval();
CTOR_Root = new AbstractInvocationConstructor.Incremental(interval0, "__root__")
{
@Override
public @NonNull MAP___root__ newInstance(@NonNull Object @NonNull [] values) {
return new MAP___root__(interval, this, values);
}
};
CTOR_Node2MiddleNode = new AbstractInvocationConstructor.Incremental(interval1, "Node2MiddleNode")
{
@Override
public @NonNull MAP_Node2MiddleNode newInstance(@NonNull Object @NonNull [] values) {
return new MAP_Node2MiddleNode(interval, this, values);
}
};
CTOR_Edge2MiddleEdge = new AbstractInvocationConstructor.Incremental(interval2, "Edge2MiddleEdge")
{
@Override
public @NonNull MAP_Edge2MiddleEdge newInstance(@NonNull Object @NonNull [] values) {
return new MAP_Edge2MiddleEdge(interval, this, values);
}
};
CTOR_MiddleNode2TallNode = new AbstractInvocationConstructor.Incremental(interval3, "MiddleNode2TallNode")
{
@Override
public @NonNull MAP_MiddleNode2TallNode newInstance(@NonNull Object @NonNull [] values) {
return new MAP_MiddleNode2TallNode(interval, this, values);
}
};
}
@Override
protected @NonNull InvocationManager createInvocationManager() {
return new IncrementalInvocationManager(executor);
}
@Override
protected @NonNull ObjectManager createObjectManager() {
return new IncrementalObjectManager((IncrementalInvocationManager)invocationManager);
}
@Override
public boolean run() {
CTOR_Root.connect(null, null);
CTOR_Root.getInstance(new @NonNull Object[]{});
// new MAP___root__(new @NonNull Object[0]);
// invocationManager.setWorkToDoAt(0);
return invocationManager.flush();
}
/**
*
* map __root__ in Tree2TallTreeInstall {
*
* nodes : OrderedSet(tree::Node)node2tallNodes : Sequence(tree2talltree::Node2TallNode)install Node2MiddleNode {
* node consumes nodes : OrderedSet(tree::Node);
* node2tallNodes appendsTo node2tallNodes;
* }
* install Edge2MiddleEdge {
* node consumes nodes : OrderedSet(tree::Node);
* }
* install MiddleNode2TallNode {
* node2tallNode consumes node2tallNodes : Sequence(tree2talltree::Node2TallNode);
* }
*/
protected class MAP___root__ extends AbstractInvocation.Incremental
{
protected final @NonNull Connection nodes;
public MAP___root__(@NonNull Interval interval, InvocationConstructor.@org.eclipse.jdt.annotation.NonNull Incremental constructor, @NonNull Object @NonNull [] boundValues) {
super(interval, constructor);
nodes = interval.createConnection("nodes", ORD_CLSSid_Node, false);
}
@Override
public boolean execute() {
try {
final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull IdResolver idResolver = executor.getIdResolver();
final /*@NonInvalid*/ org.eclipse.ocl.pivot.@org.eclipse.jdt.annotation.NonNull Class TYP_tree_c_c_Node_0 = idResolver.getClass(CLSSid_Node, null);
final /*@NonInvalid*/ org.eclipse.ocl.pivot.@org.eclipse.jdt.annotation.NonNull StandardLibrary standardLibrary = idResolver.getStandardLibrary();
// connection variables
final /*@NonInvalid*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull SetValue objectsOfKind = ModelObjectsOfKindOperation.INSTANCE.evaluate(executor, SET_CLSSid_Node, models[0/*tree*/], TYP_tree_c_c_Node_0);
final org.eclipse.ocl.pivot.@org.eclipse.jdt.annotation.NonNull Class TYPE_sortedBy_0 = executor.getStaticTypeOf(objectsOfKind);
final LibraryIteration.@org.eclipse.jdt.annotation.NonNull LibraryIterationExtension IMPL_sortedBy_0 = (LibraryIteration.LibraryIterationExtension)TYPE_sortedBy_0.lookupImplementation(standardLibrary, OCLstdlibTables.Operations._Set__sortedBy);
final @NonNull Object ACC_sortedBy_0 = IMPL_sortedBy_0.createAccumulatorValue(executor, ORD_CLSSid_Node, TypeId.STRING);
/**
* Implementation of the iterator body.
*/
final @NonNull AbstractBinaryOperation BODY_sortedBy_0 = new AbstractBinaryOperation()
{
/**
* name
*/
@Override
public @Nullable Object evaluate(final @NonNull Executor executor, final @NonNull TypeId typeId, final @Nullable Object objectsOfKind, final /*@NonInvalid*/ java.lang.@org.eclipse.jdt.annotation.Nullable Object _1) {
final /*@NonInvalid*/ tree2talltree.tree.@org.eclipse.jdt.annotation.Nullable Node symbol_4 = (Node)_1;
if (symbol_4 == null) {
throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/qvt/examples/0.1/Tree\'::Node::name\'");
}
@SuppressWarnings("null")
final /*@Thrown*/ java.lang.@org.eclipse.jdt.annotation.NonNull String name = symbol_4.getName();
objectManager.got(MAP___root__.this, symbol_4, TreePackage.Literals.NODE__NAME, name);
return name;
}
};
final @NonNull ExecutorSingleIterationManager MGR_sortedBy_0 = new ExecutorSingleIterationManager(executor, ORD_CLSSid_Node, BODY_sortedBy_0, objectsOfKind, ACC_sortedBy_0);
final /*@Thrown*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull OrderedSetValue sortedBy = ClassUtil.nonNullState((OrderedSetValue)IMPL_sortedBy_0.evaluateIteration(MGR_sortedBy_0));
for (tree2talltree.tree.@org.eclipse.jdt.annotation.NonNull Node iterator : ValueUtil.typedIterable(Node.class, sortedBy)) {
nodes.append(iterator);
}
final @NonNull Connection node2tallNodes_1 = interval2.createConnection("node2tallNodes_1", SEQ_CLSSid_Node2TallNode, false);
// mapping statements
CTOR_Node2MiddleNode.connect(new @NonNull Connection[]{nodes}, new @NonNull Connection[]{node2tallNodes_1});
CTOR_Edge2MiddleEdge.connect(new @NonNull Connection[]{nodes}, null);
CTOR_MiddleNode2TallNode.connect(new @NonNull Connection[]{node2tallNodes_1}, null);
final /*@Thrown*/ java.lang.@org.eclipse.jdt.annotation.Nullable Boolean __root__ = ValueUtil.TRUE_VALUE;
return __root__;
} catch (Throwable e) {
return handleExecutionFailure("MAP___root__", e);
}
}
@Override
public boolean isEqual(@NonNull IdResolver idResolver, @NonNull Object @NonNull [] thoseValues) {
return true;
}
}
/**
*
* map Node2MiddleNode in Tree2TallTreeInstall {
* guard:tree node : tree::Node[?];
* append node2tallNodes : Sequence(tree2talltree::Node2TallNode);
* new:tree2talltree node2tallNode : tree2talltree::Node2TallNode[?];
* set node2tallNode.node := node;
* set node2tallNode.name := node.name;
* add node2tallNodes += node2tallNode;
*
*/
protected class MAP_Node2MiddleNode extends AbstractInvocation.Incremental
{
protected final /*@NonInvalid*/ tree2talltree.tree.@org.eclipse.jdt.annotation.NonNull Node node;
protected final @NonNull Connection node2tallNodes;
public MAP_Node2MiddleNode(@NonNull Interval interval, InvocationConstructor.@org.eclipse.jdt.annotation.NonNull Incremental constructor, @NonNull Object @NonNull [] boundValues) {
super(interval, constructor);
node = (Node)boundValues[0];
node2tallNodes = (Connection)boundValues[1];
}
@Override
public boolean execute() {
try {
// creations
final /*@Thrown*/ tree2talltree.tree2talltree.@org.eclipse.jdt.annotation.Nullable Node2TallNode node2tallNode_0 = Tree2talltreeFactory.eINSTANCE.createNode2TallNode();
assert node2tallNode_0 != null;
models[2/*tree2talltree*/].add(node2tallNode_0);
objectManager.created(this, node2tallNode_0);
// mapping statements
OPPOSITE_OF_Node2TallNode_node.put(node, node2tallNode_0);
node2tallNode_0.setNode(node);
objectManager.assigned(this, node2tallNode_0, Tree2talltreePackage.Literals.NODE2_TALL_NODE__NODE, node, null);
@SuppressWarnings("null")
final /*@Thrown*/ java.lang.@org.eclipse.jdt.annotation.NonNull String name = node.getName();
objectManager.got(MAP_Node2MiddleNode.this, node, TreePackage.Literals.NODE__NAME, name);
node2tallNode_0.setName(name);
objectManager.assigned(this, node2tallNode_0, Tree2talltreePackage.Literals.NODE2_TALL_NODE__NAME, name, null);
node2tallNodes.append(node2tallNode_0);
final /*@Thrown*/ java.lang.@org.eclipse.jdt.annotation.Nullable Boolean Node2MiddleNode = ValueUtil.TRUE_VALUE;
return Node2MiddleNode;
} catch (Throwable e) {
return handleExecutionFailure("MAP_Node2MiddleNode", e);
}
}
@Override
public boolean isEqual(@NonNull IdResolver idResolver, @NonNull Object @NonNull [] thoseValues) {
return idResolver.oclEquals(node, thoseValues[0])
&& idResolver.oclEquals(node2tallNodes, thoseValues[1]);
}
}
/**
*
* map Edge2MiddleEdge in Tree2TallTreeInstall {
* guard:tree node : tree::Node[?];
* var node2tallNode : tree2talltree::Node2TallNode[?] := node.Node2TallNode;
* check node.parent <> null;
* notify set node2tallNode.parent := node.parent.Node2TallNode;
*
*/
protected class MAP_Edge2MiddleEdge extends AbstractInvocation.Incremental
{
protected final /*@NonInvalid*/ tree2talltree.tree.@org.eclipse.jdt.annotation.NonNull Node node_0;
public MAP_Edge2MiddleEdge(@NonNull Interval interval, InvocationConstructor.@org.eclipse.jdt.annotation.NonNull Incremental constructor, @NonNull Object @NonNull [] boundValues) {
super(interval, constructor);
node_0 = (Node)boundValues[0];
}
@Override
public boolean execute() {
try {
final /*@Thrown*/ tree2talltree.tree2talltree.@org.eclipse.jdt.annotation.NonNull Node2TallNode Node2TallNode = ClassUtil.nonNullState (OPPOSITE_OF_Node2TallNode_node.get(node_0));
objectManager.got(MAP_Edge2MiddleEdge.this, node_0, Tree2talltreePackage.Literals.NODE2_TALL_NODE__NODE, Node2TallNode);
final /*@Thrown*/ tree2talltree.tree.@org.eclipse.jdt.annotation.Nullable Node parent = node_0.getParent();
objectManager.got(MAP_Edge2MiddleEdge.this, node_0, TreePackage.Literals.NODE__PARENT, parent);
final /*@Thrown*/ boolean ne = parent != null;
/*@Thrown*/ java.lang.@org.eclipse.jdt.annotation.Nullable Boolean symbol_2;
if (ne) {
// mapping statements
if (parent == null) {
throw new InvalidValueException("Null source for \'\'http://www.eclipse.org/qvt/examples/0.1/Tree\'::Node::Node2TallNode\'");
}
final /*@Thrown*/ tree2talltree.tree2talltree.@org.eclipse.jdt.annotation.NonNull Node2TallNode Node2TallNode_0 = ClassUtil.nonNullState (OPPOSITE_OF_Node2TallNode_node.get(parent));
objectManager.got(MAP_Edge2MiddleEdge.this, parent, Tree2talltreePackage.Literals.NODE2_TALL_NODE__NODE, Node2TallNode_0);
Node2TallNode.setParent(Node2TallNode_0);
objectManager.assigned(this, Node2TallNode, Tree2talltreePackage.Literals.NODE2_TALL_NODE__PARENT, Node2TallNode_0, null);
final /*@Thrown*/ java.lang.@org.eclipse.jdt.annotation.Nullable Boolean Edge2MiddleEdge = ValueUtil.TRUE_VALUE;
symbol_2 = Edge2MiddleEdge;
}
else {
symbol_2 = ValueUtil.FALSE_VALUE;
}
return symbol_2;
} catch (Throwable e) {
return handleExecutionFailure("MAP_Edge2MiddleEdge", e);
}
}
@Override
public boolean isEqual(@NonNull IdResolver idResolver, @NonNull Object @NonNull [] thoseValues) {
return idResolver.oclEquals(node_0, thoseValues[0]);
}
}
/**
*
* map MiddleNode2TallNode in Tree2TallTreeInstall {
*
* guard:tree2talltree node2tallNode : tree2talltree::Node2TallNode[?];
* var tallNode_name : String[?] := node2tallNode.name;
* var tallNode_children : Set(talltree::TallNode) := node2tallNode.children?.tallNode->asSet()
* ;
* var tallNode_height : Integer[?] := if node2tallNode.children->notEmpty()
* then node2tallNode.children.tallNode.height->max() + 1
* else 0
* endif;
* new:talltree tallNode : talltree::TallNode[?];
* notify set node2tallNode.tallNode := tallNode;
* set tallNode.name := tallNode_name;
* set tallNode.children := tallNode_children;
* notify set tallNode.height := tallNode_height;
*
*/
protected class MAP_MiddleNode2TallNode extends AbstractInvocation.Incremental
{
protected final /*@NonInvalid*/ tree2talltree.tree2talltree.@org.eclipse.jdt.annotation.NonNull Node2TallNode node2tallNode;
public MAP_MiddleNode2TallNode(@NonNull Interval interval, InvocationConstructor.@org.eclipse.jdt.annotation.NonNull Incremental constructor, @NonNull Object @NonNull [] boundValues) {
super(interval, constructor);
node2tallNode = (Node2TallNode)boundValues[0];
}
@Override
public boolean execute() {
try {
final /*@NonInvalid*/ org.eclipse.ocl.pivot.ids.@org.eclipse.jdt.annotation.NonNull IdResolver idResolver = executor.getIdResolver();
@SuppressWarnings("null")
final /*@Thrown*/ java.lang.@org.eclipse.jdt.annotation.NonNull String name = node2tallNode.getName();
objectManager.got(MAP_MiddleNode2TallNode.this, node2tallNode, Tree2talltreePackage.Literals.NODE2_TALL_NODE__NAME, name);
objectManager.getting(node2tallNode, Tree2talltreePackage.Literals.NODE2_TALL_NODE__CHILDREN, false);
@SuppressWarnings("null")
final /*@Thrown*/ java.util.@org.eclipse.jdt.annotation.NonNull List<Node2TallNode> children_0 = node2tallNode.getChildren();
objectManager.got(MAP_MiddleNode2TallNode.this, node2tallNode, Tree2talltreePackage.Literals.NODE2_TALL_NODE__CHILDREN, children_0);
final /*@Thrown*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull SetValue BOXED_children_0 = idResolver.createSetOfAll(SET_CLSSid_Node2TallNode, children_0);
final /*@Thrown*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull SetValue safe_collect_sources = (SetValue)CollectionExcludingOperation.INSTANCE.evaluate(BOXED_children_0, (Object)null);
/*@Thrown*/ BagValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator = ValueUtil.createBagAccumulatorValue(BAG_CLSSid_TallNode);
@NonNull Iterator<Object> ITERATOR__1 = safe_collect_sources.iterator();
/*@Thrown*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull BagValue collect;
while (true) {
if (!ITERATOR__1.hasNext()) {
collect = accumulator;
break;
}
@SuppressWarnings("null")
/*@NonInvalid*/ tree2talltree.tree2talltree.@org.eclipse.jdt.annotation.NonNull Node2TallNode _1 = (Node2TallNode)ITERATOR__1.next();
/**
* tallNode
*/
objectManager.getting(_1, Tree2talltreePackage.Literals.NODE2_TALL_NODE__TALL_NODE, false);
@SuppressWarnings("null")
final /*@Thrown*/ tree2talltree.talltree.@org.eclipse.jdt.annotation.NonNull TallNode tallNode_0 = _1.getTallNode();
objectManager.got(MAP_MiddleNode2TallNode.this, _1, Tree2talltreePackage.Literals.NODE2_TALL_NODE__TALL_NODE, tallNode_0);
//
accumulator.add(tallNode_0);
}
final /*@Thrown*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull SetValue asSet = CollectionAsSetOperation.INSTANCE.evaluate(collect);
final /*@Thrown*/ boolean notEmpty = CollectionNotEmptyOperation.INSTANCE.evaluate(BOXED_children_0).booleanValue();
/*@Thrown*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull IntegerValue symbol_0;
if (notEmpty) {
/*@Thrown*/ BagValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator_0 = ValueUtil.createBagAccumulatorValue(BAG_CLSSid_TallNode);
@NonNull Iterator<Object> ITERATOR__1_0 = BOXED_children_0.iterator();
/*@Thrown*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull BagValue collect_1;
while (true) {
if (!ITERATOR__1_0.hasNext()) {
collect_1 = accumulator_0;
break;
}
@SuppressWarnings("null")
/*@NonInvalid*/ tree2talltree.tree2talltree.@org.eclipse.jdt.annotation.NonNull Node2TallNode _1_0 = (Node2TallNode)ITERATOR__1_0.next();
/**
* tallNode
*/
objectManager.getting(_1_0, Tree2talltreePackage.Literals.NODE2_TALL_NODE__TALL_NODE, false);
@SuppressWarnings("null")
final /*@Thrown*/ tree2talltree.talltree.@org.eclipse.jdt.annotation.NonNull TallNode tallNode_1 = _1_0.getTallNode();
objectManager.got(MAP_MiddleNode2TallNode.this, _1_0, Tree2talltreePackage.Literals.NODE2_TALL_NODE__TALL_NODE, tallNode_1);
//
accumulator_0.add(tallNode_1);
}
/*@Thrown*/ BagValue.@org.eclipse.jdt.annotation.NonNull Accumulator accumulator_1 = ValueUtil.createBagAccumulatorValue(BAG_DATAid_EInt);
@NonNull Iterator<Object> ITERATOR__1_1 = collect_1.iterator();
/*@Thrown*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull BagValue collect_0;
while (true) {
if (!ITERATOR__1_1.hasNext()) {
collect_0 = accumulator_1;
break;
}
@SuppressWarnings("null")
/*@NonInvalid*/ tree2talltree.talltree.@org.eclipse.jdt.annotation.NonNull TallNode _1_1 = (TallNode)ITERATOR__1_1.next();
/**
* height
*/
objectManager.getting(_1_1, TalltreePackage.Literals.TALL_NODE__HEIGHT, false);
final /*@Thrown*/ int height = _1_1.getHeight();
objectManager.got(MAP_MiddleNode2TallNode.this, _1_1, TalltreePackage.Literals.TALL_NODE__HEIGHT, height);
final /*@Thrown*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull IntegerValue BOXED_height = ValueUtil.integerValueOf(height);
//
accumulator_1.add(BOXED_height);
}
final /*@Thrown*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull IntegerValue max = (IntegerValue)CollectionMaxOperation.INSTANCE.evaluate(collect_0);
final /*@Thrown*/ org.eclipse.ocl.pivot.values.@org.eclipse.jdt.annotation.NonNull IntegerValue sum = (IntegerValue)NumericPlusOperation.INSTANCE.evaluate(max, INT_1);
symbol_0 = sum;
}
else {
symbol_0 = INT_0;
}
// creations
final /*@Thrown*/ tree2talltree.talltree.@org.eclipse.jdt.annotation.Nullable TallNode tallNode = TalltreeFactory.eINSTANCE.createTallNode();
assert tallNode != null;
models[1/*talltree*/].add(tallNode);
objectManager.created(this, tallNode);
// mapping statements
node2tallNode.setTallNode(tallNode);
objectManager.assigned(this, node2tallNode, Tree2talltreePackage.Literals.NODE2_TALL_NODE__TALL_NODE, tallNode, null);
tallNode.setName(name);
objectManager.assigned(this, tallNode, TalltreePackage.Literals.TALL_NODE__NAME, name, null);
final /*@Thrown*/ java.util.@org.eclipse.jdt.annotation.NonNull List<TallNode> ECORE_asSet = ((IdResolver.IdResolverExtension)idResolver).ecoreValueOfAll(TallNode.class, asSet);
tallNode.getChildren().addAll(ECORE_asSet);
objectManager.assigned(this, tallNode, TalltreePackage.Literals.TALL_NODE__CHILDREN, ECORE_asSet, null);
final int ECORE_symbol_0 = ValueUtil.intValueOf(symbol_0);
tallNode.setHeight(ECORE_symbol_0);
objectManager.assigned(this, tallNode, TalltreePackage.Literals.TALL_NODE__HEIGHT, ECORE_symbol_0, null);
final /*@Thrown*/ java.lang.@org.eclipse.jdt.annotation.Nullable Boolean MiddleNode2TallNode = ValueUtil.TRUE_VALUE;
return MiddleNode2TallNode;
} catch (Throwable e) {
return handleExecutionFailure("MAP_MiddleNode2TallNode", e);
}
}
@Override
public boolean isEqual(@NonNull IdResolver idResolver, @NonNull Object @NonNull [] thoseValues) {
return idResolver.oclEquals(node2tallNode, thoseValues[0]);
}
}
}
|
