+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/collect-library/src/main/assets/navi_speed_limit_gen.svg b/collect-library/src/main/assets/navi_speed_limit_gen.svg
new file mode 100644
index 00000000..e4de71a6
--- /dev/null
+++ b/collect-library/src/main/assets/navi_speed_limit_gen.svg
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/collect-library/src/main/assets/navtest.xml b/collect-library/src/main/assets/navtest.xml
new file mode 100644
index 00000000..f0fe475f
--- /dev/null
+++ b/collect-library/src/main/assets/navtest.xml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
diff --git a/collect-library/src/main/assets/oneway_left.svg b/collect-library/src/main/assets/oneway_left.svg
new file mode 100644
index 00000000..9acd8dbe
--- /dev/null
+++ b/collect-library/src/main/assets/oneway_left.svg
@@ -0,0 +1,11 @@
+
\ No newline at end of file
diff --git a/collect-library/src/main/assets/speed_gen_end.svg b/collect-library/src/main/assets/speed_gen_end.svg
new file mode 100644
index 00000000..12483478
--- /dev/null
+++ b/collect-library/src/main/assets/speed_gen_end.svg
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/collect-library/src/main/assets/speed_gen_start.svg b/collect-library/src/main/assets/speed_gen_start.svg
new file mode 100644
index 00000000..27859d11
--- /dev/null
+++ b/collect-library/src/main/assets/speed_gen_start.svg
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/collect-library/src/main/assets/tunnel_1.svg b/collect-library/src/main/assets/tunnel_1.svg
new file mode 100644
index 00000000..eb31bbe6
--- /dev/null
+++ b/collect-library/src/main/assets/tunnel_1.svg
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/collect-library/src/main/assets/tunnel_2.svg b/collect-library/src/main/assets/tunnel_2.svg
new file mode 100644
index 00000000..df17cf50
--- /dev/null
+++ b/collect-library/src/main/assets/tunnel_2.svg
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/collect-library/src/main/assets/tunnel_3.svg b/collect-library/src/main/assets/tunnel_3.svg
new file mode 100644
index 00000000..ce889964
--- /dev/null
+++ b/collect-library/src/main/assets/tunnel_3.svg
@@ -0,0 +1,2 @@
+
\ No newline at end of file
diff --git a/collect-library/src/main/java/com/google/gson/DefaultDateTypeAdapter.java b/collect-library/src/main/java/com/google/gson/DefaultDateTypeAdapter.java
new file mode 100644
index 00000000..2694a7e3
--- /dev/null
+++ b/collect-library/src/main/java/com/google/gson/DefaultDateTypeAdapter.java
@@ -0,0 +1,121 @@
+/*
+ * 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 java.lang.reflect.Type;
+import java.sql.Timestamp;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+
+/**
+ * This type adapter supports three subclasses of date: Date, Timestamp, and
+ * java.sql.Date.
+ *
+ * @author Inderjeet Singh
+ * @author Joel Leitch
+ */
+final class DefaultDateTypeAdapter implements JsonSerializer, JsonDeserializer {
+
+ // TODO: migrate to streaming adapter
+
+ private final DateFormat enUsFormat;
+ private final DateFormat localFormat;
+ private final DateFormat iso8601Format;
+
+ DefaultDateTypeAdapter() {
+ this(DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT, Locale.US),
+ DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT));
+ }
+
+ DefaultDateTypeAdapter(String datePattern) {
+ this(new SimpleDateFormat(datePattern, Locale.US), new SimpleDateFormat(datePattern));
+ }
+
+ DefaultDateTypeAdapter(int style) {
+ this(DateFormat.getDateInstance(style, Locale.US), DateFormat.getDateInstance(style));
+ }
+
+ public DefaultDateTypeAdapter(int dateStyle, int timeStyle) {
+ this(DateFormat.getDateTimeInstance(dateStyle, timeStyle, Locale.US),
+ DateFormat.getDateTimeInstance(dateStyle, timeStyle));
+ }
+
+ DefaultDateTypeAdapter(DateFormat enUsFormat, DateFormat localFormat) {
+ this.enUsFormat = enUsFormat;
+ this.localFormat = localFormat;
+ this.iso8601Format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US);
+ this.iso8601Format.setTimeZone(TimeZone.getTimeZone("UTC"));
+ }
+
+ // These methods need to be synchronized since JDK DateFormat classes are not thread-safe
+ // See issue 162
+ @Override
+public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
+ synchronized (localFormat) {
+ String dateFormatAsString = enUsFormat.format(src);
+ return new JsonPrimitive(dateFormatAsString);
+ }
+ }
+
+ @Override
+public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
+ throws JsonParseException {
+ if (!(json instanceof JsonPrimitive)) {
+ throw new JsonParseException("The date should be a string value");
+ }
+ Date date = deserializeToDate(json);
+ if (typeOfT == Date.class) {
+ return date;
+ } else if (typeOfT == Timestamp.class) {
+ return new Timestamp(date.getTime());
+ } else if (typeOfT == java.sql.Date.class) {
+ return new java.sql.Date(date.getTime());
+ } else {
+ throw new IllegalArgumentException(getClass() + " cannot deserialize to " + typeOfT);
+ }
+ }
+
+ private Date deserializeToDate(JsonElement json) {
+ synchronized (localFormat) {
+ try {
+ return localFormat.parse(json.getAsString());
+ } catch (ParseException ignored) {
+ }
+ try {
+ return enUsFormat.parse(json.getAsString());
+ } catch (ParseException ignored) {
+ }
+ try {
+ return iso8601Format.parse(json.getAsString());
+ } catch (ParseException e) {
+ throw new JsonSyntaxException(json.getAsString(), e);
+ }
+ }
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append(DefaultDateTypeAdapter.class.getSimpleName());
+ sb.append('(').append(localFormat.getClass().getSimpleName()).append(')');
+ return sb.toString();
+ }
+}
diff --git a/collect-library/src/main/java/com/google/gson/ExclusionStrategy.java b/collect-library/src/main/java/com/google/gson/ExclusionStrategy.java
new file mode 100644
index 00000000..08fafedf
--- /dev/null
+++ b/collect-library/src/main/java/com/google/gson/ExclusionStrategy.java
@@ -0,0 +1,109 @@
+/*
+ * 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;
+
+/**
+ * A strategy (or policy) definition that is used to decide whether or not a field or top-level
+ * class should be serialized or deserialized as part of the JSON output/input. For serialization,
+ * if the {@link #shouldSkipClass(Class)} method returns false then that class or field type
+ * will not be part of the JSON output. For deserialization, if {@link #shouldSkipClass(Class)}
+ * returns false, then it will not be set as part of the Java object structure.
+ *
+ *
The following are a few examples that shows how you can use this exclusion mechanism.
+ *
+ *
Exclude fields and objects based on a particular class type:
+ *
Excludes fields and objects based on a particular annotation:
+ *
+ * public @interface FooAnnotation {
+ * // some implementation here
+ * }
+ *
+ * // Excludes any field (or class) that is tagged with an "@FooAnnotation"
+ * private static class FooAnnotationExclusionStrategy implements ExclusionStrategy {
+ * public boolean shouldSkipClass(Class<?> clazz) {
+ * return clazz.getAnnotation(FooAnnotation.class) != null;
+ * }
+ *
+ * public boolean shouldSkipField(FieldAttributes f) {
+ * return f.getAnnotation(FooAnnotation.class) != null;
+ * }
+ * }
+ *
+ *
+ *
Now if you want to configure {@code Gson} to use a user defined exclusion strategy, then
+ * the {@code GsonBuilder} is required. The following is an example of how you can use the
+ * {@code GsonBuilder} to configure Gson to use one of the above sample:
+ *
For certain model classes, you may only want to serialize a field, but exclude it for
+ * deserialization. To do that, you can write an {@code ExclusionStrategy} as per normal;
+ * however, you would register it with the
+ * {@link GsonBuilder#addDeserializationExclusionStrategy(ExclusionStrategy)} method.
+ * For example:
+ *
+ *
+ * @author Inderjeet Singh
+ * @author Joel Leitch
+ *
+ * @see GsonBuilder#setExclusionStrategies(ExclusionStrategy...)
+ * @see GsonBuilder#addDeserializationExclusionStrategy(ExclusionStrategy)
+ * @see GsonBuilder#addSerializationExclusionStrategy(ExclusionStrategy)
+ *
+ * @since 1.4
+ */
+public interface ExclusionStrategy {
+
+ /**
+ * @param f the field object that is under test
+ * @return true if the field should be ignored; otherwise false
+ */
+ public boolean shouldSkipField(FieldAttributes f);
+
+ /**
+ * @param clazz the class object that is under test
+ * @return true if the class should be ignored; otherwise false
+ */
+ public boolean shouldSkipClass(Class clazz);
+}
diff --git a/collect-library/src/main/java/com/google/gson/FieldAttributes.java b/collect-library/src/main/java/com/google/gson/FieldAttributes.java
new file mode 100644
index 00000000..cb89ff11
--- /dev/null
+++ b/collect-library/src/main/java/com/google/gson/FieldAttributes.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2009 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.$Gson$Preconditions;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.Type;
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * A data object that stores attributes of a field.
+ *
+ *
This class is immutable; therefore, it can be safely shared across threads.
+ *
+ * @author Inderjeet Singh
+ * @author Joel Leitch
+ *
+ * @since 1.4
+ */
+public final class FieldAttributes {
+ private final Field field;
+
+ /**
+ * Constructs a Field Attributes object from the {@code f}.
+ *
+ * @param f the field to pull attributes from
+ */
+ public FieldAttributes(Field f) {
+ $Gson$Preconditions.checkNotNull(f);
+ this.field = f;
+ }
+
+ /**
+ * @return the declaring class that contains this field
+ */
+ public Class getDeclaringClass() {
+ return field.getDeclaringClass();
+ }
+
+ /**
+ * @return the name of the field
+ */
+ public String getName() {
+ return field.getName();
+ }
+
+ /**
+ *
For example, assume the following class definition:
+ *
+ * public class Foo {
+ * private String bar;
+ * private List<String> red;
+ * }
+ *
+ * Type listParmeterizedType = new TypeToken<List<String>>() {}.getType();
+ *
+ *
+ *
This method would return {@code String.class} for the {@code bar} field and
+ * {@code listParameterizedType} for the {@code red} field.
+ *
+ * @return the specific type declared for this field
+ */
+ public Type getDeclaredType() {
+ return field.getGenericType();
+ }
+
+ /**
+ * Returns the {@code Class} object that was declared for this field.
+ *
+ *
For example, assume the following class definition:
+ *
This method would return {@code String.class} for the {@code bar} field and
+ * {@code List.class} for the {@code red} field.
+ *
+ * @return the specific class object that was declared for the field
+ */
+ public Class getDeclaredClass() {
+ return field.getType();
+ }
+
+ /**
+ * Return the {@code T} annotation object from this field if it exist; otherwise returns
+ * {@code null}.
+ *
+ * @param annotation the class of the annotation that will be retrieved
+ * @return the annotation instance if it is bound to the field; otherwise {@code null}
+ */
+ public T getAnnotation(Class annotation) {
+ return field.getAnnotation(annotation);
+ }
+
+ /**
+ * Return the annotations that are present on this field.
+ *
+ * @return an array of all the annotations set on the field
+ * @since 1.4
+ */
+ public Collection getAnnotations() {
+ return Arrays.asList(field.getAnnotations());
+ }
+
+ /**
+ * Returns {@code true} if the field is defined with the {@code modifier}.
+ *
+ *
+ *
+ * @see java.lang.reflect.Modifier
+ */
+ public boolean hasModifier(int modifier) {
+ return (field.getModifiers() & modifier) != 0;
+ }
+
+ /**
+ * This is exposed internally only for the removing synthetic fields from the JSON output.
+ *
+ * @return true if the field is synthetic; otherwise false
+ * @throws IllegalAccessException
+ * @throws IllegalArgumentException
+ */
+ Object get(Object instance) throws IllegalAccessException {
+ return field.get(instance);
+ }
+
+ /**
+ * This is exposed internally only for the removing synthetic fields from the JSON output.
+ *
+ * @return true if the field is synthetic; otherwise false
+ */
+ boolean isSynthetic() {
+ return field.isSynthetic();
+ }
+}
diff --git a/collect-library/src/main/java/com/google/gson/FieldNamingPolicy.java b/collect-library/src/main/java/com/google/gson/FieldNamingPolicy.java
new file mode 100644
index 00000000..56fc28d6
--- /dev/null
+++ b/collect-library/src/main/java/com/google/gson/FieldNamingPolicy.java
@@ -0,0 +1,173 @@
+/*
+ * 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 java.lang.reflect.Field;
+
+/**
+ * An enumeration that defines a few standard naming conventions for JSON field names.
+ * This enumeration should be used in conjunction with {@link com.google.gson.GsonBuilder}
+ * to configure a {@link com.google.gson.Gson} instance to properly translate Java field
+ * names into the desired JSON field names.
+ *
+ * @author Inderjeet Singh
+ * @author Joel Leitch
+ */
+public enum FieldNamingPolicy implements FieldNamingStrategy {
+
+ /**
+ * Using this naming policy with Gson will ensure that the field name is
+ * unchanged.
+ */
+ IDENTITY() {
+ @Override
+ public String translateName(Field f) {
+ return f.getName();
+ }
+ },
+
+ /**
+ * Using this naming policy with Gson will ensure that the first "letter" of the Java
+ * field name is capitalized when serialized to its JSON form.
+ *
+ *
Here's a few examples of the form "Java Field Name" ---> "JSON Field Name":
+ *
+ *
someFieldName ---> SomeFieldName
+ *
_someFieldName ---> _SomeFieldName
+ *
+ */
+ UPPER_CAMEL_CASE() {
+ @Override
+ public String translateName(Field f) {
+ return upperCaseFirstLetter(f.getName());
+ }
+ },
+
+ /**
+ * Using this naming policy with Gson will ensure that the first "letter" of the Java
+ * field name is capitalized when serialized to its JSON form and the words will be
+ * separated by a space.
+ *
+ *
Here's a few examples of the form "Java Field Name" ---> "JSON Field Name":
+ *
+ *
someFieldName ---> Some Field Name
+ *
_someFieldName ---> _Some Field Name
+ *
+ *
+ * @since 1.4
+ */
+ UPPER_CAMEL_CASE_WITH_SPACES() {
+ @Override
+ public String translateName(Field f) {
+ return upperCaseFirstLetter(separateCamelCase(f.getName(), " "));
+ }
+ },
+
+ /**
+ * Using this naming policy with Gson will modify the Java Field name from its camel cased
+ * form to a lower case field name where each word is separated by an underscore (_).
+ *
+ *
Here's a few examples of the form "Java Field Name" ---> "JSON Field Name":
+ *
+ *
someFieldName ---> some_field_name
+ *
_someFieldName ---> _some_field_name
+ *
aStringField ---> a_string_field
+ *
aURL ---> a_u_r_l
+ *
+ */
+ LOWER_CASE_WITH_UNDERSCORES() {
+ @Override
+ public String translateName(Field f) {
+ return separateCamelCase(f.getName(), "_").toLowerCase();
+ }
+ },
+
+ /**
+ * Using this naming policy with Gson will modify the Java Field name from its camel cased
+ * form to a lower case field name where each word is separated by a dash (-).
+ *
+ *
Here's a few examples of the form "Java Field Name" ---> "JSON Field Name":
+ *
+ *
someFieldName ---> some-field-name
+ *
_someFieldName ---> _some-field-name
+ *
aStringField ---> a-string-field
+ *
aURL ---> a-u-r-l
+ *
+ * Using dashes in JavaScript is not recommended since dash is also used for a minus sign in
+ * expressions. This requires that a field named with dashes is always accessed as a quoted
+ * property like {@code myobject['my-field']}. Accessing it as an object field
+ * {@code myobject.my-field} will result in an unintended javascript expression.
+ * @since 1.4
+ */
+ LOWER_CASE_WITH_DASHES() {
+ @Override
+ public String translateName(Field f) {
+ return separateCamelCase(f.getName(), "-").toLowerCase();
+ }
+ };
+
+ /**
+ * Converts the field name that uses camel-case define word separation into
+ * separate words that are separated by the provided {@code separatorString}.
+ */
+ private static String separateCamelCase(String name, String separator) {
+ StringBuilder translation = new StringBuilder();
+ for (int i = 0; i < name.length(); i++) {
+ char character = name.charAt(i);
+ if (Character.isUpperCase(character) && translation.length() != 0) {
+ translation.append(separator);
+ }
+ translation.append(character);
+ }
+ return translation.toString();
+ }
+
+ /**
+ * Ensures the JSON field names begins with an upper case letter.
+ */
+ private static String upperCaseFirstLetter(String name) {
+ StringBuilder fieldNameBuilder = new StringBuilder();
+ int index = 0;
+ char firstCharacter = name.charAt(index);
+
+ while (index < name.length() - 1) {
+ if (Character.isLetter(firstCharacter)) {
+ break;
+ }
+
+ fieldNameBuilder.append(firstCharacter);
+ firstCharacter = name.charAt(++index);
+ }
+
+ if (index == name.length()) {
+ return fieldNameBuilder.toString();
+ }
+
+ if (!Character.isUpperCase(firstCharacter)) {
+ String modifiedTarget = modifyString(Character.toUpperCase(firstCharacter), name, ++index);
+ return fieldNameBuilder.append(modifiedTarget).toString();
+ } else {
+ return name;
+ }
+ }
+
+ private static String modifyString(char firstCharacter, String srcString, int indexOfSubstring) {
+ return (indexOfSubstring < srcString.length())
+ ? firstCharacter + srcString.substring(indexOfSubstring)
+ : String.valueOf(firstCharacter);
+ }
+}
\ No newline at end of file
diff --git a/collect-library/src/main/java/com/google/gson/FieldNamingStrategy.java b/collect-library/src/main/java/com/google/gson/FieldNamingStrategy.java
new file mode 100644
index 00000000..9be453ad
--- /dev/null
+++ b/collect-library/src/main/java/com/google/gson/FieldNamingStrategy.java
@@ -0,0 +1,40 @@
+/*
+ * 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 java.lang.reflect.Field;
+
+/**
+ * A mechanism for providing custom field naming in Gson. This allows the client code to translate
+ * field names into a particular convention that is not supported as a normal Java field
+ * declaration rules. For example, Java does not support "-" characters in a field name.
+ *
+ * @author Inderjeet Singh
+ * @author Joel Leitch
+ * @since 1.3
+ */
+public interface FieldNamingStrategy {
+
+ /**
+ * Translates the field name into its JSON field name representation.
+ *
+ * @param f the field object that we are translating
+ * @return the translated field name.
+ * @since 1.3
+ */
+ public String translateName(Field f);
+}
diff --git a/collect-library/src/main/java/com/google/gson/Gson.java b/collect-library/src/main/java/com/google/gson/Gson.java
new file mode 100644
index 00000000..b80d6c53
--- /dev/null
+++ b/collect-library/src/main/java/com/google/gson/Gson.java
@@ -0,0 +1,947 @@
+/*
+ * 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 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;
+
+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;
+
+/**
+ * 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.
+ *
+ *
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.
+ *
+ *
Here is an example of how Gson is used for a simple Class:
+ *
+ *
+ * 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
+ *
+ *
+ *
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}:
+ *
+ *
See the Gson User Guide
+ * for a more complete set of examples.
+ *
+ * @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, FutureTypeAdapter>> calls
+ = new ThreadLocal, FutureTypeAdapter>>();
+
+ private final Map, TypeAdapter> typeTokenCache
+ = Collections.synchronizedMap(new HashMap, TypeAdapter>());
+
+ /** Indicates whether Gson is in the phase of constructor invocation. It is used to determine
+ * whether to add a constructor in preconfiguredGeneratedTypeAdapter set or not. */
+ private boolean inConstructorPhase = true;
+ /** List of type adapters that are generated by Gson during its constructor */
+ private Set> preconfiguredGeneratedTypeAdapters = new HashSet>();
+ /** List of type adapters that are generated by Gson during toJson/fromJson. */
+ private final ThreadLocal>> runtimeGeneratedTypeAdapters =
+ new ThreadLocal>>();
+
+ private final List 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() {
+ @Override
+ @SuppressWarnings("unchecked")
+ public T deserialize(JsonElement json, Type typeOfT) throws JsonParseException {
+ return (T) fromJson(json, typeOfT);
+ }
+ };
+
+ final JsonSerializationContext serializationContext = new JsonSerializationContext() {
+ @Override
+ public JsonElement serialize(Object src) {
+ return toJsonTree(src);
+ }
+ @Override
+ 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:
+ *
+ *
The JSON generated by toJson methods is in compact representation. This
+ * means that all the unneeded white-space is removed. You can change this behavior with
+ * {@link GsonBuilder#setPrettyPrinting()}.
+ *
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()}.
+ *
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)}.
+ *
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)}.
+ *
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()}.
+ *
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)}.
+ *
The default field naming policy for the output Json is same as in Java. So, a Java class
+ * field versionNumber will be output as "versionNumber" 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)}.
+ *
By default, Gson excludes transient or static fields from
+ * consideration for serialization and deserialization. You can change this behavior through
+ * {@link GsonBuilder#excludeFieldsWithModifiers(int...)}.
+ *
+ */
+ public Gson() {
+ this(Excluder.DEFAULT, FieldNamingPolicy.IDENTITY,
+ Collections.>emptyMap(), false, false, DEFAULT_JSON_NON_EXECUTABLE,
+ true, false, false, LongSerializationPolicy.DEFAULT,
+ Collections.emptyList());
+ }
+
+ Gson(final Excluder excluder, final FieldNamingStrategy fieldNamingPolicy,
+ final Map> instanceCreators, boolean serializeNulls,
+ boolean complexMapKeySerialization, boolean generateNonExecutableGson, boolean htmlSafe,
+ boolean prettyPrinting, boolean serializeSpecialFloatingPointValues,
+ LongSerializationPolicy longSerializationPolicy,
+ List typeAdapterFactories) {
+ this.constructorConstructor = new ConstructorConstructor(instanceCreators);
+ this.serializeNulls = serializeNulls;
+ this.generateNonExecutableJson = generateNonExecutableGson;
+ this.htmlSafe = htmlSafe;
+ this.prettyPrinting = prettyPrinting;
+
+ List factories = new ArrayList();
+
+ // 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);
+ this.preconfiguredGeneratedTypeAdapters = Collections.unmodifiableSet(preconfiguredGeneratedTypeAdapters);
+ inConstructorPhase = false;
+ }
+
+ private TypeAdapter doubleAdapter(boolean serializeSpecialFloatingPointValues) {
+ if (serializeSpecialFloatingPointValues) {
+ return TypeAdapters.DOUBLE;
+ }
+ return new TypeAdapter() {
+ @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 floatAdapter(boolean serializeSpecialFloatingPointValues) {
+ if (serializeSpecialFloatingPointValues) {
+ return TypeAdapters.FLOAT;
+ }
+ return new TypeAdapter() {
+ @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 longAdapter(LongSerializationPolicy longSerializationPolicy) {
+ if (longSerializationPolicy == LongSerializationPolicy.DEFAULT) {
+ return TypeAdapters.LONG;
+ }
+ return new TypeAdapter() {
+ @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 TypeAdapter getAdapter(TypeToken type) {
+ TypeAdapter cached = typeTokenCache.get(type);
+ if (cached != null) {
+ return (TypeAdapter) cached;
+ }
+
+ Map, FutureTypeAdapter> threadCalls = calls.get();
+ boolean requiresThreadLocalCleanup = false;
+ if (threadCalls == null) {
+ threadCalls = new HashMap, FutureTypeAdapter>();
+ calls.set(threadCalls);
+ requiresThreadLocalCleanup = true;
+ }
+
+ // the key and value type parameters always agree
+ FutureTypeAdapter ongoingCall = (FutureTypeAdapter) threadCalls.get(type);
+ if (ongoingCall != null) {
+ return ongoingCall;
+ }
+
+ try {
+ FutureTypeAdapter call = new FutureTypeAdapter();
+ threadCalls.put(type, call);
+
+ for (TypeAdapterFactory factory : factories) {
+ TypeAdapter 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:
+ *
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 getDelegateAdapter method:
+ *
{@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);
+ * }
+ * };
+ * }
+ * }
+ * }
+ * 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 this (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 TypeAdapter getDelegateAdapter(TypeAdapterFactory skipPast, TypeToken type) {
+ boolean skipPastFound = false;
+
+ for (TypeAdapterFactory factory : factories) {
+ if (!skipPastFound) {
+ if (factory == skipPast) {
+ skipPastFound = true;
+ }
+ continue;
+ }
+
+ TypeAdapter 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 TypeAdapter getAdapter(Class 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}, you should use:
+ *
+ * Type typeOfSrc = new TypeToken<Collection<Foo>>(){}.getType();
+ *
+ * @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}, you should use:
+ *
+ * Type typeOfSrc = new TypeToken<Collection<Foo>>(){}.getType();
+ *
+ * @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}, you should use:
+ *
+ * Type typeOfSrc = new TypeToken<Collection<Foo>>(){}.getType();
+ *
+ * @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();
+// Log.i("json", oldSerializeNulls+"==============");
+ writer.setSerializeNulls(true);//齐济修改，生成key值，value为空也生成
+ try {
+ ((TypeAdapter