1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32 package nom.tam.util.array;
33
34 import java.util.Collections;
35 import java.util.HashMap;
36 import java.util.Map;
37
38 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
39
40
41
42
43
44
45
46
47 @Deprecated
48 @SuppressFBWarnings(value = "SING_SINGLETON_HAS_NONPRIVATE_CONSTRUCTOR", justification = "warning persists despite private constructor")
49 public class MultiArrayCopyFactory<Source, Destination> {
50
51 private MultiArrayCopyFactory() {
52 }
53
54 private static final class ByteToChar extends MultiArrayCopyFactory<byte[], char[]> {
55
56 @Override
57 public void arraycopy(byte[] src, int srcPos, char[] dest, int destPos, int length) {
58 for (int index = 0; index < length; index++) {
59 dest[index + destPos] = (char) src[index + srcPos];
60 }
61 }
62 }
63
64 private static final class ByteToDouble extends MultiArrayCopyFactory<byte[], double[]> {
65
66 @Override
67 public void arraycopy(byte[] src, int srcPos, double[] dest, int destPos, int length) {
68 for (int index = 0; index < length; index++) {
69 dest[index + destPos] = src[index + srcPos];
70 }
71 }
72 }
73
74 private static final class ByteToFloat extends MultiArrayCopyFactory<byte[], float[]> {
75
76 @Override
77 public void arraycopy(byte[] src, int srcPos, float[] dest, int destPos, int length) {
78 for (int index = 0; index < length; index++) {
79 dest[index + destPos] = src[index + srcPos];
80 }
81 }
82 }
83
84 private static final class ByteToInt extends MultiArrayCopyFactory<byte[], int[]> {
85
86 @Override
87 public void arraycopy(byte[] src, int srcPos, int[] dest, int destPos, int length) {
88 for (int index = 0; index < length; index++) {
89 dest[index + destPos] = src[index + srcPos];
90 }
91 }
92 }
93
94 private static final class ByteToLong extends MultiArrayCopyFactory<byte[], long[]> {
95
96 @Override
97 public void arraycopy(byte[] src, int srcPos, long[] dest, int destPos, int length) {
98 for (int index = 0; index < length; index++) {
99 dest[index + destPos] = src[index + srcPos];
100 }
101 }
102 }
103
104 private static final class ByteToShort extends MultiArrayCopyFactory<byte[], short[]> {
105
106 @Override
107 public void arraycopy(byte[] src, int srcPos, short[] dest, int destPos, int length) {
108 for (int index = 0; index < length; index++) {
109 dest[index + destPos] = src[index + srcPos];
110 }
111 }
112 }
113
114 private static final class CharToByte extends MultiArrayCopyFactory<char[], byte[]> {
115
116 @Override
117 public void arraycopy(char[] src, int srcPos, byte[] dest, int destPos, int length) {
118 for (int index = 0; index < length; index++) {
119 dest[index + destPos] = (byte) src[index + srcPos];
120 }
121 }
122 }
123
124 private static final class CharToDouble extends MultiArrayCopyFactory<char[], double[]> {
125
126 @Override
127 public void arraycopy(char[] src, int srcPos, double[] dest, int destPos, int length) {
128 for (int index = 0; index < length; index++) {
129 dest[index + destPos] = src[index + srcPos];
130 }
131 }
132 }
133
134 private static final class CharToFloat extends MultiArrayCopyFactory<char[], float[]> {
135
136 @Override
137 public void arraycopy(char[] src, int srcPos, float[] dest, int destPos, int length) {
138 for (int index = 0; index < length; index++) {
139 dest[index + destPos] = src[index + srcPos];
140 }
141 }
142 }
143
144 private static final class CharToInt extends MultiArrayCopyFactory<char[], int[]> {
145
146 @Override
147 public void arraycopy(char[] src, int srcPos, int[] dest, int destPos, int length) {
148 for (int index = 0; index < length; index++) {
149 dest[index + destPos] = src[index + srcPos];
150 }
151 }
152 }
153
154 private static final class CharToLong extends MultiArrayCopyFactory<char[], long[]> {
155
156 @Override
157 public void arraycopy(char[] src, int srcPos, long[] dest, int destPos, int length) {
158 for (int index = 0; index < length; index++) {
159 dest[index + destPos] = src[index + srcPos];
160 }
161 }
162 }
163
164 private static final class CharToShort extends MultiArrayCopyFactory<char[], short[]> {
165
166 @Override
167 public void arraycopy(char[] src, int srcPos, short[] dest, int destPos, int length) {
168 for (int index = 0; index < length; index++) {
169 dest[index + destPos] = (short) src[index + srcPos];
170 }
171 }
172 }
173
174 private static final class DoubleToByte extends MultiArrayCopyFactory<double[], byte[]> {
175
176 @Override
177 public void arraycopy(double[] src, int srcPos, byte[] dest, int destPos, int length) {
178 for (int index = 0; index < length; index++) {
179 dest[index + destPos] = (byte) Math.round(src[index + srcPos]);
180 }
181 }
182 }
183
184 private static final class DoubleToChar extends MultiArrayCopyFactory<double[], char[]> {
185
186 @Override
187 public void arraycopy(double[] src, int srcPos, char[] dest, int destPos, int length) {
188 for (int index = 0; index < length; index++) {
189 dest[index + destPos] = (char) Math.round(src[index + srcPos]);
190 }
191 }
192 }
193
194 private static final class DoubleToFloat extends MultiArrayCopyFactory<double[], float[]> {
195
196 @Override
197 public void arraycopy(double[] src, int srcPos, float[] dest, int destPos, int length) {
198 for (int index = 0; index < length; index++) {
199 dest[index + destPos] = (float) src[index + srcPos];
200 }
201 }
202 }
203
204 private static final class DoubleToInt extends MultiArrayCopyFactory<double[], int[]> {
205
206 @Override
207 public void arraycopy(double[] src, int srcPos, int[] dest, int destPos, int length) {
208 for (int index = 0; index < length; index++) {
209 dest[index + destPos] = (int) Math.round(src[index + srcPos]);
210 }
211 }
212 }
213
214 private static final class DoubleToLong extends MultiArrayCopyFactory<double[], long[]> {
215
216 @Override
217 public void arraycopy(double[] src, int srcPos, long[] dest, int destPos, int length) {
218 for (int index = 0; index < length; index++) {
219 dest[index + destPos] = Math.round(src[index + srcPos]);
220 }
221 }
222 }
223
224 private static final class DoubleToShort extends MultiArrayCopyFactory<double[], short[]> {
225
226 @Override
227 public void arraycopy(double[] src, int srcPos, short[] dest, int destPos, int length) {
228 for (int index = 0; index < length; index++) {
229 dest[index + destPos] = (short) Math.round(src[index + srcPos]);
230 }
231 }
232 }
233
234 private static final class FloatToByte extends MultiArrayCopyFactory<float[], byte[]> {
235
236 @Override
237 public void arraycopy(float[] src, int srcPos, byte[] dest, int destPos, int length) {
238 for (int index = 0; index < length; index++) {
239 dest[index + destPos] = (byte) Math.round(src[index + srcPos]);
240 }
241 }
242 }
243
244 private static final class FloatToChar extends MultiArrayCopyFactory<float[], char[]> {
245
246 @Override
247 public void arraycopy(float[] src, int srcPos, char[] dest, int destPos, int length) {
248 for (int index = 0; index < length; index++) {
249 dest[index + destPos] = (char) Math.round(src[index + srcPos]);
250 }
251 }
252 }
253
254 private static final class FloatToDouble extends MultiArrayCopyFactory<float[], double[]> {
255
256 @Override
257 public void arraycopy(float[] src, int srcPos, double[] dest, int destPos, int length) {
258 for (int index = 0; index < length; index++) {
259 dest[index + destPos] = src[index + srcPos];
260 }
261 }
262 }
263
264 private static final class FloatToInt extends MultiArrayCopyFactory<float[], int[]> {
265
266 @Override
267 public void arraycopy(float[] src, int srcPos, int[] dest, int destPos, int length) {
268 for (int index = 0; index < length; index++) {
269 dest[index + destPos] = Math.round(src[index + srcPos]);
270 }
271 }
272 }
273
274 private static final class FloatToLong extends MultiArrayCopyFactory<float[], long[]> {
275
276 @Override
277 public void arraycopy(float[] src, int srcPos, long[] dest, int destPos, int length) {
278 for (int index = 0; index < length; index++) {
279 dest[index + destPos] = Math.round(src[index + srcPos]);
280 }
281 }
282 }
283
284 private static final class FloatToShort extends MultiArrayCopyFactory<float[], short[]> {
285
286 @Override
287 public void arraycopy(float[] src, int srcPos, short[] dest, int destPos, int length) {
288 for (int index = 0; index < length; index++) {
289 dest[index + destPos] = (short) Math.round(src[index + srcPos]);
290 }
291 }
292 }
293
294 private static final class Generic extends MultiArrayCopyFactory<Object, Object> {
295
296 @Override
297 public void arraycopy(Object srcO, int srcPos, Object destO, int destPos, int length) {
298 System.arraycopy(srcO, srcPos, destO, destPos, length);
299 }
300 }
301
302 private static final class IntToByte extends MultiArrayCopyFactory<int[], byte[]> {
303
304 @Override
305 public void arraycopy(int[] src, int srcPos, byte[] dest, int destPos, int length) {
306 for (int index = 0; index < length; index++) {
307 dest[index + destPos] = (byte) src[index + srcPos];
308 }
309 }
310 }
311
312 private static final class IntToChar extends MultiArrayCopyFactory<int[], char[]> {
313
314 @Override
315 public void arraycopy(int[] src, int srcPos, char[] dest, int destPos, int length) {
316 for (int index = 0; index < length; index++) {
317 dest[index + destPos] = (char) src[index + srcPos];
318 }
319 }
320 }
321
322 private static final class IntToDouble extends MultiArrayCopyFactory<int[], double[]> {
323
324 @Override
325 public void arraycopy(int[] src, int srcPos, double[] dest, int destPos, int length) {
326 for (int index = 0; index < length; index++) {
327 dest[index + destPos] = src[index + srcPos];
328 }
329 }
330 }
331
332 private static final class IntToFloat extends MultiArrayCopyFactory<int[], float[]> {
333
334 @Override
335 public void arraycopy(int[] src, int srcPos, float[] dest, int destPos, int length) {
336 for (int index = 0; index < length; index++) {
337 dest[index + destPos] = src[index + srcPos];
338 }
339 }
340 }
341
342 private static final class IntToLong extends MultiArrayCopyFactory<int[], long[]> {
343
344 @Override
345 public void arraycopy(int[] src, int srcPos, long[] dest, int destPos, int length) {
346 for (int index = 0; index < length; index++) {
347 dest[index + destPos] = src[index + srcPos];
348 }
349 }
350 }
351
352 private static final class IntToShort extends MultiArrayCopyFactory<int[], short[]> {
353
354 @Override
355 public void arraycopy(int[] src, int srcPos, short[] dest, int destPos, int length) {
356 for (int index = 0; index < length; index++) {
357 dest[index + destPos] = (short) src[index + srcPos];
358 }
359 }
360 }
361
362 private static final class LongToByte extends MultiArrayCopyFactory<long[], byte[]> {
363
364 @Override
365 public void arraycopy(long[] src, int srcPos, byte[] dest, int destPos, int length) {
366 for (int index = 0; index < length; index++) {
367 dest[index + destPos] = (byte) src[index + srcPos];
368 }
369 }
370 }
371
372 private static final class LongToChar extends MultiArrayCopyFactory<long[], char[]> {
373
374 @Override
375 public void arraycopy(long[] src, int srcPos, char[] dest, int destPos, int length) {
376 for (int index = 0; index < length; index++) {
377 dest[index + destPos] = (char) src[index + srcPos];
378 }
379 }
380 }
381
382 private static final class LongToDouble extends MultiArrayCopyFactory<long[], double[]> {
383
384 @Override
385 public void arraycopy(long[] src, int srcPos, double[] dest, int destPos, int length) {
386 for (int index = 0; index < length; index++) {
387 dest[index + destPos] = src[index + srcPos];
388 }
389 }
390 }
391
392 private static final class LongToFloat extends MultiArrayCopyFactory<long[], float[]> {
393
394 @Override
395 public void arraycopy(long[] src, int srcPos, float[] dest, int destPos, int length) {
396 for (int index = 0; index < length; index++) {
397 dest[index + destPos] = src[index + srcPos];
398 }
399 }
400 }
401
402 private static final class LongToInt extends MultiArrayCopyFactory<long[], int[]> {
403
404 @Override
405 public void arraycopy(long[] src, int srcPos, int[] dest, int destPos, int length) {
406 for (int index = 0; index < length; index++) {
407 dest[index + destPos] = (int) src[index + srcPos];
408 }
409 }
410 }
411
412 private static final class LongToShort extends MultiArrayCopyFactory<long[], short[]> {
413
414 @Override
415 public void arraycopy(long[] src, int srcPos, short[] dest, int destPos, int length) {
416 for (int index = 0; index < length; index++) {
417 dest[index + destPos] = (short) src[index + srcPos];
418 }
419 }
420 }
421
422 private static final class ShortToByte extends MultiArrayCopyFactory<short[], byte[]> {
423
424 @Override
425 public void arraycopy(short[] src, int srcPos, byte[] dest, int destPos, int length) {
426 for (int index = 0; index < length; index++) {
427 dest[index + destPos] = (byte) src[index + srcPos];
428 }
429 }
430 }
431
432 private static final class ShortToChar extends MultiArrayCopyFactory<short[], char[]> {
433
434 @Override
435 public void arraycopy(short[] src, int srcPos, char[] dest, int destPos, int length) {
436 for (int index = 0; index < length; index++) {
437 dest[index + destPos] = (char) src[index + srcPos];
438 }
439 }
440 }
441
442 private static final class ShortToDouble extends MultiArrayCopyFactory<short[], double[]> {
443
444 @Override
445 public void arraycopy(short[] src, int srcPos, double[] dest, int destPos, int length) {
446 for (int index = 0; index < length; index++) {
447 dest[index + destPos] = src[index + srcPos];
448 }
449 }
450 }
451
452 private static final class ShortToFloat extends MultiArrayCopyFactory<short[], float[]> {
453
454 @Override
455 public void arraycopy(short[] src, int srcPos, float[] dest, int destPos, int length) {
456 for (int index = 0; index < length; index++) {
457 dest[index + destPos] = src[index + srcPos];
458 }
459 }
460 }
461
462 private static final class ShortToInt extends MultiArrayCopyFactory<short[], int[]> {
463
464 @Override
465 public void arraycopy(short[] src, int srcPos, int[] dest, int destPos, int length) {
466 for (int index = 0; index < length; index++) {
467 dest[index + destPos] = src[index + srcPos];
468 }
469 }
470 }
471
472 private static final class ShortToLong extends MultiArrayCopyFactory<short[], long[]> {
473
474 @Override
475 public void arraycopy(short[] src, int srcPos, long[] dest, int destPos, int length) {
476 for (int index = 0; index < length; index++) {
477 dest[index + destPos] = src[index + srcPos];
478 }
479 }
480 }
481
482 private static final Map<Class<?>, Map<Class<?>, MultiArrayCopyFactory<?, ?>>> FACTORIES;
483
484 private static final MultiArrayCopyFactory<Object, Object> GENERIC = new Generic();
485
486 static {
487 Map<Class<?>, Map<Class<?>, MultiArrayCopyFactory<?, ?>>> factories = new HashMap<>();
488
489 Map<Class<?>, MultiArrayCopyFactory<byte[], ?>> byteMap = new HashMap<>();
490 byteMap.put(byte.class, new MultiArrayCopyFactory<>());
491 byteMap.put(char.class, new ByteToChar());
492 byteMap.put(short.class, new ByteToShort());
493 byteMap.put(int.class, new ByteToInt());
494 byteMap.put(long.class, new ByteToLong());
495 byteMap.put(float.class, new ByteToFloat());
496 byteMap.put(double.class, new ByteToDouble());
497 factories.put(byte.class, Collections.unmodifiableMap(byteMap));
498
499 Map<Class<?>, MultiArrayCopyFactory<char[], ?>> charMap = new HashMap<>();
500 charMap.put(byte.class, new CharToByte());
501 charMap.put(char.class, new MultiArrayCopyFactory<>());
502 charMap.put(short.class, new CharToShort());
503 charMap.put(int.class, new CharToInt());
504 charMap.put(long.class, new CharToLong());
505 charMap.put(float.class, new CharToFloat());
506 charMap.put(double.class, new CharToDouble());
507 factories.put(char.class, Collections.unmodifiableMap(charMap));
508
509 Map<Class<?>, MultiArrayCopyFactory<short[], ?>> shortMap = new HashMap<>();
510 shortMap.put(byte.class, new ShortToByte());
511 shortMap.put(char.class, new ShortToChar());
512 shortMap.put(short.class, new MultiArrayCopyFactory<>());
513 shortMap.put(int.class, new ShortToInt());
514 shortMap.put(long.class, new ShortToLong());
515 shortMap.put(float.class, new ShortToFloat());
516 shortMap.put(double.class, new ShortToDouble());
517 factories.put(short.class, Collections.unmodifiableMap(shortMap));
518
519 Map<Class<?>, MultiArrayCopyFactory<int[], ?>> intMap = new HashMap<>();
520 intMap.put(byte.class, new IntToByte());
521 intMap.put(char.class, new IntToChar());
522 intMap.put(short.class, new IntToShort());
523 intMap.put(int.class, new MultiArrayCopyFactory<>());
524 intMap.put(long.class, new IntToLong());
525 intMap.put(float.class, new IntToFloat());
526 intMap.put(double.class, new IntToDouble());
527 factories.put(int.class, Collections.unmodifiableMap(intMap));
528
529 Map<Class<?>, MultiArrayCopyFactory<long[], ?>> longMap = new HashMap<>();
530 longMap.put(byte.class, new LongToByte());
531 longMap.put(char.class, new LongToChar());
532 longMap.put(short.class, new LongToShort());
533 longMap.put(int.class, new LongToInt());
534 longMap.put(long.class, new MultiArrayCopyFactory<>());
535 longMap.put(float.class, new LongToFloat());
536 longMap.put(double.class, new LongToDouble());
537 factories.put(long.class, Collections.unmodifiableMap(longMap));
538
539 Map<Class<?>, MultiArrayCopyFactory<float[], ?>> floatMap = new HashMap<>();
540 floatMap.put(byte.class, new FloatToByte());
541 floatMap.put(char.class, new FloatToChar());
542 floatMap.put(short.class, new FloatToShort());
543 floatMap.put(int.class, new FloatToInt());
544 floatMap.put(long.class, new FloatToLong());
545 floatMap.put(float.class, new MultiArrayCopyFactory<>());
546 floatMap.put(double.class, new FloatToDouble());
547 factories.put(float.class, Collections.unmodifiableMap(floatMap));
548
549 Map<Class<?>, MultiArrayCopyFactory<double[], ?>> doubleMap = new HashMap<>();
550 doubleMap.put(byte.class, new DoubleToByte());
551 doubleMap.put(char.class, new DoubleToChar());
552 doubleMap.put(short.class, new DoubleToShort());
553 doubleMap.put(int.class, new DoubleToInt());
554 doubleMap.put(long.class, new DoubleToLong());
555 doubleMap.put(float.class, new DoubleToFloat());
556 doubleMap.put(double.class, new MultiArrayCopyFactory<>());
557 factories.put(double.class, Collections.unmodifiableMap(doubleMap));
558
559 FACTORIES = Collections.unmodifiableMap(factories);
560 }
561
562
563
564
565 @SuppressWarnings("javadoc")
566 public static synchronized MultiArrayCopyFactory<?, ?> select(Class<?> primitiveType, Class<?> primitiveType2) {
567 Map<Class<?>, MultiArrayCopyFactory<?, ?>> from = MultiArrayCopyFactory.FACTORIES.get(primitiveType);
568 if (from != null) {
569 MultiArrayCopyFactory<?, ?> to = from.get(primitiveType2);
570 if (to != null) {
571 return to;
572 }
573 }
574 return MultiArrayCopyFactory.GENERIC;
575 }
576
577
578
579
580 @SuppressWarnings("javadoc")
581 public void arraycopy(Source src, int srcPos, Destination dest, int destPos, int length) {
582 System.arraycopy(src, srcPos, dest, destPos, length);
583 }
584
585 }