|
13 | 13 | public class TypeSerializerFactory {
|
14 | 14 |
|
15 | 15 | public static List<TypeSerializer> createTypeSerializers(java.util.List<ValueParameterDescriptor> fields) {
|
16 |
| - List<TypeSerializer> typeSerializers = new ArrayList<>(); |
| 16 | + List<TypeSerializer> typeSerializers = new ArrayList<TypeSerializer>(); |
17 | 17 | for(ValueParameterDescriptor field : fields) {
|
18 | 18 | KotlinType type = field.getType();
|
19 | 19 | String typeName = type.toString();
|
20 | 20 |
|
21 |
| - switch (typeName) { |
22 |
| - case "String": |
23 |
| - case "Byte": |
24 |
| - case "Double": |
25 |
| - case "Float": |
26 |
| - case "Int": |
27 |
| - case "Long": |
28 |
| - typeSerializers.add(new NormalSerializer(field)); |
29 |
| - break; |
30 |
| - |
31 |
| - case "Boolean": |
32 |
| - typeSerializers.add(new BooleanSerializer(field)); |
33 |
| - break; |
34 |
| - |
35 |
| - case "Char": |
36 |
| - typeSerializers.add(new CharSerializer(field)); |
37 |
| - break; |
38 |
| - |
39 |
| - case "List<String>": |
40 |
| - case "ArrayList<String>": |
41 |
| - case "MutableList<String>": |
42 |
| - typeSerializers.add(new StringListSerializer(field)); |
43 |
| - break; |
44 |
| - |
45 |
| - case "Array<String>": |
46 |
| - case "ByteArray": |
47 |
| - case "DoubleArray": |
48 |
| - case "FloatArray": |
49 |
| - case "IntArray": |
50 |
| - case "LongArray": |
51 |
| - case "CharArray": |
52 |
| - case "BooleanArray": |
53 |
| - typeSerializers.add(new OriginalArraySerializer(field)); |
54 |
| - break; |
55 |
| - |
56 |
| - case "Array<Byte>": |
57 |
| - case "Array<Double>": |
58 |
| - case "Array<Float>": |
59 |
| - case "Array<Int>": |
60 |
| - case "Array<Long>": |
61 |
| - case "Array<Char>": |
62 |
| - case "Array<Boolean>": |
63 |
| - typeSerializers.add(new NormalArraySerializer(field)); |
64 |
| - break; |
65 |
| - |
66 |
| - default: |
67 |
| - Collection<KotlinType> supertypes; |
68 |
| - |
69 |
| - // Check if type is List or Array |
70 |
| - if(typeName.startsWith("List") || typeName.startsWith("ArrayList") || typeName.startsWith("MutableList")) { |
71 |
| - KotlinType typeProjectionType = type.getArguments().get(0).getType(); |
72 |
| - |
73 |
| - Boolean isParcelable = false; |
74 |
| - supertypes = typeProjectionType.getConstructor().getSupertypes(); |
75 |
| - for(KotlinType supertype : supertypes) { |
76 |
| - String supertypeName = supertype.toString(); |
77 |
| - if(supertypeName.equals("Parcelable")) { |
78 |
| - typeSerializers.add(new ParcelableListSerializer(field)); |
79 |
| - isParcelable = true; |
80 |
| - break; |
81 |
| - } |
| 21 | + if (typeName.equals("String") || typeName.equals("Byte") || typeName.equals("Double") || |
| 22 | + typeName.equals("Float") || typeName.equals("Int") || typeName.equals("Long")) { |
| 23 | + typeSerializers.add(new NormalSerializer(field)); |
| 24 | + |
| 25 | + } else if (typeName.equals("Boolean")) { |
| 26 | + typeSerializers.add(new BooleanSerializer(field)); |
| 27 | + |
| 28 | + } else if (typeName.equals("Char")) { |
| 29 | + typeSerializers.add(new CharSerializer(field)); |
| 30 | + |
| 31 | + } else if (typeName.equals("List<String>") || typeName.equals("ArrayList<String>") || |
| 32 | + typeName.equals("MutableList<String>")) { |
| 33 | + typeSerializers.add(new StringListSerializer(field)); |
| 34 | + |
| 35 | + } else if (typeName.equals("Array<String>") || typeName.equals("ByteArray") || typeName.equals("DoubleArray") || |
| 36 | + typeName.equals("FloatArray") || typeName.equals("IntArray") || typeName.equals("LongArray") || |
| 37 | + typeName.equals("CharArray") || typeName.equals("BooleanArray")) { |
| 38 | + typeSerializers.add(new OriginalArraySerializer(field)); |
| 39 | + |
| 40 | + } else if (typeName.equals("Array<Byte>") || typeName.equals("Array<Double>") || typeName.equals("Array<Float>") || |
| 41 | + typeName.equals("Array<Int>") || typeName.equals("Array<Long>") || typeName.equals("Array<Char>") || |
| 42 | + typeName.equals("Array<Boolean>")) { |
| 43 | + typeSerializers.add(new NormalArraySerializer(field)); |
| 44 | + |
| 45 | + } else { |
| 46 | + Collection<KotlinType> supertypes; |
| 47 | + |
| 48 | + // Check if type is List or Array |
| 49 | + if(typeName.startsWith("List") || typeName.startsWith("ArrayList") || typeName.startsWith("MutableList")) { |
| 50 | + KotlinType typeProjectionType = type.getArguments().get(0).getType(); |
| 51 | + |
| 52 | + Boolean isParcelable = false; |
| 53 | + supertypes = typeProjectionType.getConstructor().getSupertypes(); |
| 54 | + for(KotlinType supertype : supertypes) { |
| 55 | + String supertypeName = supertype.toString(); |
| 56 | + if(supertypeName.equals("Parcelable")) { |
| 57 | + typeSerializers.add(new ParcelableListSerializer(field)); |
| 58 | + isParcelable = true; |
| 59 | + break; |
82 | 60 | }
|
| 61 | + } |
83 | 62 |
|
84 |
| - if(!isParcelable) { |
85 |
| - typeSerializers.add(new NormalListSerializer(field)); |
86 |
| - } |
| 63 | + if(!isParcelable) { |
| 64 | + typeSerializers.add(new NormalListSerializer(field)); |
| 65 | + } |
87 | 66 |
|
88 | 67 |
|
89 |
| - } else if(typeName.startsWith("Array")) { |
90 |
| - KotlinType typeProjectionType = type.getArguments().get(0).getType(); |
| 68 | + } else if(typeName.startsWith("Array")) { |
| 69 | + KotlinType typeProjectionType = type.getArguments().get(0).getType(); |
91 | 70 |
|
92 |
| - boolean found = false; |
93 |
| - supertypes = typeProjectionType.getConstructor().getSupertypes(); |
94 |
| - for(KotlinType supertype : supertypes) { |
95 |
| - String supertypeName = supertype.toString(); |
96 |
| - if(supertypeName.equals("Parcelable")) { |
97 |
| - typeSerializers.add(new ParcelableArraySerializer(field)); |
98 |
| - found = true; |
99 |
| - break; |
100 |
| - } |
| 71 | + boolean found = false; |
| 72 | + supertypes = typeProjectionType.getConstructor().getSupertypes(); |
| 73 | + for(KotlinType supertype : supertypes) { |
| 74 | + String supertypeName = supertype.toString(); |
| 75 | + if(supertypeName.equals("Parcelable")) { |
| 76 | + typeSerializers.add(new ParcelableArraySerializer(field)); |
| 77 | + found = true; |
| 78 | + break; |
101 | 79 | }
|
| 80 | + } |
102 | 81 |
|
103 |
| - // Not found |
104 |
| - if(!found) { |
105 |
| - typeSerializers.add(new NormalSerializer(field)); |
106 |
| - } |
| 82 | + // Not found |
| 83 | + if(!found) { |
| 84 | + typeSerializers.add(new NormalSerializer(field)); |
| 85 | + } |
107 | 86 |
|
108 | 87 |
|
109 |
| - } else { |
110 |
| - // Check if supertype is Parcelable or Serializable |
111 |
| - boolean found = false; |
112 |
| - supertypes = type.getConstructor().getSupertypes(); |
113 |
| - for(KotlinType supertype : supertypes) { |
114 |
| - String supertypeName = supertype.toString(); |
115 |
| - if(supertypeName.equals("Parcelable")) { |
116 |
| - typeSerializers.add(new ParcelableObjectSerializer(field)); |
117 |
| - found = true; |
118 |
| - break; |
119 |
| - |
120 |
| - } else if(supertypeName.equals("Serializable")) { |
121 |
| - typeSerializers.add(new SerializableObjectSerializer(field)); |
122 |
| - found = true; |
123 |
| - break; |
124 |
| - } |
| 88 | + } else { |
| 89 | + // Check if supertype is Parcelable or Serializable |
| 90 | + boolean found = false; |
| 91 | + supertypes = type.getConstructor().getSupertypes(); |
| 92 | + for(KotlinType supertype : supertypes) { |
| 93 | + String supertypeName = supertype.toString(); |
| 94 | + if(supertypeName.equals("Parcelable")) { |
| 95 | + typeSerializers.add(new ParcelableObjectSerializer(field)); |
| 96 | + found = true; |
| 97 | + break; |
| 98 | + |
| 99 | + } else if(supertypeName.equals("Serializable")) { |
| 100 | + typeSerializers.add(new SerializableObjectSerializer(field)); |
| 101 | + found = true; |
| 102 | + break; |
125 | 103 | }
|
| 104 | + } |
126 | 105 |
|
127 |
| - // Not found |
128 |
| - if(!found) { |
129 |
| - typeSerializers.add(new NormalSerializer(field)); |
130 |
| - } |
| 106 | + // Not found |
| 107 | + if(!found) { |
| 108 | + typeSerializers.add(new NormalSerializer(field)); |
131 | 109 | }
|
| 110 | + } |
132 | 111 | }
|
133 | 112 | }
|
134 | 113 | return typeSerializers;
|
|
0 commit comments