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
|
/**
* Copyright (c) 2017 protos software gmbh (http://www.protos.de).
* 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:
* Henrik Rentz-Reichert (initial contribution)
*/
package org.eclipse.etrice.core.room.util;
import com.google.common.base.Objects;
import com.google.common.collect.Iterables;
import java.util.List;
import java.util.Set;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.etrice.core.fsm.fSM.MessageFromIf;
import org.eclipse.etrice.core.fsm.fSM.RefinedTransition;
import org.eclipse.etrice.core.fsm.fSM.Transition;
import org.eclipse.etrice.core.fsm.fSM.TransitionBase;
import org.eclipse.etrice.core.fsm.fSM.Trigger;
import org.eclipse.etrice.core.fsm.fSM.TriggeredTransition;
import org.eclipse.etrice.core.genmodel.fsm.ICommonDataCalculator;
import org.eclipse.etrice.core.genmodel.fsm.fsmgen.Link;
import org.eclipse.etrice.core.room.DataType;
import org.eclipse.etrice.core.room.Message;
import org.eclipse.etrice.core.room.RefableType;
import org.eclipse.etrice.core.room.RoomFactory;
import org.eclipse.etrice.core.room.VarDecl;
import org.eclipse.etrice.core.room.util.RoomHelpers;
import org.eclipse.xtext.xbase.lib.Functions.Function1;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.ListExtensions;
@SuppressWarnings("all")
public class CommonDataCalculator implements ICommonDataCalculator {
private RoomHelpers roomHelpers = new RoomHelpers();
@Override
public EObject calculateCommonData(final Link l) {
boolean _isIfitemTriggered = l.isIfitemTriggered();
boolean _not = (!_isIfitemTriggered);
if (_not) {
return null;
} else {
EList<Link> _chainHeads = l.getChainHeads();
final Function1<Link, TransitionBase> _function = new Function1<Link, TransitionBase>() {
@Override
public TransitionBase apply(final Link it) {
TransitionBase _transition = it.getTransition();
return CommonDataCalculator.realTransition(_transition);
}
};
List<TransitionBase> _map = ListExtensions.<Link, TransitionBase>map(_chainHeads, _function);
Iterable<TriggeredTransition> transitions = Iterables.<TriggeredTransition>filter(_map, TriggeredTransition.class);
final Function1<TriggeredTransition, EList<Trigger>> _function_1 = new Function1<TriggeredTransition, EList<Trigger>>() {
@Override
public EList<Trigger> apply(final TriggeredTransition it) {
return it.getTriggers();
}
};
Iterable<EList<Trigger>> _map_1 = IterableExtensions.<TriggeredTransition, EList<Trigger>>map(transitions, _function_1);
final Iterable<Trigger> triggers = Iterables.<Trigger>concat(_map_1);
final Function1<Trigger, EList<MessageFromIf>> _function_2 = new Function1<Trigger, EList<MessageFromIf>>() {
@Override
public EList<MessageFromIf> apply(final Trigger it) {
return it.getMsgFromIfPairs();
}
};
Iterable<EList<MessageFromIf>> _map_2 = IterableExtensions.<Trigger, EList<MessageFromIf>>map(triggers, _function_2);
Iterable<MessageFromIf> _flatten = Iterables.<MessageFromIf>concat(_map_2);
final Function1<MessageFromIf, VarDecl> _function_3 = new Function1<MessageFromIf, VarDecl>() {
@Override
public VarDecl apply(final MessageFromIf it) {
EObject _message = it.getMessage();
return ((Message) _message).getData();
}
};
final Iterable<VarDecl> varDeclarations = IterableExtensions.<MessageFromIf, VarDecl>map(_flatten, _function_3);
final Function1<VarDecl, DataType> _function_4 = new Function1<VarDecl, DataType>() {
@Override
public DataType apply(final VarDecl it) {
RefableType _refType = null;
if (it!=null) {
_refType=it.getRefType();
}
DataType _type = null;
if (_refType!=null) {
_type=_refType.getType();
}
return _type;
}
};
Iterable<DataType> _map_3 = IterableExtensions.<VarDecl, DataType>map(varDeclarations, _function_4);
final Set<DataType> allData = IterableExtensions.<DataType>toSet(_map_3);
int _size = allData.size();
boolean _equals = (_size == 1);
if (_equals) {
return IterableExtensions.<VarDecl>head(varDeclarations);
} else {
final Function1<VarDecl, RefableType> _function_5 = new Function1<VarDecl, RefableType>() {
@Override
public RefableType apply(final VarDecl it) {
RefableType _refType = null;
if (it!=null) {
_refType=it.getRefType();
}
return _refType;
}
};
Iterable<RefableType> _map_4 = IterableExtensions.<VarDecl, RefableType>map(varDeclarations, _function_5);
final List<RefableType> types = IterableExtensions.<RefableType>toList(_map_4);
final RefableType rt = this.roomHelpers.getLastCommonSuperType(types);
boolean _notEquals = (!Objects.equal(rt, null));
if (_notEquals) {
final VarDecl vd = RoomFactory.eINSTANCE.createVarDecl();
vd.setName("data");
vd.setRefType(rt);
return vd;
}
}
}
return null;
}
private static TransitionBase realTransition(final TransitionBase t) {
TransitionBase tr = t;
while ((tr instanceof RefinedTransition)) {
Transition _target = ((RefinedTransition)tr).getTarget();
tr = _target;
}
return tr;
}
}
|
