blob: 0fc9e9771a26243b71051e7d004c93bfc80c7de5 (
plain) (
blame)
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
|
/*****************************************************************************
* Copyright (c) 2012 CEA LIST.
*
*
* 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:
* CEA LIST - Initial API and implementation
*
*****************************************************************************/
package org.eclipse.papyrus.moka.fuml.Semantics.Actions.CompleteActions;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.papyrus.moka.fuml.Semantics.Actions.BasicActions.ActionActivation;
import org.eclipse.papyrus.moka.fuml.Semantics.Activities.IntermediateActivities.Token;
import org.eclipse.papyrus.moka.fuml.Semantics.Classes.Kernel.FeatureValue;
import org.eclipse.papyrus.moka.fuml.Semantics.Classes.Kernel.Value;
import org.eclipse.papyrus.moka.fuml.Semantics.CommonBehaviors.Communications.SignalInstance;
import org.eclipse.papyrus.moka.fuml.debug.Debug;
import org.eclipse.uml2.uml.AcceptEventAction;
import org.eclipse.uml2.uml.OutputPin;
import org.eclipse.uml2.uml.Signal;
import org.eclipse.uml2.uml.SignalEvent;
import org.eclipse.uml2.uml.Trigger;
public class AcceptEventActionActivation extends ActionActivation {
/*
* If the accept event action activation is waiting for an event, then this
* is the accepter it has registered for the event.
*/
public AcceptEventActionEventAccepter eventAccepter;
public Boolean waiting;
@Override
public void run() {
// Create an event accepter and initialize waiting to false.
super.run();
this.eventAccepter = new AcceptEventActionEventAccepter();
this.eventAccepter.actionActivation = this;
this.waiting = false;
}
@Override
public void fire(List<Token> incomingTokens) {
// Register the event accepter for this accept event action activation
// with the context object of the enclosing activity execution
// and wait for an event to be accepted.
Debug.println("[fire] Action " + this.node.getName() + "...");
this.getExecutionContext().register(this.eventAccepter);
this.waiting = true;
this.firing = false;
this.suspend();
}
@Override
public Boolean isReady() {
// An accept event action activiation is ready to fire only if it is not
// already waiting for an event.
boolean ready;
if (this.isWaiting()) { // CHANGED "this.waiting" to "this.isWaiting()".
ready = false;
} else {
ready = super.isReady();
}
return ready;
}
// ADDED:
public Boolean isWaiting() {
return this.waiting == null ? false : this.waiting;
}
//
@Override
public void doAction() {
// Do nothing. [This will never be called.]
return;
}
public void accept(SignalInstance signalInstance) {
// Accept a signal occurance for the given signal instance.
// If the action does not unmarshall, then place the signal instance on
// the result pin, if any.
// If the action does unmarshall, then get the feature values of the
// signal instance, and place the values for each feature on the
// corresponding output pin.
// Concurrently fire all output pins while offering a single control
// token.
// If there are no incoming edges, then re-register this accept event
// action execution with the context object.
AcceptEventAction action = (AcceptEventAction) (this.node);
List<OutputPin> resultPins = action.getResults();
Debug.println("[accept] action = " + action.getName() + ", signalinstance = " + signalInstance);
if (this.running) {
if (!action.isUnmarshall()) {
List<Value> result = new ArrayList<Value>();
result.add(signalInstance);
if (resultPins.size() > 0) {
this.putTokens(resultPins.get(0), result);
}
} else {
List<FeatureValue> featureValues = signalInstance.getFeatureValues();
for (int i = 0; i < featureValues.size(); i++) {
FeatureValue featureValue = featureValues.get(i);
OutputPin resultPin = resultPins.get(i);
this.putTokens(resultPin, featureValue.values);
}
}
this.sendOffers();
this.waiting = false;
Debug.println("[fire] Checking if " + this.node.getName() + " should fire again...");
this.receiveOffer();
this.resume();
}
}
public Boolean match(SignalInstance signalInstance) {
// Return true if the given signal instance matches a trigger of the
// accept action of this activation.
AcceptEventAction action = (AcceptEventAction) (this.node);
List<Trigger> triggers = action.getTriggers();
Signal signal = signalInstance.type;
boolean matches = false;
int i = 1;
while (!matches & i <= triggers.size()) {
matches = ((SignalEvent) (triggers.get(i - 1).getEvent())).getSignal() == signal;
i = i + 1;
}
return matches;
}
@Override
public void terminate() {
// Terminate this action and unregister its event accepter.
super.terminate();
if (this.isWaiting()) { // CHANGED "this.waiting" to "this.isWaiting()".
this.getExecutionContext().unregister(this.eventAccepter);
this.waiting = false;
}
}
}
|
