← Back to branch summary

~danilovesky/workcraft/trunk-menu-tools

« back to all changes in this revision

Viewing changes to SONPlugin/src/org/workcraft/plugins/son/algorithm/RelationAlgorithm.java

  • Committer: Danil Sokolov
  • Date: 2015-05-15 15:46:50 UTC
  • mfrom: (599.1.8 trunk-son-mbson)
  • Revision ID: danilovesky@gmail.com-20150515154650-es3cqmx1x1d4p757
Merge proposal for blueprint son-bson-extension approved.

Show diffs side-by-side

added added

removed removed

Lines of Context:
SONPlugin/src/org/workcraft/plugins/son/algorithm/RelationAlgorithm.java
71
71
        }
72
72
        
73
73
        /**
74
 
         * check if a given node is initial state i.e., empty preset 
 
74
         * check if a given node is initial state (condition)
75
75
         */
76
76
        public boolean isInitial(Node n){
77
77
                boolean conType = true;
78
 
        
 
78
                
79
79
                if(net.getPreset(n).size() == 0)
80
80
                        return true;
81
81
                else{
93
93
        }
94
94
        
95
95
        /**
96
 
         * check if a given node is final state i.e., empty postset 
 
96
         * check if a given node is final state (condition)
97
97
         */
98
98
        public boolean isFinal(Node n){
99
99
                boolean conType = true;
117
117
        /**
118
118
         * check if a given set of nodes contains initial states.
119
119
         */
120
 
        public boolean hasInitial(Collection<Node> nodes){
 
120
        public boolean hasInitial(Collection<? extends Node> nodes){
121
121
                boolean result = false;
122
122
                
123
123
                for(Node node : nodes)
129
129
        /**
130
130
         * check if a given set of nodes contains final states.
131
131
         */
132
 
        public boolean hasFinal(Collection<Node> nodes){
 
132
        public boolean hasFinal(Collection<? extends Node> nodes){
133
133
                boolean result = false;
134
134
                
135
135
                for(Node node : nodes)
141
141
        /**
142
142
         * get all initial states of a given node set
143
143
         */
144
 
        public Collection<Node> getInitial(Collection<Node> nodes){
145
 
                ArrayList<Node> result =  new ArrayList<Node>();
 
144
        public Collection<Condition> getInitial(Collection<? extends Node> nodes){
 
145
                ArrayList<Condition> result =  new ArrayList<Condition>();
146
146
                for (Node node : nodes)
147
 
                        if (isInitial(node))
148
 
                                result.add(node);
 
147
                        if (isInitial(node) && (node instanceof Condition))
 
148
                                result.add((Condition)node);
149
149
                return result;
150
150
        }
151
151
 
152
152
        /**
153
153
         * get all final states of a given node set
154
154
         */
155
 
        public Collection<Node> getFinal(Collection<Node> nodes){
156
 
                ArrayList<Node> result =  new ArrayList<Node>();
 
155
        public Collection<Condition> getFinal(Collection<? extends Node> nodes){
 
156
                ArrayList<Condition> result =  new ArrayList<Condition>();
157
157
                for (Node node : nodes)
158
 
                        if (isFinal(node))
159
 
                                result.add(node);
 
158
                        if (isFinal(node) && (node instanceof Condition))
 
159
                                result.add((Condition)node);
160
160
                return result;
161
161
        }
162
162
 
216
216
         */
217
217
        public Collection<TransitionNode> getPreAsynEvents (TransitionNode e){
218
218
                Collection<TransitionNode> result = new ArrayList<TransitionNode>();
219
 
                for(Node node : net.getPreset(e)){
220
 
                        if((node instanceof ChannelPlace) && net.getSONConnectionType(node, e) == Semantics.ASYNLINE){
 
219
                for(Node pre : net.getPreset(e)){
 
220
                        if((pre instanceof ChannelPlace) && net.getSONConnectionType(pre, e) == Semantics.ASYNLINE){
221
221
                                
222
 
                                Iterator<Node> it = net.getPreset(node).iterator();
 
222
                                Iterator<Node> it = net.getPreset(pre).iterator();
223
223
                                
224
224
                                while(it.hasNext()){
225
225
                                        result.add((TransitionNode)it.next());
234
234
         */
235
235
        public Collection<TransitionNode> getPostAsynEvents (TransitionNode e){
236
236
                Collection<TransitionNode> result = new ArrayList<TransitionNode>();
237
 
                for(Node node : net.getPostset(e) )
238
 
                        if((node instanceof ChannelPlace) && net.getSONConnectionType(node, e) == Semantics.ASYNLINE){
 
237
                for(Node post : net.getPostset(e) )
 
238
                        if((post instanceof ChannelPlace) && net.getSONConnectionType(post, e) == Semantics.ASYNLINE){
239
239
 
240
 
                                Iterator<Node> it = net.getPostset(node).iterator();
 
240
                                Iterator<Node> it = net.getPostset(post).iterator();
241
241
                                
242
242
                                while(it.hasNext()){
243
243
                                        result.add((TransitionNode)it.next());
249
249
        /**
250
250
         * get all asynchronous and synchronous (Communication-SON) pre-event for a given event or collapsed block
251
251
         */
252
 
        public Collection<TransitionNode> getPreASynEvents(TransitionNode node){
 
252
        public Collection<TransitionNode> getPreASynEvents(TransitionNode e){
253
253
                Collection<TransitionNode> result = new ArrayList<TransitionNode>();
254
254
 
255
 
                for(Node pre : net.getPreset(node)){
 
255
                for(Node pre : net.getPreset(e)){
256
256
                        if(pre instanceof ChannelPlace){
257
257
 
258
 
                                Iterator<Node> it = net.getPreset(node).iterator();
 
258
                                Iterator<Node> it = net.getPreset(pre).iterator();
259
259
                                
260
260
                                while(it.hasNext()){
261
261
                                        result.add((TransitionNode)it.next());
262
262
                                }
263
263
                        }
264
264
                }
265
 
                for(Node post : net.getPostset(node)){
266
 
                        if((post instanceof ChannelPlace) && net.getSONConnectionType(post, node) == Semantics.SYNCLINE){
 
265
                for(Node post : net.getPostset(e)){
 
266
                        if((post instanceof ChannelPlace) && net.getSONConnectionType(post, e) == Semantics.SYNCLINE){
267
267
                                
268
 
                                Iterator<Node> it = net.getPostset(node).iterator();
 
268
                                Iterator<Node> it = net.getPostset(post).iterator();
269
269
                                
270
270
                                while(it.hasNext()){
271
271
                                        result.add((TransitionNode)it.next());
285
285
                for(Node post : net.getPostset(node)){
286
286
                        if(post instanceof ChannelPlace){
287
287
                                
288
 
                                Iterator<Node> it = net.getPostset(node).iterator();
 
288
                                Iterator<Node> it = net.getPostset(post).iterator();
289
289
                                
290
290
                                while(it.hasNext()){
291
291
                                        result.add((TransitionNode)it.next());
295
295
                for(Node pre : net.getPreset(node)){
296
296
                        if(pre instanceof ChannelPlace && net.getSONConnectionType(pre, node) == Semantics.SYNCLINE){
297
297
                                
298
 
                                Iterator<Node> it = net.getPreset(node).iterator();
 
298
                                Iterator<Node> it = net.getPreset(pre).iterator();
299
299
                                
300
300
                                while(it.hasNext()){
301
301
                                        result.add((TransitionNode)it.next());