← 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/ReachabilityAlg.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/ReachabilityAlg.java
 
1
package org.workcraft.plugins.son.algorithm;
 
2
 
 
3
import java.util.ArrayList;
 
4
import java.util.Collection;
 
5
import java.util.LinkedList;
 
6
import java.util.Map;
 
7
 
 
8
import org.workcraft.dom.Node;
 
9
import org.workcraft.plugins.son.ONGroup;
 
10
import org.workcraft.plugins.son.Phase;
 
11
import org.workcraft.plugins.son.SON;
 
12
import org.workcraft.plugins.son.elements.Condition;
 
13
import org.workcraft.plugins.son.elements.TransitionNode;
 
14
 
 
15
public class ReachabilityAlg {
 
16
        
 
17
        private BSONAlg bsonAlg;
 
18
        private RelationAlgorithm relationAlg;
 
19
        private Collection<ONGroup> upperGroups;
 
20
        private Map<Condition, Collection<Phase>> phases;
 
21
        
 
22
        private static Collection<Node> pathResult =new ArrayList<Node>();
 
23
        
 
24
        public ReachabilityAlg(SON net) {
 
25
                bsonAlg = new BSONAlg(net);
 
26
                relationAlg = new RelationAlgorithm(net);
 
27
                
 
28
                upperGroups = bsonAlg.getUpperGroups(net.getGroups());
 
29
                phases = bsonAlg.getAllPhases();
 
30
        }
 
31
        
 
32
    //get path between a given initial node and a set of final nodes. (recursion)
 
33
    private void dfs(LinkedList<Node> visited, Collection<Node> v,  Collection<TransitionNode[]> before) {
 
34
        LinkedList<Node> post = getCausalPreset(visited.getLast(), before);        
 
35
        
 
36
        if (v.contains(visited.getLast())) {
 
37
            pathResult.addAll(visited);         
 
38
        }
 
39
        
 
40
        // examine post nodes
 
41
        for (Node node : post) {
 
42
            if (visited.contains(node)) {
 
43
                continue;
 
44
            }
 
45
            if (v.contains(node)) {
 
46
                visited.add(node);
 
47
                pathResult.addAll(visited);     
 
48
                visited.removeLast();
 
49
                break;
 
50
            }
 
51
        }
 
52
        // in depth-first, recursion needs to come after visiting post nodes
 
53
        for (Node node : post) {
 
54
            if (visited.contains(node) || node.equals(v)) {
 
55
                continue;
 
56
            }
 
57
            visited.addLast(node);
 
58
            dfs(visited, v, before);
 
59
            visited.removeLast();
 
60
 
 
61
        }
 
62
    }
 
63
    
 
64
    public Collection<Node> getCausalPredecessors (Node s, Collection<Node> v){
 
65
        pathResult.clear();
 
66
        LinkedList<Node> visited = new LinkedList<Node>();
 
67
        Collection<TransitionNode[]> before = getBeforeRelations();
 
68
        visited.add(s);
 
69
        dfs(visited, v, before);
 
70
        return pathResult;
 
71
    }
 
72
        
 
73
        private Collection<TransitionNode[]> getBeforeRelations(){
 
74
                 Collection<TransitionNode[]>  result = new ArrayList<TransitionNode[]>();
 
75
 
 
76
                for(ONGroup group : upperGroups){
 
77
                        for(TransitionNode e : group.getTransitionNodes()){
 
78
                                result.addAll( bsonAlg.before(e, phases));      
 
79
                        }
 
80
                }
 
81
 
 
82
                return result;
 
83
        }
 
84
        
 
85
    private LinkedList<Node> getCausalPreset(Node n, Collection<TransitionNode[]> before){
 
86
        LinkedList<Node> result = new LinkedList<Node>();
 
87
        
 
88
        if(relationAlg.isInitial(n) && (n instanceof Condition)){
 
89
                result.addAll(relationAlg.getPostBhvSet((Condition)n));
 
90
        }
 
91
        
 
92
        for(TransitionNode[] pre : before){
 
93
                if(pre[1] == n)
 
94
                        result.add(pre[0]);
 
95
        }
 
96
        
 
97
        result.addAll(relationAlg.getPrePNSet(n));
 
98
 
 
99
        if(n instanceof TransitionNode){
 
100
                result.addAll(relationAlg.getPreASynEvents((TransitionNode)n));
 
101
        }
 
102
        
 
103
        return result;
 
104
    }
 
105
}