1 | package com.hammurapi.extract; |
2 | |
3 | import java.io.Serializable; |
4 | import java.util.Collections; |
5 | import java.util.HashSet; |
6 | import java.util.Map; |
7 | import java.util.Set; |
8 | import java.util.TreeSet; |
9 | import java.util.concurrent.TimeUnit; |
10 | |
11 | |
12 | /** |
13 | * Commutative OR. |
14 | * @author Pavel Vlasov. |
15 | * |
16 | * @param <T> |
17 | */ |
18 | public class CommutativeOr<T, C> extends ExtractorBase<T, Boolean, C> implements CommutativeCompositePredicate<T, C, CommutativeOr<T,C>>, Serializable { |
19 | |
20 | private Set<Predicate<T, C>> parts = new HashSet<Predicate<T, C>>(); |
21 | |
22 | public CommutativeOr(double initialCost, TimeUnit costUnit) { |
23 | super(initialCost,costUnit); |
24 | } |
25 | |
26 | public CommutativeOr(double initialCost,TimeUnit costUnit, Predicate<T,C>... parts) { |
27 | super(initialCost,costUnit); |
28 | for (Predicate<T,C> part: parts) { |
29 | addPart(part); |
30 | } |
31 | } |
32 | |
33 | public CommutativeOr(double initialCost,TimeUnit costUnit, Iterable<Predicate<T,C>> parts) { |
34 | super(initialCost,costUnit); |
35 | for (Predicate<T,C> part: parts) { |
36 | addPart(part); |
37 | } |
38 | } |
39 | |
40 | private void addPart(Predicate<T, C> part) { |
41 | if (part instanceof CommutativeOr) { |
42 | for (Predicate<T, C> pp: ((CommutativeOr<T, C>) part).getParts()) { |
43 | addPart(pp); |
44 | } |
45 | } else { |
46 | parts.add(part); |
47 | } |
48 | } |
49 | |
50 | public Set<Predicate<T, C>> getParts() { |
51 | return Collections.unmodifiableSet(parts); |
52 | } |
53 | |
54 | @Override |
55 | @SuppressWarnings("unchecked") |
56 | public ComparisonResult compareTo(Extractor<T, Boolean, C> otherPredicate) { |
57 | if (getParts().isEmpty()) { |
58 | return True.getInstance().compareTo((Extractor<Object, Boolean, Object>) otherPredicate); |
59 | } |
60 | |
61 | if (otherPredicate instanceof CommutativeOr && parts.equals(((CommutativeOr) otherPredicate).parts)) { |
62 | return ComparisonResult.EQUAL_NM; |
63 | } |
64 | |
65 | boolean isTrue = false; |
66 | boolean isFalse = true; |
67 | for (Predicate<T, C> part: getParts()) { |
68 | ComparisonResult pcr = part.compareTo((Predicate<T, C>) True.getInstance()); |
69 | if (pcr.getType().equals(ComparisonResult.Type.EQUAL)) { |
70 | isTrue = true; |
71 | isFalse = false; |
72 | break; |
73 | } else if (!pcr.getType().equals(ComparisonResult.Type.OPPOSITE)) { |
74 | isFalse = false; |
75 | } |
76 | } |
77 | |
78 | if (isTrue) { |
79 | return otherPredicate.compareTo((Predicate<T, C>) True.getInstance()); |
80 | } |
81 | |
82 | if (isFalse) { |
83 | return otherPredicate.compareTo((Predicate<T, C>) False.getInstance()); |
84 | } |
85 | |
86 | if (getParts().size()==1) { |
87 | return getParts().iterator().next().compareTo(otherPredicate); |
88 | } |
89 | for (Predicate<T, C> part: getParts()) { |
90 | ComparisonResult pcr = part.compareTo(otherPredicate); |
91 | if (pcr.isOneToOneMapping()) { |
92 | switch (pcr.getType()) { |
93 | case EQUAL: |
94 | case LESS_RESTRICTIVE: |
95 | return ComparisonResult.LESS_RESTRICTIVE_NM; |
96 | // case OPPOSITE: |
97 | // case OPPOSITE_LESS_RESTRICTIVE: |
98 | // return ComparisonResult.OPPOSITE_MORE_RESTRICTIVE_NM; |
99 | } |
100 | } |
101 | } |
102 | |
103 | return super.compareTo(otherPredicate); |
104 | } |
105 | |
106 | protected Boolean extractInternal(C context, Map<C, Map<Extractor<T, ? super Boolean, C>, ? super Boolean>> cache, T... obj) { |
107 | for (Predicate<T, C> part: parts) { |
108 | if (part.extract(context, cache, obj)) { |
109 | return true; |
110 | } |
111 | } |
112 | return false; |
113 | } |
114 | |
115 | public Set<Integer> parameterIndices() { |
116 | Set<Integer> ret = new TreeSet<Integer>(); |
117 | for (Predicate<T, C> part: parts) { |
118 | ret.addAll(part.parameterIndices()); |
119 | } |
120 | return ret; |
121 | } |
122 | |
123 | |
124 | @SuppressWarnings("unchecked") |
125 | public Predicate<T, C> remove(Predicate<T, C> part) { |
126 | if (!parts.contains(part)) { |
127 | return this; |
128 | } |
129 | try { |
130 | CommutativeOr<T, C> ret = (CommutativeOr<T, C>) clone(); |
131 | ret.parts.remove(part); |
132 | return ret.parts.size()==1 ? ret.parts.iterator().next() : ret; |
133 | } catch (CloneNotSupportedException e) { |
134 | throw new ExtractorException(e); |
135 | } |
136 | } |
137 | |
138 | @SuppressWarnings("unchecked") |
139 | public Predicate<T, C> normalize() { |
140 | if (getParts().isEmpty()) { |
141 | return True.getInstance(); |
142 | } |
143 | if (getParts().size()==1) { |
144 | Predicate<T, C> ret = getParts().iterator().next(); |
145 | if (ret instanceof CompositePredicate) { |
146 | ((CompositePredicate) ret).normalize(); |
147 | } |
148 | return ret; |
149 | } |
150 | ComparisonResult cr = compareTo((Predicate<T, C>) True.getInstance()); |
151 | if (cr.getType().equals(ComparisonResult.Type.EQUAL)) { |
152 | return True.getInstance(); |
153 | } |
154 | if (cr.getType().equals(ComparisonResult.Type.OPPOSITE)) { |
155 | return False.getInstance(); |
156 | } |
157 | |
158 | Predicate<T, C>[] pa = getParts().toArray(new Predicate[getParts().size()]); |
159 | Z: for (int i=0; i<pa.length; ++i) { |
160 | for (int j=0; j<pa.length; ++j) { |
161 | if (j!=i && pa[i]!=null && pa[j]!=null) { |
162 | ComparisonResult pcr1 = pa[i].compareTo(pa[j]); |
163 | if (pcr1.isOneToOneMapping()) { |
164 | switch (pcr1.getType()) { |
165 | case EQUAL: |
166 | case MORE_RESTRICTIVE: |
167 | pa[j]=null; |
168 | continue; |
169 | case OPPOSITE: |
170 | case OPPOSITE_MORE_RESTRICTIVE: |
171 | return True.getInstance(); |
172 | } |
173 | } |
174 | |
175 | ComparisonResult pcr2 = pa[j].compareTo(pa[i]); |
176 | if (pcr2.isOneToOneMapping()) { |
177 | switch (pcr2.getType()) { |
178 | case EQUAL: |
179 | case MORE_RESTRICTIVE: |
180 | pa[i]=null; |
181 | continue Z; |
182 | case OPPOSITE: |
183 | case OPPOSITE_MORE_RESTRICTIVE: |
184 | return True.getInstance(); |
185 | } |
186 | } |
187 | } |
188 | } |
189 | } |
190 | |
191 | int pc = 0; |
192 | for (Predicate<T, C> part: pa) { |
193 | if (part!=null) { |
194 | ++pc; |
195 | } |
196 | } |
197 | |
198 | if (pc==0) { |
199 | return True.getInstance(); |
200 | } |
201 | |
202 | if (pc==1) { |
203 | for (Predicate<T, C> part: pa) { |
204 | if (part!=null) { |
205 | if (part instanceof CompositePredicate) { |
206 | ((CompositePredicate) part).normalize(); |
207 | } |
208 | return part; |
209 | } |
210 | } |
211 | } |
212 | |
213 | if (pc!=pa.length) { |
214 | CommutativeOr<T, C> ret = new CommutativeOr<T, C>(cost,costUnit); |
215 | for (Predicate<T, C> part: pa) { |
216 | if (part!=null) { |
217 | ret.addPart(part); |
218 | } |
219 | } |
220 | return ret; |
221 | } |
222 | |
223 | |
224 | return this; |
225 | } |
226 | |
227 | public boolean isContextDependent() { |
228 | for (Predicate<T, C> part: getParts()) { |
229 | if (part.isContextDependent()) { |
230 | return true; |
231 | } |
232 | } |
233 | return false; |
234 | } |
235 | |
236 | @Override |
237 | public String toString() { |
238 | return getClass().getName()+getParts(); |
239 | } |
240 | |
241 | @Override |
242 | public double getCost() { |
243 | if (cost==0 && costUnit==null) { |
244 | double ret = 0; |
245 | for (Predicate<T,C> part: parts) { |
246 | ret+=part.getCost(); |
247 | } |
248 | return ret; |
249 | } |
250 | return super.getCost(); |
251 | } |
252 | |
253 | |
254 | @Override |
255 | public Extractor<T, Boolean, C> map(int[] map) { |
256 | CommutativeOr<T,C> ret = new CommutativeOr<T, C>(initialCost, costUnit); |
257 | for (Predicate<T,C> part: parts) { |
258 | ret.addPart(MappedPredicate.mapPredicate(part, map)); |
259 | } |
260 | return ret; |
261 | } |
262 | |
263 | @Override |
264 | public Object clone() throws CloneNotSupportedException { |
265 | @SuppressWarnings("unchecked") |
266 | CommutativeOr<T,C> ret = (CommutativeOr<T, C>) super.clone(); |
267 | ret.parts = new HashSet<Predicate<T,C>>(parts); |
268 | return ret; |
269 | } |
270 | |
271 | @Override |
272 | public CommutativeOr<T, C> add(Predicate<T, C> part) { |
273 | CommutativeOr<T, C> ret = new CommutativeOr<T, C>(initialCost, costUnit, parts); |
274 | ret.parts.add(part); |
275 | return ret; |
276 | } |
277 | |
278 | } |