]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * Copyright (C) 2011 Google Inc. | |
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.google.gson.internal.bind; | |
18 | ||
19 | import com.google.gson.FieldNamingStrategy; | |
20 | import com.google.gson.Gson; | |
21 | import com.google.gson.JsonSyntaxException; | |
22 | import com.google.gson.TypeAdapter; | |
23 | import com.google.gson.TypeAdapterFactory; | |
24 | import com.google.gson.annotations.SerializedName; | |
25 | import com.google.gson.internal.$Gson$Types; | |
26 | import com.google.gson.internal.ConstructorConstructor; | |
27 | import com.google.gson.internal.Excluder; | |
28 | import com.google.gson.internal.ObjectConstructor; | |
29 | import com.google.gson.internal.Primitives; | |
30 | import com.google.gson.reflect.TypeToken; | |
31 | import com.google.gson.stream.JsonReader; | |
32 | import com.google.gson.stream.JsonToken; | |
33 | import com.google.gson.stream.JsonWriter; | |
34 | import java.io.IOException; | |
35 | import java.lang.reflect.Field; | |
36 | import java.lang.reflect.Type; | |
37 | import java.util.LinkedHashMap; | |
38 | import java.util.Map; | |
39 | ||
40 | /** | |
41 | * Type adapter that reflects over the fields and methods of a class. | |
42 | */ | |
43 | public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory { | |
44 | private final ConstructorConstructor constructorConstructor; | |
45 | private final FieldNamingStrategy fieldNamingPolicy; | |
46 | private final Excluder excluder; | |
47 | ||
48 | public ReflectiveTypeAdapterFactory(ConstructorConstructor constructorConstructor, | |
49 | FieldNamingStrategy fieldNamingPolicy, Excluder excluder) { | |
50 | this.constructorConstructor = constructorConstructor; | |
51 | this.fieldNamingPolicy = fieldNamingPolicy; | |
52 | this.excluder = excluder; | |
53 | } | |
54 | ||
55 | public boolean excludeField(Field f, boolean serialize) { | |
56 | return !excluder.excludeClass(f.getType(), serialize) && !excluder.excludeField(f, serialize); | |
57 | } | |
58 | ||
59 | private String getFieldName(Field f) { | |
60 | SerializedName serializedName = f.getAnnotation(SerializedName.class); | |
61 | return serializedName == null ? fieldNamingPolicy.translateName(f) : serializedName.value(); | |
62 | } | |
63 | ||
64 | public <T> TypeAdapter<T> create(Gson gson, final TypeToken<T> type) { | |
65 | Class<? super T> raw = type.getRawType(); | |
66 | ||
67 | if (!Object.class.isAssignableFrom(raw)) { | |
68 | return null; // it's a primitive! | |
69 | } | |
70 | ||
71 | ObjectConstructor<T> constructor = constructorConstructor.get(type); | |
72 | return new Adapter<T>(constructor, getBoundFields(gson, type, raw)); | |
73 | } | |
74 | ||
75 | private ReflectiveTypeAdapterFactory.BoundField createBoundField( | |
76 | final Gson context, final Field field, final String name, | |
77 | final TypeToken<?> fieldType, boolean serialize, boolean deserialize) { | |
78 | final boolean isPrimitive = Primitives.isPrimitive(fieldType.getRawType()); | |
79 | ||
80 | // special casing primitives here saves ~5% on Android... | |
81 | return new ReflectiveTypeAdapterFactory.BoundField(name, serialize, deserialize) { | |
82 | final TypeAdapter<?> typeAdapter = context.getAdapter(fieldType); | |
83 | @SuppressWarnings({"unchecked", "rawtypes"}) // the type adapter and field type always agree | |
84 | @Override void write(JsonWriter writer, Object value) | |
85 | throws IOException, IllegalAccessException { | |
86 | Object fieldValue = field.get(value); | |
87 | TypeAdapter t = | |
88 | new TypeAdapterRuntimeTypeWrapper(context, this.typeAdapter, fieldType.getType()); | |
89 | t.write(writer, fieldValue); | |
90 | } | |
91 | @Override void read(JsonReader reader, Object value) | |
92 | throws IOException, IllegalAccessException { | |
93 | Object fieldValue = typeAdapter.read(reader); | |
94 | if (fieldValue != null || !isPrimitive) { | |
95 | field.set(value, fieldValue); | |
96 | } | |
97 | } | |
98 | }; | |
99 | } | |
100 | ||
101 | private Map<String, BoundField> getBoundFields(Gson context, TypeToken<?> type, Class<?> raw) { | |
102 | Map<String, BoundField> result = new LinkedHashMap<String, BoundField>(); | |
103 | if (raw.isInterface()) { | |
104 | return result; | |
105 | } | |
106 | ||
107 | Type declaredType = type.getType(); | |
108 | while (raw != Object.class) { | |
109 | Field[] fields = raw.getDeclaredFields(); | |
110 | for (Field field : fields) { | |
111 | boolean serialize = excludeField(field, true); | |
112 | boolean deserialize = excludeField(field, false); | |
113 | if (!serialize && !deserialize) { | |
114 | continue; | |
115 | } | |
116 | field.setAccessible(true); | |
117 | Type fieldType = $Gson$Types.resolve(type.getType(), raw, field.getGenericType()); | |
118 | BoundField boundField = createBoundField(context, field, getFieldName(field), | |
119 | TypeToken.get(fieldType), serialize, deserialize); | |
120 | BoundField previous = result.put(boundField.name, boundField); | |
121 | if (previous != null) { | |
122 | throw new IllegalArgumentException(declaredType | |
123 | + " declares multiple JSON fields named " + previous.name); | |
124 | } | |
125 | } | |
126 | type = TypeToken.get($Gson$Types.resolve(type.getType(), raw, raw.getGenericSuperclass())); | |
127 | raw = type.getRawType(); | |
128 | } | |
129 | return result; | |
130 | } | |
131 | ||
132 | static abstract class BoundField { | |
133 | final String name; | |
134 | final boolean serialized; | |
135 | final boolean deserialized; | |
136 | ||
137 | protected BoundField(String name, boolean serialized, boolean deserialized) { | |
138 | this.name = name; | |
139 | this.serialized = serialized; | |
140 | this.deserialized = deserialized; | |
141 | } | |
142 | ||
143 | abstract void write(JsonWriter writer, Object value) throws IOException, IllegalAccessException; | |
144 | abstract void read(JsonReader reader, Object value) throws IOException, IllegalAccessException; | |
145 | } | |
146 | ||
147 | public static final class Adapter<T> extends TypeAdapter<T> { | |
148 | private final ObjectConstructor<T> constructor; | |
149 | private final Map<String, BoundField> boundFields; | |
150 | ||
151 | private Adapter(ObjectConstructor<T> constructor, Map<String, BoundField> boundFields) { | |
152 | this.constructor = constructor; | |
153 | this.boundFields = boundFields; | |
154 | } | |
155 | ||
156 | @Override public T read(JsonReader in) throws IOException { | |
157 | if (in.peek() == JsonToken.NULL) { | |
158 | in.nextNull(); | |
159 | return null; | |
160 | } | |
161 | ||
162 | T instance = constructor.construct(); | |
163 | ||
164 | try { | |
165 | in.beginObject(); | |
166 | while (in.hasNext()) { | |
167 | String name = in.nextName(); | |
168 | BoundField field = boundFields.get(name); | |
169 | if (field == null || !field.deserialized) { | |
170 | in.skipValue(); | |
171 | } else { | |
172 | field.read(in, instance); | |
173 | } | |
174 | } | |
175 | } catch (IllegalStateException e) { | |
176 | throw new JsonSyntaxException(e); | |
177 | } catch (IllegalAccessException e) { | |
178 | throw new AssertionError(e); | |
179 | } | |
180 | in.endObject(); | |
181 | return instance; | |
182 | } | |
183 | ||
184 | @Override public void write(JsonWriter out, T value) throws IOException { | |
185 | if (value == null) { | |
186 | out.nullValue(); | |
187 | return; | |
188 | } | |
189 | ||
190 | out.beginObject(); | |
191 | try { | |
192 | for (BoundField boundField : boundFields.values()) { | |
193 | if (boundField.serialized) { | |
194 | out.name(boundField.name); | |
195 | boundField.write(out, value); | |
196 | } | |
197 | } | |
198 | } catch (IllegalAccessException e) { | |
199 | throw new AssertionError(); | |
200 | } | |
201 | out.endObject(); | |
202 | } | |
203 | } | |
204 | } |