001 package edu.rice.cs.cunit.util;
002
003 /**
004 * Unary predicate interface Boolean <- P
005 * @author Mathias Ricken
006 */
007 public interface IPredicate<P> extends ILambda<Boolean, P> {
008 /**
009 * Unary NOT.
010 */
011 public static class Not implements IPredicate<Boolean> {
012 private Not() { }
013 public static final Not ONLY = new Not();
014 public Boolean apply(Boolean param) {
015 return !param;
016 }
017 }
018
019 /**
020 * TRUE.
021 */
022 public static class True implements IPredicate<Boolean> {
023 private True() { }
024 public static final True ONLY = new True();
025 public Boolean apply(Boolean param) {
026 return true;
027 }
028 }
029
030 /**
031 * FALSE.
032 */
033 public static class False implements IPredicate<Boolean> {
034 private False() { }
035 public static final False ONLY = new False();
036 public Boolean apply(Boolean param) {
037 return false;
038 }
039 }
040
041 /**
042 * Binary predicate interface Boolean <- P x Q.
043 */
044 public static interface Binary<P, Q> extends ILambda.Binary<Boolean, P, Q> {
045 /**
046 * Unary decorator for a binary predicate that binds a constant to its first parameter.
047 */
048 public static class Bind1st<Boolean, P, Q> extends ILambda.Binary.Bind1st<Boolean, P, Q> {
049 public Bind1st(Binary<Boolean, P, Q> decoree, P constant) {
050 super(decoree, constant);
051 }
052 }
053
054 /**
055 * Unary decorator for a binary predicate that binds a constant to its second parameter.
056 */
057 public static class Bind2nd<Boolean, P, Q> extends ILambda.Binary.Bind2nd<Boolean, P, Q> {
058 public Bind2nd(Binary<Boolean, P, Q> decoree, Q constant) {
059 super(decoree, constant);
060 }
061 }
062
063 /**
064 * TRUE.
065 */
066 public static class True implements IPredicate.Binary<Boolean, Boolean> {
067 private True() { }
068 public static final True ONLY = new True();
069 public Boolean apply(Boolean param1, Boolean param2) {
070 return true;
071 }
072 }
073
074 /**
075 * FALSE.
076 */
077 public static class False implements IPredicate.Binary<Boolean, Boolean> {
078 private False() { }
079 public static final False ONLY = new False();
080 public Boolean apply(Boolean param1, Boolean param2) {
081 return false;
082 }
083 }
084
085 /**
086 * Binary AND.
087 */
088 public static class And implements IPredicate.Binary<Boolean, Boolean> {
089 private And() { }
090 public static final And ONLY = new And();
091 public Boolean apply(Boolean param1, Boolean param2) {
092 return (param1 && param2);
093 }
094 }
095
096 /**
097 * Binary OR.
098 */
099 public static class Or implements IPredicate.Binary<Boolean, Boolean> {
100 private Or() { }
101 public static final Or ONLY = new Or();
102 public Boolean apply(Boolean param1, Boolean param2) {
103 return (param1 || param2);
104 }
105 }
106
107 /**
108 * Binary XOR.
109 */
110 public static class Xor implements IPredicate.Binary<Boolean, Boolean> {
111 private Xor() { }
112 public static final Xor ONLY = new Xor();
113 public Boolean apply(Boolean param1, Boolean param2) {
114 return (param1 ^ param2);
115 }
116 }
117
118 /**
119 * Less-than.
120 */
121 public static class Less<T extends Comparable<T>> implements IPredicate.Binary<T, T> {
122 public Boolean apply(T param1, T param2) {
123 return (param1.compareTo(param2) < 0);
124 }
125 }
126
127 /**
128 * Greater-than.
129 */
130 public static class Greater<T extends Comparable<T>> implements IPredicate.Binary<T, T> {
131 public Boolean apply(T param1, T param2) {
132 return (param1.compareTo(param2) > 0);
133 }
134 }
135
136 /**
137 * Less-than-or-equal.
138 */
139 public static class LessEq<T extends Comparable<T>> implements IPredicate.Binary<T, T> {
140 public Boolean apply(T param1, T param2) {
141 return (param1.compareTo(param2) <= 0);
142 }
143 }
144
145 /**
146 * Greater-than-or-equal.
147 */
148 public static class GreaterEq<T extends Comparable<T>> implements IPredicate.Binary<T, T> {
149 public Boolean apply(T param1, T param2) {
150 return (param1.compareTo(param2) >= 0);
151 }
152 }
153
154 /**
155 * Equals.
156 */
157 public static class Equals implements IPredicate.Binary<Object, Object> {
158 private Equals() { }
159 public static final Equals ONLY = new Equals();
160 public Boolean apply(Object param1, Object param2) {
161 return param1.equals(param2);
162 }
163 }
164 }
165
166 /**
167 * Ternary predicate interface Boolean <- P x Q x S.
168 */
169 public static interface Ternary<P, Q, S> extends ILambda.Ternary<Boolean, P, Q, S> {
170 /**
171 * Binary decorator for a ternary predicate that binds a constant to its first parameter.
172 */
173 public static class Bind1st<Boolean, P, Q, S> extends ILambda.Ternary.Bind1st<Boolean, P, Q, S> {
174 public Bind1st(ILambda.Ternary<Boolean, P, Q, S> decoree, P constant) {
175 super(decoree, constant);
176 }
177 }
178
179 /**
180 * Binary decorator for a ternary predicate that binds a constant to its second parameter.
181 */
182 public static class Bind2nd<Boolean, P, Q, S> extends ILambda.Ternary.Bind2nd<Boolean, P, Q, S> {
183 public Bind2nd(ILambda.Ternary<Boolean, P, Q, S> decoree, Q constant) {
184 super(decoree, constant);
185 }
186 }
187
188 /**
189 * Binary decorator for a ternary predicate that binds a constant to its third parameter.
190 */
191 public static class Bind3rd<Boolean, P, Q, S> extends ILambda.Ternary.Bind3rd<Boolean, P, Q, S> {
192 public Bind3rd(ILambda.Ternary<Boolean, P, Q, S> decoree, S constant) {
193 super(decoree, constant);
194 }
195 }
196
197 /**
198 * Unary decorator for a ternary predicate that binds constants to its first and second parameters.
199 */
200 public static class Bind1st2nd<Boolean, P, Q, S> extends ILambda.Ternary.Bind1st2nd<Boolean, P, Q, S> {
201 public Bind1st2nd(Ternary<Boolean, P, Q, S> decoree, P constant1, Q constant2) {
202 super(decoree, constant1, constant2);
203 }
204 }
205
206 /**
207 * Unary decorator for a ternary predicate that binds constants to its first and third parameters.
208 */
209 public static class Bind1st3rd<Boolean, P, Q, S> extends ILambda.Ternary.Bind1st3rd<Boolean, P, Q, S> {
210 public Bind1st3rd(Ternary<Boolean, P, Q, S> decoree, P constant1, S constant3) {
211 super(decoree, constant1, constant3);
212 }
213 }
214
215 /**
216 * Unary decorator for a ternary predicate that binds constants to its second and third parameters.
217 */
218 public static class Bind2nd3rd<Boolean, P, Q, S> extends ILambda.Ternary.Bind2nd3rd<Boolean, P, Q, S> {
219 public Bind2nd3rd(Ternary<Boolean, P, Q, S> decoree, Q constant2, S constant3) {
220 super(decoree, constant2, constant3);
221 }
222 }
223
224 /**
225 * TRUE.
226 */
227 public static class True implements IPredicate.Ternary<Boolean, Boolean, Boolean> {
228 private True() { }
229 public static final True ONLY = new True();
230 public Boolean apply(Boolean param1, Boolean param2, Boolean param3) {
231 return true;
232 }
233 }
234
235 /**
236 * FALSE.
237 */
238 public static class False implements IPredicate.Ternary<Boolean, Boolean, Boolean> {
239 private False() { }
240 public static final False ONLY = new False();
241 public Boolean apply(Boolean param1, Boolean param2, Boolean param3) {
242 return false;
243 }
244 }
245
246 /**
247 * Ternary AND.
248 */
249 public static class And implements IPredicate.Ternary<Boolean, Boolean, Boolean> {
250 private And() { }
251 public static final And ONLY = new And();
252 public Boolean apply(Boolean param1, Boolean param2, Boolean param3) {
253 return (param1 && param2 && param3);
254 }
255 }
256
257 /**
258 * Ternary OR.
259 */
260 public static class Or implements IPredicate.Ternary<Boolean, Boolean, Boolean> {
261 private Or() { }
262 public static final Or ONLY = new Or();
263 public Boolean apply(Boolean param1, Boolean param2, Boolean param3) {
264 return (param1 || param2 || param3);
265 }
266 }
267
268 /**
269 * Ternary XOR.
270 */
271 public static class Xor implements IPredicate.Ternary<Boolean, Boolean, Boolean> {
272 private Xor() { }
273 public static final Xor ONLY = new Xor();
274 public Boolean apply(Boolean param1, Boolean param2, Boolean param3) {
275 return ((param1 ^ param2) && !param3) || ((param1 ^ param3) && !param2) || ((param2 ^ param3) && !param1);
276 }
277 }
278
279 /**
280 * Between.
281 */
282 public static class Between<T extends Comparable<T>> implements IPredicate.Ternary<T, T, T> {
283 /** @return true iff param1 >= param2 and param1 <= param3 */
284 public Boolean apply(T param1, T param2, T param3) {
285 return (param1.compareTo(param2) >= 0) && (param1.compareTo(param3) <= 0);
286 }
287 }
288 }
289
290 /**
291 * N-ary predicate interface Boolean <- P x P x ... x P.
292 */
293 public static interface Nary<P> extends ILambda.Nary<Boolean, P> {
294 /**
295 * (N-1)-ary decorator for an N-ary predicate that binds a constant to one of its parameters.
296 */
297 public static class Bind<P> extends ILambda.Nary.Bind<Boolean, P> {
298 public Bind(ILambda.Nary<Boolean, P> decoree, int index, P constant) {
299 super(decoree, index, constant);
300 }
301 }
302
303 /**
304 * (N-K)-ary decorator for an N-ary predicate that binds constants to K of its parameters.
305 */
306 public static class BindK<P> extends ILambda.Nary.BindK<Boolean, P> {
307 public BindK(ILambda.Nary<Boolean, P> decoree, int[] indices, P... constants) {
308 super(decoree, indices, constants);
309 }
310 }
311
312 /**
313 * TRUE.
314 */
315 public static class True implements IPredicate.Nary<Boolean> {
316 private True() { }
317 public static final True ONLY = new True();
318 public Boolean apply(Boolean ... param) {
319 return true;
320 }
321 }
322
323 /**
324 * FALSE.
325 */
326 public static class False implements IPredicate.Nary<Boolean> {
327 private False() { }
328 public static final False ONLY = new False();
329 public Boolean apply(Boolean ... param) {
330 return false;
331 }
332 }
333
334 /**
335 * N-ary AND.
336 */
337 public static class And implements IPredicate.Nary<Boolean> {
338 private And() { }
339 public static final And ONLY = new And();
340 public Boolean apply(Boolean ... param) {
341 boolean accum = true;
342 for (Boolean b: param) { accum &= b; }
343 return accum;
344 }
345 }
346
347 /**
348 * N-ary OR.
349 */
350 public static class Or implements IPredicate.Nary<Boolean> {
351 private Or() { }
352 public static final Or ONLY = new Or();
353 public Boolean apply(Boolean ... param) {
354 boolean accum = false;
355 for (Boolean b: param) { accum |= b; }
356 return accum;
357 }
358 }
359
360 /**
361 * N-ary XOR.
362 */
363 public static class Xor implements IPredicate.Nary<Boolean> {
364 private Xor() { }
365 public static final Xor ONLY = new Xor();
366 public Boolean apply(Boolean ... param) {
367 int trueCount = 0;
368 for (Boolean b: param) { if (b) ++trueCount; }
369 return (trueCount == 1);
370 }
371 }
372 }
373 }