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