Debian Codegraph @

chunkio-processor/src/com/android/tools/chunkio/reader/ChunkReaders.java

raw
1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 package com.android.tools.chunkio.reader;
18
19 import com.android.tools.chunkio.Chunked;
20 import com.android.tools.chunkio.processor.FieldChunk;
21 import com.android.tools.chunkio.ChunkUtils;
22 import com.android.tools.chunkio.codegen.MethodDef;
23 import com.android.tools.chunkio.codegen.TypeDef;
24
25 import javax.lang.model.element.TypeElement;
26 import javax.lang.model.type.TypeKind;
27 import javax.lang.model.type.TypeMirror;
28 import java.io.DataInputStream;
29 import java.nio.charset.Charset;
30 import java.util.ArrayList;
31 import java.util.EnumMap;
32 import java.util.HashMap;
33 import java.util.List;
34 import java.util.Map;
35
36 /**
37 * Holds all supported instances of {@link ChunkReader}. These instances
38 * can be queried using the following methods:
39 * <ul>
40 * <li>{@link #get(String)}, to retrieve a Class chunk reader</li>
41 * <li>{@link #get(TypeKind)}, to retrieve a primitive chunk reader</li>
42 * <li>{@link #getArrayReader(TypeKind)}, to retrieve an array chunk reader</li>
43 * <li>{@link #getCollectionReader(String)}, to retrieve a collection chunk reader</li>
44 * </ul>
45 */
46 public final class ChunkReaders {
47 private static final Map<TypeKind, ChunkReader> typeReaders = new EnumMap<>(TypeKind.class);
48 private static final Map<TypeKind, ChunkReader> arrayReaders = new EnumMap<>(TypeKind.class);
49 private static final Map<String, ChunkReader> classReaders = new HashMap<>();
50 private static final Map<String, ChunkReader> collectionReaders = new HashMap<>();
51
52 static {
53 typeReaders.put(TypeKind.BOOLEAN, new BooleanChunkReaderImpl());
54 typeReaders.put(TypeKind.BYTE, new ByteChunkReaderImpl());
55 typeReaders.put(TypeKind.CHAR, new CharChunkReaderImpl());
56 typeReaders.put(TypeKind.DOUBLE, new DoubleChunkReaderImpl());
57 typeReaders.put(TypeKind.FLOAT, new FloatChunkReaderImpl());
58 typeReaders.put(TypeKind.INT, new IntChunkReaderImpl());
59 typeReaders.put(TypeKind.LONG, new LongChunkReaderImpl());
60 typeReaders.put(TypeKind.SHORT, new ShortChunkReaderImpl());
61
62 arrayReaders.put(TypeKind.BYTE, new ByteArrayChunkReaderImpl());
63
64 classReaders.put(Object.class.getCanonicalName(), new ObjectChunkReaderImpl());
65 classReaders.put(String.class.getCanonicalName(), new StringChunkReaderImpl());
66 classReaders.put(Void.class.getCanonicalName(), new VoidChunkReaderImpl());
67
68 collectionReaders.put(List.class.getCanonicalName(), new ListChunkReaderImpl());
69 collectionReaders.put(Map.class.getCanonicalName(), new MapChunkReaderImpl());
70 }
71
72 private ChunkReaders() {
73 }
74
75 /**
76 * Returns a chunk reader for the specified type. The only supported types
77 * are primitives: boolean, byte, char, double, float, int, long and short.
78 */
79 public static ChunkReader get(TypeKind kind) {
80 return typeReaders.get(kind);
81 }
82
83 /**
84 * Returns a chunk reader for the specified fully qualified class name.
85 * Classes supported by default are: Object, String and Void. More
86 * readers can be added using {@link #createReader(String, String)} and
87 * {@link #createEnumReader(String, String)}.
88 */
89 public static ChunkReader get(String className) {
90 return classReaders.get(className);
91 }
92
93 /**
94 * Returns a chunk reader for an array of the specified type.
95 * Only byte arrays are supported.
96 */
97 public static ChunkReader getArrayReader(TypeKind kind) {
98 return arrayReaders.get(kind);
99 }
100
101 /**
102 * Returns a chunk reader for the specified fully qualified collection
103 * name. The supported collections are <code>java.util.List</code> and
104 * <code>java.util.Map</code>.
105 */
106 public static ChunkReader getCollectionReader(String className) {
107 return collectionReaders.get(className);
108 }
109
110 /**
111 * Creates and returns a reader for the specified class in the specified
112 * package. The class <strong>must</strong> declared the {@link Chunked}
113 * annotation for the reader to be valid.
114 * The created reader is cached and be subsequently accessed using
115 * {@link #get(String)}.
116 *
117 * @param packageName The package name of the class to read
118 * @param className The name of the class to read
119 */
120 public static ChunkReader createReader(String packageName, String className) {
121 ChunkReader reader = new ChunkedChunkReaderImpl(packageName, className);
122 cacheReader(className, reader);
123 return reader;
124 }
125
126 /**
127 * Creates and returns a reader for the specified enum.
128 * The created reader is cached and be subsequently accessed using
129 * {@link #get(String)}.
130 *
131 * @param packageName The package name of the enum to read
132 * @param className The name of the enum to read
133 */
134 public static ChunkReader createEnumReader(String packageName, String className) {
135 ChunkReader reader = new EnumChunkReaderImpl(packageName, className);
136 cacheReader(className, reader);
137 return reader;
138 }
139
140 private static void cacheReader(String className, ChunkReader reader) {
141 classReaders.put(className + '.' + className, reader);
142 }
143
144 private abstract static class ClassChunkReader implements ChunkReader {
145 @Override
146 public void emitPrologue(MethodDef.Builder builder, String target, FieldChunk chunk) {
147 }
148
149 @Override
150 public void emitEpilogue(MethodDef.Builder builder, String target, FieldChunk chunk) {
151 }
152
153 @Override
154 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
155 }
156
157 @Override
158 public void emitDynamicRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
159 }
160 }
161
162 private abstract static class CollectionClassChunkReader extends ClassChunkReader
163 implements CollectionChunkReader {
164 List<TypeElement> parameters;
165
166 @Override
167 public void emitPrologue(MethodDef.Builder builder, String target, FieldChunk chunk) {
168 if (chunk.hasByteCount() && !chunk.hasSize()) {
169 if (!chunk.hasDynamicByteCount()) {
170 builder.addStatement("byteCount = $L", chunk.byteCount());
171 }
172 builder.addStatement("in.pushRange(byteCount)", DataInputStream.class);
173 }
174 }
175
176 @Override
177 public void emitEpilogue(MethodDef.Builder builder, String target, FieldChunk chunk) {
178 if (chunk.hasByteCount() && !chunk.hasSize()) {
179 builder.addStatement("in.popRange()");
180 }
181 }
182
183 @Override
184 public boolean acceptTypeParameters(List<TypeElement> parameters) {
185 this.parameters = parameters;
186 return true;
187 }
188
189 @Override
190 public TypeMirror getElementType() {
191 // the last parameter works for lists and maps
192 return parameters.get(parameters.size() - 1).asType();
193 }
194 }
195
196 private static class ListChunkReaderImpl extends CollectionClassChunkReader {
197 @Override
198 public boolean acceptTypeParameters(List<TypeElement> parameters) {
199 return parameters.size() == 1 && super.acceptTypeParameters(parameters);
200 }
201
202 @Override
203 public void pushElement(MethodDef.Builder builder, String target, FieldChunk chunk,
204 String elementName) {
205 builder.addStatement("$L$L.add($L)", target, chunk.name, elementName);
206 }
207
208 @Override
209 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
210 builder.addStatement("$L$L = new $T<$T>()", target, chunk.name, ArrayList.class,
211 parameters.get(0).asType());
212 }
213
214 @Override
215 public void emitDynamicRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
216 emitRead(builder, target, chunk);
217 }
218 }
219
220 private static class MapChunkReaderImpl extends CollectionClassChunkReader {
221 @Override
222 public boolean acceptTypeParameters(List<TypeElement> parameters) {
223 if (parameters.size() != 2) {
224 return false;
225 }
226
227 return super.acceptTypeParameters(parameters);
228 }
229
230 @Override
231 public void pushElement(MethodDef.Builder builder, String target, FieldChunk chunk,
232 String elementName) {
233 builder.addStatement("$L$L.put($L, $L)", target, chunk.name, chunk.key(), elementName);
234 }
235
236 @Override
237 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
238 builder.addStatement("$L$L = new $T<$T, $T>()", target, chunk.name, HashMap.class,
239 parameters.get(0).asType(), parameters.get(1).asType());
240 }
241
242 @Override
243 public void emitDynamicRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
244 emitRead(builder, target, chunk);
245 }
246 }
247
248 private static class EnumChunkReaderImpl implements ChunkReader, EnumChunkReader {
249 private final TypeDef type;
250 private boolean skip;
251 private long count;
252
253 private EnumChunkReaderImpl(String packageName, String className) {
254 type = TypeDef.fromClass(packageName, className);
255 }
256
257 @Override
258 public void emitPrologue(MethodDef.Builder builder, String target, FieldChunk chunk) {
259 }
260
261 @Override
262 public void emitEpilogue(MethodDef.Builder builder, String target, FieldChunk chunk) {
263 if (skip) {
264 builder.addStatement("$T.skip(in, $L)", ChunkUtils.class, count - 4);
265 }
266 }
267
268 @Override
269 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
270 String expression;
271 skip = false;
272 count = chunk.byteCount();
273
274 switch ((int)count) {
275 case 1:
276 expression = "in.readUnsignedByte()";
277 break;
278 case 2:
279 expression = "in.readUnsignedShort()";
280 break;
281 case -1:
282 case 4:
283 expression = "in.readInt()";
284 break;
285 default:
286 expression = "in.readInt()";
287 skip = true;
288 }
289 builder.addStatement("$L$L = $T.values()[\n" +
290 "Math.max(0, Math.min($L, $T.values().length - 1))]",
291 target, chunk.name, type, expression, type);
292 }
293
294 @Override
295 public void emitDynamicRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
296 builder.addStatement("$L$L = $T.values()[\n" +
297 "Math.max(0, Math.min($T.readInt(in, byteCount), $T.values().length - 1))]",
298 target, chunk.name, type, ChunkUtils.class, type);
299 }
300 }
301
302 private static class ChunkedChunkReaderImpl extends ClassChunkReader {
303 private final TypeDef type;
304
305 private ChunkedChunkReaderImpl(String packageName, String className) {
306 type = TypeDef.fromClass(packageName, className);
307 }
308
309 @Override
310 public void emitPrologue(MethodDef.Builder builder, String target, FieldChunk chunk) {
311 if (chunk.hasByteCount()) {
312 if (!chunk.hasDynamicByteCount()) {
313 builder.addStatement("byteCount = $L", chunk.byteCount());
314 }
315 builder.addStatement("in.pushRange(byteCount)");
316 }
317 }
318
319 @Override
320 public void emitEpilogue(MethodDef.Builder builder, String target, FieldChunk chunk) {
321 if (chunk.hasByteCount()) {
322 builder.addStatement("in.popRange()");
323 }
324 }
325
326 @Override
327 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
328 long byteCount = chunk.byteCount();
329 if (byteCount > 0) {
330 emitRangedRead(builder, target, chunk);
331 } else {
332 builder.addStatement("$L$L = $T.read(in, stack)", target, chunk.name, type);
333 }
334 }
335
336 @Override
337 public void emitDynamicRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
338 emitRangedRead(builder, target, chunk);
339 }
340
341 private void emitRangedRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
342 builder.addStatement("$L$L = $T.read(in, stack)", target, chunk.name, type);
343 }
344 }
345
346 private static class StringChunkReaderImpl extends ClassChunkReader {
347 @Override
348 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
349 builder.addStatement("$L$L = $T.readString(in, $L, $T.forName($S))", target,
350 chunk.name, ChunkUtils.class, chunk.byteCount(), Charset.class, chunk.encoding());
351 }
352
353 @Override
354 public void emitDynamicRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
355 builder.addStatement("$L$L = $T.readString(in, byteCount, $T.forName($S))",
356 target, chunk.name, ChunkUtils.class, Charset.class, chunk.encoding());
357 }
358 }
359
360 private static class ObjectChunkReaderImpl extends VoidChunkReaderImpl
361 implements DynamicTypeChunkReader {
362 @Override
363 public void emitPrologue(MethodDef.Builder builder, String target, FieldChunk chunk) {
364 if (chunk.hasByteCount()) {
365 if (!chunk.hasDynamicByteCount()) {
366 builder.addStatement("byteCount = $L", chunk.byteCount());
367 }
368 builder.addStatement("in.pushRange(byteCount)");
369 }
370 }
371
372 @Override
373 public void emitEpilogue(MethodDef.Builder builder, String target, FieldChunk chunk) {
374 if (chunk.hasByteCount()) {
375 builder.addStatement("in.popRange()");
376 }
377 }
378 }
379
380 private static class VoidChunkReaderImpl extends ClassChunkReader {
381 @Override
382 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
383 builder.add("/* $L$L */\n", target, chunk.name);
384 builder.addStatement("$T.skip(in, $L)", ChunkUtils.class, chunk.byteCount());
385 }
386
387 @Override
388 public void emitDynamicRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
389 builder.add("/* $L$L */\n", target, chunk.name);
390 builder.addStatement("$T.skip(in, byteCount)", ChunkUtils.class);
391 }
392 }
393
394 private abstract static class PrimitiveChunkReaderImpl implements ChunkReader, PrimitiveChunkReader {
395 private String primitive;
396
397 private PrimitiveChunkReaderImpl(String primitive) {
398 this.primitive = primitive;
399 }
400
401 @Override
402 public void emitPrologue(MethodDef.Builder builder, String target, FieldChunk chunk) {
403 }
404
405 @Override
406 public void emitEpilogue(MethodDef.Builder builder, String target, FieldChunk chunk) {
407 }
408
409 @Override
410 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
411 }
412
413 @Override
414 public void emitDynamicRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
415 builder.addStatement("$L$L = $T.read$L(in, byteCount)", target, chunk.name,
416 ChunkUtils.class, primitive);
417 }
418
419 void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk,
420 String expression, boolean skip, long count) {
421 builder.addStatement("$L$L = $L", target, chunk.name, expression);
422 if (skip) {
423 builder.addStatement("$T.skip(in, $L)", ChunkUtils.class, count);
424 }
425 }
426 }
427
428 private static class BooleanChunkReaderImpl extends PrimitiveChunkReaderImpl {
429 private BooleanChunkReaderImpl() {
430 super("Boolean");
431 }
432
433 @Override
434 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
435 String expression;
436 boolean skip = false;
437 long count = chunk.byteCount();
438
439 switch ((int) count) {
440 case -1:
441 case 1:
442 expression = "in.readByte() != 0";
443 break;
444 case 2:
445 expression = "in.readShort() != 0";
446 break;
447 case 4:
448 expression = "in.readInt() != 0";
449 break;
450 case 8:
451 expression = "in.readLong() != 0";
452 break;
453 default:
454 expression = "in.readByte() != 0";
455 skip = true;
456 }
457
458 emitRead(builder, target, chunk, expression, skip, count - 1);
459 }
460 }
461
462 private static class ByteChunkReaderImpl extends PrimitiveChunkReaderImpl {
463 private ByteChunkReaderImpl() {
464 super("Byte");
465 }
466
467 @Override
468 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
469 String expression;
470 boolean skip = false;
471 long count = chunk.byteCount();
472
473 switch ((int) count) {
474 case -1:
475 case 1:
476 expression = "in.readByte()";
477 break;
478 default:
479 expression = "in.readByte()";
480 skip = true;
481 }
482
483 emitRead(builder, target, chunk, expression, skip, count - 1);
484 }
485 }
486
487
488 private static class CharChunkReaderImpl extends PrimitiveChunkReaderImpl {
489 private CharChunkReaderImpl() {
490 super("Char");
491 }
492
493 @Override
494 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
495 String expression;
496 boolean skip = false;
497 long count = chunk.byteCount();
498
499 switch ((int) count) {
500 case 1:
501 expression = "(char) (in.readByte() & 0xff)";
502 break;
503 case -1:
504 case 2:
505 expression = "in.readChar()";
506 break;
507 default:
508 expression = "in.readChar()";
509 skip = true;
510 }
511
512 emitRead(builder, target, chunk, expression, skip, count - 2);
513 }
514 }
515
516 private static class DoubleChunkReaderImpl extends PrimitiveChunkReaderImpl {
517 private DoubleChunkReaderImpl() {
518 super("Double");
519 }
520
521 @Override
522 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
523 String expression;
524 boolean skip = false;
525 long count = chunk.byteCount();
526
527 switch ((int) count) {
528 case 4:
529 expression = "in.readFloat()";
530 break;
531 case -1:
532 case 8:
533 expression = "in.readDouble()";
534 break;
535 default:
536 expression = "in.readDouble()";
537 skip = true;
538 }
539
540 emitRead(builder, target, chunk, expression, skip, count - 8);
541 }
542 }
543
544 private static class FloatChunkReaderImpl extends PrimitiveChunkReaderImpl {
545 private FloatChunkReaderImpl() {
546 super("Float");
547 }
548
549 @Override
550 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
551 String expression;
552 boolean skip = false;
553 long count = chunk.byteCount();
554
555 switch ((int) count) {
556 case -1:
557 case 4:
558 expression = "in.readFloat()";
559 break;
560 default:
561 expression = "in.readFloat()";
562 skip = true;
563 }
564
565 emitRead(builder, target, chunk, expression, skip, count - 4);
566 }
567 }
568
569 private static class IntChunkReaderImpl extends PrimitiveChunkReaderImpl {
570 private IntChunkReaderImpl() {
571 super("Int");
572 }
573
574 @Override
575 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
576 String expression;
577 boolean skip = false;
578 long count = chunk.byteCount();
579
580 switch ((int) count) {
581 case 1:
582 expression = "in.readUnsignedByte()";
583 break;
584 case 2:
585 expression = "in.readUnsignedShort()";
586 break;
587 case -1:
588 case 4:
589 expression = "in.readInt()";
590 break;
591 default:
592 expression = "in.readInt()";
593 skip = true;
594 }
595
596 emitRead(builder, target, chunk, expression, skip, count - 4);
597 }
598 }
599
600 private static class LongChunkReaderImpl extends PrimitiveChunkReaderImpl {
601 private LongChunkReaderImpl() {
602 super("Long");
603 }
604
605 @Override
606 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
607 String expression;
608 boolean skip = false;
609 long count = chunk.byteCount();
610
611 switch ((int) count) {
612 case 1:
613 expression = "in.readUnsignedByte()";
614 break;
615 case 2:
616 expression = "in.readUnsignedShort()";
617 break;
618 case 4:
619 expression = "in.readInt() & 0xffffffffL";
620 break;
621 case -1:
622 case 8:
623 expression = "in.readLong()";
624 break;
625 default:
626 expression = "in.readLong()";
627 skip = true;
628 }
629
630 emitRead(builder, target, chunk, expression, skip, count - 8);
631 }
632 }
633
634 private static class ShortChunkReaderImpl extends PrimitiveChunkReaderImpl {
635 private ShortChunkReaderImpl() {
636 super("Short");
637 }
638
639 @Override
640 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
641 String expression;
642 boolean skip = false;
643 long count = chunk.byteCount();
644
645 switch ((int) count) {
646 case 1:
647 expression = "(short) (in.readByte() & 0xff)";
648 break;
649 case -1:
650 case 2:
651 expression = "in.readShort()";
652 break;
653 default:
654 expression = "in.readShort()";
655 skip = true;
656 }
657
658 emitRead(builder, target, chunk, expression, skip, count - 2);
659 }
660 }
661
662 private static class ByteArrayChunkReaderImpl implements ChunkReader, ArrayChunkReader {
663 @Override
664 public void emitPrologue(MethodDef.Builder builder, String target, FieldChunk chunk) {
665 }
666
667 @Override
668 public void emitEpilogue(MethodDef.Builder builder, String target, FieldChunk chunk) {
669 }
670
671 @Override
672 public void emitRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
673 long count = chunk.byteCount();
674 if (count >= 0) {
675 builder.addStatement("$L$L = $T.readByteArray(in, $L)", target, chunk.name,
676 ChunkUtils.class, count);
677 } else {
678 builder.addStatement("$L$L = $T.readUnboundedByteArray(in, $L)", target,
679 chunk.name, ChunkUtils.class, chunk.bufferSize());
680 }
681 }
682
683 @Override
684 public void emitDynamicRead(MethodDef.Builder builder, String target, FieldChunk chunk) {
685 builder.addStatement("$L$L = $T.readByteArray(in, byteCount, $L)", target, chunk.name,
686 ChunkUtils.class, chunk.bufferSize());
687 }
688 }
689 }