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 AND. |
14 | * @author Pavel Vlasov. |
15 | * |
16 | * @param <T> |
17 | */ |
18 | public class CommutativeAnd<T, C> extends ExtractorBase<T, Boolean, C> implements CommutativeCompositePredicate<T, C, CommutativeAnd<T,C>>, Serializable { |
19 | |
20 | private Set<Predicate<T, C>> parts = new HashSet<Predicate<T, C>>(); |
21 | |
22 | public CommutativeAnd(double initialCost, TimeUnit costUnit) { |
23 | super(initialCost,costUnit); |
24 | } |
25 | |
26 | public CommutativeAnd(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 CommutativeAnd(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 CommutativeAnd) { |
42 | for (Predicate<T, C> pp: ((CommutativeAnd<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 CommutativeAnd && parts.equals(((CommutativeAnd) otherPredicate).parts)) { |
62 | return ComparisonResult.EQUAL_NM; |
63 | } |
64 | |
65 | boolean isTrue = true; |
66 | boolean isFalse = false; |
67 | for (Predicate<T, C> part: getParts()) { |
68 | ComparisonResult pcr = part.compareTo((Predicate<T, C>) False.getInstance()); |
69 | if (pcr.getType().equals(ComparisonResult.Type.EQUAL)) { |
70 | isFalse = true; |
71 | isTrue = false; |
72 | break; |
73 | } else if (!pcr.getType().equals(ComparisonResult.Type.OPPOSITE)) { |
74 | isTrue = 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 MORE_RESTRICTIVE: |
95 | return ComparisonResult.MORE_RESTRICTIVE_NM; |
96 | // case OPPOSITE: |
97 | // case OPPOSITE_MORE_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 false; |
110 | } |
111 | } |
112 | return true; |
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 | CommutativeAnd<T, C> ret = (CommutativeAnd<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 | Predicate<T, C>[] pa = getParts().toArray(new Predicate[getParts().size()]); |
158 | Z: for (int i=0; i<pa.length; ++i) { |
159 | for (int j=0; j<pa.length; ++j) { |
160 | if (j!=i && pa[i]!=null && pa[j]!=null) { |
161 | ComparisonResult pcr1 = pa[i].compareTo(pa[j]); |
162 | if (pcr1.isOneToOneMapping()) { |
163 | switch (pcr1.getType()) { |
164 | case EQUAL: |
165 | case LESS_RESTRICTIVE: |
166 | pa[j]=null; |
167 | continue; |
168 | case OPPOSITE: |
169 | case OPPOSITE_LESS_RESTRICTIVE: |
170 | return False.getInstance(); |
171 | } |
172 | } |
173 | |
174 | ComparisonResult pcr2 = pa[j].compareTo(pa[i]); |
175 | if (pcr2.isOneToOneMapping()) { |
176 | switch (pcr2.getType()) { |
177 | case EQUAL: |
178 | case LESS_RESTRICTIVE: |
179 | pa[i]=null; |
180 | continue Z; |
181 | case OPPOSITE: |
182 | case OPPOSITE_LESS_RESTRICTIVE: |
183 | return False.getInstance(); |
184 | } |
185 | } |
186 | } |
187 | } |
188 | } |
189 | |
190 | int pc = 0; |
191 | for (Predicate<T, C> part: pa) { |
192 | if (part!=null) { |
193 | ++pc; |
194 | } |
195 | } |
196 | |
197 | if (pc==0) { |
198 | return True.getInstance(); |
199 | } |
200 | |
201 | if (pc==1) { |
202 | for (Predicate<T, C> part: pa) { |
203 | if (part!=null) { |
204 | if (part instanceof CompositePredicate) { |
205 | ((CompositePredicate) part).normalize(); |
206 | } |
207 | return part; |
208 | } |
209 | } |
210 | } |
211 | |
212 | if (pc!=pa.length) { |
213 | CommutativeAnd<T, C> ret = new CommutativeAnd<T, C>(cost, costUnit); |
214 | for (Predicate<T, C> part: pa) { |
215 | if (part!=null) { |
216 | ret.addPart(part); |
217 | } |
218 | } |
219 | return ret; |
220 | } |
221 | |
222 | return this; |
223 | } |
224 | |
225 | public boolean isContextDependent() { |
226 | for (Predicate<T, C> part: getParts()) { |
227 | if (part.isContextDependent()) { |
228 | return true; |
229 | } |
230 | } |
231 | return false; |
232 | } |
233 | |
234 | @Override |
235 | public String toString() { |
236 | return getClass().getName()+getParts(); |
237 | } |
238 | |
239 | @Override |
240 | public double getCost() { |
241 | if (cost==0 && costUnit==null) { |
242 | double ret = 0; |
243 | for (Predicate<T,C> part: parts) { |
244 | ret+=part.getCost(); |
245 | } |
246 | return ret; |
247 | } |
248 | return super.getCost(); |
249 | } |
250 | |
251 | |
252 | @Override |
253 | public Extractor<T, Boolean, C> map(int[] map) { |
254 | CommutativeAnd<T,C> ret = new CommutativeAnd<T, C>(initialCost, costUnit); |
255 | for (Predicate<T,C> part: parts) { |
256 | ret.addPart(MappedPredicate.mapPredicate(part, map)); |
257 | } |
258 | return ret; |
259 | } |
260 | |
261 | @Override |
262 | public Object clone() throws CloneNotSupportedException { |
263 | @SuppressWarnings("unchecked") |
264 | CommutativeAnd<T,C> ret = (CommutativeAnd<T, C>) super.clone(); |
265 | ret.parts = new HashSet<Predicate<T,C>>(parts); |
266 | return ret; |
267 | } |
268 | |
269 | @Override |
270 | public CommutativeAnd<T, C> add(Predicate<T, C> part) { |
271 | CommutativeAnd<T, C> ret = new CommutativeAnd<T, C>(initialCost, costUnit, parts); |
272 | ret.parts.add(part); |
273 | return ret; |
274 | } |
275 | } |