View Javadoc

1   package net.kwfgrid.gworkflowdl.analysis;
2   
3   import net.kwfgrid.gworkflowdl.structure.Edge;
4   import net.kwfgrid.gworkflowdl.structure.Place;
5   import net.kwfgrid.gworkflowdl.structure.Transition;
6   import net.kwfgrid.gworkflowdl.structure.Workflow;
7   
8   import java.util.ArrayList;
9   import java.util.Hashtable;
10  
11  /***
12   * Created by IntelliJ IDEA.
13   * User: hans
14   * Date: 10.10.2005
15   * Time: 13:15:03
16   * To change this template use File | Settings | File Templates.
17   */
18  public final class Conflict {
19  
20      public static Decision[] getDecisions(Workflow wf) {
21          Transition[] enabled = wf.getEnabledTransitions();
22          Place[] ps = wf.getPlaces();
23          ArrayList retArrayList = new ArrayList();
24  
25          for (int k = 0; k < ps.length; k++) {
26              Place p = ps[k];
27              int type = -1;
28              ArrayList al = new ArrayList();
29              if (p.getTokenNumber() == 1) {
30                  type = Decision.TAKE_CONFLICT;
31              } else {
32                  type = Decision.TAKE_CHOICE;
33              }
34  
35  
36              for (int i = 0; i < enabled.length; i++) {
37                  Transition t = enabled[i];
38  
39                  //boolean pIsOutPlaceForAll = true;
40                  Edge[] es = t.getInEdges();
41                  for (int j = 0; j < es.length; j++) {
42                      if (es[j].getPlace() == p) {
43                          al.add(t);
44                      }
45                  }
46              }
47              if (al.size() > 1) {
48                  Decision decision = new Decision();
49                  decision.type  = type;
50                  decision.place = p;
51                  decision.transitions = new Transition[al.size()];
52                  for (int i = 0; i < al.size(); i++) {
53                      decision.transitions[i] = (Transition) al.get(i);
54                  }
55                  retArrayList.add(decision);
56              }
57          }
58  
59          for (int k = 0; k < ps.length; k++) {
60              Place p = ps[k];
61              int type = -1;
62              ArrayList al = new ArrayList();
63  
64              if (p.getTokenNumber() == p.getCapacity() - 1) {
65                  type = Decision.PUT_CONFLICT;
66              } else {
67                  type = Decision.PUT_CHOICE;
68              }
69  
70              for (int i = 0; i < enabled.length; i++) {
71                  Transition t = enabled[i];
72  
73                  //boolean pIsOutPlaceForAll = true;
74                  Edge[] es = t.getOutEdges();
75                  for (int j = 0; j < es.length; j++) {
76                      if (es[j].getPlace() == p) {
77                          al.add(t);
78                      }
79                  }
80              }
81              if (al.size() > 1) {
82                  Decision decision = new Decision();
83                  decision.type  = type;
84                  decision.place = p;
85                  decision.transitions = new Transition[al.size()];
86                  for (int i = 0; i < al.size(); i++) {
87                      decision.transitions[i] = (Transition) al.get(i);
88                  }
89                  retArrayList.add(decision);
90              }
91          }
92  
93          Decision[] ret = new Decision[retArrayList.size()];
94          for (int i = 0; i < ret.length; i++) {
95              ret[i] = (Decision) retArrayList.get(i);
96          }
97          return ret;
98      }
99  
100 
101     /***
102      * @param t1 first transition
103      * @param t2 second transition
104      * @return true if transition t1 takes off concession of transition t2
105      */
106     private static boolean takesConcession(final Transition t1, final Transition t2) {
107 
108         final Edge[] in1  = t1.getInEdges();
109         final Edge[] in2  = t2.getInEdges();
110         final Edge[] out1 = t1.getOutEdges();
111         final Edge[] out2 = t2.getOutEdges();
112 
113         final Hashtable ht = new Hashtable();
114 
115         for (int i = 0; i < in1.length; i++) {
116             final Place p = in1[i].getPlace();
117             ht.put(p.getID(), new Integer(p.getTokenNumber() - 1));
118         }
119         for (int i = 0; i < out1.length; i++) {
120             final Place p = out1[i].getPlace();
121             final String id = p.getID();
122             final Integer tokenNumber = (Integer) ht.get(id);
123             if (tokenNumber == null) {
124                 ht.put(id, new Integer(p.getTokenNumber() + 1));
125             } else {
126                 ht.put(id, new Integer(tokenNumber.intValue() + 1));
127             }
128         }
129 
130         for (int i = 0; i < in2.length; i++) {
131             final Place p = in2[i].getPlace();
132             final Integer tokenNumber = (Integer) ht.get(p.getID());
133             if (tokenNumber != null) {
134                 if (tokenNumber.intValue() < 1) return true;
135             }
136 
137         }
138         for (int i = 0; i < out2.length; i++) {
139             final Place p = out2[i].getPlace();
140             final Integer tokenNumber = (Integer) ht.get(p.getID());
141             if (tokenNumber != null) {
142                 if (tokenNumber.intValue() + 1 > p.getCapacity()) return true;
143             }
144 
145         }
146 
147         return false;
148     }
149 
150 
151     /*
152     we need at least one of both takesOffConcession() because:
153     suppose one token at p, t1 looses concession by firing of t2, but not vice versa
154 
155      p ----> t1 ----> p
156 
157      p ----> t2
158 
159     */
160 
161     public static boolean inConflict(Transition t1, Transition t2) {
162         if (!t1.isEnabled() || !t2.isEnabled()) {
163             return false;
164         }
165         return Conflict.takesConcession(t1, t2) || Conflict.takesConcession(t2, t1);
166     }
167 
168 
169 
170 }