1 |
/* |
2 |
* Written by Doug Lea with assistance from members of JCP JSR-166 |
3 |
* Expert Group and released to the public domain, as explained at |
4 |
* http://creativecommons.org/publicdomain/zero/1.0/ |
5 |
*/ |
6 |
|
7 |
package extra166y; |
8 |
|
9 |
import java.util.*; |
10 |
|
11 |
/** |
12 |
* Interfaces and utilities declaring per-element operations used |
13 |
* within parallel methods on aggregates. This class provides type |
14 |
* names for all operation signatures accepting zero, one or two |
15 |
* arguments, and returning zero or one results, for parameterized |
16 |
* types, as well as specializations to {@code int}, {@code long}, |
17 |
* and {@code double}. In keeping with normal Java evaluation rules |
18 |
* that promote, for example {@code short} to {@code int}, operation |
19 |
* names for these smaller types are absent. |
20 |
* |
21 |
* <p><b>Preliminary release note: Some of the declarations in this |
22 |
* class are likely to be moved elsewhere in the JDK libraries |
23 |
* upon actual release, and most likely will not all nested in the |
24 |
* same class.</b> |
25 |
* |
26 |
* <p>The naming conventions are as follows: |
27 |
* <ul> |
28 |
* |
29 |
* <li> The name of the single method declared in each interface is |
30 |
* simply {@code op} (short for "operate"). |
31 |
* |
32 |
* <li> An {@code Op} (short for "operation") maps a single argument to |
33 |
* a result. Example: negating a value. |
34 |
* |
35 |
* <li> The names for scalar ops accepting and returning the same type |
36 |
* are prefaced by their type name. |
37 |
* |
38 |
* <li> A {@code BinaryOp} maps two arguments to a result. Example: |
39 |
* dividing two numbers |
40 |
* |
41 |
* <li>A {@code Reducer} is an <em>associative</em> binary op |
42 |
* accepting and returning values of the same type; where op(a, op(b, |
43 |
* c)) should have the same result as op(op(a, b), c). Example: |
44 |
* adding two numbers. |
45 |
* |
46 |
* <li> Scalar binary ops accepting and returning the same type |
47 |
* include their type name. |
48 |
* |
49 |
* <li> Mixed-type operators are named just by their argument type |
50 |
* names. |
51 |
* |
52 |
* <li> A {@code Generator} takes no arguments and returns a result. |
53 |
* Examples: random number generators, builders |
54 |
* |
55 |
* <li> A {@code Procedure} accepts an argument but doesn't return a |
56 |
* result. Example: printing a value. An {@code Action} is a |
57 |
* Procedure that takes no arguments. |
58 |
* |
59 |
* <li>A {@code Predicate} accepts a value and returns a boolean indicator |
60 |
* that the argument obeys some property. Example: testing if a number is even. |
61 |
* |
62 |
* <li>A {@code BinaryPredicate} accepts two values and returns a |
63 |
* boolean indicator that the arguments obeys some relation. Example: |
64 |
* testing if two numbers are relatively prime. |
65 |
* |
66 |
* <li>Scalar versions of {@link Comparator} have the same properties |
67 |
* as the Object version -- returning negative, zero, or positive |
68 |
* if the first argument is less, equal, or greater than the second. |
69 |
* |
70 |
* </ul> |
71 |
* |
72 |
* <table border=1 cellpadding=0 cellspacing=0 > <caption>result = op(a) or |
73 |
* result = op(a,b)</caption> |
74 |
* <tr> |
75 |
* <td > |
76 |
* <td > |
77 |
* <td > |
78 |
* <td > |
79 |
* <td > |
80 |
* <td > |
81 |
* <td > |
82 |
* <td > |
83 |
* <tr> |
84 |
* <td > |
85 |
* <th colspan=2 >arg types |
86 |
* <th colspan=4 >result type |
87 |
* <td > |
88 |
* <tr> |
89 |
* <td > |
90 |
* <th >a |
91 |
* <th >b |
92 |
* <th >{@code int} |
93 |
* <th >{@code long} |
94 |
* <th >{@code double} |
95 |
* <th >Object |
96 |
* <td > |
97 |
* <tr> |
98 |
* <td > |
99 |
* <td > |
100 |
* <td > |
101 |
* <td > |
102 |
* <td > |
103 |
* <td > |
104 |
* <td > |
105 |
* <td > |
106 |
* <tr> |
107 |
* <td > |
108 |
* <td >{@code int} |
109 |
* <td ><em><none></em> |
110 |
* <td ><a href="Ops.IntOp.html">Ops.IntOp</a> |
111 |
* <td ><a href="Ops.IntToLong.html">Ops.IntToLong</a> |
112 |
* <td ><a href="Ops.IntToDouble.html">Ops.IntToDouble</a> |
113 |
* <td ><a href="Ops.IntToObject.html">Ops.IntToObject</a> |
114 |
* <td > |
115 |
* <tr> |
116 |
* <td > |
117 |
* <td > |
118 |
* <td >{@code int} |
119 |
* <td ><a href="Ops.BinaryIntOp.html">Ops.BinaryIntOp</a> |
120 |
* <td ><a href="Ops.IntAndIntToLong.html">Ops.IntAndIntToLong</a> |
121 |
* <td ><a href="Ops.IntAndIntToDouble.html">Ops.IntAndIntToDouble</a> |
122 |
* <td ><a href="Ops.IntAndIntToObject.html">Ops.IntAndIntToObject</a> |
123 |
* <td > |
124 |
* <tr> |
125 |
* <td > |
126 |
* <td > |
127 |
* <td >{@code long} |
128 |
* <td ><a href="Ops.IntAndLongToInt.html">Ops.IntAndLongToInt</a> |
129 |
* <td ><a href="Ops.IntAndLongToLong.html">Ops.IntAndLongToLong</a> |
130 |
* <td ><a href="Ops.IntAndLongToDouble.html">Ops.IntAndLongToDouble</a> |
131 |
* <td ><a href="Ops.IntAndLongToObject.html">Ops.IntAndLongToObject</a> |
132 |
* <td > |
133 |
* <tr> |
134 |
* <td > |
135 |
* <td > |
136 |
* <td >{@code double} |
137 |
* <td ><a href="Ops.IntAndDoubleToInt.html">Ops.IntAndDoubleToInt</a> |
138 |
* <td ><a href="Ops.IntAndDoubleToLong.html">Ops.IntAndDoubleToLong</a> |
139 |
* <td ><a href="Ops.IntAndDoubleToDouble.html">Ops.IntAndDoubleToDouble</a> |
140 |
* <td ><a href="Ops.IntAndDoubleToObject.html">Ops.IntAndDoubleToObject</a> |
141 |
* <td > |
142 |
* <tr> |
143 |
* <td > |
144 |
* <td > |
145 |
* <td >Object |
146 |
* <td ><a href="Ops.IntAndObjectToInt.html">Ops.IntAndObjectToInt</a> |
147 |
* <td ><a href="Ops.IntAndObjectToLong.html">Ops.IntAndObjectToLong</a> |
148 |
* <td ><a href="Ops.IntAndObjectToDouble.html">Ops.IntAndObjectToDouble</a> |
149 |
* <td ><a href="Ops.IntAndObjectToObject.html">Ops.IntAndObjectToObject</a> |
150 |
* <td > |
151 |
* <tr> |
152 |
* <td > |
153 |
* <td > |
154 |
* <td > |
155 |
* <td > |
156 |
* <td > |
157 |
* <td > |
158 |
* <td > |
159 |
* <td > |
160 |
* <tr> |
161 |
* <td > |
162 |
* <td >{@code long} |
163 |
* <td ><em><none></em> |
164 |
* <td ><a href="Ops.LongToInt.html">Ops.LongToInt</a> |
165 |
* <td ><a href="Ops.LongOp.html">Ops.LongOp</a> |
166 |
* <td ><a href="Ops.LongToDouble.html">Ops.LongToDouble</a> |
167 |
* <td ><a href="Ops.LongToObject.html">Ops.LongToObject</a> |
168 |
* <td > |
169 |
* <tr> |
170 |
* <td > |
171 |
* <td > |
172 |
* <td >{@code int} |
173 |
* <td ><a href="Ops.LongAndIntToInt.html">Ops.LongAndIntToInt</a> |
174 |
* <td ><a href="Ops.LongAndIntToLong.html">Ops.LongAndIntToLong</a> |
175 |
* <td ><a href="Ops.LongAndIntToDouble.html">Ops.LongAndIntToDouble</a> |
176 |
* <td ><a href="Ops.LongAndIntToObject.html">Ops.LongAndIntToObject</a> |
177 |
* <td > |
178 |
* <tr> |
179 |
* <td > |
180 |
* <td > |
181 |
* <td >{@code long} |
182 |
* <td ><a href="Ops.LongAndLongToInt.html">Ops.LongAndLongToInt</a> |
183 |
* <td ><a href="Ops.BinaryLongOp.html">Ops.BinaryLongOp</a> |
184 |
* <td ><a href="Ops.LongAndLongToDouble.html">Ops.LongAndLongToDouble</a> |
185 |
* <td ><a href="Ops.LongAndLongToObject.html">Ops.LongAndLongToObject</a> |
186 |
* <td > |
187 |
* <tr> |
188 |
* <td > |
189 |
* <td > |
190 |
* <td >{@code double} |
191 |
* <td ><a href="Ops.LongAndDoubleToInt.html">Ops.LongAndDoubleToInt</a> |
192 |
* <td ><a href="Ops.LongAndDoubleToLong.html">Ops.LongAndDoubleToLong</a> |
193 |
* <td ><a href="Ops.LongAndDoubleToDouble.html">Ops.LongAndDoubleToDouble</a> |
194 |
* <td ><a href="Ops.LongAndDoubleToObject.html">Ops.LongAndDoubleToObject</a> |
195 |
* <td > |
196 |
* <tr> |
197 |
* <td > |
198 |
* <td > |
199 |
* <td >Object |
200 |
* <td ><a href="Ops.LongAndObjectToInt.html">Ops.LongAndObjectToInt</a> |
201 |
* <td ><a href="Ops.LongAndObjectToLong.html">Ops.LongAndObjectToLong</a> |
202 |
* <td ><a href="Ops.LongAndObjectToDouble.html">Ops.LongAndObjectToDouble</a> |
203 |
* <td ><a href="Ops.LongAndObjectToObject.html">Ops.LongAndObjectToObject</a> |
204 |
* <td > |
205 |
* <tr> |
206 |
* <td > |
207 |
* <td > |
208 |
* <td > |
209 |
* <td > |
210 |
* <td > |
211 |
* <td > |
212 |
* <td > |
213 |
* <td > |
214 |
* <tr> |
215 |
* <td > |
216 |
* <td >{@code double} |
217 |
* <td ><em><none></em> |
218 |
* <td ><a href="Ops.DoubleToInt.html">Ops.DoubleToInt</a> |
219 |
* <td ><a href="Ops.DoubleToLong.html">Ops.DoubleToLong</a> |
220 |
* <td ><a href="Ops.DoubleOp.html">Ops.DoubleOp</a> |
221 |
* <td ><a href="Ops.DoubleToObject.html">Ops.DoubleToObject</a> |
222 |
* <td > |
223 |
* <tr> |
224 |
* <td > |
225 |
* <td > |
226 |
* <td >{@code int} |
227 |
* <td ><a href="Ops.DoubleAndIntToInt.html">Ops.DoubleAndIntToInt</a> |
228 |
* <td ><a href="Ops.DoubleAndIntToLong.html">Ops.DoubleAndIntToLong</a> |
229 |
* <td ><a href="Ops.DoubleAndIntToDouble.html">Ops.DoubleAndIntToDouble</a> |
230 |
* <td ><a href="Ops.DoubleAndIntToObject.html">Ops.DoubleAndIntToObject</a> |
231 |
* <td > |
232 |
* <tr> |
233 |
* <td > |
234 |
* <td > |
235 |
* <td >{@code long} |
236 |
* <td ><a href="Ops.DoubleAndLongToInt.html">Ops.DoubleAndLongToInt</a> |
237 |
* <td ><a href="Ops.DoubleAndLongToLong.html">Ops.DoubleAndLongToLong</a> |
238 |
* <td ><a href="Ops.DoubleAndLongToDouble.html">Ops.DoubleAndLongToDouble</a> |
239 |
* <td ><a href="Ops.DoubleAndLongToObject.html">Ops.DoubleAndLongToObject</a> |
240 |
* <td > |
241 |
* <tr> |
242 |
* <td > |
243 |
* <td > |
244 |
* <td >{@code double} |
245 |
* <td ><a href="Ops.DoubleAndDoubleToInt.html">Ops.DoubleAndDoubleToInt</a> |
246 |
* <td ><a href="Ops.DoubleAndDoubleToLong.html">Ops.DoubleAndDoubleToLong</a> |
247 |
* <td ><a href="Ops.BinaryDoubleOp.html">Ops.BinaryDoubleOp</a> |
248 |
* <td ><a href="Ops.DoubleAndDoubleToObject.html">Ops.DoubleAndDoubleToObject</a> |
249 |
* <tr> |
250 |
* <td > |
251 |
* <td > |
252 |
* <td >Object |
253 |
* <td ><a href="Ops.DoubleAndObjectToInt.html">Ops.DoubleAndObjectToInt</a> |
254 |
* <td ><a href="Ops.DoubleAndObjectToLong.html">Ops.DoubleAndObjectToLong</a> |
255 |
* <td ><a href="Ops.DoubleAndObjectToDouble.html">Ops.DoubleAndObjectToDouble</a> |
256 |
* <td ><a href="Ops.DoubleAndObjectToObject.html">Ops.DoubleAndObjectToObject</a> |
257 |
* <td > |
258 |
* <tr> |
259 |
* <td > |
260 |
* <td > |
261 |
* <td > |
262 |
* <td > |
263 |
* <td > |
264 |
* <td > |
265 |
* <td > |
266 |
* <td > |
267 |
* <tr> |
268 |
* <td > |
269 |
* <td >Object |
270 |
* <td ><em><none></em> |
271 |
* <td ><a href="Ops.ObjectToInt.html">Ops.ObjectToInt</a> |
272 |
* <td ><a href="Ops.ObjectToLong.html">Ops.ObjectToLong</a> |
273 |
* <td ><a href="Ops.ObjectToDouble.html">Ops.ObjectToDouble</a> |
274 |
* <td ><a href="Ops.Op.html">Ops.Op</a> |
275 |
* <td > |
276 |
* <tr> |
277 |
* <td > |
278 |
* <td > |
279 |
* <td >{@code int} |
280 |
* <td ><a href="Ops.ObjectAndIntToInt.html">Ops.ObjectAndIntToInt</a> |
281 |
* <td ><a href="Ops.ObjectAndIntToLong.html">Ops.ObjectAndIntToLong</a> |
282 |
* <td ><a href="Ops.ObjectAndIntToDouble.html">Ops.ObjectAndIntToDouble</a> |
283 |
* <td ><a href="Ops.ObjectAndIntToObject.html">Ops.ObjectAndIntToObject</a> |
284 |
* <td > |
285 |
* <tr> |
286 |
* <td > |
287 |
* <td > |
288 |
* <td >{@code long} |
289 |
* <td ><a href="Ops.ObjectAndLongToInt.html">Ops.ObjectAndLongToInt</a> |
290 |
* <td ><a href="Ops.ObjectAndLongToLong.html">Ops.ObjectAndLongToLong</a> |
291 |
* <td ><a href="Ops.ObjectAndLongToDouble.html">Ops.ObjectAndLongToDouble</a> |
292 |
* <td ><a href="Ops.ObjectAndLongToObject.html">Ops.ObjectAndLongToObject</a> |
293 |
* <td > |
294 |
* <tr> |
295 |
* <td > |
296 |
* <td > |
297 |
* <td >{@code double} |
298 |
* <td ><a href="Ops.ObjectAndDoubleToInt.html">Ops.ObjectAndDoubleToInt</a> |
299 |
* <td ><a href="Ops.ObjectAndDoubleToLong.html">Ops.ObjectAndDoubleToLong</a> |
300 |
* <td ><a href="Ops.ObjectAndDoubleToDouble.html">Ops.ObjectAndDoubleToDouble</a> |
301 |
* <td ><a href="Ops.ObjectAndDoubleToObject.html">Ops.ObjectAndDoubleToObject</a> |
302 |
* <td > |
303 |
* <tr> |
304 |
* <td > |
305 |
* <td > |
306 |
* <td >Object |
307 |
* <td ><a href="Ops.ObjectAndObjectToInt.html">Ops.ObjectAndObjectToInt</a> |
308 |
* <td ><a href="Ops.ObjectAndObjectToLong.html">Ops.ObjectAndObjectToLong</a> |
309 |
* <td ><a href="Ops.ObjectAndObjectToDouble.html">Ops.ObjectAndObjectToDouble</a> |
310 |
* <td ><a href="Ops.BinaryOp.html">Ops.BinaryOp</a> |
311 |
* <td > |
312 |
* <tr> |
313 |
* <td > |
314 |
* <td > |
315 |
* <td > |
316 |
* <td > |
317 |
* <td > |
318 |
* <td > |
319 |
* <td > |
320 |
* <td > </table> |
321 |
* |
322 |
* <p>In addition to stated signatures, implementations of these |
323 |
* interfaces must work safely in parallel. In general, this means |
324 |
* methods should operate only on their arguments, and should not rely |
325 |
* on ThreadLocals, unsafely published globals, or other unsafe |
326 |
* constructions. Additionally, they should not block waiting for |
327 |
* synchronization. |
328 |
* |
329 |
* <p>This class is normally best used via {@code import static}. |
330 |
*/ |
331 |
public class Ops { |
332 |
private Ops() {} // disable construction |
333 |
|
334 |
// Thanks to David Biesack for the above html table |
335 |
// You want to read/edit this with a wide editor panel |
336 |
|
337 |
public static interface Op<A,R> { R op(A a);} |
338 |
public static interface BinaryOp<A,B,R> { R op(A a, B b);} |
339 |
public static interface Predicate<A> { boolean op(A a);} |
340 |
public static interface BinaryPredicate<A,B> { boolean op(A a, B b);} |
341 |
public static interface Procedure<A> { void op(A a);} |
342 |
public static interface Generator<R> { R op();} |
343 |
public static interface Reducer<A> extends BinaryOp<A,A,A> {} |
344 |
|
345 |
public static interface IntOp { int op(int a);} |
346 |
public static interface BinaryIntOp { int op(int a, int b);} |
347 |
public static interface IntPredicate { boolean op(int a);} |
348 |
public static interface IntProcedure { void op(int a);} |
349 |
public static interface IntGenerator { int op();} |
350 |
public static interface BinaryIntPredicate { boolean op(int a, int b);} |
351 |
public static interface IntReducer extends BinaryIntOp {} |
352 |
public static interface IntComparator { int compare(int a, int b);} |
353 |
|
354 |
public static interface LongOp { long op(long a);} |
355 |
public static interface BinaryLongOp { long op(long a, long b);} |
356 |
public static interface LongPredicate { boolean op(long a);} |
357 |
public static interface BinaryLongPredicate { boolean op(long a, long b);} |
358 |
public static interface LongProcedure { void op(long a);} |
359 |
public static interface LongGenerator { long op();} |
360 |
public static interface LongReducer extends BinaryLongOp {} |
361 |
public static interface LongComparator { int compare(long a, long b);} |
362 |
|
363 |
public static interface DoubleOp { double op(double a);} |
364 |
public static interface BinaryDoubleOp { double op(double a, double b);} |
365 |
public static interface DoublePredicate { boolean op(double a);} |
366 |
public static interface BinaryDoublePredicate { boolean op(double a, double b);} |
367 |
public static interface DoubleProcedure { void op(double a);} |
368 |
public static interface DoubleGenerator { double op();} |
369 |
public static interface DoubleReducer extends BinaryDoubleOp {} |
370 |
public static interface DoubleComparator { int compare(double a, double b);} |
371 |
|
372 |
public static interface Action { void op();} |
373 |
|
374 |
// mixed mode ops |
375 |
public static interface IntToLong { long op(int a);} |
376 |
public static interface IntToDouble { double op(int a);} |
377 |
public static interface IntToObject<R> { R op(int a);} |
378 |
public static interface LongToInt { int op(long a);} |
379 |
public static interface LongToDouble { double op(long a);} |
380 |
public static interface LongToObject<R> { R op(long a);} |
381 |
public static interface DoubleToInt { int op(double a);} |
382 |
public static interface DoubleToLong { long op(double a);} |
383 |
public static interface DoubleToObject<R> { R op(double a);} |
384 |
public static interface ObjectToInt<A> { int op(A a);} |
385 |
public static interface ObjectToLong<A> { long op(A a);} |
386 |
public static interface ObjectToDouble<A> { double op(A a);} |
387 |
|
388 |
public static interface IntAndIntProcedure { void op(int a, int b);} |
389 |
public static interface IntAndIntToLong { long op(int a, int b);} |
390 |
public static interface IntAndIntToDouble { double op(int a, int b);} |
391 |
public static interface IntAndIntToObject<R> { R op(int a, int b);} |
392 |
public static interface IntAndLongProcedure { void op(int a, long b);} |
393 |
public static interface IntAndLongPredicate { boolean op(int a, long b);} |
394 |
public static interface IntAndLongToInt { int op(int a, long b);} |
395 |
public static interface IntAndLongToLong { long op(int a, long b);} |
396 |
public static interface IntAndLongToDouble { double op(int a, long b);} |
397 |
public static interface IntAndLongToObject<R> { R op(int a, long b);} |
398 |
public static interface IntAndDoubleProcedure { void op(int a, double b);} |
399 |
public static interface IntAndDoublePredicate { boolean op(int a, double b);} |
400 |
public static interface IntAndDoubleToInt { int op(int a, double b);} |
401 |
public static interface IntAndDoubleToLong { long op(int a, double b);} |
402 |
public static interface IntAndDoubleToDouble { double op(int a, double b);} |
403 |
public static interface IntAndDoubleToObject<R> { R op(int a, double b);} |
404 |
public static interface IntAndObjectProcedure<A> { void op(int a, A b);} |
405 |
public static interface IntAndObjectPredicate<A> { boolean op(int a, A b);} |
406 |
public static interface IntAndObjectToInt<A> { int op(int a, A b);} |
407 |
public static interface IntAndObjectToLong<A> { long op(int a, A b);} |
408 |
public static interface IntAndObjectToDouble<A> { double op(int a, A b);} |
409 |
public static interface IntAndObjectToObject<A,R> { R op(int a, A b);} |
410 |
public static interface LongAndIntProcedure { void op(long a, int b);} |
411 |
public static interface LongAndIntPredicate { boolean op(long a, int b);} |
412 |
public static interface LongAndIntToInt { int op(long a, int b);} |
413 |
public static interface LongAndIntToLong { long op(long a, int b);} |
414 |
public static interface LongAndIntToDouble { double op(long a, int b);} |
415 |
public static interface LongAndIntToObject<R> { R op(long a, int b);} |
416 |
public static interface LongAndLongProcedure { void op(long a, long b);} |
417 |
public static interface LongAndLongToInt { int op(long a, long b);} |
418 |
public static interface LongAndLongToDouble { double op(long a, long b);} |
419 |
public static interface LongAndLongToObject<R> { R op(long a, long b);} |
420 |
public static interface LongAndDoubleProcedure { void op(long a, double b);} |
421 |
public static interface LongAndDoublePredicate { boolean op(long a, double b);} |
422 |
public static interface LongAndDoubleToInt { int op(long a, double b);} |
423 |
public static interface LongAndDoubleToLong { long op(long a, double b);} |
424 |
public static interface LongAndDoubleToDouble { double op(long a, double b);} |
425 |
public static interface LongAndDoubleToObject<R> { R op(long a, double b);} |
426 |
public static interface LongAndObjectProcedure<A> { void op(long a, A b);} |
427 |
public static interface LongAndObjectPredicate<A> { boolean op(long a, A b);} |
428 |
public static interface LongAndObjectToInt<A> { int op(long a, A b);} |
429 |
public static interface LongAndObjectToLong<A> { long op(long a, A b);} |
430 |
public static interface LongAndObjectToDouble<A> { double op(long a, A b);} |
431 |
public static interface LongAndObjectToObject<A,R> { R op(long a, A b);} |
432 |
public static interface DoubleAndIntProcedure { void op(double a, int b);} |
433 |
public static interface DoubleAndIntPredicate { boolean op(double a, int b);} |
434 |
public static interface DoubleAndIntToInt { int op(double a, int b);} |
435 |
public static interface DoubleAndIntToLong { long op(double a, int b);} |
436 |
public static interface DoubleAndIntToDouble { double op(double a, int b);} |
437 |
public static interface DoubleAndIntToObject<R> { R op(double a, int b);} |
438 |
public static interface DoubleAndLongProcedure { void op(double a, long b);} |
439 |
public static interface DoubleAndLongPredicate { boolean op(double a, long b);} |
440 |
public static interface DoubleAndLongToInt { int op(double a, long b);} |
441 |
public static interface DoubleAndLongToLong { long op(double a, long b);} |
442 |
public static interface DoubleAndLongToDouble { double op(double a, long b);} |
443 |
public static interface DoubleAndLongToObject<R> { R op(double a, long b);} |
444 |
public static interface DoubleAndDoubleProcedure { void op(double a, double b);} |
445 |
public static interface DoubleAndDoubleToInt { int op(double a, double b);} |
446 |
public static interface DoubleAndDoubleToLong { long op(double a, double b);} |
447 |
public static interface DoubleAndDoubleToObject<R> { R op(double a, double b);} |
448 |
public static interface DoubleAndObjectProcedure<A> { void op(double a, A b);} |
449 |
public static interface DoubleAndObjectPredicate<A> { boolean op(double a, A b);} |
450 |
public static interface DoubleAndObjectToInt<A> { int op(double a, A b);} |
451 |
public static interface DoubleAndObjectToLong<A> { long op(double a, A b);} |
452 |
public static interface DoubleAndObjectToDouble<A> { double op(double a, A b);} |
453 |
public static interface DoubleAndObjectToObject<A,R> { R op(double a, A b);} |
454 |
public static interface ObjectAndIntProcedure<A> { void op(A a, int b);} |
455 |
public static interface ObjectAndIntPredicate<A> { boolean op(A a, int b);} |
456 |
public static interface ObjectAndIntToInt<A> { int op(A a, int b);} |
457 |
public static interface ObjectAndIntToLong<A> { long op(A a, int b);} |
458 |
public static interface ObjectAndIntToDouble<A> { double op(A a, int b);} |
459 |
public static interface ObjectAndIntToObject<A,R> { R op(A a, int b);} |
460 |
public static interface ObjectAndLongProcedure<A> { void op(A a, long b);} |
461 |
public static interface ObjectAndLongPredicate<A> { boolean op(A a, long b);} |
462 |
public static interface ObjectAndLongToInt<A> { int op(A a, long b);} |
463 |
public static interface ObjectAndLongToLong<A> { long op(A a, long b);} |
464 |
public static interface ObjectAndLongToDouble<A> { double op(A a, long b);} |
465 |
public static interface ObjectAndLongToObject<A,R> { R op(A a, long b);} |
466 |
public static interface ObjectAndDoubleProcedure<A> { void op(A a, double b);} |
467 |
public static interface ObjectAndDoublePredicate<A> { boolean op(A a, double b);} |
468 |
public static interface ObjectAndDoubleToInt<A> { int op(A a, double b);} |
469 |
public static interface ObjectAndDoubleToLong<A> { long op(A a, double b);} |
470 |
public static interface ObjectAndDoubleToDouble<A> { double op(A a, double b);} |
471 |
public static interface ObjectAndDoubleToObject<A,R> { R op(A a, double b);} |
472 |
public static interface ObjectAndObjectProcedure<A,B>{ void op(A a, B b);} |
473 |
public static interface ObjectAndObjectToInt<A,B> { int op(A a, B b);} |
474 |
public static interface ObjectAndObjectToLong<A,B> { long op(A a, B b);} |
475 |
public static interface ObjectAndObjectToDouble<A,B> { double op(A a, B b);} |
476 |
} |