| /* |
| * Copyright (C) 2008 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.google.gson; |
| |
| import com.google.gson.internal.ConstructorConstructor; |
| import com.google.gson.internal.Excluder; |
| import com.google.gson.internal.Primitives; |
| import com.google.gson.internal.Streams; |
| import com.google.gson.internal.bind.ArrayTypeAdapter; |
| import com.google.gson.internal.bind.CollectionTypeAdapterFactory; |
| import com.google.gson.internal.bind.DateTypeAdapter; |
| import com.google.gson.internal.bind.JsonAdapterAnnotationTypeAdapterFactory; |
| import com.google.gson.internal.bind.JsonTreeReader; |
| import com.google.gson.internal.bind.JsonTreeWriter; |
| import com.google.gson.internal.bind.MapTypeAdapterFactory; |
| import com.google.gson.internal.bind.ObjectTypeAdapter; |
| import com.google.gson.internal.bind.ReflectiveTypeAdapterFactory; |
| import com.google.gson.internal.bind.SqlDateTypeAdapter; |
| import com.google.gson.internal.bind.TimeTypeAdapter; |
| import com.google.gson.internal.bind.TypeAdapters; |
| import com.google.gson.reflect.TypeToken; |
| import com.google.gson.stream.JsonReader; |
| import com.google.gson.stream.JsonToken; |
| import com.google.gson.stream.JsonWriter; |
| import com.google.gson.stream.MalformedJsonException; |
| import java.io.EOFException; |
| import java.io.IOException; |
| import java.io.Reader; |
| import java.io.StringReader; |
| import java.io.StringWriter; |
| import java.io.Writer; |
| import java.lang.reflect.Type; |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * This is the main class for using Gson. Gson is typically used by first constructing a |
| * Gson instance and then invoking {@link #toJson(Object)} or {@link #fromJson(String, Class)} |
| * methods on it. |
| * |
| * <p>You can create a Gson instance by invoking {@code new Gson()} if the default configuration |
| * is all you need. You can also use {@link GsonBuilder} to build a Gson instance with various |
| * configuration options such as versioning support, pretty printing, custom |
| * {@link JsonSerializer}s, {@link JsonDeserializer}s, and {@link InstanceCreator}s.</p> |
| * |
| * <p>Here is an example of how Gson is used for a simple Class: |
| * |
| * <pre> |
| * Gson gson = new Gson(); // Or use new GsonBuilder().create(); |
| * MyType target = new MyType(); |
| * String json = gson.toJson(target); // serializes target to Json |
| * MyType target2 = gson.fromJson(json, MyType.class); // deserializes json into target2 |
| * </pre></p> |
| * |
| * <p>If the object that your are serializing/deserializing is a {@code ParameterizedType} |
| * (i.e. contains at least one type parameter and may be an array) then you must use the |
| * {@link #toJson(Object, Type)} or {@link #fromJson(String, Type)} method. Here is an |
| * example for serializing and deserialing a {@code ParameterizedType}: |
| * |
| * <pre> |
| * Type listType = new TypeToken<List<String>>() {}.getType(); |
| * List<String> target = new LinkedList<String>(); |
| * target.add("blah"); |
| * |
| * Gson gson = new Gson(); |
| * String json = gson.toJson(target, listType); |
| * List<String> target2 = gson.fromJson(json, listType); |
| * </pre></p> |
| * |
| * <p>See the <a href="https://sites.google.com/site/gson/gson-user-guide">Gson User Guide</a> |
| * for a more complete set of examples.</p> |
| * |
| * @see com.google.gson.reflect.TypeToken |
| * |
| * @author Inderjeet Singh |
| * @author Joel Leitch |
| * @author Jesse Wilson |
| */ |
| public final class Gson { |
| static final boolean DEFAULT_JSON_NON_EXECUTABLE = false; |
| |
| private static final String JSON_NON_EXECUTABLE_PREFIX = ")]}'\n"; |
| |
| /** |
| * This thread local guards against reentrant calls to getAdapter(). In |
| * certain object graphs, creating an adapter for a type may recursively |
| * require an adapter for the same type! Without intervention, the recursive |
| * lookup would stack overflow. We cheat by returning a proxy type adapter. |
| * The proxy is wired up once the initial adapter has been created. |
| */ |
| private final ThreadLocal<Map<TypeToken<?>, FutureTypeAdapter<?>>> calls |
| = new ThreadLocal<Map<TypeToken<?>, FutureTypeAdapter<?>>>(); |
| |
| private final Map<TypeToken<?>, TypeAdapter<?>> typeTokenCache |
| = Collections.synchronizedMap(new HashMap<TypeToken<?>, TypeAdapter<?>>()); |
| |
| private final List<TypeAdapterFactory> factories; |
| private final ConstructorConstructor constructorConstructor; |
| |
| private final boolean serializeNulls; |
| private final boolean htmlSafe; |
| private final boolean generateNonExecutableJson; |
| private final boolean prettyPrinting; |
| |
| final JsonDeserializationContext deserializationContext = new JsonDeserializationContext() { |
| @SuppressWarnings("unchecked") |
| public <T> T deserialize(JsonElement json, Type typeOfT) throws JsonParseException { |
| return (T) fromJson(json, typeOfT); |
| } |
| }; |
| |
| final JsonSerializationContext serializationContext = new JsonSerializationContext() { |
| public JsonElement serialize(Object src) { |
| return toJsonTree(src); |
| } |
| public JsonElement serialize(Object src, Type typeOfSrc) { |
| return toJsonTree(src, typeOfSrc); |
| } |
| }; |
| |
| /** |
| * Constructs a Gson object with default configuration. The default configuration has the |
| * following settings: |
| * <ul> |
| * <li>The JSON generated by <code>toJson</code> methods is in compact representation. This |
| * means that all the unneeded white-space is removed. You can change this behavior with |
| * {@link GsonBuilder#setPrettyPrinting()}. </li> |
| * <li>The generated JSON omits all the fields that are null. Note that nulls in arrays are |
| * kept as is since an array is an ordered list. Moreover, if a field is not null, but its |
| * generated JSON is empty, the field is kept. You can configure Gson to serialize null values |
| * by setting {@link GsonBuilder#serializeNulls()}.</li> |
| * <li>Gson provides default serialization and deserialization for Enums, {@link Map}, |
| * {@link java.net.URL}, {@link java.net.URI}, {@link java.util.Locale}, {@link java.util.Date}, |
| * {@link java.math.BigDecimal}, and {@link java.math.BigInteger} classes. If you would prefer |
| * to change the default representation, you can do so by registering a type adapter through |
| * {@link GsonBuilder#registerTypeAdapter(Type, Object)}. </li> |
| * <li>The default Date format is same as {@link java.text.DateFormat#DEFAULT}. This format |
| * ignores the millisecond portion of the date during serialization. You can change |
| * this by invoking {@link GsonBuilder#setDateFormat(int)} or |
| * {@link GsonBuilder#setDateFormat(String)}. </li> |
| * <li>By default, Gson ignores the {@link com.google.gson.annotations.Expose} annotation. |
| * You can enable Gson to serialize/deserialize only those fields marked with this annotation |
| * through {@link GsonBuilder#excludeFieldsWithoutExposeAnnotation()}. </li> |
| * <li>By default, Gson ignores the {@link com.google.gson.annotations.Since} annotation. You |
| * can enable Gson to use this annotation through {@link GsonBuilder#setVersion(double)}.</li> |
| * <li>The default field naming policy for the output Json is same as in Java. So, a Java class |
| * field <code>versionNumber</code> will be output as <code>"versionNumber@quot;</code> in |
| * Json. The same rules are applied for mapping incoming Json to the Java classes. You can |
| * change this policy through {@link GsonBuilder#setFieldNamingPolicy(FieldNamingPolicy)}.</li> |
| * <li>By default, Gson excludes <code>transient</code> or <code>static</code> fields from |
| * consideration for serialization and deserialization. You can change this behavior through |
| * {@link GsonBuilder#excludeFieldsWithModifiers(int...)}.</li> |
| * </ul> |
| */ |
| public Gson() { |
| this(Excluder.DEFAULT, FieldNamingPolicy.IDENTITY, |
| Collections.<Type, InstanceCreator<?>>emptyMap(), false, false, DEFAULT_JSON_NON_EXECUTABLE, |
| true, false, false, LongSerializationPolicy.DEFAULT, |
| Collections.<TypeAdapterFactory>emptyList()); |
| } |
| |
| Gson(final Excluder excluder, final FieldNamingStrategy fieldNamingPolicy, |
| final Map<Type, InstanceCreator<?>> instanceCreators, boolean serializeNulls, |
| boolean complexMapKeySerialization, boolean generateNonExecutableGson, boolean htmlSafe, |
| boolean prettyPrinting, boolean serializeSpecialFloatingPointValues, |
| LongSerializationPolicy longSerializationPolicy, |
| List<TypeAdapterFactory> typeAdapterFactories) { |
| this.constructorConstructor = new ConstructorConstructor(instanceCreators); |
| this.serializeNulls = serializeNulls; |
| this.generateNonExecutableJson = generateNonExecutableGson; |
| this.htmlSafe = htmlSafe; |
| this.prettyPrinting = prettyPrinting; |
| |
| List<TypeAdapterFactory> factories = new ArrayList<TypeAdapterFactory>(); |
| |
| // built-in type adapters that cannot be overridden |
| factories.add(TypeAdapters.JSON_ELEMENT_FACTORY); |
| factories.add(ObjectTypeAdapter.FACTORY); |
| |
| // the excluder must precede all adapters that handle user-defined types |
| factories.add(excluder); |
| |
| // user's type adapters |
| factories.addAll(typeAdapterFactories); |
| |
| // type adapters for basic platform types |
| factories.add(TypeAdapters.STRING_FACTORY); |
| factories.add(TypeAdapters.INTEGER_FACTORY); |
| factories.add(TypeAdapters.BOOLEAN_FACTORY); |
| factories.add(TypeAdapters.BYTE_FACTORY); |
| factories.add(TypeAdapters.SHORT_FACTORY); |
| factories.add(TypeAdapters.newFactory(long.class, Long.class, |
| longAdapter(longSerializationPolicy))); |
| factories.add(TypeAdapters.newFactory(double.class, Double.class, |
| doubleAdapter(serializeSpecialFloatingPointValues))); |
| factories.add(TypeAdapters.newFactory(float.class, Float.class, |
| floatAdapter(serializeSpecialFloatingPointValues))); |
| factories.add(TypeAdapters.NUMBER_FACTORY); |
| factories.add(TypeAdapters.CHARACTER_FACTORY); |
| factories.add(TypeAdapters.STRING_BUILDER_FACTORY); |
| factories.add(TypeAdapters.STRING_BUFFER_FACTORY); |
| factories.add(TypeAdapters.newFactory(BigDecimal.class, TypeAdapters.BIG_DECIMAL)); |
| factories.add(TypeAdapters.newFactory(BigInteger.class, TypeAdapters.BIG_INTEGER)); |
| factories.add(TypeAdapters.URL_FACTORY); |
| factories.add(TypeAdapters.URI_FACTORY); |
| factories.add(TypeAdapters.UUID_FACTORY); |
| factories.add(TypeAdapters.LOCALE_FACTORY); |
| factories.add(TypeAdapters.INET_ADDRESS_FACTORY); |
| factories.add(TypeAdapters.BIT_SET_FACTORY); |
| factories.add(DateTypeAdapter.FACTORY); |
| factories.add(TypeAdapters.CALENDAR_FACTORY); |
| factories.add(TimeTypeAdapter.FACTORY); |
| factories.add(SqlDateTypeAdapter.FACTORY); |
| factories.add(TypeAdapters.TIMESTAMP_FACTORY); |
| factories.add(ArrayTypeAdapter.FACTORY); |
| factories.add(TypeAdapters.ENUM_FACTORY); |
| factories.add(TypeAdapters.CLASS_FACTORY); |
| |
| // type adapters for composite and user-defined types |
| factories.add(new CollectionTypeAdapterFactory(constructorConstructor)); |
| factories.add(new MapTypeAdapterFactory(constructorConstructor, complexMapKeySerialization)); |
| factories.add(new JsonAdapterAnnotationTypeAdapterFactory(constructorConstructor)); |
| factories.add(new ReflectiveTypeAdapterFactory( |
| constructorConstructor, fieldNamingPolicy, excluder)); |
| |
| this.factories = Collections.unmodifiableList(factories); |
| } |
| |
| private TypeAdapter<Number> doubleAdapter(boolean serializeSpecialFloatingPointValues) { |
| if (serializeSpecialFloatingPointValues) { |
| return TypeAdapters.DOUBLE; |
| } |
| return new TypeAdapter<Number>() { |
| @Override public Double read(JsonReader in) throws IOException { |
| if (in.peek() == JsonToken.NULL) { |
| in.nextNull(); |
| return null; |
| } |
| return in.nextDouble(); |
| } |
| @Override public void write(JsonWriter out, Number value) throws IOException { |
| if (value == null) { |
| out.nullValue(); |
| return; |
| } |
| double doubleValue = value.doubleValue(); |
| checkValidFloatingPoint(doubleValue); |
| out.value(value); |
| } |
| }; |
| } |
| |
| private TypeAdapter<Number> floatAdapter(boolean serializeSpecialFloatingPointValues) { |
| if (serializeSpecialFloatingPointValues) { |
| return TypeAdapters.FLOAT; |
| } |
| return new TypeAdapter<Number>() { |
| @Override public Float read(JsonReader in) throws IOException { |
| if (in.peek() == JsonToken.NULL) { |
| in.nextNull(); |
| return null; |
| } |
| return (float) in.nextDouble(); |
| } |
| @Override public void write(JsonWriter out, Number value) throws IOException { |
| if (value == null) { |
| out.nullValue(); |
| return; |
| } |
| float floatValue = value.floatValue(); |
| checkValidFloatingPoint(floatValue); |
| out.value(value); |
| } |
| }; |
| } |
| |
| private void checkValidFloatingPoint(double value) { |
| if (Double.isNaN(value) || Double.isInfinite(value)) { |
| throw new IllegalArgumentException(value |
| + " is not a valid double value as per JSON specification. To override this" |
| + " behavior, use GsonBuilder.serializeSpecialFloatingPointValues() method."); |
| } |
| } |
| |
| private TypeAdapter<Number> longAdapter(LongSerializationPolicy longSerializationPolicy) { |
| if (longSerializationPolicy == LongSerializationPolicy.DEFAULT) { |
| return TypeAdapters.LONG; |
| } |
| return new TypeAdapter<Number>() { |
| @Override public Number read(JsonReader in) throws IOException { |
| if (in.peek() == JsonToken.NULL) { |
| in.nextNull(); |
| return null; |
| } |
| return in.nextLong(); |
| } |
| @Override public void write(JsonWriter out, Number value) throws IOException { |
| if (value == null) { |
| out.nullValue(); |
| return; |
| } |
| out.value(value.toString()); |
| } |
| }; |
| } |
| |
| /** |
| * Returns the type adapter for {@code} type. |
| * |
| * @throws IllegalArgumentException if this GSON cannot serialize and |
| * deserialize {@code type}. |
| */ |
| @SuppressWarnings("unchecked") |
| public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) { |
| TypeAdapter<?> cached = typeTokenCache.get(type); |
| if (cached != null) { |
| return (TypeAdapter<T>) cached; |
| } |
| |
| Map<TypeToken<?>, FutureTypeAdapter<?>> threadCalls = calls.get(); |
| boolean requiresThreadLocalCleanup = false; |
| if (threadCalls == null) { |
| threadCalls = new HashMap<TypeToken<?>, FutureTypeAdapter<?>>(); |
| calls.set(threadCalls); |
| requiresThreadLocalCleanup = true; |
| } |
| |
| // the key and value type parameters always agree |
| FutureTypeAdapter<T> ongoingCall = (FutureTypeAdapter<T>) threadCalls.get(type); |
| if (ongoingCall != null) { |
| return ongoingCall; |
| } |
| |
| try { |
| FutureTypeAdapter<T> call = new FutureTypeAdapter<T>(); |
| threadCalls.put(type, call); |
| |
| for (TypeAdapterFactory factory : factories) { |
| TypeAdapter<T> candidate = factory.create(this, type); |
| if (candidate != null) { |
| call.setDelegate(candidate); |
| typeTokenCache.put(type, candidate); |
| return candidate; |
| } |
| } |
| throw new IllegalArgumentException("GSON cannot handle " + type); |
| } finally { |
| threadCalls.remove(type); |
| |
| if (requiresThreadLocalCleanup) { |
| calls.remove(); |
| } |
| } |
| } |
| |
| /** |
| * This method is used to get an alternate type adapter for the specified type. This is used |
| * to access a type adapter that is overridden by a {@link TypeAdapterFactory} that you |
| * may have registered. This features is typically used when you want to register a type |
| * adapter that does a little bit of work but then delegates further processing to the Gson |
| * default type adapter. Here is an example: |
| * <p>Let's say we want to write a type adapter that counts the number of objects being read |
| * from or written to JSON. We can achieve this by writing a type adapter factory that uses |
| * the <code>getDelegateAdapter</code> method: |
| * <pre> {@code |
| * class StatsTypeAdapterFactory implements TypeAdapterFactory { |
| * public int numReads = 0; |
| * public int numWrites = 0; |
| * public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) { |
| * final TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type); |
| * return new TypeAdapter<T>() { |
| * public void write(JsonWriter out, T value) throws IOException { |
| * ++numWrites; |
| * delegate.write(out, value); |
| * } |
| * public T read(JsonReader in) throws IOException { |
| * ++numReads; |
| * return delegate.read(in); |
| * } |
| * }; |
| * } |
| * } |
| * } </pre> |
| * This factory can now be used like this: |
| * <pre> {@code |
| * StatsTypeAdapterFactory stats = new StatsTypeAdapterFactory(); |
| * Gson gson = new GsonBuilder().registerTypeAdapterFactory(stats).create(); |
| * // Call gson.toJson() and fromJson methods on objects |
| * System.out.println("Num JSON reads" + stats.numReads); |
| * System.out.println("Num JSON writes" + stats.numWrites); |
| * }</pre> |
| * Note that since you can not override type adapter factories for String and Java primitive |
| * types, our stats factory will not count the number of String or primitives that will be |
| * read or written. |
| * @param skipPast The type adapter factory that needs to be skipped while searching for |
| * a matching type adapter. In most cases, you should just pass <i>this</i> (the type adapter |
| * factory from where {@link #getDelegateAdapter} method is being invoked). |
| * @param type Type for which the delegate adapter is being searched for. |
| * |
| * @since 2.2 |
| */ |
| public <T> TypeAdapter<T> getDelegateAdapter(TypeAdapterFactory skipPast, TypeToken<T> type) { |
| boolean skipPastFound = false; |
| |
| for (TypeAdapterFactory factory : factories) { |
| if (!skipPastFound) { |
| if (factory == skipPast) { |
| skipPastFound = true; |
| } |
| continue; |
| } |
| |
| TypeAdapter<T> candidate = factory.create(this, type); |
| if (candidate != null) { |
| return candidate; |
| } |
| } |
| throw new IllegalArgumentException("GSON cannot serialize " + type); |
| } |
| |
| /** |
| * Returns the type adapter for {@code} type. |
| * |
| * @throws IllegalArgumentException if this GSON cannot serialize and |
| * deserialize {@code type}. |
| */ |
| public <T> TypeAdapter<T> getAdapter(Class<T> type) { |
| return getAdapter(TypeToken.get(type)); |
| } |
| |
| /** |
| * This method serializes the specified object into its equivalent representation as a tree of |
| * {@link JsonElement}s. This method should be used when the specified object is not a generic |
| * type. This method uses {@link Class#getClass()} to get the type for the specified object, but |
| * the {@code getClass()} loses the generic type information because of the Type Erasure feature |
| * of Java. Note that this method works fine if the any of the object fields are of generic type, |
| * just the object itself should not be of a generic type. If the object is of generic type, use |
| * {@link #toJsonTree(Object, Type)} instead. |
| * |
| * @param src the object for which Json representation is to be created setting for Gson |
| * @return Json representation of {@code src}. |
| * @since 1.4 |
| */ |
| public JsonElement toJsonTree(Object src) { |
| if (src == null) { |
| return JsonNull.INSTANCE; |
| } |
| return toJsonTree(src, src.getClass()); |
| } |
| |
| /** |
| * This method serializes the specified object, including those of generic types, into its |
| * equivalent representation as a tree of {@link JsonElement}s. This method must be used if the |
| * specified object is a generic type. For non-generic objects, use {@link #toJsonTree(Object)} |
| * instead. |
| * |
| * @param src the object for which JSON representation is to be created |
| * @param typeOfSrc The specific genericized type of src. You can obtain |
| * this type by using the {@link com.google.gson.reflect.TypeToken} class. For example, |
| * to get the type for {@code Collection<Foo>}, you should use: |
| * <pre> |
| * Type typeOfSrc = new TypeToken<Collection<Foo>>(){}.getType(); |
| * </pre> |
| * @return Json representation of {@code src} |
| * @since 1.4 |
| */ |
| public JsonElement toJsonTree(Object src, Type typeOfSrc) { |
| JsonTreeWriter writer = new JsonTreeWriter(); |
| toJson(src, typeOfSrc, writer); |
| return writer.get(); |
| } |
| |
| /** |
| * This method serializes the specified object into its equivalent Json representation. |
| * This method should be used when the specified object is not a generic type. This method uses |
| * {@link Class#getClass()} to get the type for the specified object, but the |
| * {@code getClass()} loses the generic type information because of the Type Erasure feature |
| * of Java. Note that this method works fine if the any of the object fields are of generic type, |
| * just the object itself should not be of a generic type. If the object is of generic type, use |
| * {@link #toJson(Object, Type)} instead. If you want to write out the object to a |
| * {@link Writer}, use {@link #toJson(Object, Appendable)} instead. |
| * |
| * @param src the object for which Json representation is to be created setting for Gson |
| * @return Json representation of {@code src}. |
| */ |
| public String toJson(Object src) { |
| if (src == null) { |
| return toJson(JsonNull.INSTANCE); |
| } |
| return toJson(src, src.getClass()); |
| } |
| |
| /** |
| * This method serializes the specified object, including those of generic types, into its |
| * equivalent Json representation. This method must be used if the specified object is a generic |
| * type. For non-generic objects, use {@link #toJson(Object)} instead. If you want to write out |
| * the object to a {@link Appendable}, use {@link #toJson(Object, Type, Appendable)} instead. |
| * |
| * @param src the object for which JSON representation is to be created |
| * @param typeOfSrc The specific genericized type of src. You can obtain |
| * this type by using the {@link com.google.gson.reflect.TypeToken} class. For example, |
| * to get the type for {@code Collection<Foo>}, you should use: |
| * <pre> |
| * Type typeOfSrc = new TypeToken<Collection<Foo>>(){}.getType(); |
| * </pre> |
| * @return Json representation of {@code src} |
| */ |
| public String toJson(Object src, Type typeOfSrc) { |
| StringWriter writer = new StringWriter(); |
| toJson(src, typeOfSrc, writer); |
| return writer.toString(); |
| } |
| |
| /** |
| * This method serializes the specified object into its equivalent Json representation. |
| * This method should be used when the specified object is not a generic type. This method uses |
| * {@link Class#getClass()} to get the type for the specified object, but the |
| * {@code getClass()} loses the generic type information because of the Type Erasure feature |
| * of Java. Note that this method works fine if the any of the object fields are of generic type, |
| * just the object itself should not be of a generic type. If the object is of generic type, use |
| * {@link #toJson(Object, Type, Appendable)} instead. |
| * |
| * @param src the object for which Json representation is to be created setting for Gson |
| * @param writer Writer to which the Json representation needs to be written |
| * @throws JsonIOException if there was a problem writing to the writer |
| * @since 1.2 |
| */ |
| public void toJson(Object src, Appendable writer) throws JsonIOException { |
| if (src != null) { |
| toJson(src, src.getClass(), writer); |
| } else { |
| toJson(JsonNull.INSTANCE, writer); |
| } |
| } |
| |
| /** |
| * This method serializes the specified object, including those of generic types, into its |
| * equivalent Json representation. This method must be used if the specified object is a generic |
| * type. For non-generic objects, use {@link #toJson(Object, Appendable)} instead. |
| * |
| * @param src the object for which JSON representation is to be created |
| * @param typeOfSrc The specific genericized type of src. You can obtain |
| * this type by using the {@link com.google.gson.reflect.TypeToken} class. For example, |
| * to get the type for {@code Collection<Foo>}, you should use: |
| * <pre> |
| * Type typeOfSrc = new TypeToken<Collection<Foo>>(){}.getType(); |
| * </pre> |
| * @param writer Writer to which the Json representation of src needs to be written. |
| * @throws JsonIOException if there was a problem writing to the writer |
| * @since 1.2 |
| */ |
| public void toJson(Object src, Type typeOfSrc, Appendable writer) throws JsonIOException { |
| try { |
| JsonWriter jsonWriter = newJsonWriter(Streams.writerForAppendable(writer)); |
| toJson(src, typeOfSrc, jsonWriter); |
| } catch (IOException e) { |
| throw new JsonIOException(e); |
| } |
| } |
| |
| /** |
| * Writes the JSON representation of {@code src} of type {@code typeOfSrc} to |
| * {@code writer}. |
| * @throws JsonIOException if there was a problem writing to the writer |
| */ |
| @SuppressWarnings("unchecked") |
| public void toJson(Object src, Type typeOfSrc, JsonWriter writer) throws JsonIOException { |
| TypeAdapter<?> adapter = getAdapter(TypeToken.get(typeOfSrc)); |
| boolean oldLenient = writer.isLenient(); |
| writer.setLenient(true); |
| boolean oldHtmlSafe = writer.isHtmlSafe(); |
| writer.setHtmlSafe(htmlSafe); |
| boolean oldSerializeNulls = writer.getSerializeNulls(); |
| writer.setSerializeNulls(serializeNulls); |
| try { |
| ((TypeAdapter<Object>) adapter).write(writer, src); |
| } catch (IOException e) { |
| throw new JsonIOException(e); |
| } finally { |
| writer.setLenient(oldLenient); |
| writer.setHtmlSafe(oldHtmlSafe); |
| writer.setSerializeNulls(oldSerializeNulls); |
| } |
| } |
| |
| /** |
| * Converts a tree of {@link JsonElement}s into its equivalent JSON representation. |
| * |
| * @param jsonElement root of a tree of {@link JsonElement}s |
| * @return JSON String representation of the tree |
| * @since 1.4 |
| */ |
| public String toJson(JsonElement jsonElement) { |
| StringWriter writer = new StringWriter(); |
| toJson(jsonElement, writer); |
| return writer.toString(); |
| } |
| |
| /** |
| * Writes out the equivalent JSON for a tree of {@link JsonElement}s. |
| * |
| * @param jsonElement root of a tree of {@link JsonElement}s |
| * @param writer Writer to which the Json representation needs to be written |
| * @throws JsonIOException if there was a problem writing to the writer |
| * @since 1.4 |
| */ |
| public void toJson(JsonElement jsonElement, Appendable writer) throws JsonIOException { |
| try { |
| JsonWriter jsonWriter = newJsonWriter(Streams.writerForAppendable(writer)); |
| toJson(jsonElement, jsonWriter); |
| } catch (IOException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| /** |
| * Returns a new JSON writer configured for this GSON and with the non-execute |
| * prefix if that is configured. |
| */ |
| private JsonWriter newJsonWriter(Writer writer) throws IOException { |
| if (generateNonExecutableJson) { |
| writer.write(JSON_NON_EXECUTABLE_PREFIX); |
| } |
| JsonWriter jsonWriter = new JsonWriter(writer); |
| if (prettyPrinting) { |
| jsonWriter.setIndent(" "); |
| } |
| jsonWriter.setSerializeNulls(serializeNulls); |
| return jsonWriter; |
| } |
| |
| /** |
| * Writes the JSON for {@code jsonElement} to {@code writer}. |
| * @throws JsonIOException if there was a problem writing to the writer |
| */ |
| public void toJson(JsonElement jsonElement, JsonWriter writer) throws JsonIOException { |
| boolean oldLenient = writer.isLenient(); |
| writer.setLenient(true); |
| boolean oldHtmlSafe = writer.isHtmlSafe(); |
| writer.setHtmlSafe(htmlSafe); |
| boolean oldSerializeNulls = writer.getSerializeNulls(); |
| writer.setSerializeNulls(serializeNulls); |
| try { |
| Streams.write(jsonElement, writer); |
| } catch (IOException e) { |
| throw new JsonIOException(e); |
| } finally { |
| writer.setLenient(oldLenient); |
| writer.setHtmlSafe(oldHtmlSafe); |
| writer.setSerializeNulls(oldSerializeNulls); |
| } |
| } |
| |
| /** |
| * This method deserializes the specified Json into an object of the specified class. It is not |
| * suitable to use if the specified class is a generic type since it will not have the generic |
| * type information because of the Type Erasure feature of Java. Therefore, this method should not |
| * be used if the desired type is a generic type. Note that this method works fine if the any of |
| * the fields of the specified object are generics, just the object itself should not be a |
| * generic type. For the cases when the object is of generic type, invoke |
| * {@link #fromJson(String, Type)}. If you have the Json in a {@link Reader} instead of |
| * a String, use {@link #fromJson(Reader, Class)} instead. |
| * |
| * @param <T> the type of the desired object |
| * @param json the string from which the object is to be deserialized |
| * @param classOfT the class of T |
| * @return an object of type T from the string |
| * @throws JsonSyntaxException if json is not a valid representation for an object of type |
| * classOfT |
| */ |
| public <T> T fromJson(String json, Class<T> classOfT) throws JsonSyntaxException { |
| Object object = fromJson(json, (Type) classOfT); |
| return Primitives.wrap(classOfT).cast(object); |
| } |
| |
| /** |
| * This method deserializes the specified Json into an object of the specified type. This method |
| * is useful if the specified object is a generic type. For non-generic objects, use |
| * {@link #fromJson(String, Class)} instead. If you have the Json in a {@link Reader} instead of |
| * a String, use {@link #fromJson(Reader, Type)} instead. |
| * |
| * @param <T> the type of the desired object |
| * @param json the string from which the object is to be deserialized |
| * @param typeOfT The specific genericized type of src. You can obtain this type by using the |
| * {@link com.google.gson.reflect.TypeToken} class. For example, to get the type for |
| * {@code Collection<Foo>}, you should use: |
| * <pre> |
| * Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType(); |
| * </pre> |
| * @return an object of type T from the string |
| * @throws JsonParseException if json is not a valid representation for an object of type typeOfT |
| * @throws JsonSyntaxException if json is not a valid representation for an object of type |
| */ |
| @SuppressWarnings("unchecked") |
| public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException { |
| if (json == null) { |
| return null; |
| } |
| StringReader reader = new StringReader(json); |
| T target = (T) fromJson(reader, typeOfT); |
| return target; |
| } |
| |
| /** |
| * This method deserializes the Json read from the specified reader into an object of the |
| * specified class. It is not suitable to use if the specified class is a generic type since it |
| * will not have the generic type information because of the Type Erasure feature of Java. |
| * Therefore, this method should not be used if the desired type is a generic type. Note that |
| * this method works fine if the any of the fields of the specified object are generics, just the |
| * object itself should not be a generic type. For the cases when the object is of generic type, |
| * invoke {@link #fromJson(Reader, Type)}. If you have the Json in a String form instead of a |
| * {@link Reader}, use {@link #fromJson(String, Class)} instead. |
| * |
| * @param <T> the type of the desired object |
| * @param json the reader producing the Json from which the object is to be deserialized. |
| * @param classOfT the class of T |
| * @return an object of type T from the string |
| * @throws JsonIOException if there was a problem reading from the Reader |
| * @throws JsonSyntaxException if json is not a valid representation for an object of type |
| * @since 1.2 |
| */ |
| public <T> T fromJson(Reader json, Class<T> classOfT) throws JsonSyntaxException, JsonIOException { |
| JsonReader jsonReader = new JsonReader(json); |
| Object object = fromJson(jsonReader, classOfT); |
| assertFullConsumption(object, jsonReader); |
| return Primitives.wrap(classOfT).cast(object); |
| } |
| |
| /** |
| * This method deserializes the Json read from the specified reader into an object of the |
| * specified type. This method is useful if the specified object is a generic type. For |
| * non-generic objects, use {@link #fromJson(Reader, Class)} instead. If you have the Json in a |
| * String form instead of a {@link Reader}, use {@link #fromJson(String, Type)} instead. |
| * |
| * @param <T> the type of the desired object |
| * @param json the reader producing Json from which the object is to be deserialized |
| * @param typeOfT The specific genericized type of src. You can obtain this type by using the |
| * {@link com.google.gson.reflect.TypeToken} class. For example, to get the type for |
| * {@code Collection<Foo>}, you should use: |
| * <pre> |
| * Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType(); |
| * </pre> |
| * @return an object of type T from the json |
| * @throws JsonIOException if there was a problem reading from the Reader |
| * @throws JsonSyntaxException if json is not a valid representation for an object of type |
| * @since 1.2 |
| */ |
| @SuppressWarnings("unchecked") |
| public <T> T fromJson(Reader json, Type typeOfT) throws JsonIOException, JsonSyntaxException { |
| JsonReader jsonReader = new JsonReader(json); |
| T object = (T) fromJson(jsonReader, typeOfT); |
| assertFullConsumption(object, jsonReader); |
| return object; |
| } |
| |
| private static void assertFullConsumption(Object obj, JsonReader reader) { |
| try { |
| if (obj != null && reader.peek() != JsonToken.END_DOCUMENT) { |
| throw new JsonIOException("JSON document was not fully consumed."); |
| } |
| } catch (MalformedJsonException e) { |
| throw new JsonSyntaxException(e); |
| } catch (IOException e) { |
| throw new JsonIOException(e); |
| } |
| } |
| |
| /** |
| * Reads the next JSON value from {@code reader} and convert it to an object |
| * of type {@code typeOfT}. |
| * Since Type is not parameterized by T, this method is type unsafe and should be used carefully |
| * |
| * @throws JsonIOException if there was a problem writing to the Reader |
| * @throws JsonSyntaxException if json is not a valid representation for an object of type |
| */ |
| @SuppressWarnings("unchecked") |
| public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException { |
| boolean isEmpty = true; |
| boolean oldLenient = reader.isLenient(); |
| reader.setLenient(true); |
| try { |
| reader.peek(); |
| isEmpty = false; |
| TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(typeOfT); |
| TypeAdapter<T> typeAdapter = getAdapter(typeToken); |
| T object = typeAdapter.read(reader); |
| return object; |
| } catch (EOFException e) { |
| /* |
| * For compatibility with JSON 1.5 and earlier, we return null for empty |
| * documents instead of throwing. |
| */ |
| if (isEmpty) { |
| return null; |
| } |
| throw new JsonSyntaxException(e); |
| } catch (IllegalStateException e) { |
| throw new JsonSyntaxException(e); |
| } catch (IOException e) { |
| // TODO(inder): Figure out whether it is indeed right to rethrow this as JsonSyntaxException |
| throw new JsonSyntaxException(e); |
| } finally { |
| reader.setLenient(oldLenient); |
| } |
| } |
| |
| /** |
| * This method deserializes the Json read from the specified parse tree into an object of the |
| * specified type. It is not suitable to use if the specified class is a generic type since it |
| * will not have the generic type information because of the Type Erasure feature of Java. |
| * Therefore, this method should not be used if the desired type is a generic type. Note that |
| * this method works fine if the any of the fields of the specified object are generics, just the |
| * object itself should not be a generic type. For the cases when the object is of generic type, |
| * invoke {@link #fromJson(JsonElement, Type)}. |
| * @param <T> the type of the desired object |
| * @param json the root of the parse tree of {@link JsonElement}s from which the object is to |
| * be deserialized |
| * @param classOfT The class of T |
| * @return an object of type T from the json |
| * @throws JsonSyntaxException if json is not a valid representation for an object of type typeOfT |
| * @since 1.3 |
| */ |
| public <T> T fromJson(JsonElement json, Class<T> classOfT) throws JsonSyntaxException { |
| Object object = fromJson(json, (Type) classOfT); |
| return Primitives.wrap(classOfT).cast(object); |
| } |
| |
| /** |
| * This method deserializes the Json read from the specified parse tree into an object of the |
| * specified type. This method is useful if the specified object is a generic type. For |
| * non-generic objects, use {@link #fromJson(JsonElement, Class)} instead. |
| * |
| * @param <T> the type of the desired object |
| * @param json the root of the parse tree of {@link JsonElement}s from which the object is to |
| * be deserialized |
| * @param typeOfT The specific genericized type of src. You can obtain this type by using the |
| * {@link com.google.gson.reflect.TypeToken} class. For example, to get the type for |
| * {@code Collection<Foo>}, you should use: |
| * <pre> |
| * Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType(); |
| * </pre> |
| * @return an object of type T from the json |
| * @throws JsonSyntaxException if json is not a valid representation for an object of type typeOfT |
| * @since 1.3 |
| */ |
| @SuppressWarnings("unchecked") |
| public <T> T fromJson(JsonElement json, Type typeOfT) throws JsonSyntaxException { |
| if (json == null) { |
| return null; |
| } |
| return (T) fromJson(new JsonTreeReader(json), typeOfT); |
| } |
| |
| static class FutureTypeAdapter<T> extends TypeAdapter<T> { |
| private TypeAdapter<T> delegate; |
| |
| public void setDelegate(TypeAdapter<T> typeAdapter) { |
| if (delegate != null) { |
| throw new AssertionError(); |
| } |
| delegate = typeAdapter; |
| } |
| |
| @Override public T read(JsonReader in) throws IOException { |
| if (delegate == null) { |
| throw new IllegalStateException(); |
| } |
| return delegate.read(in); |
| } |
| |
| @Override public void write(JsonWriter out, T value) throws IOException { |
| if (delegate == null) { |
| throw new IllegalStateException(); |
| } |
| delegate.write(out, value); |
| } |
| } |
| |
| @Override |
| public String toString() { |
| return new StringBuilder("{serializeNulls:") |
| .append(serializeNulls) |
| .append("factories:").append(factories) |
| .append(",instanceCreators:").append(constructorConstructor) |
| .append("}") |
| .toString(); |
| } |
| |
| private final Set<TypeAdapter<?>> generatedTypeAdapters = new HashSet<TypeAdapter<?>>(); |
| public static final class $$Internal { |
| public static void addGeneratedTypeAdapter(Gson gson, TypeAdapter<?> typeAdapter) { |
| gson.generatedTypeAdapters.add(typeAdapter); |
| } |
| public static boolean isGeneratedTypeAdapter(Gson gson, TypeAdapter<?> typeAdapter) { |
| return gson.generatedTypeAdapters.contains(typeAdapter); |
| } |
| } |
| } |