rta = RuntimeTypeAdapterFactory.of(
BillingInstrument.class);
rta.registerSubtype(CreditCard.class, "CC");
try {
rta.registerSubtype(BankTransfer.class, "CC");
fail();
} catch (IllegalArgumentException expected) {
}
}
public void testDeserializeMissingTypeField() {
TypeAdapterFactory billingAdapter = RuntimeTypeAdapterFactory.of(BillingInstrument.class)
.registerSubtype(CreditCard.class);
Gson gson = new GsonBuilder()
.registerTypeAdapterFactory(billingAdapter)
.create();
try {
gson.fromJson("{ownerName:'Jesse'}", BillingInstrument.class);
fail();
} catch (JsonParseException expected) {
}
}
public void testDeserializeMissingSubtype() {
TypeAdapterFactory billingAdapter = RuntimeTypeAdapterFactory.of(BillingInstrument.class)
.registerSubtype(BankTransfer.class);
Gson gson = new GsonBuilder()
.registerTypeAdapterFactory(billingAdapter)
.create();
try {
gson.fromJson("{type:'CreditCard',ownerName:'Jesse'}", BillingInstrument.class);
fail();
} catch (JsonParseException expected) {
}
}
public void testSerializeMissingSubtype() {
TypeAdapterFactory billingAdapter = RuntimeTypeAdapterFactory.of(BillingInstrument.class)
.registerSubtype(BankTransfer.class);
Gson gson = new GsonBuilder()
.registerTypeAdapterFactory(billingAdapter)
.create();
try {
gson.toJson(new CreditCard("Jesse", 456), BillingInstrument.class);
fail();
} catch (JsonParseException expected) {
}
}
public void testSerializeCollidingTypeFieldName() {
TypeAdapterFactory billingAdapter = RuntimeTypeAdapterFactory.of(BillingInstrument.class, "cvv")
.registerSubtype(CreditCard.class);
Gson gson = new GsonBuilder()
.registerTypeAdapterFactory(billingAdapter)
.create();
try {
gson.toJson(new CreditCard("Jesse", 456), BillingInstrument.class);
fail();
} catch (JsonParseException expected) {
}
}
public void testSerializeWrappedNullValue() {
TypeAdapterFactory billingAdapter = RuntimeTypeAdapterFactory.of(BillingInstrument.class)
.registerSubtype(CreditCard.class)
.registerSubtype(BankTransfer.class);
Gson gson = new GsonBuilder()
.registerTypeAdapterFactory(billingAdapter)
.create();
String serialized = gson.toJson(new BillingInstrumentWrapper(null), BillingInstrumentWrapper.class);
BillingInstrumentWrapper deserialized = gson.fromJson(serialized, BillingInstrumentWrapper.class);
assertNull(deserialized.instrument);
}
static class BillingInstrumentWrapper {
BillingInstrument instrument;
BillingInstrumentWrapper(BillingInstrument instrument) {
this.instrument = instrument;
}
}
static class BillingInstrument {
private final String ownerName;
BillingInstrument(String ownerName) {
this.ownerName = ownerName;
}
}
static class CreditCard extends BillingInstrument {
int cvv;
CreditCard(String ownerName, int cvv) {
super(ownerName);
this.cvv = cvv;
}
}
static class BankTransfer extends BillingInstrument {
int bankAccount;
BankTransfer(String ownerName, int bankAccount) {
super(ownerName);
this.bankAccount = bankAccount;
}
}
}
gson-gson-2.4/extras/src/test/java/com/google/gson/typeadapters/UtcDateTypeAdapterTest.java 0000664 0000000 0000000 00000005312 12604067504 0032177 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 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.typeadapters;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
import junit.framework.TestCase;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
public final class UtcDateTypeAdapterTest extends TestCase {
private final Gson gson = new GsonBuilder()
.registerTypeAdapter(Date.class, new UtcDateTypeAdapter())
.create();
public void testLocalTimeZone() {
Date expected = new Date();
String json = gson.toJson(expected);
Date actual = gson.fromJson(json, Date.class);
assertEquals(expected.getTime(), actual.getTime());
}
public void testDifferentTimeZones() {
for (String timeZone : TimeZone.getAvailableIDs()) {
Calendar cal = Calendar.getInstance(TimeZone.getTimeZone(timeZone));
Date expected = cal.getTime();
String json = gson.toJson(expected);
// System.out.println(json + ": " + timeZone);
Date actual = gson.fromJson(json, Date.class);
assertEquals(expected.getTime(), actual.getTime());
}
}
/**
* JDK 1.7 introduced support for XXX format to indicate UTC date. But Android is older JDK.
* We want to make sure that this date is parseable in Android.
*/
public void testUtcDatesOnJdkBefore1_7() {
Gson gson = new GsonBuilder()
.registerTypeAdapter(Date.class, new UtcDateTypeAdapter())
.create();
gson.fromJson("'2014-12-05T04:00:00.000Z'", Date.class);
}
public void testUtcWithJdk7Default() {
Date expected = new Date();
SimpleDateFormat iso8601Format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX", Locale.US);
iso8601Format.setTimeZone(TimeZone.getTimeZone("UTC"));
String expectedJson = "\"" + iso8601Format.format(expected) + "\"";
String actualJson = gson.toJson(expected);
assertEquals(expectedJson, actualJson);
Date actual = gson.fromJson(expectedJson, Date.class);
assertEquals(expected.getTime(), actual.getTime());
}
public void testNullDateSerialization() {
String json = gson.toJson(null, Date.class);
assertEquals("null", json);
}
}
gson-gson-2.4/gson/ 0000775 0000000 0000000 00000000000 12604067504 0014243 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/Gson 2.1 notes.txt 0000664 0000000 0000000 00000000454 12604067504 0017307 0 ustar 00root root 0000000 0000000 Dropped support for GsonBuilder.registerTypeHierarchyAdapter+InstanceCreator
Relax registerTypeHierarchyAdapter order
Gson 2.0 failed if you registered Manager then Employee would fail
Gson 2.1 it isn't a problem
com.google.gson.functional.TypeHierarchyAdapterTest#testRegisterSubTypeFirstNotAllowed gson-gson-2.4/gson/LICENSE 0000664 0000000 0000000 00000026452 12604067504 0015261 0 ustar 00root root 0000000 0000000 Google Gson
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2008-2011 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.
gson-gson-2.4/gson/README 0000664 0000000 0000000 00000000573 12604067504 0015130 0 ustar 00root root 0000000 0000000 Gson is a Java library that can be used to convert a Java object into its
JSON representation. It can also be used to convert a JSON string into an
equivalent Java object. Gson can work with arbitrary Java objects including
pre-existing objects that you do not have source-code of.
Complete Gson documentation is available at its project page
https://github.com/google/gson
gson-gson-2.4/gson/assembly-descriptor.xml 0000664 0000000 0000000 00000000705 12604067504 0020762 0 ustar 00root root 0000000 0000000
release
zip
README*
LICENSE*
target
gson-*.jar
gson-gson-2.4/gson/docs/ 0000775 0000000 0000000 00000000000 12604067504 0015173 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/docs/javadocs/ 0000775 0000000 0000000 00000000000 12604067504 0016765 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/docs/javadocs/allclasses-frame.html 0000664 0000000 0000000 00000012020 12604067504 0023064 0 ustar 00root root 0000000 0000000
All Classes (Gson 2.3.1 API)
All Classes
All Classes (Gson 2.3.1 API)
All Classes
ExclusionStrategy (Gson 2.3.1 API)
com.google.gson
public interface ExclusionStrategy
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 shouldSkipClass(Class)shouldSkipClass(Class)
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:
private static class SpecificClassExclusionStrategy implements ExclusionStrategy {
private final Class<?> excludedThisClass;
public SpecificClassExclusionStrategy(Class<?> excludedThisClass) {
this.excludedThisClass = excludedThisClass;
}
public boolean shouldSkipClass(Class<?> clazz) {
return excludedThisClass.equals(clazz);
}
public boolean shouldSkipField(FieldAttributes f) {
return excludedThisClass.equals(f.getDeclaredClass());
}
}
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 Gson to use a user defined exclusion strategy, then
the GsonBuilder is required. The following is an example of how you can use the
GsonBuilder to configure Gson to use one of the above sample:
ExclusionStrategy excludeStrings = new UserDefinedExclusionStrategy(String.class);
Gson gson = new GsonBuilder()
.setExclusionStrategies(excludeStrings)
.create();
For certain model classes, you may only want to serialize a field, but exclude it for
deserialization. To do that, you can write an ExclusionStrategy as per normal;
however, you would register it with the
GsonBuilder.addDeserializationExclusionStrategy(ExclusionStrategy)
ExclusionStrategy excludeStrings = new UserDefinedExclusionStrategy(String.class);
Gson gson = new GsonBuilder()
.addDeserializationExclusionStrategy(excludeStrings)
.create();
Since: 1.4
Author: Inderjeet Singh, Joel Leitch
See Also: GsonBuilder.setExclusionStrategies(ExclusionStrategy...)GsonBuilder.addDeserializationExclusionStrategy(ExclusionStrategy)GsonBuilder.addSerializationExclusionStrategy(ExclusionStrategy)
shouldSkipField
boolean shouldSkipField (FieldAttributes f)
Parameters: f - the field object that is under test
Returns: true if the field should be ignored; otherwise false
shouldSkipClass
boolean shouldSkipClass (Class <?> clazz)
Parameters: clazz - the class object that is under test
Returns: true if the class should be ignored; otherwise false
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/FieldAttributes.html 0000664 0000000 0000000 00000050777 12604067504 0025765 0 ustar 00root root 0000000 0000000
FieldAttributes (Gson 2.3.1 API)
com.google.gson
java.lang.Object
com.google.gson.FieldAttributes
public final class FieldAttributes extends Object
A data object that stores attributes of a field.
This class is immutable; therefore, it can be safely shared across threads.
Since: 1.4
Author: Inderjeet Singh, Joel Leitch
Methods inherited from class java.lang.Object
clone , equals , finalize , getClass , hashCode , notify , notifyAll , toString , wait , wait , wait
FieldAttributes
public FieldAttributes (Field f)
Constructs a Field Attributes object from the f.
Parameters: f - the field to pull attributes from
getDeclaringClass
public Class <?> getDeclaringClass ()
Returns: the declaring class that contains this field
getName
public String getName ()
Returns: the name of the field
getDeclaredType
public Type getDeclaredType ()
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 String.class for the bar field and
listParameterizedType for the red field.
Returns: the specific type declared for this field
getDeclaredClass
public Class <?> getDeclaredClass ()
Returns the Class object that was declared for this field.
For example, assume the following class definition:
public class Foo {
private String bar;
private List<String> red;
}
This method would return String.class for the bar field and
List.class for the red field.
Returns: the specific class object that was declared for the field
getAnnotation
public <T extends Annotation > T getAnnotation (Class <T> annotation)
Return the T annotation object from this field if it exist; otherwise returns
null.
Parameters: annotation - the class of the annotation that will be retrieved
Returns: the annotation instance if it is bound to the field; otherwise null
getAnnotations
public Collection <Annotation > getAnnotations ()
Return the annotations that are present on this field.
Returns: an array of all the annotations set on the field Since: 1.4
hasModifier
public boolean hasModifier (int modifier)
Returns true if the field is defined with the modifier.
This method is meant to be called as:
boolean hasPublicModifier = fieldAttribute.hasModifier(java.lang.reflect.Modifier.PUBLIC);
See Also: Modifier
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/FieldNamingPolicy.html 0000664 0000000 0000000 00000055605 12604067504 0026223 0 ustar 00root root 0000000 0000000
FieldNamingPolicy (Gson 2.3.1 API)
com.google.gson
java.lang.Object
java.lang.Enum <FieldNamingPolicy >
com.google.gson.FieldNamingPolicy
All Implemented Interfaces: FieldNamingStrategy , Serializable , Comparable <FieldNamingPolicy >
public enum FieldNamingPolicy extends Enum <FieldNamingPolicy >implements FieldNamingStrategy
An enumeration that defines a few standard naming conventions for JSON field names.
This enumeration should be used in conjunction with GsonBuilderGson
Author: Inderjeet Singh, Joel Leitch
Enum Constant Summary
IDENTITY
LOWER_CASE_WITH_DASHES
LOWER_CASE_WITH_UNDERSCORES
UPPER_CAMEL_CASE
UPPER_CAMEL_CASE_WITH_SPACES
IDENTITY
public static final FieldNamingPolicy IDENTITY
Using this naming policy with Gson will ensure that the field name is
unchanged.
UPPER_CAMEL_CASE
public static final FieldNamingPolicy UPPER_CAMEL_CASE
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_WITH_SPACES
public static final FieldNamingPolicy UPPER_CAMEL_CASE_WITH_SPACES
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
LOWER_CASE_WITH_UNDERSCORES
public static final FieldNamingPolicy LOWER_CASE_WITH_UNDERSCORES
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_DASHES
public static final FieldNamingPolicy LOWER_CASE_WITH_DASHES
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 myobject['my-field']. Accessing it as an object field
myobject.my-field will result in an unintended javascript expression.
Since: 1.4
values
public static FieldNamingPolicy [] values ()
Returns an array containing the constants of this enum type, in
the order they are declared. This method may be used to iterate
over the constants as follows:
for (FieldNamingPolicy c : FieldNamingPolicy.values())
System.out.println(c);
Returns: an array containing the constants of this enum type, in
the order they are declared
valueOf
public static FieldNamingPolicy valueOf (String name)
Returns the enum constant of this type with the specified name.
The string must match exactly an identifier used to declare an
enum constant in this type. (Extraneous whitespace characters are
not permitted.)
Parameters: name - the name of the enum constant to be returned.
Returns: the enum constant with the specified name
Throws:
IllegalArgumentException NullPointerException
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/FieldNamingStrategy.html 0000664 0000000 0000000 00000022633 12604067504 0026561 0 ustar 00root root 0000000 0000000
FieldNamingStrategy (Gson 2.3.1 API)
com.google.gson
All Known Implementing Classes: FieldNamingPolicy
public interface FieldNamingStrategy
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.
Since: 1.3
Author: Inderjeet Singh, Joel Leitch
translateName
String translateName (Field f)
Translates the field name into its JSON field name representation.
Parameters: f - the field object that we are translating
Returns: the translated field name. Since: 1.3
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/Gson.html 0000664 0000000 0000000 00000216030 12604067504 0023563 0 ustar 00root root 0000000 0000000
Gson (Gson 2.3.1 API)
com.google.gson
java.lang.Object
com.google.gson.Gson
public final class Gson extends Object
This is the main class for using Gson. Gson is typically used by first constructing a
Gson instance and then invoking toJson(Object)fromJson(String, Class)
You can create a Gson instance by invoking new Gson() if the default configuration
is all you need. You can also use GsonBuilderJsonSerializerJsonDeserializerInstanceCreator
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 ParameterizedType
(i.e. contains at least one type parameter and may be an array) then you must use the
toJson(Object, Type)fromJson(String, Type)ParameterizedType:
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);
See the Gson User Guide
for a more complete set of examples.
Author: Inderjeet Singh, Joel Leitch, Jesse Wilson
See Also: TypeToken
Constructor Summary
Gson
Method Summary
fromJson JsonElement json,
Class <T> classOfT)
fromJson JsonElement json,
Type typeOfT)
fromJson JsonReader reader,
Type typeOfT)reader and convert it to an object
of type typeOfT.
fromJson Reader json,
Class <T> classOfT)
fromJson Reader json,
Type typeOfT)
fromJson String json,
Class <T> classOfT)
fromJson String json,
Type typeOfT)
getAdapter Class <T> type)
getAdapter TypeToken <T> type)
getDelegateAdapter TypeAdapterFactory skipPast,
TypeToken <T> type)
String toJson JsonElement jsonElement)JsonElement
void toJson JsonElement jsonElement,
Appendable writer)JsonElement
void toJson JsonElement jsonElement,
JsonWriter writer)jsonElement to writer.
String toJson Object src)
void toJson Object src,
Appendable writer)
String toJson Object src,
Type typeOfSrc)
void toJson Object src,
Type typeOfSrc,
Appendable writer)
void toJson Object src,
Type typeOfSrc,
JsonWriter writer)src of type typeOfSrc to
writer.
JsonElement toJsonTree Object src)JsonElement
JsonElement toJsonTree Object src,
Type typeOfSrc)JsonElement
String toString
Gson
public Gson ()
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
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 GsonBuilder.serializeNulls()
Gson provides default serialization and deserialization for Enums, MapURLURILocaleDateBigDecimalBigIntegerGsonBuilder.registerTypeAdapter(Type, Object)
The default Date format is same as DateFormat.DEFAULTGsonBuilder.setDateFormat(int)GsonBuilder.setDateFormat(String)
By default, Gson ignores the ExposeGsonBuilder.excludeFieldsWithoutExposeAnnotation()
By default, Gson ignores the SinceGsonBuilder.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 GsonBuilder.setFieldNamingPolicy(FieldNamingPolicy)
By default, Gson excludes transient or static fields from
consideration for serialization and deserialization. You can change this behavior through
GsonBuilder.excludeFieldsWithModifiers(int...)
getAdapter
public <T> TypeAdapter <T> getAdapter (TypeToken <T> type)
Returns the type adapter for
Throws:
IllegalArgumentException type.
getDelegateAdapter
public <T> TypeAdapter <T> getDelegateAdapter (TypeAdapterFactory skipPast,
TypeToken <T> type)
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 TypeAdapterFactoryLet'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:
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);
}
};
}
}
This factory can now be used like this:
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);
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.
Parameters: 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 getDelegateAdapter(com.google.gson.TypeAdapterFactory, com.google.gson.reflect.TypeToken) type - Type for which the delegate adapter is being searched for.Since: 2.2
getAdapter
public <T> TypeAdapter <T> getAdapter (Class <T> type)
Returns the type adapter for
Throws:
IllegalArgumentException type.
toJsonTree
public JsonElement toJsonTree (Object src)
This method serializes the specified object into its equivalent representation as a tree of
JsonElementObject.getClass()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
toJsonTree(Object, Type)
Parameters: src - the object for which Json representation is to be created setting for Gson
Returns: Json representation of src. Since: 1.4
toJsonTree
public JsonElement toJsonTree (Object src,
Type typeOfSrc)
This method serializes the specified object, including those of generic types, into its
equivalent representation as a tree of JsonElementtoJsonTree(Object)
Parameters: src - the object for which JSON representation is to be createdtypeOfSrc - The specific genericized type of src. You can obtain
this type by using the TypeTokenCollection<Foo>, you should use:
Type typeOfSrc = new TypeToken<Collection<Foo>>(){}.getType();
Returns: Json representation of src Since: 1.4
toJson
public String toJson (Object src)
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
Object.getClass()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
toJson(Object, Type)WritertoJson(Object, Appendable)
Parameters: src - the object for which Json representation is to be created setting for Gson
Returns: Json representation of src.
toJson
public String toJson (Object src,
Type typeOfSrc)
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 toJson(Object)AppendabletoJson(Object, Type, Appendable)
Parameters: src - the object for which JSON representation is to be createdtypeOfSrc - The specific genericized type of src. You can obtain
this type by using the TypeTokenCollection<Foo>, you should use:
Type typeOfSrc = new TypeToken<Collection<Foo>>(){}.getType();
Returns: Json representation of src
toJson
public void toJson (Object src,
Appendable writer)
throws JsonIOException
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
Object.getClass()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
toJson(Object, Type, Appendable)
Parameters: src - the object for which Json representation is to be created setting for Gsonwriter - Writer to which the Json representation needs to be written
Throws:
JsonIOException Since: 1.2
toJson
public void toJson (Object src,
Type typeOfSrc,
Appendable writer)
throws JsonIOException
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 toJson(Object, Appendable)
Parameters: src - the object for which JSON representation is to be createdtypeOfSrc - The specific genericized type of src. You can obtain
this type by using the TypeTokenCollection<Foo>, you should use:
Type typeOfSrc = new TypeToken<Collection<Foo>>(){}.getType();
writer - Writer to which the Json representation of src needs to be written.
Throws:
JsonIOException Since: 1.2
toJson
public void toJson (Object src,
Type typeOfSrc,
JsonWriter writer)
throws JsonIOException
Writes the JSON representation of src of type typeOfSrc to
writer.
Throws:
JsonIOException
toJson
public String toJson (JsonElement jsonElement)
Converts a tree of JsonElement
Parameters: jsonElement - root of a tree of JsonElementReturns: JSON String representation of the tree Since: 1.4
toJson
public void toJson (JsonElement jsonElement,
Appendable writer)
throws JsonIOException
Writes out the equivalent JSON for a tree of JsonElement
Parameters: jsonElement - root of a tree of JsonElementwriter - Writer to which the Json representation needs to be written
Throws:
JsonIOException Since: 1.4
toJson
public void toJson (JsonElement jsonElement,
JsonWriter writer)
throws JsonIOException
Writes the JSON for jsonElement to writer.
Throws:
JsonIOException
fromJson
public <T> T fromJson (String json,
Class <T> classOfT)
throws JsonSyntaxException
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
fromJson(String, Type)ReaderfromJson(Reader, Class)
Type Parameters: T - the type of the desired objectParameters: json - the string from which the object is to be deserializedclassOfT - the class of T
Returns: an object of type T from the string. Returns null if json is null.
Throws:
JsonSyntaxException
fromJson
public <T> T fromJson (String json,
Type typeOfT)
throws JsonSyntaxException
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
fromJson(String, Class)ReaderfromJson(Reader, Type)
Type Parameters: T - the type of the desired objectParameters: json - the string from which the object is to be deserializedtypeOfT - The specific genericized type of src. You can obtain this type by using the
TypeTokenCollection<Foo>, you should use:
Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType();
Returns: an object of type T from the string. Returns null if json is null.
Throws:
JsonParseException JsonSyntaxException
fromJson
public <T> T fromJson (Reader json,
Class <T> classOfT)
throws JsonSyntaxException ,
JsonIOException
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 fromJson(Reader, Type)ReaderfromJson(String, Class)
Type Parameters: T - the type of the desired objectParameters: json - the reader producing the Json from which the object is to be deserialized.classOfT - the class of T
Returns: an object of type T from the string. Returns null if json is at EOF.
Throws:
JsonIOException JsonSyntaxException Since: 1.2
fromJson
public <T> T fromJson (Reader json,
Type typeOfT)
throws JsonIOException ,
JsonSyntaxException
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 fromJson(Reader, Class)ReaderfromJson(String, Type)
Type Parameters: T - the type of the desired objectParameters: json - the reader producing Json from which the object is to be deserializedtypeOfT - The specific genericized type of src. You can obtain this type by using the
TypeTokenCollection<Foo>, you should use:
Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType();
Returns: an object of type T from the json. Returns null if json is at EOF.
Throws:
JsonIOException JsonSyntaxException Since: 1.2
fromJson
public <T> T fromJson (JsonReader reader,
Type typeOfT)
throws JsonIOException ,
JsonSyntaxException
Reads the next JSON value from reader and convert it to an object
of type typeOfT. Returns null, if the reader is at EOF.
Since Type is not parameterized by T, this method is type unsafe and should be used carefully
Throws:
JsonIOException JsonSyntaxException
fromJson
public <T> T fromJson (JsonElement json,
Class <T> classOfT)
throws JsonSyntaxException
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 fromJson(JsonElement, Type)
Type Parameters: T - the type of the desired objectParameters: json - the root of the parse tree of JsonElementclassOfT - The class of T
Returns: an object of type T from the json. Returns null if json is null.
Throws:
JsonSyntaxException Since: 1.3
fromJson
public <T> T fromJson (JsonElement json,
Type typeOfT)
throws JsonSyntaxException
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 fromJson(JsonElement, Class)
Type Parameters: T - the type of the desired objectParameters: json - the root of the parse tree of JsonElementtypeOfT - The specific genericized type of src. You can obtain this type by using the
TypeTokenCollection<Foo>, you should use:
Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType();
Returns: an object of type T from the json. Returns null if json is null.
Throws:
JsonSyntaxException Since: 1.3
toString
public String toString ()
Overrides: toString Object
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/GsonBuilder.html 0000664 0000000 0000000 00000154232 12604067504 0025077 0 ustar 00root root 0000000 0000000
GsonBuilder (Gson 2.3.1 API)
com.google.gson
java.lang.Object
com.google.gson.GsonBuilder
public final class GsonBuilder extends Object
Use this builder to construct a GsonGsonnew Gson(). GsonBuilder is best used by creating it, and then invoking its
various configuration methods, and finally calling create.
The following is an example shows how to use the GsonBuilder to construct a Gson
instance:
Gson gson = new GsonBuilder()
.registerTypeAdapter(Id.class, new IdTypeAdapter())
.enableComplexMapKeySerialization()
.serializeNulls()
.setDateFormat(DateFormat.LONG)
.setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)
.setPrettyPrinting()
.setVersion(1.0)
.create();
NOTES:
the order of invocation of configuration methods does not matter.
The default serialization of DateGsonBuilder and its setDateFormat methods.
Author: Inderjeet Singh, Joel Leitch, Jesse Wilson
Constructor Summary
GsonBuilder
Methods inherited from class java.lang.Object
clone , equals , finalize , getClass , hashCode , notify , notifyAll , toString , wait , wait , wait
GsonBuilder
public GsonBuilder ()
Creates a GsonBuilder instance that can be used to build Gson with various configuration
settings. GsonBuilder follows the builder pattern, and it is typically used by first
invoking various configuration methods to set desired options, and finally calling
create()
setVersion
public GsonBuilder setVersion (double ignoreVersionsAfter)
Configures Gson to enable versioning support.
Parameters: ignoreVersionsAfter - any field or type marked with a version higher than this value
are ignored during serialization or deserialization.
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern
excludeFieldsWithModifiers
public GsonBuilder excludeFieldsWithModifiers (int... modifiers)
Configures Gson to excludes all class fields that have the specified modifiers. By default,
Gson will exclude all fields marked transient or static. This method will override that
behavior.
Parameters: modifiers - the field modifiers. You must use the modifiers specified in the
ModifierModifier.TRANSIENTModifier.STATICReturns: a reference to this GsonBuilder object to fulfill the "Builder" pattern
generateNonExecutableJson
public GsonBuilder generateNonExecutableJson ()
Makes the output JSON non-executable in Javascript by prefixing the generated JSON with some
special text. This prevents attacks from third-party sites through script sourcing. See
Gson Issue 42
for details.
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.3
excludeFieldsWithoutExposeAnnotation
public GsonBuilder excludeFieldsWithoutExposeAnnotation ()
Configures Gson to exclude all fields from consideration for serialization or deserialization
that do not have the Expose
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern
serializeNulls
public GsonBuilder serializeNulls ()
Configure Gson to serialize null fields. By default, Gson omits all fields that are null
during serialization.
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.2
enableComplexMapKeySerialization
public GsonBuilder enableComplexMapKeySerialization ()
Enabling this feature will only change the serialized form if the map key is
a complex type (i.e. non-primitive) in its serialized JSON
form. The default implementation of map serialization uses toString()
on the key; however, when this is called then one of the following cases
apply:
Maps as JSON objects
For this case, assume that a type adapter is registered to serialize and
deserialize some Point class, which contains an x and y coordinate,
to/from the JSON Primitive string value "(x,y)". The Java map would
then be serialized as a JsonObjectBelow is an example:
Gson gson = new GsonBuilder()
.register(Point.class, new MyPointTypeAdapter())
.enableComplexMapKeySerialization()
.create();
Map<Point, String> original = new LinkedHashMap<Point, String>();
original.put(new Point(5, 6), "a");
original.put(new Point(8, 8), "b");
System.out.println(gson.toJson(original, type));
The above code prints this JSON object: {
"(5,6)": "a",
"(8,8)": "b"
}
Maps as JSON arrays
For this case, assume that a type adapter was NOT registered for some
Point class, but rather the default Gson serialization is applied.
In this case, some new Point(2,3) would serialize as {"x":2,"y":5}.
Given the assumption above, a Map<Point, String> will be
serialize as an array of arrays (can be viewed as an entry set of pairs).
Below is an example of serializing complex types as JSON arrays:
Gson gson = new GsonBuilder()
.enableComplexMapKeySerialization()
.create();
Map<Point, String> original = new LinkedHashMap<Point, String>();
original.put(new Point(5, 6), "a");
original.put(new Point(8, 8), "b");
System.out.println(gson.toJson(original, type));
The JSON output would look as follows:
[
[
{
"x": 5,
"y": 6
},
"a"
],
[
{
"x": 8,
"y": 8
},
"b"
]
]
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.7
disableInnerClassSerialization
public GsonBuilder disableInnerClassSerialization ()
Configures Gson to exclude inner classes during serialization.
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.3
setLongSerializationPolicy
public GsonBuilder setLongSerializationPolicy (LongSerializationPolicy serializationPolicy)
Configures Gson to apply a specific serialization policy for Long and long
objects.
Parameters: serializationPolicy - the particular policy to use for serializing longs.
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.3
setFieldNamingPolicy
public GsonBuilder setFieldNamingPolicy (FieldNamingPolicy namingConvention)
Configures Gson to apply a specific naming policy to an object's field during serialization
and deserialization.
Parameters: namingConvention - the JSON field naming convention to use for serialization and
deserialization.
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern
setFieldNamingStrategy
public GsonBuilder setFieldNamingStrategy (FieldNamingStrategy fieldNamingStrategy)
Configures Gson to apply a specific naming policy strategy to an object's field during
serialization and deserialization.
Parameters: fieldNamingStrategy - the actual naming strategy to apply to the fields
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.3
setExclusionStrategies
public GsonBuilder setExclusionStrategies (ExclusionStrategy ... strategies)
Configures Gson to apply a set of exclusion strategies during both serialization and
deserialization. Each of the strategies will be applied as a disjunction rule.
This means that if one of the strategies suggests that a field (or class) should be
skipped then that field (or object) is skipped during serializaiton/deserialization.
Parameters: strategies - the set of strategy object to apply during object (de)serialization.
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.4
addSerializationExclusionStrategy
public GsonBuilder addSerializationExclusionStrategy (ExclusionStrategy strategy)
Configures Gson to apply the passed in exclusion strategy during serialization.
If this method is invoked numerous times with different exclusion strategy objects
then the exclusion strategies that were added will be applied as a disjunction rule.
This means that if one of the added exclusion strategies suggests that a field (or
class) should be skipped then that field (or object) is skipped during its
serialization.
Parameters: strategy - an exclusion strategy to apply during serialization.
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.7
addDeserializationExclusionStrategy
public GsonBuilder addDeserializationExclusionStrategy (ExclusionStrategy strategy)
Configures Gson to apply the passed in exclusion strategy during deserialization.
If this method is invoked numerous times with different exclusion strategy objects
then the exclusion strategies that were added will be applied as a disjunction rule.
This means that if one of the added exclusion strategies suggests that a field (or
class) should be skipped then that field (or object) is skipped during its
deserialization.
Parameters: strategy - an exclusion strategy to apply during deserialization.
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.7
setPrettyPrinting
public GsonBuilder setPrettyPrinting ()
Configures Gson to output Json that fits in a page for pretty printing. This option only
affects Json serialization.
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern
disableHtmlEscaping
public GsonBuilder disableHtmlEscaping ()
By default, Gson escapes HTML characters such as < > etc. Use this option to configure
Gson to pass-through HTML characters as is.
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.3
setDateFormat
public GsonBuilder setDateFormat (String pattern)
Configures Gson to serialize Date objects according to the pattern provided. You can
call this method or setDateFormat(int)The date format will be used to serialize and deserialize DateTimestampDate
Note that this pattern must abide by the convention provided by SimpleDateFormat
class. See the documentation in SimpleDateFormat
Parameters: pattern - the pattern that dates will be serialized/deserialized to/from
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.2
setDateFormat
public GsonBuilder setDateFormat (int style)
Configures Gson to to serialize Date objects according to the style value provided.
You can call this method or setDateFormat(String)Note that this style value should be one of the predefined constants in the
DateFormat class. See the documentation in DateFormat
Parameters: style - the predefined date style that date objects will be serialized/deserialized
to/from
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.2
setDateFormat
public GsonBuilder setDateFormat (int dateStyle,
int timeStyle)
Configures Gson to to serialize Date objects according to the style value provided.
You can call this method or setDateFormat(String)Note that this style value should be one of the predefined constants in the
DateFormat class. See the documentation in DateFormat
Parameters: dateStyle - the predefined date style that date objects will be serialized/deserialized
to/fromtimeStyle - the predefined style for the time portion of the date objects
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.2
registerTypeAdapter
public GsonBuilder registerTypeAdapter (Type type,
Object typeAdapter)
Configures Gson for custom serialization or deserialization. This method combines the
registration of an TypeAdapterInstanceCreatorJsonSerializerJsonDeserializertypeAdapter implements
all the required interfaces for custom serialization with Gson. If a type adapter was
previously registered for the specified type, it is overwritten.
This registers the type specified and no other types: you must manually register related
types! For example, applications registering boolean.class should also register Boolean.class.
Parameters: type - the type definition for the type adapter being registeredtypeAdapter - This object must implement at least one of the TypeAdapterInstanceCreatorJsonSerializerJsonDeserializerReturns: a reference to this GsonBuilder object to fulfill the "Builder" pattern
registerTypeAdapterFactory
public GsonBuilder registerTypeAdapterFactory (TypeAdapterFactory factory)
Register a factory for type adapters. Registering a factory is useful when the type
adapter needs to be configured based on the type of the field being processed. Gson
is designed to handle a large number of factories, so you should consider registering
them to be at par with registering an individual type adapter.
Since: 2.1
registerTypeHierarchyAdapter
public GsonBuilder registerTypeHierarchyAdapter (Class <?> baseType,
Object typeAdapter)
Configures Gson for custom serialization or deserialization for an inheritance type hierarchy.
This method combines the registration of a TypeAdapterJsonSerializerJsonDeserializer
Parameters: baseType - the class definition for the type adapter being registered for the base class
or interfacetypeAdapter - This object must implement at least one of TypeAdapterJsonSerializerJsonDeserializerReturns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.7
serializeSpecialFloatingPointValues
public GsonBuilder serializeSpecialFloatingPointValues ()
Section 2.4 of JSON specification disallows
special double values (NaN, Infinity, -Infinity). However,
Javascript
specification (see section 4.3.20, 4.3.22, 4.3.23) allows these values as valid Javascript
values. Moreover, most JavaScript engines will accept these special values in JSON without
problem. So, at a practical level, it makes sense to accept these values as valid JSON even
though JSON specification disallows them.
Gson always accepts these special values during deserialization. However, it outputs
strictly compliant JSON. Hence, if it encounters a float value Float.NaNFloat.POSITIVE_INFINITYFloat.NEGATIVE_INFINITYDouble.NaNDouble.POSITIVE_INFINITYDouble.NEGATIVE_INFINITYIllegalArgumentException
Returns: a reference to this GsonBuilder object to fulfill the "Builder" pattern Since: 1.3
create
public Gson create ()
Creates a GsonGsonBuilder instance and hence can be called multiple times.
Returns: an instance of Gson configured with the options currently set in this builder
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/InstanceCreator.html 0000664 0000000 0000000 00000027334 12604067504 0025750 0 ustar 00root root 0000000 0000000
InstanceCreator (Gson 2.3.1 API)
com.google.gson
Type Parameters: T - the type of object that will be created by this implementation.
public interface InstanceCreator<T>
This interface is implemented to create instances of a class that does not define a no-args
constructor. If you can modify the class, you should instead add a private, or public
no-args constructor. However, that is not possible for library classes, such as JDK classes, or
a third-party library that you do not have source-code of. In such cases, you should define an
instance creator for the class. Implementations of this interface should be registered with
GsonBuilder.registerTypeAdapter(Type, Object)
Let us look at an example where defining an InstanceCreator might be useful. The
Id class defined below does not have a default no-args constructor.
public class Id<T> {
private final Class<T> clazz;
private final long value;
public Id(Class<T> clazz, long value) {
this.clazz = clazz;
this.value = value;
}
}
If Gson encounters an object of type Id during deserialization, it will throw an
exception. The easiest way to solve this problem will be to add a (public or private) no-args
constructor as follows:
private Id() {
this(Object.class, 0L);
}
However, let us assume that the developer does not have access to the source-code of the
Id class, or does not want to define a no-args constructor for it. The developer
can solve this problem by defining an InstanceCreator for Id:
class IdInstanceCreator implements InstanceCreator<Id> {
public Id createInstance(Type type) {
return new Id(Object.class, 0L);
}
}
Note that it does not matter what the fields of the created instance contain since Gson will
overwrite them with the deserialized values specified in Json. You should also ensure that a
new object is returned, not a common object since its fields will be overwritten.
The developer will need to register IdInstanceCreator with Gson as follows:
Gson gson = new GsonBuilder().registerTypeAdapter(Id.class, new IdInstanceCreator()).create();
Author: Inderjeet Singh, Joel Leitch
Method Summary
T createInstance Type type)
createInstance
T createInstance (Type type)
Gson invokes this call-back method during deserialization to create an instance of the
specified type. The fields of the returned instance are overwritten with the data present
in the Json. Since the prior contents of the object are destroyed and overwritten, do not
return an instance that is useful elsewhere. In particular, do not return a common instance,
always use new to create a new instance.
Parameters: type - the parameterized T represented as a TypeReturns: a default object instance of type T.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonArray.html 0000664 0000000 0000000 00000135603 12604067504 0024573 0 ustar 00root root 0000000 0000000
JsonArray (Gson 2.3.1 API)
com.google.gson
java.lang.Object
com.google.gson.JsonElement
com.google.gson.JsonArray
All Implemented Interfaces: Iterable <JsonElement >
public final class JsonArray extends JsonElement implements Iterable <JsonElement >
A class representing an array type in Json. An array is a list of JsonElement
Author: Inderjeet Singh, Joel Leitch
Constructor Summary
JsonArray
Method Summary
void add JsonElement element)
void addAll JsonArray array)
boolean contains JsonElement element)
boolean equals Object o)
JsonElement get
BigDecimal getAsBigDecimal BigDecimal
BigInteger getAsBigInteger BigInteger
boolean getAsBoolean
byte getAsByte
char getAsCharacter
double getAsDouble
float getAsFloat
int getAsInt
long getAsLong
Number getAsNumber Number
short getAsShort
String getAsString String
int hashCode
Iterator <JsonElement > iterator
JsonElement remove
boolean remove JsonElement element)
JsonElement set JsonElement element)
int size
JsonArray
public JsonArray ()
Creates an empty JsonArray.
add
public void add (JsonElement element)
Adds the specified element to self.
Parameters: element - the element that needs to be added to the array.
addAll
public void addAll (JsonArray array)
Adds all the elements of the specified array to self.
Parameters: array - the array whose elements need to be added to the array.
set
public JsonElement set (int index,
JsonElement element)
Replaces the element at the specified position in this array with the specified element.
Element can be null.
Parameters: index - index of the element to replaceelement - element to be stored at the specified position
Returns: the element previously at the specified position
Throws:
IndexOutOfBoundsException
remove
public boolean remove (JsonElement element)
Removes the first occurrence of the specified element from this array, if it is present.
If the array does not contain the element, it is unchanged.
Parameters: element - element to be removed from this array, if present
Returns: true if this array contained the specified element, false otherwise Since: 2.3
remove
public JsonElement remove (int index)
Removes the element at the specified position in this array. Shifts any subsequent elements
to the left (subtracts one from their indices). Returns the element that was removed from
the array.
Parameters: index - index the index of the element to be removed
Returns: the element previously at the specified position
Throws:
IndexOutOfBoundsException Since: 2.3
contains
public boolean contains (JsonElement element)
Returns true if this array contains the specified element.
Parameters: element - whose presence in this array is to be tested
Returns: true if this array contains the specified element. Since: 2.3
size
public int size ()
Returns the number of elements in the array.
Returns: the number of elements in the array.
iterator
public Iterator <JsonElement > iterator ()
Returns an iterator to navigate the elemetns of the array. Since the array is an ordered list,
the iterator navigates the elements in the order they were inserted.
Specified by: iterator Iterable <JsonElement >
Returns: an iterator to navigate the elements of the array.
get
public JsonElement get (int i)
Returns the ith element of the array.
Parameters: i - the index of the element that is being sought.
Returns: the element present at the ith index.
Throws:
IndexOutOfBoundsException size()
getAsNumber
public Number getAsNumber ()
convenience method to get this array as a Number
Overrides: getAsNumber JsonElement
Returns: get this element as a number if it is single element array.
Throws:
ClassCastException JsonPrimitiveIllegalStateException
getAsString
public String getAsString ()
convenience method to get this array as a String
Overrides: getAsString JsonElement
Returns: get this element as a String if it is single element array.
Throws:
ClassCastException JsonPrimitiveIllegalStateException
getAsDouble
public double getAsDouble ()
convenience method to get this array as a double if it contains a single element.
Overrides: getAsDouble JsonElement
Returns: get this element as a double if it is single element array.
Throws:
ClassCastException JsonPrimitiveIllegalStateException
getAsBigDecimal
public BigDecimal getAsBigDecimal ()
convenience method to get this array as a BigDecimal
Overrides: getAsBigDecimal JsonElement
Returns: get this element as a BigDecimal Throws:
ClassCastException JsonPrimitiveNumberFormatException BigDecimalIllegalStateException Since: 1.2
getAsBigInteger
public BigInteger getAsBigInteger ()
convenience method to get this array as a BigInteger
Overrides: getAsBigInteger JsonElement
Returns: get this element as a BigInteger Throws:
ClassCastException JsonPrimitiveNumberFormatException BigIntegerIllegalStateException Since: 1.2
getAsFloat
public float getAsFloat ()
convenience method to get this array as a float if it contains a single element.
Overrides: getAsFloat JsonElement
Returns: get this element as a float if it is single element array.
Throws:
ClassCastException JsonPrimitiveIllegalStateException
getAsLong
public long getAsLong ()
convenience method to get this array as a long if it contains a single element.
Overrides: getAsLong JsonElement
Returns: get this element as a long if it is single element array.
Throws:
ClassCastException JsonPrimitiveIllegalStateException
getAsInt
public int getAsInt ()
convenience method to get this array as an integer if it contains a single element.
Overrides: getAsInt JsonElement
Returns: get this element as an integer if it is single element array.
Throws:
ClassCastException JsonPrimitiveIllegalStateException
getAsByte
public byte getAsByte ()
Description copied from class: JsonElement convenience method to get this element as a primitive byte value.
Overrides: getAsByte JsonElement
Returns: get this element as a primitive byte value.
getAsCharacter
public char getAsCharacter ()
Description copied from class: JsonElement convenience method to get this element as a primitive character value.
Overrides: getAsCharacter JsonElement
Returns: get this element as a primitive char value.
getAsShort
public short getAsShort ()
convenience method to get this array as a primitive short if it contains a single element.
Overrides: getAsShort JsonElement
Returns: get this element as a primitive short if it is single element array.
Throws:
ClassCastException JsonPrimitiveIllegalStateException
getAsBoolean
public boolean getAsBoolean ()
convenience method to get this array as a boolean if it contains a single element.
Overrides: getAsBoolean JsonElement
Returns: get this element as a boolean if it is single element array.
Throws:
ClassCastException JsonPrimitiveIllegalStateException
equals
public boolean equals (Object o)
Overrides: equals Object
hashCode
public int hashCode ()
Overrides: hashCode Object
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonDeserializationContext.html 0000664 0000000 0000000 00000024624 12604067504 0030210 0 ustar 00root root 0000000 0000000
JsonDeserializationContext (Gson 2.3.1 API)
com.google.gson
public interface JsonDeserializationContext
Context for deserialization that is passed to a custom deserializer during invocation of its
JsonDeserializer.deserialize(JsonElement, Type, JsonDeserializationContext)
Author: Inderjeet Singh, Joel Leitch
deserialize
<T> T deserialize (JsonElement json,
Type typeOfT)
throws JsonParseException
Invokes default deserialization on the specified object. It should never be invoked on
the element received as a parameter of the
JsonDeserializer.deserialize(JsonElement, Type, JsonDeserializationContext)
Type Parameters: T - The type of the deserialized object.Parameters: json - the parse tree.typeOfT - type of the expected return value.
Returns: An object of type typeOfT.
Throws:
JsonParseException
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonDeserializer.html 0000664 0000000 0000000 00000031340 12604067504 0026130 0 ustar 00root root 0000000 0000000
JsonDeserializer (Gson 2.3.1 API)
com.google.gson
Type Parameters: T - type for which the deserializer is being registered. It is possible that a
deserializer may be asked to deserialize a specific generic type of the T.
public interface JsonDeserializer<T>
Interface representing a custom deserializer for Json. You should write a custom
deserializer, if you are not happy with the default deserialization done by Gson. You will
also need to register this deserializer through
GsonBuilder.registerTypeAdapter(Type, Object)
Let us look at example where defining a deserializer will be useful. The Id class
defined below has two fields: clazz and value.
public class Id<T> {
private final Class<T> clazz;
private final long value;
public Id(Class<T> clazz, long value) {
this.clazz = clazz;
this.value = value;
}
public long getValue() {
return value;
}
}
The default deserialization of Id(com.foo.MyObject.class, 20L) will require the
Json string to be {"clazz":com.foo.MyObject,"value":20}. Suppose, you already know
the type of the field that the Id will be deserialized into, and hence just want to
deserialize it from a Json string 20. You can achieve that by writing a custom
deserializer:
class IdDeserializer implements JsonDeserializer<Id>() {
public Id deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
throws JsonParseException {
return new Id((Class)typeOfT, id.getValue());
}
You will also need to register IdDeserializer with Gson as follows:
Gson gson = new GsonBuilder().registerTypeAdapter(Id.class, new IdDeserializer()).create();
New applications should prefer TypeAdapter
Author: Inderjeet Singh, Joel Leitch
deserialize
T deserialize (JsonElement json,
Type typeOfT,
JsonDeserializationContext context)
throws JsonParseException
Gson invokes this call-back method during deserialization when it encounters a field of the
specified type.
In the implementation of this call-back method, you should consider invoking
JsonDeserializationContext.deserialize(JsonElement, Type)json since that will cause an infinite loop (Gson will call your
call-back method again).
Parameters: json - The Json data being deserializedtypeOfT - The type of the Object to deserialize to
Returns: a deserialized object of the specified type typeOfT which is a subclass of T
Throws:
JsonParseException typeofT
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonElement.html 0000664 0000000 0000000 00000126770 12604067504 0025113 0 ustar 00root root 0000000 0000000
JsonElement (Gson 2.3.1 API)
com.google.gson
java.lang.Object
com.google.gson.JsonElement
Direct Known Subclasses: JsonArray , JsonNull , JsonObject , JsonPrimitive
public abstract class JsonElement extends Object
A class representing an element of Json. It could either be a JsonObjectJsonArrayJsonPrimitiveJsonNull
Author: Inderjeet Singh, Joel Leitch
JsonElement
public JsonElement ()
isJsonArray
public boolean isJsonArray ()
provides check for verifying if this element is an array or not.
Returns: true if this element is of type JsonArray
isJsonObject
public boolean isJsonObject ()
provides check for verifying if this element is a Json object or not.
Returns: true if this element is of type JsonObject
isJsonPrimitive
public boolean isJsonPrimitive ()
provides check for verifying if this element is a primitive or not.
Returns: true if this element is of type JsonPrimitive
isJsonNull
public boolean isJsonNull ()
provides check for verifying if this element represents a null value or not.
Returns: true if this element is of type JsonNull Since: 1.2
getAsJsonObject
public JsonObject getAsJsonObject ()
convenience method to get this element as a JsonObjectIllegalStateExceptionisJsonObject()
Returns: get this element as a JsonObject Throws:
IllegalStateException
getAsJsonArray
public JsonArray getAsJsonArray ()
convenience method to get this element as a JsonArrayIllegalStateExceptionisJsonArray()
Returns: get this element as a JsonArray Throws:
IllegalStateException
getAsJsonPrimitive
public JsonPrimitive getAsJsonPrimitive ()
convenience method to get this element as a JsonPrimitiveIllegalStateExceptionisJsonPrimitive()
Returns: get this element as a JsonPrimitive Throws:
IllegalStateException
getAsJsonNull
public JsonNull getAsJsonNull ()
convenience method to get this element as a JsonNullIllegalStateExceptionisJsonNull()
Returns: get this element as a JsonNull Throws:
IllegalStateException Since: 1.2
getAsBoolean
public boolean getAsBoolean ()
convenience method to get this element as a boolean value.
Returns: get this element as a primitive boolean value.
Throws:
ClassCastException JsonPrimitiveIllegalStateException JsonArray
getAsNumber
public Number getAsNumber ()
convenience method to get this element as a Number
Returns: get this element as a Number Throws:
ClassCastException JsonPrimitiveIllegalStateException JsonArray
getAsString
public String getAsString ()
convenience method to get this element as a string value.
Returns: get this element as a string value.
Throws:
ClassCastException JsonPrimitiveIllegalStateException JsonArray
getAsDouble
public double getAsDouble ()
convenience method to get this element as a primitive double value.
Returns: get this element as a primitive double value.
Throws:
ClassCastException JsonPrimitiveIllegalStateException JsonArray
getAsFloat
public float getAsFloat ()
convenience method to get this element as a primitive float value.
Returns: get this element as a primitive float value.
Throws:
ClassCastException JsonPrimitiveIllegalStateException JsonArray
getAsLong
public long getAsLong ()
convenience method to get this element as a primitive long value.
Returns: get this element as a primitive long value.
Throws:
ClassCastException JsonPrimitiveIllegalStateException JsonArray
getAsInt
public int getAsInt ()
convenience method to get this element as a primitive integer value.
Returns: get this element as a primitive integer value.
Throws:
ClassCastException JsonPrimitiveIllegalStateException JsonArray
getAsByte
public byte getAsByte ()
convenience method to get this element as a primitive byte value.
Returns: get this element as a primitive byte value.
Throws:
ClassCastException JsonPrimitiveIllegalStateException JsonArraySince: 1.3
getAsCharacter
public char getAsCharacter ()
convenience method to get this element as a primitive character value.
Returns: get this element as a primitive char value.
Throws:
ClassCastException JsonPrimitiveIllegalStateException JsonArraySince: 1.3
getAsBigDecimal
public BigDecimal getAsBigDecimal ()
convenience method to get this element as a BigDecimal
Returns: get this element as a BigDecimal Throws:
ClassCastException JsonPrimitiveBigDecimalIllegalStateException JsonArraySince: 1.2
getAsBigInteger
public BigInteger getAsBigInteger ()
convenience method to get this element as a BigInteger
Returns: get this element as a BigInteger Throws:
ClassCastException JsonPrimitiveNumberFormatException BigIntegerIllegalStateException JsonArraySince: 1.2
getAsShort
public short getAsShort ()
convenience method to get this element as a primitive short value.
Returns: get this element as a primitive short value.
Throws:
ClassCastException JsonPrimitiveIllegalStateException JsonArray
toString
public String toString ()
Returns a String representation of this element.
Overrides: toString Object
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonIOException.html 0000664 0000000 0000000 00000042014 12604067504 0025674 0 ustar 00root root 0000000 0000000
JsonIOException (Gson 2.3.1 API)
com.google.gson
java.lang.Object
java.lang.Throwable
java.lang.Exception
java.lang.RuntimeException
com.google.gson.JsonParseException
com.google.gson.JsonIOException
All Implemented Interfaces: Serializable
public final class JsonIOException extends JsonParseException
This exception is raised when Gson was unable to read an input stream
or write to one.
Author: Inderjeet Singh, Joel Leitch
See Also: Serialized Form
Methods inherited from class java.lang.Throwable
fillInStackTrace , getCause , getLocalizedMessage , getMessage , getStackTrace , initCause , printStackTrace , printStackTrace , printStackTrace , setStackTrace , toString
JsonIOException
public JsonIOException (String msg)
JsonIOException
public JsonIOException (String msg,
Throwable cause)
JsonIOException
public JsonIOException (Throwable cause)
Creates exception with the specified cause. Consider using
JsonIOException(String, Throwable)
Parameters: cause - root exception that caused this exception to be thrown.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonNull.html 0000664 0000000 0000000 00000042064 12604067504 0024425 0 ustar 00root root 0000000 0000000
JsonNull (Gson 2.3.1 API)
com.google.gson
java.lang.Object
com.google.gson.JsonElement
com.google.gson.JsonNull
public final class JsonNull extends JsonElement
A class representing a Json null value.
Since: 1.2
Author: Inderjeet Singh, Joel Leitch
Constructor Summary
JsonNull Deprecated.
Method Summary
boolean equals Object other)
int hashCode
Methods inherited from class com.google.gson.JsonElement
getAsBigDecimal , getAsBigInteger , getAsBoolean , getAsByte , getAsCharacter , getAsDouble , getAsFloat , getAsInt , getAsJsonArray , getAsJsonNull , getAsJsonObject , getAsJsonPrimitive , getAsLong , getAsNumber , getAsShort , getAsString , isJsonArray , isJsonNull , isJsonObject , isJsonPrimitive , toString
INSTANCE
public static final JsonNull INSTANCE
singleton for JsonNull
Since: 1.8
JsonNull
@Deprecated
JsonNull ()
Deprecated.
Creates a new JsonNull object.
Deprecated since Gson version 1.8. Use INSTANCE
hashCode
public int hashCode ()
All instances of JsonNull have the same hash code since they are indistinguishable
Overrides: hashCode Object
equals
public boolean equals (Object other)
All instances of JsonNull are the same
Overrides: equals Object
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonObject.html 0000664 0000000 0000000 00000100257 12604067504 0024720 0 ustar 00root root 0000000 0000000
JsonObject (Gson 2.3.1 API)
com.google.gson
java.lang.Object
com.google.gson.JsonElement
com.google.gson.JsonObject
public final class JsonObject extends JsonElement
A class representing an object type in Json. An object consists of name-value pairs where names
are strings, and values are any other type of JsonElement
Author: Inderjeet Singh, Joel Leitch
Methods inherited from class com.google.gson.JsonElement
getAsBigDecimal , getAsBigInteger , getAsBoolean , getAsByte , getAsCharacter , getAsDouble , getAsFloat , getAsInt , getAsJsonArray , getAsJsonNull , getAsJsonObject , getAsJsonPrimitive , getAsLong , getAsNumber , getAsShort , getAsString , isJsonArray , isJsonNull , isJsonObject , isJsonPrimitive , toString
JsonObject
public JsonObject ()
add
public void add (String property,
JsonElement value)
Adds a member, which is a name-value pair, to self. The name must be a String, but the value
can be an arbitrary JsonElement, thereby allowing you to build a full tree of JsonElements
rooted at this node.
Parameters: property - name of the member.value - the member object.
remove
public JsonElement remove (String property)
Removes the property from this JsonObject
Parameters: property - name of the member that should be removed.
Returns: the JsonElement Since: 1.3
addProperty
public void addProperty (String property,
String value)
Convenience method to add a primitive member. The specified value is converted to a
JsonPrimitive of String.
Parameters: property - name of the member.value - the string value associated with the member.
addProperty
public void addProperty (String property,
Number value)
Convenience method to add a primitive member. The specified value is converted to a
JsonPrimitive of Number.
Parameters: property - name of the member.value - the number value associated with the member.
addProperty
public void addProperty (String property,
Boolean value)
Convenience method to add a boolean member. The specified value is converted to a
JsonPrimitive of Boolean.
Parameters: property - name of the member.value - the number value associated with the member.
addProperty
public void addProperty (String property,
Character value)
Convenience method to add a char member. The specified value is converted to a
JsonPrimitive of Character.
Parameters: property - name of the member.value - the number value associated with the member.
entrySet
public Set <Map.Entry <String ,JsonElement >> entrySet ()
Returns a set of members of this object. The set is ordered, and the order is in which the
elements were added.
Returns: a set of members of this object.
has
public boolean has (String memberName)
Convenience method to check if a member with the specified name is present in this object.
Parameters: memberName - name of the member that is being checked for presence.
Returns: true if there is a member with the specified name, false otherwise.
get
public JsonElement get (String memberName)
Returns the member with the specified name.
Parameters: memberName - name of the member that is being requested.
Returns: the member matching the name. Null if no such member exists.
getAsJsonPrimitive
public JsonPrimitive getAsJsonPrimitive (String memberName)
Convenience method to get the specified member as a JsonPrimitive element.
Parameters: memberName - name of the member being requested.
Returns: the JsonPrimitive corresponding to the specified member.
getAsJsonArray
public JsonArray getAsJsonArray (String memberName)
Convenience method to get the specified member as a JsonArray.
Parameters: memberName - name of the member being requested.
Returns: the JsonArray corresponding to the specified member.
getAsJsonObject
public JsonObject getAsJsonObject (String memberName)
Convenience method to get the specified member as a JsonObject.
Parameters: memberName - name of the member being requested.
Returns: the JsonObject corresponding to the specified member.
equals
public boolean equals (Object o)
Overrides: equals Object
hashCode
public int hashCode ()
Overrides: hashCode Object
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonParseException.html 0000664 0000000 0000000 00000045577 12604067504 0026460 0 ustar 00root root 0000000 0000000
JsonParseException (Gson 2.3.1 API)
com.google.gson
java.lang.Object
java.lang.Throwable
java.lang.Exception
java.lang.RuntimeException
com.google.gson.JsonParseException
All Implemented Interfaces: Serializable
Direct Known Subclasses: JsonIOException , JsonSyntaxException
public class JsonParseException extends RuntimeException
This exception is raised if there is a serious issue that occurs during parsing of a Json
string. One of the main usages for this class is for the Gson infrastructure. If the incoming
Json is bad/malicious, an instance of this exception is raised.
This exception is a RuntimeExceptionRuntimeExceptionJsonParseException
Author: Inderjeet Singh, Joel Leitch
See Also: Serialized Form
Methods inherited from class java.lang.Throwable
fillInStackTrace , getCause , getLocalizedMessage , getMessage , getStackTrace , initCause , printStackTrace , printStackTrace , printStackTrace , setStackTrace , toString
JsonParseException
public JsonParseException (String msg)
Creates exception with the specified message. If you are wrapping another exception, consider
using JsonParseException(String, Throwable)
Parameters: msg - error message describing a possible cause of this exception.
JsonParseException
public JsonParseException (String msg,
Throwable cause)
Creates exception with the specified message and cause.
Parameters: msg - error message describing what happened.cause - root exception that caused this exception to be thrown.
JsonParseException
public JsonParseException (Throwable cause)
Creates exception with the specified cause. Consider using
JsonParseException(String, Throwable)
Parameters: cause - root exception that caused this exception to be thrown.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonParser.html 0000664 0000000 0000000 00000041734 12604067504 0024752 0 ustar 00root root 0000000 0000000
JsonParser (Gson 2.3.1 API)
com.google.gson
java.lang.Object
com.google.gson.JsonParser
public final class JsonParser extends Object
A parser to parse Json into a parse tree of JsonElement
Since: 1.3
Author: Inderjeet Singh, Joel Leitch
Methods inherited from class java.lang.Object
clone , equals , finalize , getClass , hashCode , notify , notifyAll , toString , wait , wait , wait
JsonParser
public JsonParser ()
parse
public JsonElement parse (String json)
throws JsonSyntaxException
Parses the specified JSON string into a parse tree
Parameters: json - JSON text
Returns: a parse tree of JsonElement Throws:
JsonParseException JsonSyntaxException Since: 1.3
parse
public JsonElement parse (Reader json)
throws JsonIOException ,
JsonSyntaxException
Parses the specified JSON string into a parse tree
Parameters: json - JSON text
Returns: a parse tree of JsonElement Throws:
JsonParseException JsonIOException JsonSyntaxException Since: 1.3
parse
public JsonElement parse (JsonReader json)
throws JsonIOException ,
JsonSyntaxException
Returns the next value from the JSON stream as a parse tree.
Throws:
JsonParseException JsonIOException JsonSyntaxException Since: 1.6
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonPrimitive.html 0000664 0000000 0000000 00000106064 12604067504 0025464 0 ustar 00root root 0000000 0000000
JsonPrimitive (Gson 2.3.1 API)
com.google.gson
java.lang.Object
com.google.gson.JsonElement
com.google.gson.JsonPrimitive
public final class JsonPrimitive extends JsonElement
A class representing a Json primitive value. A primitive value
is either a String, a Java primitive, or a Java primitive
wrapper type.
Author: Inderjeet Singh, Joel Leitch
Method Summary
boolean equals Object obj)
BigDecimal getAsBigDecimal BigDecimal
BigInteger getAsBigInteger BigInteger
boolean getAsBoolean
byte getAsByte
char getAsCharacter
double getAsDouble
float getAsFloat
int getAsInt
long getAsLong
Number getAsNumber
short getAsShort
String getAsString
int hashCode
boolean isBoolean
boolean isNumber
boolean isString
JsonPrimitive
public JsonPrimitive (Boolean bool)
Create a primitive containing a boolean value.
Parameters: bool - the value to create the primitive with.
JsonPrimitive
public JsonPrimitive (Number number)
Create a primitive containing a Number
Parameters: number - the value to create the primitive with.
JsonPrimitive
public JsonPrimitive (String string)
Create a primitive containing a String value.
Parameters: string - the value to create the primitive with.
JsonPrimitive
public JsonPrimitive (Character c)
Create a primitive containing a character. The character is turned into a one character String
since Json only supports String.
Parameters: c - the value to create the primitive with.
isBoolean
public boolean isBoolean ()
Check whether this primitive contains a boolean value.
Returns: true if this primitive contains a boolean value, false otherwise.
getAsBoolean
public boolean getAsBoolean ()
convenience method to get this element as a boolean value.
Overrides: getAsBoolean JsonElement
Returns: get this element as a primitive boolean value.
isNumber
public boolean isNumber ()
Check whether this primitive contains a Number.
Returns: true if this primitive contains a Number, false otherwise.
getAsNumber
public Number getAsNumber ()
convenience method to get this element as a Number.
Overrides: getAsNumber JsonElement
Returns: get this element as a Number.
Throws:
NumberFormatException
isString
public boolean isString ()
Check whether this primitive contains a String value.
Returns: true if this primitive contains a String value, false otherwise.
getAsString
public String getAsString ()
convenience method to get this element as a String.
Overrides: getAsString JsonElement
Returns: get this element as a String.
getAsDouble
public double getAsDouble ()
convenience method to get this element as a primitive double.
Overrides: getAsDouble JsonElement
Returns: get this element as a primitive double.
Throws:
NumberFormatException
getAsBigDecimal
public BigDecimal getAsBigDecimal ()
convenience method to get this element as a BigDecimal
Overrides: getAsBigDecimal JsonElement
Returns: get this element as a BigDecimal Throws:
NumberFormatException BigDecimal
getAsBigInteger
public BigInteger getAsBigInteger ()
convenience method to get this element as a BigInteger
Overrides: getAsBigInteger JsonElement
Returns: get this element as a BigInteger Throws:
NumberFormatException BigInteger
getAsFloat
public float getAsFloat ()
convenience method to get this element as a float.
Overrides: getAsFloat JsonElement
Returns: get this element as a float.
Throws:
NumberFormatException
getAsLong
public long getAsLong ()
convenience method to get this element as a primitive long.
Overrides: getAsLong JsonElement
Returns: get this element as a primitive long.
Throws:
NumberFormatException
getAsShort
public short getAsShort ()
convenience method to get this element as a primitive short.
Overrides: getAsShort JsonElement
Returns: get this element as a primitive short.
Throws:
NumberFormatException
getAsInt
public int getAsInt ()
convenience method to get this element as a primitive integer.
Overrides: getAsInt JsonElement
Returns: get this element as a primitive integer.
Throws:
NumberFormatException
getAsByte
public byte getAsByte ()
Description copied from class: JsonElement convenience method to get this element as a primitive byte value.
Overrides: getAsByte JsonElement
Returns: get this element as a primitive byte value.
getAsCharacter
public char getAsCharacter ()
Description copied from class: JsonElement convenience method to get this element as a primitive character value.
Overrides: getAsCharacter JsonElement
Returns: get this element as a primitive char value.
hashCode
public int hashCode ()
Overrides: hashCode Object
equals
public boolean equals (Object obj)
Overrides: equals Object
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonSerializationContext.html 0000664 0000000 0000000 00000027114 12604067504 0027674 0 ustar 00root root 0000000 0000000
JsonSerializationContext (Gson 2.3.1 API)
com.google.gson
public interface JsonSerializationContext
Context for serialization that is passed to a custom serializer during invocation of its
JsonSerializer.serialize(Object, Type, JsonSerializationContext)
Author: Inderjeet Singh, Joel Leitch
serialize
JsonElement serialize (Object src)
Invokes default serialization on the specified object.
Parameters: src - the object that needs to be serialized.
Returns: a tree of JsonElementsrc.
serialize
JsonElement serialize (Object src,
Type typeOfSrc)
Invokes default serialization on the specified object passing the specific type information.
It should never be invoked on the element received as a parameter of the
JsonSerializer.serialize(Object, Type, JsonSerializationContext)
Parameters: src - the object that needs to be serialized.typeOfSrc - the actual genericized type of src object.
Returns: a tree of JsonElementsrc.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonSerializer.html 0000664 0000000 0000000 00000030361 12604067504 0025621 0 ustar 00root root 0000000 0000000
JsonSerializer (Gson 2.3.1 API)
com.google.gson
Type Parameters: T - type for which the serializer is being registered. It is possible that a serializer
may be asked to serialize a specific generic type of the T.
public interface JsonSerializer<T>
Interface representing a custom serializer for Json. You should write a custom serializer, if
you are not happy with the default serialization done by Gson. You will also need to register
this serializer through GsonBuilder.registerTypeAdapter(Type, Object)
Let us look at example where defining a serializer will be useful. The Id class
defined below has two fields: clazz and value.
public class Id<T> {
private final Class<T> clazz;
private final long value;
public Id(Class<T> clazz, long value) {
this.clazz = clazz;
this.value = value;
}
public long getValue() {
return value;
}
}
The default serialization of Id(com.foo.MyObject.class, 20L) will be
{"clazz":com.foo.MyObject,"value":20}. Suppose, you just want the output to be
the value instead, which is 20 in this case. You can achieve that by writing a custom
serializer:
class IdSerializer implements JsonSerializer<Id>() {
public JsonElement serialize(Id id, Type typeOfId, JsonSerializationContext context) {
return new JsonPrimitive(id.getValue());
}
}
You will also need to register IdSerializer with Gson as follows:
Gson gson = new GsonBuilder().registerTypeAdapter(Id.class, new IdSerializer()).create();
New applications should prefer TypeAdapter
Author: Inderjeet Singh, Joel Leitch
serialize
JsonElement serialize (T src,
Type typeOfSrc,
JsonSerializationContext context)
Gson invokes this call-back method during serialization when it encounters a field of the
specified type.
In the implementation of this call-back method, you should consider invoking
JsonSerializationContext.serialize(Object, Type)src object. However, you should never invoke it on the
src object itself since that will cause an infinite loop (Gson will call your
call-back method again).
Parameters: src - the object that needs to be converted to Json.typeOfSrc - the actual type (fully genericized version) of the source object.
Returns: a JsonElement corresponding to the specified object.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonStreamParser.html 0000664 0000000 0000000 00000045475 12604067504 0026134 0 ustar 00root root 0000000 0000000
JsonStreamParser (Gson 2.3.1 API)
com.google.gson
java.lang.Object
com.google.gson.JsonStreamParser
All Implemented Interfaces: Iterator <JsonElement >
public final class JsonStreamParser extends Object implements Iterator <JsonElement >
A streaming parser that allows reading of multiple JsonElement
This class is conditionally thread-safe (see Item 70, Effective Java second edition). To
properly use this class across multiple threads, you will need to add some external
synchronization. For example:
JsonStreamParser parser = new JsonStreamParser("['first'] {'second':10} 'third'");
JsonElement element;
synchronized (parser) { // synchronize on an object shared by threads
if (parser.hasNext()) {
element = parser.next();
}
}
Since: 1.4
Author: Inderjeet Singh, Joel Leitch
Methods inherited from class java.lang.Object
clone , equals , finalize , getClass , hashCode , notify , notifyAll , toString , wait , wait , wait
JsonStreamParser
public JsonStreamParser (String json)
Parameters: json - The string containing JSON elements concatenated to each other.Since: 1.4
JsonStreamParser
public JsonStreamParser (Reader reader)
Parameters: reader - The data stream containing JSON elements concatenated to each other.Since: 1.4
next
public JsonElement next ()
throws JsonParseException
Returns the next available JsonElement
Specified by: next Iterator <JsonElement >
Returns: the next available JsonElement Throws:
JsonParseException Since: 1.4
hasNext
public boolean hasNext ()
Returns true if a JsonElement
Specified by: hasNext Iterator <JsonElement >
Returns: true if a JsonElement Since: 1.4
remove
public void remove ()
This optional Iterator
Specified by: remove Iterator <JsonElement >
Since: 1.4
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/JsonSyntaxException.html 0000664 0000000 0000000 00000042312 12604067504 0026654 0 ustar 00root root 0000000 0000000
JsonSyntaxException (Gson 2.3.1 API)
com.google.gson
java.lang.Object
java.lang.Throwable
java.lang.Exception
java.lang.RuntimeException
com.google.gson.JsonParseException
com.google.gson.JsonSyntaxException
All Implemented Interfaces: Serializable
public final class JsonSyntaxException extends JsonParseException
This exception is raised when Gson attempts to read (or write) a malformed
JSON element.
Author: Inderjeet Singh, Joel Leitch
See Also: Serialized Form
Methods inherited from class java.lang.Throwable
fillInStackTrace , getCause , getLocalizedMessage , getMessage , getStackTrace , initCause , printStackTrace , printStackTrace , printStackTrace , setStackTrace , toString
JsonSyntaxException
public JsonSyntaxException (String msg)
JsonSyntaxException
public JsonSyntaxException (String msg,
Throwable cause)
JsonSyntaxException
public JsonSyntaxException (Throwable cause)
Creates exception with the specified cause. Consider using
JsonSyntaxException(String, Throwable)
Parameters: cause - root exception that caused this exception to be thrown.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/LongSerializationPolicy.html 0000664 0000000 0000000 00000046472 12604067504 0027505 0 ustar 00root root 0000000 0000000
LongSerializationPolicy (Gson 2.3.1 API)
com.google.gson
java.lang.Object
java.lang.Enum <LongSerializationPolicy >
com.google.gson.LongSerializationPolicy
All Implemented Interfaces: Serializable , Comparable <LongSerializationPolicy >
public enum LongSerializationPolicy extends Enum <LongSerializationPolicy >
Defines the expected format for a long or Long type when its serialized.
Since: 1.3
Author: Inderjeet Singh, Joel Leitch
Enum Constant Summary
DEFAULT long object as a JSON
number.
STRING
DEFAULT
public static final LongSerializationPolicy DEFAULT
This is the "default" serialization policy that will output a long object as a JSON
number. For example, assume an object has a long field named "f" then the serialized output
would be:
{"f":123}.
STRING
public static final LongSerializationPolicy STRING
Serializes a long value as a quoted string. For example, assume an object has a long field
named "f" then the serialized output would be:
{"f":"123"}.
values
public static LongSerializationPolicy [] values ()
Returns an array containing the constants of this enum type, in
the order they are declared. This method may be used to iterate
over the constants as follows:
for (LongSerializationPolicy c : LongSerializationPolicy.values())
System.out.println(c);
Returns: an array containing the constants of this enum type, in
the order they are declared
valueOf
public static LongSerializationPolicy valueOf (String name)
Returns the enum constant of this type with the specified name.
The string must match exactly an identifier used to declare an
enum constant in this type. (Extraneous whitespace characters are
not permitted.)
Parameters: name - the name of the enum constant to be returned.
Returns: the enum constant with the specified name
Throws:
IllegalArgumentException NullPointerException
serialize
public abstract JsonElement serialize (Long value)
Serialize this value using this serialization policy.
Parameters: value - the long value to be serialized into a JsonElementReturns: the serialized version of value
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/TypeAdapter.html 0000664 0000000 0000000 00000075517 12604067504 0025114 0 ustar 00root root 0000000 0000000
TypeAdapter (Gson 2.3.1 API)
com.google.gson
java.lang.Object
com.google.gson.TypeAdapter<T>
public abstract class TypeAdapter<T> extends Object
Converts Java objects to and from JSON.
Defining a type's JSON form
By default Gson converts application classes to JSON using its built-in type
adapters. If Gson's default JSON conversion isn't appropriate for a type,
extend this class to customize the conversion. Here's an example of a type
adapter for an (X,Y) coordinate point: public class PointAdapter extends TypeAdapter<Point> {
public Point read(JsonReader reader) throws IOException {
if (reader.peek() == JsonToken.NULL) {
reader.nextNull();
return null;
}
String xy = reader.nextString();
String[] parts = xy.split(",");
int x = Integer.parseInt(parts[0]);
int y = Integer.parseInt(parts[1]);
return new Point(x, y);
}
public void write(JsonWriter writer, Point value) throws IOException {
if (value == null) {
writer.nullValue();
return;
}
String xy = value.getX() + "," + value.getY();
writer.value(xy);
}
}
With this type adapter installed, Gson will convert Points to JSON as
strings like "5,8" rather than objects like {"x":5,"y":8}. In
this case the type adapter binds a rich Java class to a compact JSON value.
The read()write()nextBoolean(), nextDouble(), nextInt(), nextLong(), nextString() or nextNull(). Writers should make
exactly one call to one of value() or nullValue().
For arrays, type adapters should start with a call to beginArray(),
convert all elements, and finish with a call to endArray(). For
objects, they should start with beginObject(), convert the object,
and finish with endObject(). Failing to convert a value or converting
too many values may cause the application to crash.
Type adapters should be prepared to read null from the stream and write it
to the stream. Alternatively, they should use nullSafe()Gson instance
has been configured to GsonBuilder.serializeNulls()
To use a custom type adapter with Gson, you must register it with a
GsonBuilder
GsonBuilder builder = new GsonBuilder();
builder.registerTypeAdapter(Point.class, new PointAdapter());
// if PointAdapter didn't check for nulls in its read/write methods, you should instead use
// builder.registerTypeAdapter(Point.class, new PointAdapter().nullSafe());
...
Gson gson = builder.create();
Since: 2.1
Method Summary
T fromJson Reader in)in to a Java object.
T fromJson String json)json to a Java object.
T fromJsonTree JsonElement jsonTree)jsonTree to a Java object.
TypeAdapter <T > nullSafe
abstract T read JsonReader in)
String toJson T value)value to a JSON document.
void toJson Writer out,
T value)value to a JSON document and writes it to out.
JsonElement toJsonTree T value)value to a JSON tree.
abstract void write JsonWriter out,
T value)value.
Methods inherited from class java.lang.Object
clone , equals , finalize , getClass , hashCode , notify , notifyAll , toString , wait , wait , wait
TypeAdapter
public TypeAdapter ()
write
public abstract void write (JsonWriter out,
T value)
throws IOException
Writes one JSON value (an array, object, string, number, boolean or null)
for value.
Parameters: value - the Java object to write. May be null.
Throws:
IOException
toJson
public final void toJson (Writer out,
T value)
throws IOException
Converts value to a JSON document and writes it to out.
Unlike Gson's similar toJsonlenientJsonWriter and call
write(com.google.gson.stream.JsonWriter, Object)
Parameters: value - the Java object to convert. May be null.
Throws:
IOException Since: 2.2
nullSafe
public final TypeAdapter <T > nullSafe ()
This wrapper method is used to make a type adapter null tolerant. In general, a
type adapter is required to handle nulls in write and read methods. Here is how this
is typically done: Gson gson = new GsonBuilder().registerTypeAdapter(Foo.class,
new TypeAdapter<Foo>() {
public Foo read(JsonReader in) throws IOException {
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
// read a Foo from in and return it
}
public void write(JsonWriter out, Foo src) throws IOException {
if (src == null) {
out.nullValue();
return;
}
// write src as JSON to out
}
}).create();
You can avoid this boilerplate handling of nulls by wrapping your type adapter with
this method. Here is how we will rewrite the above example:
Gson gson = new GsonBuilder().registerTypeAdapter(Foo.class,
new TypeAdapter<Foo>() {
public Foo read(JsonReader in) throws IOException {
// read a Foo from in and return it
}
public void write(JsonWriter out, Foo src) throws IOException {
// write src as JSON to out
}
}.nullSafe()).create();
Note that we didn't need to check for nulls in our type adapter after we used nullSafe.
toJson
public final String toJson (T value)
throws IOException
Converts value to a JSON document. Unlike Gson's similar toJsonlenientJsonWriter and call
write(com.google.gson.stream.JsonWriter, Object)
Parameters: value - the Java object to convert. May be null.
Throws:
IOException Since: 2.2
toJsonTree
public final JsonElement toJsonTree (T value)
Converts value to a JSON tree.
Parameters: value - the Java object to convert. May be null.
Returns: the converted JSON tree. May be JsonNull Since: 2.2
read
public abstract T read (JsonReader in)
throws IOException
Reads one JSON value (an array, object, string, number, boolean or null)
and converts it to a Java object. Returns the converted object.
Returns: the converted Java object. May be null.
Throws:
IOException
fromJson
public final T fromJson (Reader in)
throws IOException
Converts the JSON document in in to a Java object. Unlike Gson's
similar fromJsonlenientJsonReader and call read(JsonReader)
Returns: the converted Java object. May be null.
Throws:
IOException Since: 2.2
fromJson
public final T fromJson (String json)
throws IOException
Converts the JSON document in json to a Java object. Unlike Gson's
similar fromJsonlenientJsonReader and call read(JsonReader)
Returns: the converted Java object. May be null.
Throws:
IOException Since: 2.2
fromJsonTree
public final T fromJsonTree (JsonElement jsonTree)
Converts jsonTree to a Java object.
Parameters: jsonTree - the Java object to convert. May be JsonNullSince: 2.2
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/TypeAdapterFactory.html 0000664 0000000 0000000 00000035233 12604067504 0026433 0 ustar 00root root 0000000 0000000
TypeAdapterFactory (Gson 2.3.1 API)
com.google.gson
public interface TypeAdapterFactory
Creates type adapters for set of related types. Type adapter factories are
most useful when several types share similar structure in their JSON form.
Example: Converting enums to lowercase
In this example, we implement a factory that creates type adapters for all
enums. The type adapters will write enums in lowercase, despite the fact
that they're defined in CONSTANT_CASE in the corresponding Java
model: public class LowercaseEnumTypeAdapterFactory implements TypeAdapterFactory {
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
Class<T> rawType = (Class<T>) type.getRawType();
if (!rawType.isEnum()) {
return null;
}
final Map<String, T> lowercaseToConstant = new HashMap<String, T>();
for (T constant : rawType.getEnumConstants()) {
lowercaseToConstant.put(toLowercase(constant), constant);
}
return new TypeAdapter<T>() {
public void write(JsonWriter out, T value) throws IOException {
if (value == null) {
out.nullValue();
} else {
out.value(toLowercase(value));
}
}
public T read(JsonReader reader) throws IOException {
if (reader.peek() == JsonToken.NULL) {
reader.nextNull();
return null;
} else {
return lowercaseToConstant.get(reader.nextString());
}
}
};
}
private String toLowercase(Object o) {
return o.toString().toLowerCase(Locale.US);
}
}
Type adapter factories select which types they provide type adapters
for. If a factory cannot support a given type, it must return null when
that type is passed to create(com.google.gson.Gson, com.google.gson.reflect.TypeToken) create() to be called on them for many types and should return null for
most of those types. In the above example the factory returns null for
calls to create() where type is not an enum.
A factory is typically called once per type, but the returned type
adapter may be used many times. It is most efficient to do expensive work
like reflection in create() so that the type adapter's read() and write() methods can be very fast. In this example the
mapping from lowercase name to enum value is computed eagerly.
As with type adapters, factories must be registered with a GsonBuilder
GsonBuilder builder = new GsonBuilder();
builder.registerTypeAdapterFactory(new LowercaseEnumTypeAdapterFactory());
...
Gson gson = builder.create();
If multiple factories support the same type, the factory registered earlier
takes precedence.
Example: composing other type adapters
In this example we implement a factory for Guava's Multiset
collection type. The factory can be used to create type adapters for
multisets of any element type: the type adapter for Multiset<String> is different from the type adapter for Multiset<URL>.
The type adapter delegates to another type adapter for the
multiset elements. It figures out the element type by reflecting on the
multiset's type token. A Gson is passed in to create for
just this purpose:
public class MultisetTypeAdapterFactory implements TypeAdapterFactory {
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
Type type = typeToken.getType();
if (typeToken.getRawType() != Multiset.class
|| !(type instanceof ParameterizedType)) {
return null;
}
Type elementType = ((ParameterizedType) type).getActualTypeArguments()[0];
TypeAdapter<?> elementAdapter = gson.getAdapter(TypeToken.get(elementType));
return (TypeAdapter<T>) newMultisetAdapter(elementAdapter);
}
private <E> TypeAdapter<Multiset<E>> newMultisetAdapter(
final TypeAdapter<E> elementAdapter) {
return new TypeAdapter<Multiset<E>>() {
public void write(JsonWriter out, Multiset<E> value) throws IOException {
if (value == null) {
out.nullValue();
return;
}
out.beginArray();
for (Multiset.Entry<E> entry : value.entrySet()) {
out.value(entry.getCount());
elementAdapter.write(out, entry.getElement());
}
out.endArray();
}
public Multiset<E> read(JsonReader in) throws IOException {
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
Multiset<E> result = LinkedHashMultiset.create();
in.beginArray();
while (in.hasNext()) {
int count = in.nextInt();
E element = elementAdapter.read(in);
result.add(element, count);
}
in.endArray();
return result;
}
};
}
}
Delegating from one type adapter to another is extremely powerful; it's
the foundation of how Gson converts Java objects and collections. Whenever
possible your factory should retrieve its delegate type adapter in the
create() method; this ensures potentially-expensive type adapter
creation happens only once.
Since: 2.1
Method Summary
create Gson gson,
TypeToken <T> type)type, or null if this factory doesn't
support type.
create
<T> TypeAdapter <T> create (Gson gson,
TypeToken <T> type)
Returns a type adapter for type, or null if this factory doesn't
support type.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/ 0000775 0000000 0000000 00000000000 12604067504 0024322 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/Expose.html 0000664 0000000 0000000 00000030070 12604067504 0026453 0 ustar 00root root 0000000 0000000
Expose (Gson 2.3.1 API)
com.google.gson.annotations
@Retention (value =RUNTIME )
@Target (value =FIELD )
Expose
An annotation that indicates this member should be exposed for JSON
serialization or deserialization.
This annotation has no effect unless you build GsonGsonBuilderGsonBuilder.excludeFieldsWithoutExposeAnnotation()
Here is an example of how this annotation is meant to be used:
public class User {
@Expose private String firstName;
@Expose(serialize = false) private String lastName;
@Expose (serialize = false, deserialize = false) private String emailAddress;
private String password;
}
If you created Gson with new Gson(), the toJson() and fromJson()
methods will use the password field along-with firstName, lastName,
and emailAddress for serialization and deserialization. However, if you created Gson
with Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create()
then the toJson() and fromJson() methods of Gson will exclude the
password field. This is because the password field is not marked with the
@Expose annotation. Gson will also exclude lastName and emailAddress
from serialization since serialize is set to false. Similarly, Gson will
exclude emailAddress from deserialization since deserialize is set to false.
Note that another way to achieve the same effect would have been to just mark the
password field as transient, and Gson would have excluded it even with default
settings. The @Expose annotation is useful in a style of programming where you want to
explicitly specify all fields that should get considered for serialization or deserialization.
Author: Inderjeet Singh, Joel Leitch
Optional Element Summary
boolean deserialize true, the field marked with this annotation is deserialized from the JSON.
boolean serialize true, the field marked with this annotation is written out in the JSON while
serializing.
serialize
public abstract boolean serialize
If true, the field marked with this annotation is written out in the JSON while
serializing. If false, the field marked with this annotation is skipped from the
serialized output. Defaults to true.
Since: 1.4
Default: true
deserialize
public abstract boolean deserialize
If true, the field marked with this annotation is deserialized from the JSON.
If false, the field marked with this annotation is skipped during deserialization.
Defaults to true.
Since: 1.4
Default: true
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/JsonAdapter.html 0000664 0000000 0000000 00000031052 12604067504 0027423 0 ustar 00root root 0000000 0000000
JsonAdapter (Gson 2.3.1 API)
com.google.gson.annotations
@Retention (value =RUNTIME )
@Target (value ={TYPE ,FIELD })
JsonAdapter
An annotation that indicates the Gson TypeAdapter
Here is an example of how this annotation is used:
@JsonAdapter(UserJsonAdapter.class)
public class User {
public final String firstName, lastName;
private User(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}
public class UserJsonAdapter extends TypeAdapter<User> {
@Override public void write(JsonWriter out, User user) throws IOException {
// implement write: combine firstName and lastName into name
out.beginObject();
out.name("name");
out.value(user.firstName + " " + user.lastName);
out.endObject();
// implement the write method
}
@Override public User read(JsonReader in) throws IOException {
// implement read: split name into firstName and lastName
in.beginObject();
in.nextName();
String[] nameParts = in.nextString().split(" ");
in.endObject();
return new User(nameParts[0], nameParts[1]);
}
}
Since User class specified UserJsonAdapter.class in @JsonAdapter annotation, it
will automatically be invoked to serialize/deserialize User instances. Here is an example of how to apply this annotation to a field.
private static final class Gadget {
@JsonAdapter(UserJsonAdapter2.class)
final User user;
Gadget(User user) {
this.user = user;
}
}
It's possible to specify different type adapters on a field, that
field's type, and in the GsonBuilderGsonBuilder-registered type
adapters, which in turn take precedence over annotated types.
The class referenced by this annotation must be either a TypeAdapterTypeAdapterFactoryGson instance.
Since: 2.3
Author: Inderjeet Singh, Joel Leitch, Jesse Wilson
value
public abstract Class <?> value
Either a TypeAdapterTypeAdapterFactory
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/SerializedName.html 0000664 0000000 0000000 00000026456 12604067504 0030121 0 ustar 00root root 0000000 0000000
SerializedName (Gson 2.3.1 API)
com.google.gson.annotations
@Retention (value =RUNTIME )
@Target (value =FIELD )
SerializedName
An annotation that indicates this member should be serialized to JSON with
the provided name value as its field name.
This annotation will override any FieldNamingPolicyGsonGsonBuilder class. See
GsonBuilder.setFieldNamingPolicy(com.google.gson.FieldNamingPolicy)
Here is an example of how this annotation is meant to be used:
public class SomeClassWithFields {
@SerializedName("name") private final String someField;
private final String someOtherField;
public SomeClassWithFields(String a, String b) {
this.someField = a;
this.someOtherField = b;
}
}
The following shows the output that is generated when serializing an instance of the
above example class:
SomeClassWithFields objectToSerialize = new SomeClassWithFields("a", "b");
Gson gson = new Gson();
String jsonRepresentation = gson.toJson(objectToSerialize);
System.out.println(jsonRepresentation);
===== OUTPUT =====
{"name":"a","someOtherField":"b"}
NOTE: The value you specify in this annotation must be a valid JSON field name.
Author: Inderjeet Singh, Joel Leitch
See Also: FieldNamingPolicy
value
public abstract String value
Returns: the desired name of the field when it is serialized
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/Since.html 0000664 0000000 0000000 00000025511 12604067504 0026255 0 ustar 00root root 0000000 0000000
Since (Gson 2.3.1 API)
com.google.gson.annotations
@Retention (value =RUNTIME )
@Target (value ={FIELD ,TYPE })
Since
An annotation that indicates the version number since a member or a type has been present.
This annotation is useful to manage versioning of your Json classes for a web-service.
This annotation has no effect unless you build GsonGsonBuilderGsonBuilder.setVersion(double)
Here is an example of how this annotation is meant to be used:
public class User {
private String firstName;
private String lastName;
@Since(1.0) private String emailAddress;
@Since(1.0) private String password;
@Since(1.1) private Address address;
}
If you created Gson with new Gson(), the toJson() and fromJson()
methods will use all the fields for serialization and deserialization. However, if you created
Gson with Gson gson = new GsonBuilder().setVersion(1.0).create() then the
toJson() and fromJson() methods of Gson will exclude the address field
since it's version number is set to 1.1.
Author: Inderjeet Singh, Joel Leitch
Required Element Summary
double value
value
public abstract double value
the value indicating a version number since this member
or type has been present.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/Until.html 0000664 0000000 0000000 00000025642 12604067504 0026314 0 ustar 00root root 0000000 0000000
Until (Gson 2.3.1 API)
com.google.gson.annotations
@Retention (value =RUNTIME )
@Target (value ={FIELD ,TYPE })
Until
An annotation that indicates the version number until a member or a type should be present.
Basically, if Gson is created with a version number that exceeds the value stored in the
Until annotation then the field will be ignored from the JSON output. This annotation
is useful to manage versioning of your JSON classes for a web-service.
This annotation has no effect unless you build GsonGsonBuilderGsonBuilder.setVersion(double)
Here is an example of how this annotation is meant to be used:
public class User {
private String firstName;
private String lastName;
@Until(1.1) private String emailAddress;
@Until(1.1) private String password;
}
If you created Gson with new Gson(), the toJson() and fromJson()
methods will use all the fields for serialization and deserialization. However, if you created
Gson with Gson gson = new GsonBuilder().setVersion(1.2).create() then the
toJson() and fromJson() methods of Gson will exclude the emailAddress
and password fields from the example above, because the version number passed to the
GsonBuilder, 1.2, exceeds the version number set on the Until annotation,
1.1, for those fields.
Since: 1.3
Author: Inderjeet Singh, Joel Leitch
Required Element Summary
double value
value
public abstract double value
the value indicating a version number until this member
or type should be ignored.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/class-use/ 0000775 0000000 0000000 00000000000 12604067504 0026221 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/class-use/Expose.html 0000664 0000000 0000000 00000013700 12604067504 0030353 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.annotations.Expose (Gson 2.3.1 API)
Uses of Class
No usage of com.google.gson.annotations.Expose
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/class-use/JsonAdapter.html 0000664 0000000 0000000 00000013762 12604067504 0031332 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.annotations.JsonAdapter (Gson 2.3.1 API)
Uses of Class
No usage of com.google.gson.annotations.JsonAdapter
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/class-use/SerializedName.html 0000664 0000000 0000000 00000014020 12604067504 0032000 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.annotations.SerializedName (Gson 2.3.1 API)
Uses of Class
No usage of com.google.gson.annotations.SerializedName
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/class-use/Since.html 0000664 0000000 0000000 00000013666 12604067504 0030164 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.annotations.Since (Gson 2.3.1 API)
Uses of Class
No usage of com.google.gson.annotations.Since
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/class-use/Until.html 0000664 0000000 0000000 00000013666 12604067504 0030216 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.annotations.Until (Gson 2.3.1 API)
Uses of Class
No usage of com.google.gson.annotations.Until
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/package-frame.html 0000664 0000000 0000000 00000002643 12604067504 0027700 0 ustar 00root root 0000000 0000000
com.google.gson.annotations (Gson 2.3.1 API)
com.google.gson.annotations
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/package-summary.html 0000664 0000000 0000000 00000020512 12604067504 0030276 0 ustar 00root root 0000000 0000000
com.google.gson.annotations (Gson 2.3.1 API)
Package com.google.gson.annotations
This package provides annotations that can be used with Gson
See:
Description
Annotation Types Summary
Expose An annotation that indicates this member should be exposed for JSON
serialization or deserialization.
JsonAdapter An annotation that indicates the Gson TypeAdapter
SerializedName An annotation that indicates this member should be serialized to JSON with
the provided name value as its field name.
Since An annotation that indicates the version number since a member or a type has been present.
Until An annotation that indicates the version number until a member or a type should be present.
Package com.google.gson.annotations Description
This package provides annotations that can be used with Gson
Author: Inderjeet Singh, Joel Leitch
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/package-tree.html 0000664 0000000 0000000 00000017517 12604067504 0027553 0 ustar 00root root 0000000 0000000
com.google.gson.annotations Class Hierarchy (Gson 2.3.1 API)
Hierarchy For Package com.google.gson.annotations
Package Hierarchies: All Packages
Annotation Type Hierarchy
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/annotations/package-use.html 0000664 0000000 0000000 00000013165 12604067504 0027403 0 ustar 00root root 0000000 0000000
Uses of Package com.google.gson.annotations (Gson 2.3.1 API)
Uses of Package
No usage of com.google.gson.annotations
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/ 0000775 0000000 0000000 00000000000 12604067504 0023664 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/ExclusionStrategy.html 0000664 0000000 0000000 00000023004 12604067504 0030245 0 ustar 00root root 0000000 0000000
Uses of Interface com.google.gson.ExclusionStrategy (Gson 2.3.1 API)
Uses of Interface
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/FieldAttributes.html 0000664 0000000 0000000 00000017451 12604067504 0027654 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.FieldAttributes (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/FieldNamingPolicy.html 0000664 0000000 0000000 00000023244 12604067504 0030114 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.FieldNamingPolicy (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/FieldNamingStrategy.html 0000664 0000000 0000000 00000021734 12604067504 0030461 0 ustar 00root root 0000000 0000000
Uses of Interface com.google.gson.FieldNamingStrategy (Gson 2.3.1 API)
Uses of Interface
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/Gson.html 0000664 0000000 0000000 00000022076 12604067504 0025467 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.Gson (Gson 2.3.1 API)
Uses of Class
Packages that use Gson
com.google.gson This package provides the Gson
Methods in com.google.gson with parameters of type Gson
TypeAdapterFactory. create Gson gson,
TypeToken <T> type)type, or null if this factory doesn't
support type.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/GsonBuilder.html 0000664 0000000 0000000 00000053073 12604067504 0026777 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.GsonBuilder (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/InstanceCreator.html 0000664 0000000 0000000 00000013571 12604067504 0027645 0 ustar 00root root 0000000 0000000
Uses of Interface com.google.gson.InstanceCreator (Gson 2.3.1 API)
Uses of Interface
No usage of com.google.gson.InstanceCreator
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonArray.html 0000664 0000000 0000000 00000022537 12604067504 0026473 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.JsonArray (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonDeserializationContext.html 0000664 0000000 0000000 00000021105 12604067504 0032076 0 ustar 00root root 0000000 0000000
Uses of Interface com.google.gson.JsonDeserializationContext (Gson 2.3.1 API)
Uses of Interface
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonDeserializer.html 0000664 0000000 0000000 00000013603 12604067504 0030031 0 ustar 00root root 0000000 0000000
Uses of Interface com.google.gson.JsonDeserializer (Gson 2.3.1 API)
Uses of Interface
No usage of com.google.gson.JsonDeserializer
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonElement.html 0000664 0000000 0000000 00000100525 12604067504 0027000 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.JsonElement (Gson 2.3.1 API)
Uses of Class
Methods in com.google.gson with parameters of type JsonElement
void JsonArray. add JsonElement element)
void JsonObject. add String property,
JsonElement value)
boolean JsonArray. contains JsonElement element)
JsonDeserializationContext. deserialize JsonElement json,
Type typeOfT)
T JsonDeserializer. deserialize JsonElement json,
Type typeOfT,
JsonDeserializationContext context)
Gson. fromJson JsonElement json,
Class <T> classOfT)
Gson. fromJson JsonElement json,
Type typeOfT)
T TypeAdapter. fromJsonTree JsonElement jsonTree)jsonTree to a Java object.
boolean JsonArray. remove JsonElement element)
JsonElement JsonArray. set JsonElement element)
String Gson. toJson JsonElement jsonElement)JsonElement
void Gson. toJson JsonElement jsonElement,
Appendable writer)JsonElement
void Gson. toJson JsonElement jsonElement,
JsonWriter writer)jsonElement to writer.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonIOException.html 0000664 0000000 0000000 00000037022 12604067504 0027576 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.JsonIOException (Gson 2.3.1 API)
Uses of Class
Methods in com.google.gson that throw JsonIOException
Gson. fromJson JsonReader reader,
Type typeOfT)reader and convert it to an object
of type typeOfT.
Gson. fromJson Reader json,
Class <T> classOfT)
Gson. fromJson Reader json,
Type typeOfT)
JsonElement JsonParser. parse JsonReader json)
JsonElement JsonParser. parse Reader json)
void Gson. toJson JsonElement jsonElement,
Appendable writer)JsonElement
void Gson. toJson JsonElement jsonElement,
JsonWriter writer)jsonElement to writer.
void Gson. toJson Object src,
Appendable writer)
void Gson. toJson Object src,
Type typeOfSrc,
Appendable writer)
void Gson. toJson Object src,
Type typeOfSrc,
JsonWriter writer)src of type typeOfSrc to
writer.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonNull.html 0000664 0000000 0000000 00000021113 12604067504 0026314 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.JsonNull (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonObject.html 0000664 0000000 0000000 00000020730 12604067504 0026614 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.JsonObject (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonParseException.html 0000664 0000000 0000000 00000026267 12604067504 0030352 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.JsonParseException (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonParser.html 0000664 0000000 0000000 00000013463 12604067504 0026647 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.JsonParser (Gson 2.3.1 API)
Uses of Class
No usage of com.google.gson.JsonParser
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonPrimitive.html 0000664 0000000 0000000 00000021056 12604067504 0027360 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.JsonPrimitive (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonSerializationContext.html 0000664 0000000 0000000 00000020766 12604067504 0031601 0 ustar 00root root 0000000 0000000
Uses of Interface com.google.gson.JsonSerializationContext (Gson 2.3.1 API)
Uses of Interface
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonSerializer.html 0000664 0000000 0000000 00000013557 12604067504 0027530 0 ustar 00root root 0000000 0000000
Uses of Interface com.google.gson.JsonSerializer (Gson 2.3.1 API)
Uses of Interface
No usage of com.google.gson.JsonSerializer
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonStreamParser.html 0000664 0000000 0000000 00000013557 12604067504 0030027 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.JsonStreamParser (Gson 2.3.1 API)
Uses of Class
No usage of com.google.gson.JsonStreamParser
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/JsonSyntaxException.html 0000664 0000000 0000000 00000037271 12604067504 0030563 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.JsonSyntaxException (Gson 2.3.1 API)
Uses of Class
Methods in com.google.gson that throw JsonSyntaxException
Gson. fromJson JsonElement json,
Class <T> classOfT)
Gson. fromJson JsonElement json,
Type typeOfT)
Gson. fromJson JsonReader reader,
Type typeOfT)reader and convert it to an object
of type typeOfT.
Gson. fromJson Reader json,
Class <T> classOfT)
Gson. fromJson Reader json,
Type typeOfT)
Gson. fromJson String json,
Class <T> classOfT)
Gson. fromJson String json,
Type typeOfT)
JsonElement JsonParser. parse JsonReader json)
JsonElement JsonParser. parse Reader json)
JsonElement JsonParser. parse String json)
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/LongSerializationPolicy.html 0000664 0000000 0000000 00000023530 12604067504 0031372 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.LongSerializationPolicy (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/TypeAdapter.html 0000664 0000000 0000000 00000026703 12604067504 0027004 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.TypeAdapter (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/class-use/TypeAdapterFactory.html 0000664 0000000 0000000 00000022060 12604067504 0030324 0 ustar 00root root 0000000 0000000
Uses of Interface com.google.gson.TypeAdapterFactory (Gson 2.3.1 API)
Uses of Interface
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/package-frame.html 0000664 0000000 0000000 00000007752 12604067504 0025351 0 ustar 00root root 0000000 0000000
com.google.gson (Gson 2.3.1 API)
com.google.gson
gson-gson-2.4/gson/docs/javadocs/com/google/gson/package-summary.html 0000664 0000000 0000000 00000035274 12604067504 0025754 0 ustar 00root root 0000000 0000000
com.google.gson (Gson 2.3.1 API)
Package com.google.gson
This package provides the Gson
See:
Description
Class Summary
FieldAttributes A data object that stores attributes of a field.
Gson This is the main class for using Gson.
GsonBuilder Use this builder to construct a Gson
JsonArray A class representing an array type in Json.
JsonElement A class representing an element of Json.
JsonNull A class representing a Json null value.
JsonObject A class representing an object type in Json.
JsonParser A parser to parse Json into a parse tree of JsonElement
JsonPrimitive A class representing a Json primitive value.
JsonStreamParser A streaming parser that allows reading of multiple JsonElement
TypeAdapter<T> Converts Java objects to and from JSON.
Enum Summary
FieldNamingPolicy An enumeration that defines a few standard naming conventions for JSON field names.
LongSerializationPolicy Defines the expected format for a long or Long type when its serialized.
Exception Summary
JsonIOException This exception is raised when Gson was unable to read an input stream
or write to one.
JsonParseException This exception is raised if there is a serious issue that occurs during parsing of a Json
string.
JsonSyntaxException This exception is raised when Gson attempts to read (or write) a malformed
JSON element.
Package com.google.gson Description
This package provides the Gson
The primary class to use is Gsonnew Gson() (using default settings) or by using GsonBuilder
Author: Inderjeet Singh, Joel Leitch
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/package-tree.html 0000664 0000000 0000000 00000026776 12604067504 0025225 0 ustar 00root root 0000000 0000000
com.google.gson Class Hierarchy (Gson 2.3.1 API)
Hierarchy For Package com.google.gson
Package Hierarchies: All Packages
Class Hierarchy
Interface Hierarchy
Enum Hierarchy
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/package-use.html 0000664 0000000 0000000 00000031552 12604067504 0025046 0 ustar 00root root 0000000 0000000
Uses of Package com.google.gson (Gson 2.3.1 API)
Uses of Package
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/reflect/ 0000775 0000000 0000000 00000000000 12604067504 0023411 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/docs/javadocs/com/google/gson/reflect/TypeToken.html 0000664 0000000 0000000 00000055437 12604067504 0026237 0 ustar 00root root 0000000 0000000
TypeToken (Gson 2.3.1 API)
com.google.gson.reflect
java.lang.Object
com.google.gson.reflect.TypeToken<T>
public class TypeToken<T> extends Object
Represents a generic type T. Java doesn't yet provide a way to
represent generic types, so this class does. Forces clients to create a
subclass of this class which enables retrieval the type information even at
runtime.
For example, to create a type literal for List<String>, you can
create an empty anonymous inner class:
TypeToken<List<String>> list = new TypeToken<List<String>>() {};
This syntax cannot be used to create type literals that have wildcard
parameters, such as Class<?> or List<? extends CharSequence>.
Author: Bob Lee, Sven Mawson, Jesse Wilson
Constructor Summary
protected TypeToken
TypeToken
protected TypeToken ()
Constructs a new type literal. Derives represented class from type
parameter.
Clients create an empty anonymous subclass. Doing so embeds the type
parameter in the anonymous class's type hierarchy so we can reconstitute it
at runtime despite erasure.
getRawType
public final Class <? super T > getRawType ()
Returns the raw (non-generic) type for this type.
getType
public final Type getType ()
Gets underlying Type instance.
isAssignableFrom
@Deprecated
isAssignableFrom (Class <?> cls)
Deprecated. this implementation may be inconsistent with javac for types
with wildcards.
Check if this type is assignable from the given class object.
isAssignableFrom
@Deprecated
isAssignableFrom (Type from)
Deprecated. this implementation may be inconsistent with javac for types
with wildcards.
Check if this type is assignable from the given Type.
isAssignableFrom
@Deprecated
isAssignableFrom (TypeToken <?> token)
Deprecated. this implementation may be inconsistent with javac for types
with wildcards.
Check if this type is assignable from the given type token.
hashCode
public final int hashCode ()
Overrides: hashCode Object
equals
public final boolean equals (Object o)
Overrides: equals Object
toString
public final String toString ()
Overrides: toString Object
get
public static TypeToken <?> get (Type type)
Gets type literal for the given Type instance.
get
public static <T> TypeToken <T> get (Class <T> type)
Gets type literal for the given Class instance.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/reflect/class-use/ 0000775 0000000 0000000 00000000000 12604067504 0025310 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/docs/javadocs/com/google/gson/reflect/class-use/TypeToken.html 0000664 0000000 0000000 00000033741 12604067504 0030130 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.reflect.TypeToken (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/reflect/package-frame.html 0000664 0000000 0000000 00000001705 12604067504 0026765 0 ustar 00root root 0000000 0000000
com.google.gson.reflect (Gson 2.3.1 API)
com.google.gson.reflect
gson-gson-2.4/gson/docs/javadocs/com/google/gson/reflect/package-summary.html 0000664 0000000 0000000 00000015454 12604067504 0027376 0 ustar 00root root 0000000 0000000
com.google.gson.reflect (Gson 2.3.1 API)
Package com.google.gson.reflect
This package provides utility classes for finding type information for generic types.
See:
Description
Package com.google.gson.reflect Description
This package provides utility classes for finding type information for generic types.
Author: Inderjeet Singh, Joel Leitch
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/reflect/package-tree.html 0000664 0000000 0000000 00000014427 12604067504 0026637 0 ustar 00root root 0000000 0000000
com.google.gson.reflect Class Hierarchy (Gson 2.3.1 API)
Hierarchy For Package com.google.gson.reflect
Package Hierarchies: All Packages
Class Hierarchy
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/reflect/package-use.html 0000664 0000000 0000000 00000017515 12604067504 0026475 0 ustar 00root root 0000000 0000000
Uses of Package com.google.gson.reflect (Gson 2.3.1 API)
Uses of Package
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/ 0000775 0000000 0000000 00000000000 12604067504 0023260 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/JsonReader.html 0000664 0000000 0000000 00000127463 12604067504 0026217 0 ustar 00root root 0000000 0000000
JsonReader (Gson 2.3.1 API)
com.google.gson.stream
java.lang.Object
com.google.gson.stream.JsonReader
All Implemented Interfaces: Closeable
public class JsonReader extends Object implements Closeable
Reads a JSON (RFC 4627 )
encoded value as a stream of tokens. This stream includes both literal
values (strings, numbers, booleans, and nulls) as well as the begin and
end delimiters of objects and arrays. The tokens are traversed in
depth-first order, the same order that they appear in the JSON document.
Within JSON objects, name/value pairs are represented by a single token.
Parsing JSON
To create a recursive descent parser for your own JSON streams, first create
an entry point method that creates a JsonReader.
Next, create handler methods for each structure in your JSON text. You'll
need a method for each object type and for each array type.
Within array handling methods, first call beginArray()hasNext()endArray() Within object handling methods, first call beginObject()hasNext()endObject()
When a nested object or array is encountered, delegate to the
corresponding handler method.
When an unknown name is encountered, strict parsers should fail with an
exception. Lenient parsers should call skipValue()
If a value may be null, you should first check using peek()nextNull()skipValue()
Example
Suppose we'd like to parse a stream of messages such as the following: [
{
"id": 912345678901,
"text": "How do I read a JSON stream in Java?",
"geo": null,
"user": {
"name": "json_newb",
"followers_count": 41
}
},
{
"id": 912345678902,
"text": "@json_newb just use JsonReader!",
"geo": [50.454722, -104.606667],
"user": {
"name": "jesse",
"followers_count": 2
}
}
]
This code implements the parser for the above structure: public List<Message> readJsonStream(InputStream in) throws IOException {
JsonReader reader = new JsonReader(new InputStreamReader(in, "UTF-8"));
try {
return readMessagesArray(reader);
} finally {
reader.close();
}
}
public List<Message> readMessagesArray(JsonReader reader) throws IOException {
List<Message> messages = new ArrayList<Message>();
reader.beginArray();
while (reader.hasNext()) {
messages.add(readMessage(reader));
}
reader.endArray();
return messages;
}
public Message readMessage(JsonReader reader) throws IOException {
long id = -1;
String text = null;
User user = null;
List<Double> geo = null;
reader.beginObject();
while (reader.hasNext()) {
String name = reader.nextName();
if (name.equals("id")) {
id = reader.nextLong();
} else if (name.equals("text")) {
text = reader.nextString();
} else if (name.equals("geo") && reader.peek() != JsonToken.NULL) {
geo = readDoublesArray(reader);
} else if (name.equals("user")) {
user = readUser(reader);
} else {
reader.skipValue();
}
}
reader.endObject();
return new Message(id, text, user, geo);
}
public List<Double> readDoublesArray(JsonReader reader) throws IOException {
List<Double> doubles = new ArrayList<Double>();
reader.beginArray();
while (reader.hasNext()) {
doubles.add(reader.nextDouble());
}
reader.endArray();
return doubles;
}
public User readUser(JsonReader reader) throws IOException {
String username = null;
int followersCount = -1;
reader.beginObject();
while (reader.hasNext()) {
String name = reader.nextName();
if (name.equals("name")) {
username = reader.nextString();
} else if (name.equals("followers_count")) {
followersCount = reader.nextInt();
} else {
reader.skipValue();
}
}
reader.endObject();
return new User(username, followersCount);
}
Number Handling
This reader permits numeric values to be read as strings and string values to
be read as numbers. For example, both elements of the JSON array [1, "1"] may be read using either nextInt()nextString()9007199254740993 cannot be represented exactly on that platform. To minimize
precision loss, extremely large values should be written and read as strings
in JSON.
Non-Execute Prefix
Web servers that serve private data using JSON may be vulnerable to Cross-site
request forgery attacks. In such an attack, a malicious site gains access
to a private JSON file by executing it with an HTML <script> tag.
Prefixing JSON files with ")]}'\n" makes them non-executable
by <script> tags, disarming the attack. Since the prefix is malformed
JSON, strict parsing fails when it is encountered. This class permits the
non-execute prefix when lenient parsing
Each JsonReader may be used to read a single JSON stream. Instances
of this class are not thread safe.
Since: 1.6
Author: Jesse Wilson
Constructor Summary
JsonReader Reader in)in.
Method Summary
void beginArray
void beginObject
void close Reader
void endArray
void endObject
String getPath JsonPath to
the current location in the JSON value.
boolean hasNext
boolean isLenient
boolean nextBoolean boolean
double nextDouble double
int nextInt int
long nextLong long
String nextName property name
void nextNull
String nextString string
JsonToken peek
void setLenient
void skipValue
String toString
JsonReader
public JsonReader (Reader in)
Creates a new instance that reads a JSON-encoded stream from in.
setLenient
public final void setLenient (boolean lenient)
Configure this parser to be be liberal in what it accepts. By default,
this parser is strict and only accepts JSON as specified by RFC 4627 . Setting the
parser to lenient causes it to ignore the following syntax errors:
Streams that start with the non-execute
prefix , ")]}'\n".
Streams that include multiple top-level values. With strict parsing,
each stream must contain exactly one top-level value.
Top-level values of any type. With strict parsing, the top-level
value must be an object or an array.
Numbers may be NaNsinfinities End of line comments starting with // or # and
ending with a newline character.
C-style comments starting with /* and ending with
*/. Such comments may not be nested.
Names that are unquoted or 'single quoted'.
Strings that are unquoted or 'single quoted'.
Array elements separated by ; instead of ,.
Unnecessary array separators. These are interpreted as if null
was the omitted value.
Names and values separated by = or => instead of
:.
Name/value pairs separated by ; instead of ,.
isLenient
public final boolean isLenient ()
Returns true if this parser is liberal in what it accepts.
beginArray
public void beginArray ()
throws IOException
Consumes the next token from the JSON stream and asserts that it is the
beginning of a new array.
Throws:
IOException
endArray
public void endArray ()
throws IOException
Consumes the next token from the JSON stream and asserts that it is the
end of the current array.
Throws:
IOException
beginObject
public void beginObject ()
throws IOException
Consumes the next token from the JSON stream and asserts that it is the
beginning of a new object.
Throws:
IOException
endObject
public void endObject ()
throws IOException
Consumes the next token from the JSON stream and asserts that it is the
end of the current object.
Throws:
IOException
hasNext
public boolean hasNext ()
throws IOException
Returns true if the current array or object has another element.
Throws:
IOException
peek
public JsonToken peek ()
throws IOException
Returns the type of the next token without consuming it.
Throws:
IOException
nextName
public String nextName ()
throws IOException
Returns the next token, a property name
Throws:
IOException
nextString
public String nextString ()
throws IOException
Returns the string
Throws:
IllegalStateException IOException
nextBoolean
public boolean nextBoolean ()
throws IOException
Returns the boolean
Throws:
IllegalStateException IOException
nextNull
public void nextNull ()
throws IOException
Consumes the next token from the JSON stream and asserts that it is a
literal null.
Throws:
IllegalStateException IOException
nextDouble
public double nextDouble ()
throws IOException
Returns the doubleDouble.parseDouble(String)
Throws:
IllegalStateException NumberFormatException IOException
nextLong
public long nextLong ()
throws IOException
Returns the longlong, this method throws.
Throws:
IllegalStateException NumberFormatException IOException
nextInt
public int nextInt ()
throws IOException
Returns the intint, this method throws.
Throws:
IllegalStateException NumberFormatException IOException
close
public void close ()
throws IOException
Closes this JSON reader and the underlying Reader
Specified by: close Closeable
Throws:
IOException
skipValue
public void skipValue ()
throws IOException
Skips the next value recursively. If it is an object or array, all nested
elements are skipped. This method is intended for use when the JSON token
stream contains unrecognized or unhandled values.
Throws:
IOException
toString
public String toString ()
Overrides: toString Object
getPath
public String getPath ()
Returns a JsonPath to
the current location in the JSON value.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/JsonToken.html 0000664 0000000 0000000 00000056215 12604067504 0026071 0 ustar 00root root 0000000 0000000
JsonToken (Gson 2.3.1 API)
com.google.gson.stream
java.lang.Object
java.lang.Enum <JsonToken >
com.google.gson.stream.JsonToken
All Implemented Interfaces: Serializable , Comparable <JsonToken >
public enum JsonToken extends Enum <JsonToken >
A structure, name or value type in a JSON-encoded string.
Since: 1.6
Author: Jesse Wilson
Method Summary
static JsonToken valueOf String name)
static JsonToken [] values
BEGIN_ARRAY
public static final JsonToken BEGIN_ARRAY
The opening of a JSON array. Written using JsonWriter.beginArray()JsonReader.beginArray()
END_ARRAY
public static final JsonToken END_ARRAY
The closing of a JSON array. Written using JsonWriter.endArray()JsonReader.endArray()
BEGIN_OBJECT
public static final JsonToken BEGIN_OBJECT
The opening of a JSON object. Written using JsonWriter.beginObject()JsonReader.beginObject()
END_OBJECT
public static final JsonToken END_OBJECT
The closing of a JSON object. Written using JsonWriter.endObject()JsonReader.endObject()
NAME
public static final JsonToken NAME
A JSON property name. Within objects, tokens alternate between names and
their values. Written using JsonWriter.name(java.lang.String)JsonReader.nextName()
STRING
public static final JsonToken STRING
A JSON string.
NUMBER
public static final JsonToken NUMBER
A JSON number represented in this API by a Java double, long, or int.
BOOLEAN
public static final JsonToken BOOLEAN
A JSON true or false.
NULL
public static final JsonToken NULL
A JSON null.
END_DOCUMENT
public static final JsonToken END_DOCUMENT
The end of the JSON stream. This sentinel value is returned by JsonReader.peek()
values
public static JsonToken [] values ()
Returns an array containing the constants of this enum type, in
the order they are declared. This method may be used to iterate
over the constants as follows:
for (JsonToken c : JsonToken.values())
System.out.println(c);
Returns: an array containing the constants of this enum type, in
the order they are declared
valueOf
public static JsonToken valueOf (String name)
Returns the enum constant of this type with the specified name.
The string must match exactly an identifier used to declare an
enum constant in this type. (Extraneous whitespace characters are
not permitted.)
Parameters: name - the name of the enum constant to be returned.
Returns: the enum constant with the specified name
Throws:
IllegalArgumentException NullPointerException
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/JsonWriter.html 0000664 0000000 0000000 00000122714 12604067504 0026263 0 ustar 00root root 0000000 0000000
JsonWriter (Gson 2.3.1 API)
com.google.gson.stream
java.lang.Object
com.google.gson.stream.JsonWriter
All Implemented Interfaces: Closeable , Flushable
public class JsonWriter extends Object implements Closeable , Flushable
Writes a JSON (RFC 4627 )
encoded value to a stream, one token at a time. The stream includes both
literal values (strings, numbers, booleans and nulls) as well as the begin
and end delimiters of objects and arrays.
Encoding JSON
To encode your data as JSON, create a new JsonWriter. Each JSON
document must contain one top-level array or object. Call methods on the
writer as you walk the structure's contents, nesting arrays and objects as
necessary:
Example
Suppose we'd like to encode a stream of messages such as the following: [
{
"id": 912345678901,
"text": "How do I stream JSON in Java?",
"geo": null,
"user": {
"name": "json_newb",
"followers_count": 41
}
},
{
"id": 912345678902,
"text": "@json_newb just use JsonWriter!",
"geo": [50.454722, -104.606667],
"user": {
"name": "jesse",
"followers_count": 2
}
}
]
This code encodes the above structure: public void writeJsonStream(OutputStream out, List<Message> messages) throws IOException {
JsonWriter writer = new JsonWriter(new OutputStreamWriter(out, "UTF-8"));
writer.setIndentSpaces(4);
writeMessagesArray(writer, messages);
writer.close();
}
public void writeMessagesArray(JsonWriter writer, List<Message> messages) throws IOException {
writer.beginArray();
for (Message message : messages) {
writeMessage(writer, message);
}
writer.endArray();
}
public void writeMessage(JsonWriter writer, Message message) throws IOException {
writer.beginObject();
writer.name("id").value(message.getId());
writer.name("text").value(message.getText());
if (message.getGeo() != null) {
writer.name("geo");
writeDoublesArray(writer, message.getGeo());
} else {
writer.name("geo").nullValue();
}
writer.name("user");
writeUser(writer, message.getUser());
writer.endObject();
}
public void writeUser(JsonWriter writer, User user) throws IOException {
writer.beginObject();
writer.name("name").value(user.getName());
writer.name("followers_count").value(user.getFollowersCount());
writer.endObject();
}
public void writeDoublesArray(JsonWriter writer, List<Double> doubles) throws IOException {
writer.beginArray();
for (Double value : doubles) {
writer.value(value);
}
writer.endArray();
}
Each JsonWriter may be used to write a single JSON stream.
Instances of this class are not thread safe. Calls that would result in a
malformed JSON string will fail with an IllegalStateException
Since: 1.6
Author: Jesse Wilson
Constructor Summary
JsonWriter Writer out)out.
Methods inherited from class java.lang.Object
clone , equals , finalize , getClass , hashCode , notify , notifyAll , toString , wait , wait , wait
JsonWriter
public JsonWriter (Writer out)
Creates a new instance that writes a JSON-encoded stream to out.
For best performance, ensure WriterBufferedWriter
setIndent
public final void setIndent (String indent)
Sets the indentation string to be repeated for each level of indentation
in the encoded document. If indent.isEmpty() the encoded document
will be compact. Otherwise the encoded document will be more
human-readable.
Parameters: indent - a string containing only whitespace.
setLenient
public final void setLenient (boolean lenient)
Configure this writer to relax its syntax rules. By default, this writer
only emits well-formed JSON as specified by RFC 4627 . Setting the writer
to lenient permits the following:
Top-level values of any type. With strict writing, the top-level
value must be an object or an array.
Numbers may be NaNsinfinities
isLenient
public boolean isLenient ()
Returns true if this writer has relaxed syntax rules.
setHtmlSafe
public final void setHtmlSafe (boolean htmlSafe)
Configure this writer to emit JSON that's safe for direct inclusion in HTML
and XML documents. This escapes the HTML characters <, >,
& and = before writing them to the stream. Without this
setting, your XML/HTML encoder should replace these characters with the
corresponding escape sequences.
isHtmlSafe
public final boolean isHtmlSafe ()
Returns true if this writer writes JSON that's safe for inclusion in HTML
and XML documents.
setSerializeNulls
public final void setSerializeNulls (boolean serializeNulls)
Sets whether object members are serialized when their value is null.
This has no impact on array elements. The default is true.
getSerializeNulls
public final boolean getSerializeNulls ()
Returns true if object members are serialized when their value is null.
This has no impact on array elements. The default is true.
beginArray
public JsonWriter beginArray ()
throws IOException
Begins encoding a new array. Each call to this method must be paired with
a call to endArray()
Returns: this writer.
Throws:
IOException
endArray
public JsonWriter endArray ()
throws IOException
Ends encoding the current array.
Returns: this writer.
Throws:
IOException
beginObject
public JsonWriter beginObject ()
throws IOException
Begins encoding a new object. Each call to this method must be paired
with a call to endObject()
Returns: this writer.
Throws:
IOException
endObject
public JsonWriter endObject ()
throws IOException
Ends encoding the current object.
Returns: this writer.
Throws:
IOException
name
public JsonWriter name (String name)
throws IOException
Encodes the property name.
Parameters: name - the name of the forthcoming value. May not be null.
Returns: this writer.
Throws:
IOException
value
public JsonWriter value (String value)
throws IOException
Encodes value.
Parameters: value - the literal string value, or null to encode a null literal.
Returns: this writer.
Throws:
IOException
nullValue
public JsonWriter nullValue ()
throws IOException
Encodes null.
Returns: this writer.
Throws:
IOException
value
public JsonWriter value (boolean value)
throws IOException
Encodes value.
Returns: this writer.
Throws:
IOException
value
public JsonWriter value (double value)
throws IOException
Encodes value.
Parameters: value - a finite value. May not be NaNsinfinitiesReturns: this writer.
Throws:
IOException
value
public JsonWriter value (long value)
throws IOException
Encodes value.
Returns: this writer.
Throws:
IOException
value
public JsonWriter value (Number value)
throws IOException
Encodes value.
Parameters: value - a finite value. May not be NaNsinfinitiesReturns: this writer.
Throws:
IOException
flush
public void flush ()
throws IOException
Ensures all buffered data is written to the underlying Writer
Specified by: flush Flushable
Throws:
IOException
close
public void close ()
throws IOException
Flushes and closes this writer and the underlying Writer
Specified by: close Closeable
Throws:
IOException
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/MalformedJsonException.html 0000664 0000000 0000000 00000041301 12604067504 0030564 0 ustar 00root root 0000000 0000000
MalformedJsonException (Gson 2.3.1 API)
com.google.gson.stream
java.lang.Object
java.lang.Throwable
java.lang.Exception
java.io.IOException
com.google.gson.stream.MalformedJsonException
All Implemented Interfaces: Serializable
public final class MalformedJsonException extends IOException
Thrown when a reader encounters malformed JSON. Some syntax errors can be
ignored by calling JsonReader.setLenient(boolean)
See Also: Serialized Form
Methods inherited from class java.lang.Throwable
fillInStackTrace , getCause , getLocalizedMessage , getMessage , getStackTrace , initCause , printStackTrace , printStackTrace , printStackTrace , setStackTrace , toString
MalformedJsonException
public MalformedJsonException (String msg)
MalformedJsonException
public MalformedJsonException (String msg,
Throwable throwable)
MalformedJsonException
public MalformedJsonException (Throwable throwable)
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/class-use/ 0000775 0000000 0000000 00000000000 12604067504 0025157 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/class-use/JsonReader.html 0000664 0000000 0000000 00000023234 12604067504 0030105 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.stream.JsonReader (Gson 2.3.1 API)
Uses of Class
Methods in com.google.gson with parameters of type JsonReader
Gson. fromJson JsonReader reader,
Type typeOfT)reader and convert it to an object
of type typeOfT.
JsonElement JsonParser. parse JsonReader json)
abstract T TypeAdapter. read JsonReader in)
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/class-use/JsonToken.html 0000664 0000000 0000000 00000021677 12604067504 0027774 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.stream.JsonToken (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/class-use/JsonWriter.html 0000664 0000000 0000000 00000041125 12604067504 0030156 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.stream.JsonWriter (Gson 2.3.1 API)
Uses of Class
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/class-use/MalformedJsonException.html 0000664 0000000 0000000 00000014044 12604067504 0032467 0 ustar 00root root 0000000 0000000
Uses of Class com.google.gson.stream.MalformedJsonException (Gson 2.3.1 API)
Uses of Class
No usage of com.google.gson.stream.MalformedJsonException
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/package-frame.html 0000664 0000000 0000000 00000003177 12604067504 0026641 0 ustar 00root root 0000000 0000000
com.google.gson.stream (Gson 2.3.1 API)
com.google.gson.stream
gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/package-summary.html 0000664 0000000 0000000 00000017006 12604067504 0027240 0 ustar 00root root 0000000 0000000
com.google.gson.stream (Gson 2.3.1 API)
Package com.google.gson.stream
Enum Summary
JsonToken A structure, name or value type in a JSON-encoded string.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/package-tree.html 0000664 0000000 0000000 00000021123 12604067504 0026475 0 ustar 00root root 0000000 0000000
com.google.gson.stream Class Hierarchy (Gson 2.3.1 API)
Hierarchy For Package com.google.gson.stream
Package Hierarchies: All Packages
Class Hierarchy
Enum Hierarchy
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/com/google/gson/stream/package-use.html 0000664 0000000 0000000 00000021042 12604067504 0026332 0 ustar 00root root 0000000 0000000
Uses of Package com.google.gson.stream (Gson 2.3.1 API)
Uses of Package
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/constant-values.html 0000664 0000000 0000000 00000012340 12604067504 0023001 0 ustar 00root root 0000000 0000000
Constant Field Values (Gson 2.3.1 API)
Constant Field Values
Contents
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/deprecated-list.html 0000664 0000000 0000000 00000016125 12604067504 0022731 0 ustar 00root root 0000000 0000000
Deprecated List (Gson 2.3.1 API)
Deprecated API
Contents
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/help-doc.html 0000664 0000000 0000000 00000023266 12604067504 0021357 0 ustar 00root root 0000000 0000000
API Help (Gson 2.3.1 API)
How This API Document Is Organized
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
Overview
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.
Package
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain four categories:
Interfaces (italic) Classes Enums Exceptions Errors Annotation Types
Class/Interface
Each class, interface, nested class and nested interface has its own separate page. Each of these pages has three sections consisting of a class/interface description, summary tables, and detailed member descriptions:
Class inheritance diagram Direct Subclasses All Known Subinterfaces All Known Implementing Classes Class/interface declaration Class/interface description
Nested Class Summary Field Summary Constructor Summary Method Summary
Field Detail Constructor Detail Method Detail
Each summary entry contains the first sentence from the detailed description for that item. The summary entries are alphabetical, while the detailed descriptions are in the order they appear in the source code. This preserves the logical groupings established by the programmer.
Annotation Type
Each annotation type has its own separate page with the following sections:
Annotation Type declaration Annotation Type description Required Element Summary Optional Element Summary Element Detail
Enum
Each enum has its own separate page with the following sections:
Enum declaration Enum description Enum Constant Summary Enum Constant Detail
Use
Each documented package, class and interface has its own Use page. This page describes what packages, classes, methods, constructors and fields use any part of the given class or package. Given a class or interface A, its Use page includes subclasses of A, fields declared as A, methods that return A, and methods and constructors with parameters of type A. You can access this page by first going to the package, class or interface, then clicking on the "Use" link in the navigation bar.
Tree (Class Hierarchy)
There is a Class Hierarchy page for all packages, plus a hierarchy for each package. Each hierarchy page contains a list of classes and a list of interfaces. The classes are organized by inheritance structure starting with java.lang.Object. The interfaces do not inherit from java.lang.Object.
When viewing the Overview page, clicking on "Tree" displays the hierarchy for all packages. When viewing a particular package, class or interface page, clicking "Tree" displays the hierarchy for only that package.
Deprecated API
The Deprecated API page lists all of the API that have been deprecated. A deprecated API is not recommended for use, generally due to improvements, and a replacement API is usually given. Deprecated APIs may be removed in future implementations.
Index
The Index contains an alphabetic list of all classes, interfaces, constructors, methods, and fields.
Prev/Next
These links take you to the next or previous class, interface, package, or related page.
Frames/No Frames
These links show and hide the HTML frames. All pages are available with or without frames.
Serialized Form
Each serializable or externalizable class has a description of its serialization fields and methods. This information is of interest to re-implementors, not to developers using the API. While there is no link in the navigation bar, you can get to this information by going to any serialized class and clicking "Serialized Form" in the "See also" section of the class description.
Constant Field Values
The Constant Field Values page lists the static final fields and their values.
This help file applies to API documentation generated using the standard doclet.
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/index-all.html 0000664 0000000 0000000 00000276105 12604067504 0021543 0 ustar 00root root 0000000 0000000
Index (Gson 2.3.1 API)
A B C D E F G H I J L M N P R S T U V W
A
add(JsonElement) JsonArray
Adds the specified element to self.
add(String, JsonElement) JsonObject
Adds a member, which is a name-value pair, to self.
addAll(JsonArray) JsonArray
Adds all the elements of the specified array to self.
addDeserializationExclusionStrategy(ExclusionStrategy) GsonBuilder
Configures Gson to apply the passed in exclusion strategy during deserialization.
addProperty(String, String) JsonObject
Convenience method to add a primitive member.
addProperty(String, Number) JsonObject
Convenience method to add a primitive member.
addProperty(String, Boolean) JsonObject
Convenience method to add a boolean member.
addProperty(String, Character) JsonObject
Convenience method to add a char member.
addSerializationExclusionStrategy(ExclusionStrategy) GsonBuilder
Configures Gson to apply the passed in exclusion strategy during serialization.
B
beginArray() JsonReader
Consumes the next token from the JSON stream and asserts that it is the
beginning of a new array.
beginArray() JsonWriter
Begins encoding a new array.
beginObject() JsonReader
Consumes the next token from the JSON stream and asserts that it is the
beginning of a new object.
beginObject() JsonWriter
Begins encoding a new object.
C
close() JsonReader
Closes this JSON reader and the underlying Reader close() JsonWriter
Flushes and closes this writer and the underlying Writer com.google.gson This package provides the Gson com.google.gson.annotations This package provides annotations that can be used with Gson com.google.gson.reflect This package provides utility classes for finding type information for generic types. com.google.gson.stream contains(JsonElement) JsonArray
Returns true if this array contains the specified element.
create() GsonBuilder
Creates a Gson create(Gson, TypeToken<T>) TypeAdapterFactory
Returns a type adapter for type, or null if this factory doesn't
support type.
createInstance(Type) InstanceCreator
Gson invokes this call-back method during deserialization to create an instance of the
specified type.
D
deserialize(JsonElement, Type) JsonDeserializationContext
Invokes default deserialization on the specified object.
deserialize(JsonElement, Type, JsonDeserializationContext) JsonDeserializer
Gson invokes this call-back method during deserialization when it encounters a field of the
specified type.
disableHtmlEscaping() GsonBuilder
By default, Gson escapes HTML characters such as < > etc.
disableInnerClassSerialization() GsonBuilder
Configures Gson to exclude inner classes during serialization.
E
enableComplexMapKeySerialization() GsonBuilder
Enabling this feature will only change the serialized form if the map key is
a complex type (i.e.
endArray() JsonReader
Consumes the next token from the JSON stream and asserts that it is the
end of the current array.
endArray() JsonWriter
Ends encoding the current array.
endObject() JsonReader
Consumes the next token from the JSON stream and asserts that it is the
end of the current object.
endObject() JsonWriter
Ends encoding the current object.
entrySet() JsonObject
Returns a set of members of this object.
equals(Object) JsonArray
equals(Object) JsonNull
All instances of JsonNull are the same
equals(Object) JsonObject
equals(Object) JsonPrimitive
equals(Object) TypeToken
excludeFieldsWithModifiers(int...) GsonBuilder
Configures Gson to excludes all class fields that have the specified modifiers.
excludeFieldsWithoutExposeAnnotation() GsonBuilder
Configures Gson to exclude all fields from consideration for serialization or deserialization
that do not have the Expose ExclusionStrategy 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. Expose com.google.gson.annotations An annotation that indicates this member should be exposed for JSON
serialization or deserialization.
F
FieldAttributes com.google.gson A data object that stores attributes of a field. FieldAttributes(Field) FieldAttributes
Constructs a Field Attributes object from the f.
FieldNamingPolicy com.google.gson An enumeration that defines a few standard naming conventions for JSON field names. FieldNamingStrategy com.google.gson A mechanism for providing custom field naming in Gson. flush() JsonWriter
Ensures all buffered data is written to the underlying Writer fromJson(String, Class<T>) Gson
This method deserializes the specified Json into an object of the specified class.
fromJson(String, Type) Gson
This method deserializes the specified Json into an object of the specified type.
fromJson(Reader, Class<T>) Gson
This method deserializes the Json read from the specified reader into an object of the
specified class.
fromJson(Reader, Type) Gson
This method deserializes the Json read from the specified reader into an object of the
specified type.
fromJson(JsonReader, Type) Gson
Reads the next JSON value from reader and convert it to an object
of type typeOfT.
fromJson(JsonElement, Class<T>) Gson
This method deserializes the Json read from the specified parse tree into an object of the
specified type.
fromJson(JsonElement, Type) Gson
This method deserializes the Json read from the specified parse tree into an object of the
specified type.
fromJson(Reader) TypeAdapter
Converts the JSON document in in to a Java object.
fromJson(String) TypeAdapter
Converts the JSON document in json to a Java object.
fromJsonTree(JsonElement) TypeAdapter
Converts jsonTree to a Java object.
G
generateNonExecutableJson() GsonBuilder
Makes the output JSON non-executable in Javascript by prefixing the generated JSON with some
special text.
get(int) JsonArray
Returns the ith element of the array.
get(String) JsonObject
Returns the member with the specified name.
get(Type) TypeToken
Gets type literal for the given Type instance.
get(Class<T>) TypeToken
Gets type literal for the given Class instance.
getAdapter(TypeToken<T>) Gson
Returns the type adapter for getAdapter(Class<T>) Gson
Returns the type adapter for getAnnotation(Class<T>) FieldAttributes
Return the T annotation object from this field if it exist; otherwise returns
null.
getAnnotations() FieldAttributes
Return the annotations that are present on this field.
getAsBigDecimal() JsonArray
convenience method to get this array as a BigDecimal getAsBigDecimal() JsonElement
convenience method to get this element as a BigDecimal getAsBigDecimal() JsonPrimitive
convenience method to get this element as a BigDecimal getAsBigInteger() JsonArray
convenience method to get this array as a BigInteger getAsBigInteger() JsonElement
convenience method to get this element as a BigInteger getAsBigInteger() JsonPrimitive
convenience method to get this element as a BigInteger getAsBoolean() JsonArray
convenience method to get this array as a boolean if it contains a single element.
getAsBoolean() JsonElement
convenience method to get this element as a boolean value.
getAsBoolean() JsonPrimitive
convenience method to get this element as a boolean value.
getAsByte() JsonArray
getAsByte() JsonElement
convenience method to get this element as a primitive byte value.
getAsByte() JsonPrimitive
getAsCharacter() JsonArray
getAsCharacter() JsonElement
convenience method to get this element as a primitive character value.
getAsCharacter() JsonPrimitive
getAsDouble() JsonArray
convenience method to get this array as a double if it contains a single element.
getAsDouble() JsonElement
convenience method to get this element as a primitive double value.
getAsDouble() JsonPrimitive
convenience method to get this element as a primitive double.
getAsFloat() JsonArray
convenience method to get this array as a float if it contains a single element.
getAsFloat() JsonElement
convenience method to get this element as a primitive float value.
getAsFloat() JsonPrimitive
convenience method to get this element as a float.
getAsInt() JsonArray
convenience method to get this array as an integer if it contains a single element.
getAsInt() JsonElement
convenience method to get this element as a primitive integer value.
getAsInt() JsonPrimitive
convenience method to get this element as a primitive integer.
getAsJsonArray() JsonElement
convenience method to get this element as a JsonArray getAsJsonArray(String) JsonObject
Convenience method to get the specified member as a JsonArray.
getAsJsonNull() JsonElement
convenience method to get this element as a JsonNull getAsJsonObject() JsonElement
convenience method to get this element as a JsonObject getAsJsonObject(String) JsonObject
Convenience method to get the specified member as a JsonObject.
getAsJsonPrimitive() JsonElement
convenience method to get this element as a JsonPrimitive getAsJsonPrimitive(String) JsonObject
Convenience method to get the specified member as a JsonPrimitive element.
getAsLong() JsonArray
convenience method to get this array as a long if it contains a single element.
getAsLong() JsonElement
convenience method to get this element as a primitive long value.
getAsLong() JsonPrimitive
convenience method to get this element as a primitive long.
getAsNumber() JsonArray
convenience method to get this array as a Number getAsNumber() JsonElement
convenience method to get this element as a Number getAsNumber() JsonPrimitive
convenience method to get this element as a Number.
getAsShort() JsonArray
convenience method to get this array as a primitive short if it contains a single element.
getAsShort() JsonElement
convenience method to get this element as a primitive short value.
getAsShort() JsonPrimitive
convenience method to get this element as a primitive short.
getAsString() JsonArray
convenience method to get this array as a String getAsString() JsonElement
convenience method to get this element as a string value.
getAsString() JsonPrimitive
convenience method to get this element as a String.
getDeclaredClass() FieldAttributes
Returns the Class object that was declared for this field.
getDeclaredType() FieldAttributes
For example, assume the following class definition:
public class Foo {
private String bar;
private List<String> red;
}
Type listParmeterizedType = new TypeToken<List<String>>() {}.getType();
getDeclaringClass() FieldAttributes
getDelegateAdapter(TypeAdapterFactory, TypeToken<T>) Gson
This method is used to get an alternate type adapter for the specified type.
getName() FieldAttributes
getPath() JsonReader
Returns a JsonPath to
the current location in the JSON value.
getRawType() TypeToken
Returns the raw (non-generic) type for this type.
getSerializeNulls() JsonWriter
Returns true if object members are serialized when their value is null.
getType() TypeToken
Gets underlying Type instance.
Gson com.google.gson This is the main class for using Gson. Gson() Gson
Constructs a Gson object with default configuration.
GsonBuilder com.google.gson Use this builder to construct a Gson GsonBuilder() GsonBuilder
Creates a GsonBuilder instance that can be used to build Gson with various configuration
settings.
H
has(String) JsonObject
Convenience method to check if a member with the specified name is present in this object.
hashCode() JsonArray
hashCode() JsonNull
All instances of JsonNull have the same hash code since they are indistinguishable
hashCode() JsonObject
hashCode() JsonPrimitive
hashCode() TypeToken
hasModifier(int) FieldAttributes
Returns true if the field is defined with the modifier.
hasNext() JsonStreamParser
Returns true if a JsonElement hasNext() JsonReader
Returns true if the current array or object has another element.
I
INSTANCE JsonNull
singleton for JsonNull
InstanceCreator T > - Interface in com.google.gson This interface is implemented to create instances of a class that does not define a no-args
constructor. isAssignableFrom(Class<?>) TypeToken
Deprecated. this implementation may be inconsistent with javac for types
with wildcards.
isAssignableFrom(Type) TypeToken
Deprecated. this implementation may be inconsistent with javac for types
with wildcards.
isAssignableFrom(TypeToken<?>) TypeToken
Deprecated. this implementation may be inconsistent with javac for types
with wildcards.
isBoolean() JsonPrimitive
Check whether this primitive contains a boolean value.
isHtmlSafe() JsonWriter
Returns true if this writer writes JSON that's safe for inclusion in HTML
and XML documents.
isJsonArray() JsonElement
provides check for verifying if this element is an array or not.
isJsonNull() JsonElement
provides check for verifying if this element represents a null value or not.
isJsonObject() JsonElement
provides check for verifying if this element is a Json object or not.
isJsonPrimitive() JsonElement
provides check for verifying if this element is a primitive or not.
isLenient() JsonReader
Returns true if this parser is liberal in what it accepts.
isLenient() JsonWriter
Returns true if this writer has relaxed syntax rules.
isNumber() JsonPrimitive
Check whether this primitive contains a Number.
isString() JsonPrimitive
Check whether this primitive contains a String value.
iterator() JsonArray
Returns an iterator to navigate the elemetns of the array.
J
JsonAdapter com.google.gson.annotations An annotation that indicates the Gson TypeAdapter JsonArray com.google.gson A class representing an array type in Json. JsonArray() JsonArray
Creates an empty JsonArray.
JsonDeserializationContext com.google.gson Context for deserialization that is passed to a custom deserializer during invocation of its
JsonDeserializer.deserialize(JsonElement, Type, JsonDeserializationContext) JsonDeserializer T > - Interface in com.google.gson Interface representing a custom deserializer for Json. JsonElement com.google.gson A class representing an element of Json. JsonElement() JsonElement
JsonIOException com.google.gson This exception is raised when Gson was unable to read an input stream
or write to one. JsonIOException(String) JsonIOException
JsonIOException(String, Throwable) JsonIOException
JsonIOException(Throwable) JsonIOException
Creates exception with the specified cause.
JsonNull com.google.gson A class representing a Json null value. JsonNull() JsonNull
Deprecated.
JsonObject com.google.gson A class representing an object type in Json. JsonObject() JsonObject
JsonParseException com.google.gson This exception is raised if there is a serious issue that occurs during parsing of a Json
string. JsonParseException(String) JsonParseException
Creates exception with the specified message.
JsonParseException(String, Throwable) JsonParseException
Creates exception with the specified message and cause.
JsonParseException(Throwable) JsonParseException
Creates exception with the specified cause.
JsonParser com.google.gson A parser to parse Json into a parse tree of JsonElement JsonParser() JsonParser
JsonPrimitive com.google.gson A class representing a Json primitive value. JsonPrimitive(Boolean) JsonPrimitive
Create a primitive containing a boolean value.
JsonPrimitive(Number) JsonPrimitive
Create a primitive containing a Number JsonPrimitive(String) JsonPrimitive
Create a primitive containing a String value.
JsonPrimitive(Character) JsonPrimitive
Create a primitive containing a character.
JsonReader com.google.gson.stream Reads a JSON (RFC 4627 )
encoded value as a stream of tokens. JsonReader(Reader) JsonReader
Creates a new instance that reads a JSON-encoded stream from in.
JsonSerializationContext com.google.gson Context for serialization that is passed to a custom serializer during invocation of its
JsonSerializer.serialize(Object, Type, JsonSerializationContext) JsonSerializer T > - Interface in com.google.gson Interface representing a custom serializer for Json. JsonStreamParser com.google.gson A streaming parser that allows reading of multiple JsonElement JsonStreamParser(String) JsonStreamParser
JsonStreamParser(Reader) JsonStreamParser
JsonSyntaxException com.google.gson This exception is raised when Gson attempts to read (or write) a malformed
JSON element. JsonSyntaxException(String) JsonSyntaxException
JsonSyntaxException(String, Throwable) JsonSyntaxException
JsonSyntaxException(Throwable) JsonSyntaxException
Creates exception with the specified cause.
JsonToken com.google.gson.stream A structure, name or value type in a JSON-encoded string. JsonWriter com.google.gson.stream Writes a JSON (RFC 4627 )
encoded value to a stream, one token at a time. JsonWriter(Writer) JsonWriter
Creates a new instance that writes a JSON-encoded stream to out.
L
LongSerializationPolicy com.google.gson Defines the expected format for a long or Long type when its serialized.
M
MalformedJsonException com.google.gson.stream Thrown when a reader encounters malformed JSON. MalformedJsonException(String) MalformedJsonException
MalformedJsonException(String, Throwable) MalformedJsonException
MalformedJsonException(Throwable) MalformedJsonException
N
name(String) JsonWriter
Encodes the property name.
next() JsonStreamParser
Returns the next available JsonElement nextBoolean() JsonReader
Returns the boolean nextDouble() JsonReader
Returns the double nextInt() JsonReader
Returns the int nextLong() JsonReader
Returns the long nextName() JsonReader
Returns the next token, a property name nextNull() JsonReader
Consumes the next token from the JSON stream and asserts that it is a
literal null.
nextString() JsonReader
Returns the string nullSafe() TypeAdapter
This wrapper method is used to make a type adapter null tolerant.
nullValue() JsonWriter
Encodes null.
P
parse(String) JsonParser
Parses the specified JSON string into a parse tree
parse(Reader) JsonParser
Parses the specified JSON string into a parse tree
parse(JsonReader) JsonParser
Returns the next value from the JSON stream as a parse tree.
peek() JsonReader
Returns the type of the next token without consuming it.
R
read(JsonReader) TypeAdapter
Reads one JSON value (an array, object, string, number, boolean or null)
and converts it to a Java object.
registerTypeAdapter(Type, Object) GsonBuilder
Configures Gson for custom serialization or deserialization.
registerTypeAdapterFactory(TypeAdapterFactory) GsonBuilder
Register a factory for type adapters.
registerTypeHierarchyAdapter(Class<?>, Object) GsonBuilder
Configures Gson for custom serialization or deserialization for an inheritance type hierarchy.
remove(JsonElement) JsonArray
Removes the first occurrence of the specified element from this array, if it is present.
remove(int) JsonArray
Removes the element at the specified position in this array.
remove(String) JsonObject
Removes the property from this JsonObject remove() JsonStreamParser
This optional Iterator
S
serialize(Object) JsonSerializationContext
Invokes default serialization on the specified object.
serialize(Object, Type) JsonSerializationContext
Invokes default serialization on the specified object passing the specific type information.
serialize(T, Type, JsonSerializationContext) JsonSerializer
Gson invokes this call-back method during serialization when it encounters a field of the
specified type.
serialize(Long) LongSerializationPolicy
Serialize this value using this serialization policy.
SerializedName com.google.gson.annotations An annotation that indicates this member should be serialized to JSON with
the provided name value as its field name. serializeNulls() GsonBuilder
Configure Gson to serialize null fields.
serializeSpecialFloatingPointValues() GsonBuilder
Section 2.4 of JSON specification disallows
special double values (NaN, Infinity, -Infinity).
set(int, JsonElement) JsonArray
Replaces the element at the specified position in this array with the specified element.
setDateFormat(String) GsonBuilder
Configures Gson to serialize Date objects according to the pattern provided.
setDateFormat(int) GsonBuilder
Configures Gson to to serialize Date objects according to the style value provided.
setDateFormat(int, int) GsonBuilder
Configures Gson to to serialize Date objects according to the style value provided.
setExclusionStrategies(ExclusionStrategy...) GsonBuilder
Configures Gson to apply a set of exclusion strategies during both serialization and
deserialization.
setFieldNamingPolicy(FieldNamingPolicy) GsonBuilder
Configures Gson to apply a specific naming policy to an object's field during serialization
and deserialization.
setFieldNamingStrategy(FieldNamingStrategy) GsonBuilder
Configures Gson to apply a specific naming policy strategy to an object's field during
serialization and deserialization.
setHtmlSafe(boolean) JsonWriter
Configure this writer to emit JSON that's safe for direct inclusion in HTML
and XML documents.
setIndent(String) JsonWriter
Sets the indentation string to be repeated for each level of indentation
in the encoded document.
setLenient(boolean) JsonReader
Configure this parser to be be liberal in what it accepts.
setLenient(boolean) JsonWriter
Configure this writer to relax its syntax rules.
setLongSerializationPolicy(LongSerializationPolicy) GsonBuilder
Configures Gson to apply a specific serialization policy for Long and long
objects.
setPrettyPrinting() GsonBuilder
Configures Gson to output Json that fits in a page for pretty printing.
setSerializeNulls(boolean) JsonWriter
Sets whether object members are serialized when their value is null.
setVersion(double) GsonBuilder
Configures Gson to enable versioning support.
shouldSkipClass(Class<?>) ExclusionStrategy
shouldSkipField(FieldAttributes) ExclusionStrategy
Since com.google.gson.annotations An annotation that indicates the version number since a member or a type has been present. size() JsonArray
Returns the number of elements in the array.
skipValue() JsonReader
Skips the next value recursively.
T
toJson(Object) Gson
This method serializes the specified object into its equivalent Json representation.
toJson(Object, Type) Gson
This method serializes the specified object, including those of generic types, into its
equivalent Json representation.
toJson(Object, Appendable) Gson
This method serializes the specified object into its equivalent Json representation.
toJson(Object, Type, Appendable) Gson
This method serializes the specified object, including those of generic types, into its
equivalent Json representation.
toJson(Object, Type, JsonWriter) Gson
Writes the JSON representation of src of type typeOfSrc to
writer.
toJson(JsonElement) Gson
Converts a tree of JsonElement toJson(JsonElement, Appendable) Gson
Writes out the equivalent JSON for a tree of JsonElement toJson(JsonElement, JsonWriter) Gson
Writes the JSON for jsonElement to writer.
toJson(Writer, T) TypeAdapter
Converts value to a JSON document and writes it to out.
toJson(T) TypeAdapter
Converts value to a JSON document.
toJsonTree(Object) Gson
This method serializes the specified object into its equivalent representation as a tree of
JsonElement toJsonTree(Object, Type) Gson
This method serializes the specified object, including those of generic types, into its
equivalent representation as a tree of JsonElement toJsonTree(T) TypeAdapter
Converts value to a JSON tree.
toString() Gson
toString() JsonElement
Returns a String representation of this element.
toString() TypeToken
toString() JsonReader
translateName(Field) FieldNamingStrategy
Translates the field name into its JSON field name representation.
TypeAdapter T > - Class in com.google.gson Converts Java objects to and from JSON. TypeAdapter() TypeAdapter
TypeAdapterFactory com.google.gson Creates type adapters for set of related types. TypeToken T > - Class in com.google.gson.reflect Represents a generic type T. TypeToken() TypeToken
Constructs a new type literal.
U
Until com.google.gson.annotations An annotation that indicates the version number until a member or a type should be present.
V
value(String) JsonWriter
Encodes value.
value(boolean) JsonWriter
Encodes value.
value(double) JsonWriter
Encodes value.
value(long) JsonWriter
Encodes value.
value(Number) JsonWriter
Encodes value.
valueOf(String) FieldNamingPolicy
Returns the enum constant of this type with the specified name.
valueOf(String) LongSerializationPolicy
Returns the enum constant of this type with the specified name.
valueOf(String) JsonToken
Returns the enum constant of this type with the specified name.
values() FieldNamingPolicy
Returns an array containing the constants of this enum type, in
the order they are declared.
values() LongSerializationPolicy
Returns an array containing the constants of this enum type, in
the order they are declared.
values() JsonToken
Returns an array containing the constants of this enum type, in
the order they are declared.
W
write(JsonWriter, T) TypeAdapter
Writes one JSON value (an array, object, string, number, boolean or null)
for value.
A B C D E F G H I J L M N P R S T U V W
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/index.html 0000664 0000000 0000000 00000005116 12604067504 0020765 0 ustar 00root root 0000000 0000000
Gson 2.3.1 API
<![CDATA[
<H2>
Frame Alert</H2>
<P>
This document is designed to be viewed using the frames feature. If you see this message, you are using a non-frame-capable web client.
<BR>
Link to<A HREF="overview-summary.html">Non-frame version.</A>
]]>
gson-gson-2.4/gson/docs/javadocs/overview-frame.html 0000664 0000000 0000000 00000002677 12604067504 0022625 0 ustar 00root root 0000000 0000000
Overview List (Gson 2.3.1 API)
gson-gson-2.4/gson/docs/javadocs/overview-summary.html 0000664 0000000 0000000 00000014555 12604067504 0023226 0 ustar 00root root 0000000 0000000
Overview (Gson 2.3.1 API)
Gson 2.3.1 API
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/overview-tree.html 0000664 0000000 0000000 00000034665 12604067504 0022474 0 ustar 00root root 0000000 0000000
Class Hierarchy (Gson 2.3.1 API)
Hierarchy For All Packages
Package Hierarchies: com.google.gson , com.google.gson.annotations , com.google.gson.reflect , com.google.gson.stream
Class Hierarchy
Interface Hierarchy
Annotation Type Hierarchy
Enum Hierarchy
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/package-list 0000664 0000000 0000000 00000000133 12604067504 0021251 0 ustar 00root root 0000000 0000000 com.google.gson
com.google.gson.annotations
com.google.gson.reflect
com.google.gson.stream
gson-gson-2.4/gson/docs/javadocs/resources/ 0000775 0000000 0000000 00000000000 12604067504 0020777 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/docs/javadocs/resources/inherit.gif 0000664 0000000 0000000 00000000071 12604067504 0023126 0 ustar 00root root 0000000 0000000 GIF89a , DrjԐ;߀Q@N ; gson-gson-2.4/gson/docs/javadocs/script.js 0000664 0000000 0000000 00000001473 12604067504 0020634 0 ustar 00root root 0000000 0000000 function show(type)
{
count = 0;
for (var key in methods) {
var row = document.getElementById(key);
if ((methods[key] & type) != 0) {
row.style.display = '';
row.className = (count++ % 2) ? rowColor : altColor;
}
else
row.style.display = 'none';
}
updateTabs(type);
}
function updateTabs(type)
{
for (var value in tabs) {
var sNode = document.getElementById(tabs[value][0]);
var spanNode = sNode.firstChild;
if (value == type) {
sNode.className = activeTableTab;
spanNode.innerHTML = tabs[value][1];
}
else {
sNode.className = tableTab;
spanNode.innerHTML = "" + tabs[value][1] + " ";
}
}
}
gson-gson-2.4/gson/docs/javadocs/serialized-form.html 0000664 0000000 0000000 00000020110 12604067504 0022741 0 ustar 00root root 0000000 0000000
Serialized Form (Gson 2.3.1 API)
Serialized Form
serialVersionUID: 1L
serialVersionUID: -4086729973971783390L
serialVersionUID: 1L
Package com.google.gson.stream
serialVersionUID: 1L
Google, Inc. . All rights reserved.
gson-gson-2.4/gson/docs/javadocs/stylesheet.css 0000664 0000000 0000000 00000002557 12604067504 0021701 0 ustar 00root root 0000000 0000000 /* Javadoc style sheet */
/* Define colors, fonts and other style attributes here to override the defaults */
/* Page background color */
body { background-color: #FFFFFF; color:#000000 }
/* Headings */
h1 { font-size: 145% }
/* Table colors */
.TableHeadingColor { background: #CCCCFF; color:#000000 } /* Dark mauve */
.TableSubHeadingColor { background: #EEEEFF; color:#000000 } /* Light mauve */
.TableRowColor { background: #FFFFFF; color:#000000 } /* White */
/* Font used in left-hand frame lists */
.FrameTitleFont { font-size: 100%; font-family: Helvetica, Arial, sans-serif; color:#000000 }
.FrameHeadingFont { font-size: 90%; font-family: Helvetica, Arial, sans-serif; color:#000000 }
.FrameItemFont { font-size: 90%; font-family: Helvetica, Arial, sans-serif; color:#000000 }
/* Navigation bar fonts and colors */
.NavBarCell1 { background-color:#EEEEFF; color:#000000} /* Light mauve */
.NavBarCell1Rev { background-color:#00008B; color:#FFFFFF} /* Dark Blue */
.NavBarFont1 { font-family: Arial, Helvetica, sans-serif; color:#000000;color:#000000;}
.NavBarFont1Rev { font-family: Arial, Helvetica, sans-serif; color:#FFFFFF;color:#FFFFFF;}
.NavBarCell2 { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF; color:#000000}
.NavBarCell3 { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF; color:#000000}
gson-gson-2.4/gson/pom.xml 0000664 0000000 0000000 00000021215 12604067504 0015561 0 ustar 00root root 0000000 0000000
4.0.0
com.google.code.gson
gson
jar
2.4
2008
Gson
org.sonatype.oss
oss-parent
9
https://github.com/google/gson
Google Gson library
UTF-8
The Apache Software License, Version 2.0
http://www.apache.org/licenses/LICENSE-2.0.txt
repo
scm:git:https://github.com/google/gson.git
scm:git:https://github.com/google/gson.git
https://github.com/google/gson
gson-${project.version}
Github Issue Tracking
https://github.com/google/gson/issues
sonatype-nexus-snapshots
Sonatype Nexus Snapshots
https://oss.sonatype.org/content/repositories/snapshots/
sonatype-nexus-staging
Nexus Release Repository
http://oss.sonatype.org/service/local/staging/deploy/maven2/
Google, Inc.
http://www.google.com
junit
junit
3.8.2
test
release-sign-artifacts
performRelease
true
org.apache.maven.plugins
maven-gpg-plugin
1.5
sign-artifacts
verify
sign
doclint-java8-disable
[1.8,)
org.apache.maven.plugins
maven-javadoc-plugin
-Xdoclint:none
package
org.apache.maven.plugins
maven-compiler-plugin
3.3
1.5
1.5
org.apache.maven.plugins
maven-jar-plugin
2.6
package
jar
false
J2SE-1.5, JavaSE-1.6, JavaSE-1.7, JavaSE-1.8
${project.version}
https://github.com/google/gson
Google Gson Project
${project.name}
${project.description}
.
2
com.google.gson
org.apache.maven.plugins
maven-source-plugin
2.4
attach-sources
verify
jar
com.google.gson;version="${project.version}"
com.google.gson.source
2
${project.version}
org.apache.maven.plugins
maven-javadoc-plugin
2.10.3
attach-javadocs
jar
com.google.gson
com.google.gson.internal:com.google.gson.internal.bind
true
protected
org.apache.maven.plugins
maven-eclipse-plugin
2.10
true
true
../eclipse-ws/
file:///${basedir}/../lib/gson-formatting-styles.xml
org.apache.maven.plugins
maven-release-plugin
-DenableCiProfile=true
maven-assembly-plugin
2.5.5
assembly-descriptor.xml
google-gson-${project.version}
target/dist
target/assembly/work
Inderjeet Singh
Joel Leitch
Google Inc.
Jesse Wilson
Square Inc.
gson-gson-2.4/gson/src/ 0000775 0000000 0000000 00000000000 12604067504 0015032 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/src/main/ 0000775 0000000 0000000 00000000000 12604067504 0015756 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/src/main/java/ 0000775 0000000 0000000 00000000000 12604067504 0016677 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/src/main/java/com/ 0000775 0000000 0000000 00000000000 12604067504 0017455 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/src/main/java/com/google/ 0000775 0000000 0000000 00000000000 12604067504 0020731 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/src/main/java/com/google/gson/ 0000775 0000000 0000000 00000000000 12604067504 0021677 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/src/main/java/com/google/gson/DefaultDateTypeAdapter.java 0000664 0000000 0000000 00000007660 12604067504 0027100 0 ustar 00root root 0000000 0000000 /*
* 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
public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
synchronized (localFormat) {
String dateFormatAsString = enUsFormat.format(src);
return new JsonPrimitive(dateFormatAsString);
}
}
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();
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/ExclusionStrategy.java 0000664 0000000 0000000 00000010141 12604067504 0026233 0 ustar 00root root 0000000 0000000 /*
* 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 true then that class or field type
* will not be part of the JSON output. For deserialization, if {@link #shouldSkipClass(Class)}
* returns true, 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:
*
* private static class SpecificClassExclusionStrategy implements ExclusionStrategy {
* private final Class<?> excludedThisClass;
*
* public SpecificClassExclusionStrategy(Class<?> excludedThisClass) {
* this.excludedThisClass = excludedThisClass;
* }
*
* public boolean shouldSkipClass(Class<?> clazz) {
* return excludedThisClass.equals(clazz);
* }
*
* public boolean shouldSkipField(FieldAttributes f) {
* return excludedThisClass.equals(f.getDeclaredClass());
* }
* }
*
*
* 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:
*
* ExclusionStrategy excludeStrings = new UserDefinedExclusionStrategy(String.class);
* Gson gson = new GsonBuilder()
* .setExclusionStrategies(excludeStrings)
* .create();
*
*
* 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:
*
* ExclusionStrategy excludeStrings = new UserDefinedExclusionStrategy(String.class);
* Gson gson = new GsonBuilder()
* .addDeserializationExclusionStrategy(excludeStrings)
* .create();
*
*
* @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);
}
gson-gson-2.4/gson/src/main/java/com/google/gson/FieldAttributes.java 0000664 0000000 0000000 00000010510 12604067504 0025631 0 ustar 00root root 0000000 0000000 /*
* 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:
*
* public class Foo {
* private String bar;
* private List<String> red;
* }
*
*
* 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}.
*
* This method is meant to be called as:
*
* boolean hasPublicModifier = fieldAttribute.hasModifier(java.lang.reflect.Modifier.PUBLIC);
*
*
* @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();
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/FieldNamingPolicy.java 0000664 0000000 0000000 00000013222 12604067504 0026077 0 ustar 00root root 0000000 0000000 /*
* 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;
import java.util.Locale;
/**
* 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() {
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() {
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() {
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() {
public String translateName(Field f) {
return separateCamelCase(f.getName(), "_").toLowerCase(Locale.ENGLISH);
}
},
/**
* 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() {
public String translateName(Field f) {
return separateCamelCase(f.getName(), "-").toLowerCase(Locale.ENGLISH);
}
};
/**
* 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);
}
} gson-gson-2.4/gson/src/main/java/com/google/gson/FieldNamingStrategy.java 0000664 0000000 0000000 00000002413 12604067504 0026442 0 ustar 00root root 0000000 0000000 /*
* 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);
}
gson-gson-2.4/gson/src/main/java/com/google/gson/Gson.java 0000664 0000000 0000000 00000116400 12604067504 0023452 0 ustar 00root root 0000000 0000000 /*
* 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.List;
import java.util.Map;
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. Gson instances are Thread-safe so you can reuse them freely across multiple
* threads.
*
* 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}:
*
*
* 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);
*
*
* 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>());
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() {
@SuppressWarnings("unchecked")
public 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:
*
* 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.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(TypeAdapters.ENUM_FACTORY);
factories.add(new ReflectiveTypeAdapterFactory(
constructorConstructor, fieldNamingPolicy, excluder));
this.factories = Collections.unmodifiableList(factories);
}
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);
* }
* };
* }
* }
* }
* This factory can now be used like this:
* {@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);
* }
* Note that this call will skip all factories registered before {@code skipPast}. In case of
* multiple TypeAdapterFactories registered it is up to the caller of this function to insure
* that the order of registration does not prevent this method from reaching a factory they
* would expect to reply from this call.
* 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;
// Skip past if and only if the specified factory is present in the factories.
// This is useful because the factories created through JsonAdapter annotations are not
// registered in this list.
if (!factories.contains(skipPast)) skipPastFound = true;
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();
writer.setSerializeNulls(serializeNulls);
try {
((TypeAdapter) 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 the settings on this Gson instance.
*/
public 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 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. Returns {@code null} if {@code json} is {@code null}.
* @throws JsonSyntaxException if json is not a valid representation for an object of type
* classOfT
*/
public T fromJson(String json, Class 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 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}, you should use:
*
* Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType();
*
* @return an object of type T from the string. Returns {@code null} if {@code json} is {@code null}.
* @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 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 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. Returns {@code null} if {@code json} is at EOF.
* @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 fromJson(Reader json, Class 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 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}, you should use:
*
* Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType();
*
* @return an object of type T from the json. Returns {@code null} if {@code json} is at EOF.
* @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 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}. Returns {@code null}, if the {@code reader} is at EOF.
* 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 fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {
boolean isEmpty = true;
boolean oldLenient = reader.isLenient();
reader.setLenient(true);
try {
reader.peek();
isEmpty = false;
TypeToken typeToken = (TypeToken) TypeToken.get(typeOfT);
TypeAdapter 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 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. Returns {@code null} if {@code json} is {@code null}.
* @throws JsonSyntaxException if json is not a valid representation for an object of type typeOfT
* @since 1.3
*/
public T fromJson(JsonElement json, Class 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 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}, you should use:
*
* Type typeOfT = new TypeToken<Collection<Foo>>(){}.getType();
*
* @return an object of type T from the json. Returns {@code null} if {@code json} is {@code null}.
* @throws JsonSyntaxException if json is not a valid representation for an object of type typeOfT
* @since 1.3
*/
@SuppressWarnings("unchecked")
public T fromJson(JsonElement json, Type typeOfT) throws JsonSyntaxException {
if (json == null) {
return null;
}
return (T) fromJson(new JsonTreeReader(json), typeOfT);
}
static class FutureTypeAdapter extends TypeAdapter {
private TypeAdapter delegate;
public void setDelegate(TypeAdapter 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();
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/GsonBuilder.java 0000664 0000000 0000000 00000056502 12604067504 0024767 0 ustar 00root root 0000000 0000000 /*
* 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.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.google.gson.internal.$Gson$Preconditions;
import com.google.gson.internal.Excluder;
import com.google.gson.internal.bind.TypeAdapters;
import com.google.gson.reflect.TypeToken;
/**
* Use this builder to construct a {@link Gson} instance when you need to set configuration
* options other than the default. For {@link Gson} with default configuration, it is simpler to
* use {@code new Gson()}. {@code GsonBuilder} is best used by creating it, and then invoking its
* various configuration methods, and finally calling create.
*
* The following is an example shows how to use the {@code GsonBuilder} to construct a Gson
* instance:
*
*
* Gson gson = new GsonBuilder()
* .registerTypeAdapter(Id.class, new IdTypeAdapter())
* .enableComplexMapKeySerialization()
* .serializeNulls()
* .setDateFormat(DateFormat.LONG)
* .setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)
* .setPrettyPrinting()
* .setVersion(1.0)
* .create();
*
*
* NOTES:
*
* the order of invocation of configuration methods does not matter.
* The default serialization of {@link Date} and its subclasses in Gson does
* not contain time-zone information. So, if you are using date/time instances,
* use {@code GsonBuilder} and its {@code setDateFormat} methods.
*
*
*
* @author Inderjeet Singh
* @author Joel Leitch
* @author Jesse Wilson
*/
public final class GsonBuilder {
private Excluder excluder = Excluder.DEFAULT;
private LongSerializationPolicy longSerializationPolicy = LongSerializationPolicy.DEFAULT;
private FieldNamingStrategy fieldNamingPolicy = FieldNamingPolicy.IDENTITY;
private final Map> instanceCreators
= new HashMap>();
private final List factories = new ArrayList();
/** tree-style hierarchy factories. These come after factories for backwards compatibility. */
private final List hierarchyFactories = new ArrayList();
private boolean serializeNulls;
private String datePattern;
private int dateStyle = DateFormat.DEFAULT;
private int timeStyle = DateFormat.DEFAULT;
private boolean complexMapKeySerialization;
private boolean serializeSpecialFloatingPointValues;
private boolean escapeHtmlChars = true;
private boolean prettyPrinting;
private boolean generateNonExecutableJson;
/**
* Creates a GsonBuilder instance that can be used to build Gson with various configuration
* settings. GsonBuilder follows the builder pattern, and it is typically used by first
* invoking various configuration methods to set desired options, and finally calling
* {@link #create()}.
*/
public GsonBuilder() {
}
/**
* Configures Gson to enable versioning support.
*
* @param ignoreVersionsAfter any field or type marked with a version higher than this value
* are ignored during serialization or deserialization.
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
*/
public GsonBuilder setVersion(double ignoreVersionsAfter) {
excluder = excluder.withVersion(ignoreVersionsAfter);
return this;
}
/**
* Configures Gson to excludes all class fields that have the specified modifiers. By default,
* Gson will exclude all fields marked transient or static. This method will override that
* behavior.
*
* @param modifiers the field modifiers. You must use the modifiers specified in the
* {@link java.lang.reflect.Modifier} class. For example,
* {@link java.lang.reflect.Modifier#TRANSIENT},
* {@link java.lang.reflect.Modifier#STATIC}.
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
*/
public GsonBuilder excludeFieldsWithModifiers(int... modifiers) {
excluder = excluder.withModifiers(modifiers);
return this;
}
/**
* Makes the output JSON non-executable in Javascript by prefixing the generated JSON with some
* special text. This prevents attacks from third-party sites through script sourcing. See
* Gson Issue 42
* for details.
*
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.3
*/
public GsonBuilder generateNonExecutableJson() {
this.generateNonExecutableJson = true;
return this;
}
/**
* Configures Gson to exclude all fields from consideration for serialization or deserialization
* that do not have the {@link com.google.gson.annotations.Expose} annotation.
*
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
*/
public GsonBuilder excludeFieldsWithoutExposeAnnotation() {
excluder = excluder.excludeFieldsWithoutExposeAnnotation();
return this;
}
/**
* Configure Gson to serialize null fields. By default, Gson omits all fields that are null
* during serialization.
*
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.2
*/
public GsonBuilder serializeNulls() {
this.serializeNulls = true;
return this;
}
/**
* Enabling this feature will only change the serialized form if the map key is
* a complex type (i.e. non-primitive) in its serialized JSON
* form. The default implementation of map serialization uses {@code toString()}
* on the key; however, when this is called then one of the following cases
* apply:
*
* Maps as JSON objects
* For this case, assume that a type adapter is registered to serialize and
* deserialize some {@code Point} class, which contains an x and y coordinate,
* to/from the JSON Primitive string value {@code "(x,y)"}. The Java map would
* then be serialized as a {@link JsonObject}.
*
* Below is an example:
*
{@code
* Gson gson = new GsonBuilder()
* .register(Point.class, new MyPointTypeAdapter())
* .enableComplexMapKeySerialization()
* .create();
*
* Map original = new LinkedHashMap();
* original.put(new Point(5, 6), "a");
* original.put(new Point(8, 8), "b");
* System.out.println(gson.toJson(original, type));
* }
* The above code prints this JSON object: {@code
* {
* "(5,6)": "a",
* "(8,8)": "b"
* }
* }
*
* Maps as JSON arrays
* For this case, assume that a type adapter was NOT registered for some
* {@code Point} class, but rather the default Gson serialization is applied.
* In this case, some {@code new Point(2,3)} would serialize as {@code
* {"x":2,"y":5}}.
*
* Given the assumption above, a {@code Map} will be
* serialize as an array of arrays (can be viewed as an entry set of pairs).
*
* Below is an example of serializing complex types as JSON arrays:
*
{@code
* Gson gson = new GsonBuilder()
* .enableComplexMapKeySerialization()
* .create();
*
* Map original = new LinkedHashMap();
* original.put(new Point(5, 6), "a");
* original.put(new Point(8, 8), "b");
* System.out.println(gson.toJson(original, type));
* }
*
* The JSON output would look as follows:
* {@code
* [
* [
* {
* "x": 5,
* "y": 6
* },
* "a"
* ],
* [
* {
* "x": 8,
* "y": 8
* },
* "b"
* ]
* ]
* }
*
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.7
*/
public GsonBuilder enableComplexMapKeySerialization() {
complexMapKeySerialization = true;
return this;
}
/**
* Configures Gson to exclude inner classes during serialization.
*
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.3
*/
public GsonBuilder disableInnerClassSerialization() {
excluder = excluder.disableInnerClassSerialization();
return this;
}
/**
* Configures Gson to apply a specific serialization policy for {@code Long} and {@code long}
* objects.
*
* @param serializationPolicy the particular policy to use for serializing longs.
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.3
*/
public GsonBuilder setLongSerializationPolicy(LongSerializationPolicy serializationPolicy) {
this.longSerializationPolicy = serializationPolicy;
return this;
}
/**
* Configures Gson to apply a specific naming policy to an object's field during serialization
* and deserialization.
*
* @param namingConvention the JSON field naming convention to use for serialization and
* deserialization.
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
*/
public GsonBuilder setFieldNamingPolicy(FieldNamingPolicy namingConvention) {
this.fieldNamingPolicy = namingConvention;
return this;
}
/**
* Configures Gson to apply a specific naming policy strategy to an object's field during
* serialization and deserialization.
*
* @param fieldNamingStrategy the actual naming strategy to apply to the fields
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.3
*/
public GsonBuilder setFieldNamingStrategy(FieldNamingStrategy fieldNamingStrategy) {
this.fieldNamingPolicy = fieldNamingStrategy;
return this;
}
/**
* Configures Gson to apply a set of exclusion strategies during both serialization and
* deserialization. Each of the {@code strategies} will be applied as a disjunction rule.
* This means that if one of the {@code strategies} suggests that a field (or class) should be
* skipped then that field (or object) is skipped during serializaiton/deserialization.
*
* @param strategies the set of strategy object to apply during object (de)serialization.
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.4
*/
public GsonBuilder setExclusionStrategies(ExclusionStrategy... strategies) {
for (ExclusionStrategy strategy : strategies) {
excluder = excluder.withExclusionStrategy(strategy, true, true);
}
return this;
}
/**
* Configures Gson to apply the passed in exclusion strategy during serialization.
* If this method is invoked numerous times with different exclusion strategy objects
* then the exclusion strategies that were added will be applied as a disjunction rule.
* This means that if one of the added exclusion strategies suggests that a field (or
* class) should be skipped then that field (or object) is skipped during its
* serialization.
*
* @param strategy an exclusion strategy to apply during serialization.
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.7
*/
public GsonBuilder addSerializationExclusionStrategy(ExclusionStrategy strategy) {
excluder = excluder.withExclusionStrategy(strategy, true, false);
return this;
}
/**
* Configures Gson to apply the passed in exclusion strategy during deserialization.
* If this method is invoked numerous times with different exclusion strategy objects
* then the exclusion strategies that were added will be applied as a disjunction rule.
* This means that if one of the added exclusion strategies suggests that a field (or
* class) should be skipped then that field (or object) is skipped during its
* deserialization.
*
* @param strategy an exclusion strategy to apply during deserialization.
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.7
*/
public GsonBuilder addDeserializationExclusionStrategy(ExclusionStrategy strategy) {
excluder = excluder.withExclusionStrategy(strategy, false, true);
return this;
}
/**
* Configures Gson to output Json that fits in a page for pretty printing. This option only
* affects Json serialization.
*
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
*/
public GsonBuilder setPrettyPrinting() {
prettyPrinting = true;
return this;
}
/**
* By default, Gson escapes HTML characters such as < > etc. Use this option to configure
* Gson to pass-through HTML characters as is.
*
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.3
*/
public GsonBuilder disableHtmlEscaping() {
this.escapeHtmlChars = false;
return this;
}
/**
* Configures Gson to serialize {@code Date} objects according to the pattern provided. You can
* call this method or {@link #setDateFormat(int)} multiple times, but only the last invocation
* will be used to decide the serialization format.
*
* The date format will be used to serialize and deserialize {@link java.util.Date}, {@link
* java.sql.Timestamp} and {@link java.sql.Date}.
*
*
Note that this pattern must abide by the convention provided by {@code SimpleDateFormat}
* class. See the documentation in {@link java.text.SimpleDateFormat} for more information on
* valid date and time patterns.
*
* @param pattern the pattern that dates will be serialized/deserialized to/from
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.2
*/
public GsonBuilder setDateFormat(String pattern) {
// TODO(Joel): Make this fail fast if it is an invalid date format
this.datePattern = pattern;
return this;
}
/**
* Configures Gson to to serialize {@code Date} objects according to the style value provided.
* You can call this method or {@link #setDateFormat(String)} multiple times, but only the last
* invocation will be used to decide the serialization format.
*
* Note that this style value should be one of the predefined constants in the
* {@code DateFormat} class. See the documentation in {@link java.text.DateFormat} for more
* information on the valid style constants.
*
* @param style the predefined date style that date objects will be serialized/deserialized
* to/from
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.2
*/
public GsonBuilder setDateFormat(int style) {
this.dateStyle = style;
this.datePattern = null;
return this;
}
/**
* Configures Gson to to serialize {@code Date} objects according to the style value provided.
* You can call this method or {@link #setDateFormat(String)} multiple times, but only the last
* invocation will be used to decide the serialization format.
*
* Note that this style value should be one of the predefined constants in the
* {@code DateFormat} class. See the documentation in {@link java.text.DateFormat} for more
* information on the valid style constants.
*
* @param dateStyle the predefined date style that date objects will be serialized/deserialized
* to/from
* @param timeStyle the predefined style for the time portion of the date objects
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.2
*/
public GsonBuilder setDateFormat(int dateStyle, int timeStyle) {
this.dateStyle = dateStyle;
this.timeStyle = timeStyle;
this.datePattern = null;
return this;
}
/**
* Configures Gson for custom serialization or deserialization. This method combines the
* registration of an {@link TypeAdapter}, {@link InstanceCreator}, {@link JsonSerializer}, and a
* {@link JsonDeserializer}. It is best used when a single object {@code typeAdapter} implements
* all the required interfaces for custom serialization with Gson. If a type adapter was
* previously registered for the specified {@code type}, it is overwritten.
*
* This registers the type specified and no other types: you must manually register related
* types! For example, applications registering {@code boolean.class} should also register {@code
* Boolean.class}.
*
* @param type the type definition for the type adapter being registered
* @param typeAdapter This object must implement at least one of the {@link TypeAdapter},
* {@link InstanceCreator}, {@link JsonSerializer}, and a {@link JsonDeserializer} interfaces.
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {
$Gson$Preconditions.checkArgument(typeAdapter instanceof JsonSerializer
|| typeAdapter instanceof JsonDeserializer
|| typeAdapter instanceof InstanceCreator
|| typeAdapter instanceof TypeAdapter);
if (typeAdapter instanceof InstanceCreator) {
instanceCreators.put(type, (InstanceCreator) typeAdapter);
}
if (typeAdapter instanceof JsonSerializer || typeAdapter instanceof JsonDeserializer) {
TypeToken typeToken = TypeToken.get(type);
factories.add(TreeTypeAdapter.newFactoryWithMatchRawType(typeToken, typeAdapter));
}
if (typeAdapter instanceof TypeAdapter) {
factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter)typeAdapter));
}
return this;
}
/**
* Register a factory for type adapters. Registering a factory is useful when the type
* adapter needs to be configured based on the type of the field being processed. Gson
* is designed to handle a large number of factories, so you should consider registering
* them to be at par with registering an individual type adapter.
*
* @since 2.1
*/
public GsonBuilder registerTypeAdapterFactory(TypeAdapterFactory factory) {
factories.add(factory);
return this;
}
/**
* Configures Gson for custom serialization or deserialization for an inheritance type hierarchy.
* This method combines the registration of a {@link TypeAdapter}, {@link JsonSerializer} and
* a {@link JsonDeserializer}. If a type adapter was previously registered for the specified
* type hierarchy, it is overridden. If a type adapter is registered for a specific type in
* the type hierarchy, it will be invoked instead of the one registered for the type hierarchy.
*
* @param baseType the class definition for the type adapter being registered for the base class
* or interface
* @param typeAdapter This object must implement at least one of {@link TypeAdapter},
* {@link JsonSerializer} or {@link JsonDeserializer} interfaces.
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.7
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public GsonBuilder registerTypeHierarchyAdapter(Class baseType, Object typeAdapter) {
$Gson$Preconditions.checkArgument(typeAdapter instanceof JsonSerializer
|| typeAdapter instanceof JsonDeserializer
|| typeAdapter instanceof TypeAdapter);
if (typeAdapter instanceof JsonDeserializer || typeAdapter instanceof JsonSerializer) {
hierarchyFactories.add(0,
TreeTypeAdapter.newTypeHierarchyFactory(baseType, typeAdapter));
}
if (typeAdapter instanceof TypeAdapter) {
factories.add(TypeAdapters.newTypeHierarchyFactory(baseType, (TypeAdapter)typeAdapter));
}
return this;
}
/**
* Section 2.4 of JSON specification disallows
* special double values (NaN, Infinity, -Infinity). However,
* Javascript
* specification (see section 4.3.20, 4.3.22, 4.3.23) allows these values as valid Javascript
* values. Moreover, most JavaScript engines will accept these special values in JSON without
* problem. So, at a practical level, it makes sense to accept these values as valid JSON even
* though JSON specification disallows them.
*
*
Gson always accepts these special values during deserialization. However, it outputs
* strictly compliant JSON. Hence, if it encounters a float value {@link Float#NaN},
* {@link Float#POSITIVE_INFINITY}, {@link Float#NEGATIVE_INFINITY}, or a double value
* {@link Double#NaN}, {@link Double#POSITIVE_INFINITY}, {@link Double#NEGATIVE_INFINITY}, it
* will throw an {@link IllegalArgumentException}. This method provides a way to override the
* default behavior when you know that the JSON receiver will be able to handle these special
* values.
*
* @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
* @since 1.3
*/
public GsonBuilder serializeSpecialFloatingPointValues() {
this.serializeSpecialFloatingPointValues = true;
return this;
}
/**
* Creates a {@link Gson} instance based on the current configuration. This method is free of
* side-effects to this {@code GsonBuilder} instance and hence can be called multiple times.
*
* @return an instance of Gson configured with the options currently set in this builder
*/
public Gson create() {
List factories = new ArrayList();
factories.addAll(this.factories);
Collections.reverse(factories);
factories.addAll(this.hierarchyFactories);
addTypeAdaptersForDate(datePattern, dateStyle, timeStyle, factories);
return new Gson(excluder, fieldNamingPolicy, instanceCreators,
serializeNulls, complexMapKeySerialization,
generateNonExecutableJson, escapeHtmlChars, prettyPrinting,
serializeSpecialFloatingPointValues, longSerializationPolicy, factories);
}
private void addTypeAdaptersForDate(String datePattern, int dateStyle, int timeStyle,
List factories) {
DefaultDateTypeAdapter dateTypeAdapter;
if (datePattern != null && !"".equals(datePattern.trim())) {
dateTypeAdapter = new DefaultDateTypeAdapter(datePattern);
} else if (dateStyle != DateFormat.DEFAULT && timeStyle != DateFormat.DEFAULT) {
dateTypeAdapter = new DefaultDateTypeAdapter(dateStyle, timeStyle);
} else {
return;
}
factories.add(TreeTypeAdapter.newFactory(TypeToken.get(Date.class), dateTypeAdapter));
factories.add(TreeTypeAdapter.newFactory(TypeToken.get(Timestamp.class), dateTypeAdapter));
factories.add(TreeTypeAdapter.newFactory(TypeToken.get(java.sql.Date.class), dateTypeAdapter));
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/InstanceCreator.java 0000664 0000000 0000000 00000007157 12604067504 0025640 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* This interface is implemented to create instances of a class that does not define a no-args
* constructor. If you can modify the class, you should instead add a private, or public
* no-args constructor. However, that is not possible for library classes, such as JDK classes, or
* a third-party library that you do not have source-code of. In such cases, you should define an
* instance creator for the class. Implementations of this interface should be registered with
* {@link GsonBuilder#registerTypeAdapter(Type, Object)} method before Gson will be able to use
* them.
* Let us look at an example where defining an InstanceCreator might be useful. The
* {@code Id} class defined below does not have a default no-args constructor.
*
*
* public class Id<T> {
* private final Class<T> clazz;
* private final long value;
* public Id(Class<T> clazz, long value) {
* this.clazz = clazz;
* this.value = value;
* }
* }
*
*
* If Gson encounters an object of type {@code Id} during deserialization, it will throw an
* exception. The easiest way to solve this problem will be to add a (public or private) no-args
* constructor as follows:
*
*
* private Id() {
* this(Object.class, 0L);
* }
*
*
* However, let us assume that the developer does not have access to the source-code of the
* {@code Id} class, or does not want to define a no-args constructor for it. The developer
* can solve this problem by defining an {@code InstanceCreator} for {@code Id}:
*
*
* class IdInstanceCreator implements InstanceCreator<Id> {
* public Id createInstance(Type type) {
* return new Id(Object.class, 0L);
* }
* }
*
*
* Note that it does not matter what the fields of the created instance contain since Gson will
* overwrite them with the deserialized values specified in Json. You should also ensure that a
* new object is returned, not a common object since its fields will be overwritten.
* The developer will need to register {@code IdInstanceCreator} with Gson as follows:
*
*
* Gson gson = new GsonBuilder().registerTypeAdapter(Id.class, new IdInstanceCreator()).create();
*
*
* @param the type of object that will be created by this implementation.
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
public interface InstanceCreator {
/**
* Gson invokes this call-back method during deserialization to create an instance of the
* specified type. The fields of the returned instance are overwritten with the data present
* in the Json. Since the prior contents of the object are destroyed and overwritten, do not
* return an instance that is useful elsewhere. In particular, do not return a common instance,
* always use {@code new} to create a new instance.
*
* @param type the parameterized T represented as a {@link Type}.
* @return a default object instance of type T.
*/
public T createInstance(Type type);
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonArray.java 0000664 0000000 0000000 00000027226 12604067504 0024463 0 ustar 00root root 0000000 0000000 /*
* 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.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* A class representing an array type in Json. An array is a list of {@link JsonElement}s each of
* which can be of a different type. This is an ordered list, meaning that the order in which
* elements are added is preserved.
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
public final class JsonArray extends JsonElement implements Iterable {
private final List elements;
/**
* Creates an empty JsonArray.
*/
public JsonArray() {
elements = new ArrayList();
}
@Override
JsonArray deepCopy() {
JsonArray result = new JsonArray();
for (JsonElement element : elements) {
result.add(element.deepCopy());
}
return result;
}
/**
* Adds the specified boolean to self.
*
* @param bool the boolean that needs to be added to the array.
*/
public void add(Boolean bool) {
elements.add(bool == null ? JsonNull.INSTANCE : new JsonPrimitive(bool));
}
/**
* Adds the specified character to self.
*
* @param character the character that needs to be added to the array.
*/
public void add(Character character) {
elements.add(character == null ? JsonNull.INSTANCE : new JsonPrimitive(character));
}
/**
* Adds the specified number to self.
*
* @param number the number that needs to be added to the array.
*/
public void add(Number number) {
elements.add(number == null ? JsonNull.INSTANCE : new JsonPrimitive(number));
}
/**
* Adds the specified string to self.
*
* @param string the string that needs to be added to the array.
*/
public void add(String string) {
elements.add(string == null ? JsonNull.INSTANCE : new JsonPrimitive(string));
}
/**
* Adds the specified element to self.
*
* @param element the element that needs to be added to the array.
*/
public void add(JsonElement element) {
if (element == null) {
element = JsonNull.INSTANCE;
}
elements.add(element);
}
/**
* Adds all the elements of the specified array to self.
*
* @param array the array whose elements need to be added to the array.
*/
public void addAll(JsonArray array) {
elements.addAll(array.elements);
}
/**
* Replaces the element at the specified position in this array with the specified element.
* Element can be null.
* @param index index of the element to replace
* @param element element to be stored at the specified position
* @return the element previously at the specified position
* @throws IndexOutOfBoundsException if the specified index is outside the array bounds
*/
public JsonElement set(int index, JsonElement element) {
return elements.set(index, element);
}
/**
* Removes the first occurrence of the specified element from this array, if it is present.
* If the array does not contain the element, it is unchanged.
* @param element element to be removed from this array, if present
* @return true if this array contained the specified element, false otherwise
* @since 2.3
*/
public boolean remove(JsonElement element) {
return elements.remove(element);
}
/**
* Removes the element at the specified position in this array. Shifts any subsequent elements
* to the left (subtracts one from their indices). Returns the element that was removed from
* the array.
* @param index index the index of the element to be removed
* @return the element previously at the specified position
* @throws IndexOutOfBoundsException if the specified index is outside the array bounds
* @since 2.3
*/
public JsonElement remove(int index) {
return elements.remove(index);
}
/**
* Returns true if this array contains the specified element.
* @return true if this array contains the specified element.
* @param element whose presence in this array is to be tested
* @since 2.3
*/
public boolean contains(JsonElement element) {
return elements.contains(element);
}
/**
* Returns the number of elements in the array.
*
* @return the number of elements in the array.
*/
public int size() {
return elements.size();
}
/**
* Returns an iterator to navigate the elemetns of the array. Since the array is an ordered list,
* the iterator navigates the elements in the order they were inserted.
*
* @return an iterator to navigate the elements of the array.
*/
public Iterator iterator() {
return elements.iterator();
}
/**
* Returns the ith element of the array.
*
* @param i the index of the element that is being sought.
* @return the element present at the ith index.
* @throws IndexOutOfBoundsException if i is negative or greater than or equal to the
* {@link #size()} of the array.
*/
public JsonElement get(int i) {
return elements.get(i);
}
/**
* convenience method to get this array as a {@link Number} if it contains a single element.
*
* @return get this element as a number if it is single element array.
* @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
* is not a valid Number.
* @throws IllegalStateException if the array has more than one element.
*/
@Override
public Number getAsNumber() {
if (elements.size() == 1) {
return elements.get(0).getAsNumber();
}
throw new IllegalStateException();
}
/**
* convenience method to get this array as a {@link String} if it contains a single element.
*
* @return get this element as a String if it is single element array.
* @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
* is not a valid String.
* @throws IllegalStateException if the array has more than one element.
*/
@Override
public String getAsString() {
if (elements.size() == 1) {
return elements.get(0).getAsString();
}
throw new IllegalStateException();
}
/**
* convenience method to get this array as a double if it contains a single element.
*
* @return get this element as a double if it is single element array.
* @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
* is not a valid double.
* @throws IllegalStateException if the array has more than one element.
*/
@Override
public double getAsDouble() {
if (elements.size() == 1) {
return elements.get(0).getAsDouble();
}
throw new IllegalStateException();
}
/**
* convenience method to get this array as a {@link BigDecimal} if it contains a single element.
*
* @return get this element as a {@link BigDecimal} if it is single element array.
* @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive}.
* @throws NumberFormatException if the element at index 0 is not a valid {@link BigDecimal}.
* @throws IllegalStateException if the array has more than one element.
* @since 1.2
*/
@Override
public BigDecimal getAsBigDecimal() {
if (elements.size() == 1) {
return elements.get(0).getAsBigDecimal();
}
throw new IllegalStateException();
}
/**
* convenience method to get this array as a {@link BigInteger} if it contains a single element.
*
* @return get this element as a {@link BigInteger} if it is single element array.
* @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive}.
* @throws NumberFormatException if the element at index 0 is not a valid {@link BigInteger}.
* @throws IllegalStateException if the array has more than one element.
* @since 1.2
*/
@Override
public BigInteger getAsBigInteger() {
if (elements.size() == 1) {
return elements.get(0).getAsBigInteger();
}
throw new IllegalStateException();
}
/**
* convenience method to get this array as a float if it contains a single element.
*
* @return get this element as a float if it is single element array.
* @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
* is not a valid float.
* @throws IllegalStateException if the array has more than one element.
*/
@Override
public float getAsFloat() {
if (elements.size() == 1) {
return elements.get(0).getAsFloat();
}
throw new IllegalStateException();
}
/**
* convenience method to get this array as a long if it contains a single element.
*
* @return get this element as a long if it is single element array.
* @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
* is not a valid long.
* @throws IllegalStateException if the array has more than one element.
*/
@Override
public long getAsLong() {
if (elements.size() == 1) {
return elements.get(0).getAsLong();
}
throw new IllegalStateException();
}
/**
* convenience method to get this array as an integer if it contains a single element.
*
* @return get this element as an integer if it is single element array.
* @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
* is not a valid integer.
* @throws IllegalStateException if the array has more than one element.
*/
@Override
public int getAsInt() {
if (elements.size() == 1) {
return elements.get(0).getAsInt();
}
throw new IllegalStateException();
}
@Override
public byte getAsByte() {
if (elements.size() == 1) {
return elements.get(0).getAsByte();
}
throw new IllegalStateException();
}
@Override
public char getAsCharacter() {
if (elements.size() == 1) {
return elements.get(0).getAsCharacter();
}
throw new IllegalStateException();
}
/**
* convenience method to get this array as a primitive short if it contains a single element.
*
* @return get this element as a primitive short if it is single element array.
* @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
* is not a valid short.
* @throws IllegalStateException if the array has more than one element.
*/
@Override
public short getAsShort() {
if (elements.size() == 1) {
return elements.get(0).getAsShort();
}
throw new IllegalStateException();
}
/**
* convenience method to get this array as a boolean if it contains a single element.
*
* @return get this element as a boolean if it is single element array.
* @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
* is not a valid boolean.
* @throws IllegalStateException if the array has more than one element.
*/
@Override
public boolean getAsBoolean() {
if (elements.size() == 1) {
return elements.get(0).getAsBoolean();
}
throw new IllegalStateException();
}
@Override
public boolean equals(Object o) {
return (o == this) || (o instanceof JsonArray && ((JsonArray) o).elements.equals(elements));
}
@Override
public int hashCode() {
return elements.hashCode();
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonDeserializationContext.java 0000664 0000000 0000000 00000003202 12604067504 0030064 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* Context for deserialization that is passed to a custom deserializer during invocation of its
* {@link JsonDeserializer#deserialize(JsonElement, Type, JsonDeserializationContext)}
* method.
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
public interface JsonDeserializationContext {
/**
* Invokes default deserialization on the specified object. It should never be invoked on
* the element received as a parameter of the
* {@link JsonDeserializer#deserialize(JsonElement, Type, JsonDeserializationContext)} method. Doing
* so will result in an infinite loop since Gson will in-turn call the custom deserializer again.
*
* @param json the parse tree.
* @param typeOfT type of the expected return value.
* @param The type of the deserialized object.
* @return An object of type typeOfT.
* @throws JsonParseException if the parse tree does not contain expected data.
*/
public T deserialize(JsonElement json, Type typeOfT) throws JsonParseException;
} gson-gson-2.4/gson/src/main/java/com/google/gson/JsonDeserializer.java 0000664 0000000 0000000 00000007135 12604067504 0026024 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* Interface representing a custom deserializer for Json. You should write a custom
* deserializer, if you are not happy with the default deserialization done by Gson. You will
* also need to register this deserializer through
* {@link GsonBuilder#registerTypeAdapter(Type, Object)}.
*
* Let us look at example where defining a deserializer will be useful. The {@code Id} class
* defined below has two fields: {@code clazz} and {@code value}.
*
*
* public class Id<T> {
* private final Class<T> clazz;
* private final long value;
* public Id(Class<T> clazz, long value) {
* this.clazz = clazz;
* this.value = value;
* }
* public long getValue() {
* return value;
* }
* }
*
*
* The default deserialization of {@code Id(com.foo.MyObject.class, 20L)} will require the
* Json string to be {"clazz":com.foo.MyObject,"value":20}. Suppose, you already know
* the type of the field that the {@code Id} will be deserialized into, and hence just want to
* deserialize it from a Json string {@code 20}. You can achieve that by writing a custom
* deserializer:
*
*
* class IdDeserializer implements JsonDeserializer<Id>() {
* public Id deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
* throws JsonParseException {
* return new Id((Class)typeOfT, id.getValue());
* }
*
*
* You will also need to register {@code IdDeserializer} with Gson as follows:
*
*
* Gson gson = new GsonBuilder().registerTypeAdapter(Id.class, new IdDeserializer()).create();
*
*
* New applications should prefer {@link TypeAdapter}, whose streaming API
* is more efficient than this interface's tree API.
*
* @author Inderjeet Singh
* @author Joel Leitch
*
* @param type for which the deserializer is being registered. It is possible that a
* deserializer may be asked to deserialize a specific generic type of the T.
*/
public interface JsonDeserializer {
/**
* Gson invokes this call-back method during deserialization when it encounters a field of the
* specified type.
* In the implementation of this call-back method, you should consider invoking
* {@link JsonDeserializationContext#deserialize(JsonElement, Type)} method to create objects
* for any non-trivial field of the returned object. However, you should never invoke it on the
* the same type passing {@code json} since that will cause an infinite loop (Gson will call your
* call-back method again).
*
* @param json The Json data being deserialized
* @param typeOfT The type of the Object to deserialize to
* @return a deserialized object of the specified type typeOfT which is a subclass of {@code T}
* @throws JsonParseException if json is not in the expected format of {@code typeofT}
*/
public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
throws JsonParseException;
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonElement.java 0000664 0000000 0000000 00000027100 12604067504 0024765 0 ustar 00root root 0000000 0000000 /*
* 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.Streams;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.io.StringWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
/**
* A class representing an element of Json. It could either be a {@link JsonObject}, a
* {@link JsonArray}, a {@link JsonPrimitive} or a {@link JsonNull}.
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
public abstract class JsonElement {
/**
* Returns a deep copy of this element. Immutable elements like primitives
* and nulls are not copied.
*/
abstract JsonElement deepCopy();
/**
* provides check for verifying if this element is an array or not.
*
* @return true if this element is of type {@link JsonArray}, false otherwise.
*/
public boolean isJsonArray() {
return this instanceof JsonArray;
}
/**
* provides check for verifying if this element is a Json object or not.
*
* @return true if this element is of type {@link JsonObject}, false otherwise.
*/
public boolean isJsonObject() {
return this instanceof JsonObject;
}
/**
* provides check for verifying if this element is a primitive or not.
*
* @return true if this element is of type {@link JsonPrimitive}, false otherwise.
*/
public boolean isJsonPrimitive() {
return this instanceof JsonPrimitive;
}
/**
* provides check for verifying if this element represents a null value or not.
*
* @return true if this element is of type {@link JsonNull}, false otherwise.
* @since 1.2
*/
public boolean isJsonNull() {
return this instanceof JsonNull;
}
/**
* convenience method to get this element as a {@link JsonObject}. If the element is of some
* other type, a {@link IllegalStateException} will result. Hence it is best to use this method
* after ensuring that this element is of the desired type by calling {@link #isJsonObject()}
* first.
*
* @return get this element as a {@link JsonObject}.
* @throws IllegalStateException if the element is of another type.
*/
public JsonObject getAsJsonObject() {
if (isJsonObject()) {
return (JsonObject) this;
}
throw new IllegalStateException("Not a JSON Object: " + this);
}
/**
* convenience method to get this element as a {@link JsonArray}. If the element is of some
* other type, a {@link IllegalStateException} will result. Hence it is best to use this method
* after ensuring that this element is of the desired type by calling {@link #isJsonArray()}
* first.
*
* @return get this element as a {@link JsonArray}.
* @throws IllegalStateException if the element is of another type.
*/
public JsonArray getAsJsonArray() {
if (isJsonArray()) {
return (JsonArray) this;
}
throw new IllegalStateException("This is not a JSON Array.");
}
/**
* convenience method to get this element as a {@link JsonPrimitive}. If the element is of some
* other type, a {@link IllegalStateException} will result. Hence it is best to use this method
* after ensuring that this element is of the desired type by calling {@link #isJsonPrimitive()}
* first.
*
* @return get this element as a {@link JsonPrimitive}.
* @throws IllegalStateException if the element is of another type.
*/
public JsonPrimitive getAsJsonPrimitive() {
if (isJsonPrimitive()) {
return (JsonPrimitive) this;
}
throw new IllegalStateException("This is not a JSON Primitive.");
}
/**
* convenience method to get this element as a {@link JsonNull}. If the element is of some
* other type, a {@link IllegalStateException} will result. Hence it is best to use this method
* after ensuring that this element is of the desired type by calling {@link #isJsonNull()}
* first.
*
* @return get this element as a {@link JsonNull}.
* @throws IllegalStateException if the element is of another type.
* @since 1.2
*/
public JsonNull getAsJsonNull() {
if (isJsonNull()) {
return (JsonNull) this;
}
throw new IllegalStateException("This is not a JSON Null.");
}
/**
* convenience method to get this element as a boolean value.
*
* @return get this element as a primitive boolean value.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
* boolean value.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
*/
public boolean getAsBoolean() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* convenience method to get this element as a {@link Boolean} value.
*
* @return get this element as a {@link Boolean} value.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
* boolean value.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
*/
Boolean getAsBooleanWrapper() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* convenience method to get this element as a {@link Number}.
*
* @return get this element as a {@link Number}.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
* number.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
*/
public Number getAsNumber() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* convenience method to get this element as a string value.
*
* @return get this element as a string value.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
* string value.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
*/
public String getAsString() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* convenience method to get this element as a primitive double value.
*
* @return get this element as a primitive double value.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
* double value.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
*/
public double getAsDouble() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* convenience method to get this element as a primitive float value.
*
* @return get this element as a primitive float value.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
* float value.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
*/
public float getAsFloat() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* convenience method to get this element as a primitive long value.
*
* @return get this element as a primitive long value.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
* long value.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
*/
public long getAsLong() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* convenience method to get this element as a primitive integer value.
*
* @return get this element as a primitive integer value.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
* integer value.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
*/
public int getAsInt() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* convenience method to get this element as a primitive byte value.
*
* @return get this element as a primitive byte value.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
* byte value.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
* @since 1.3
*/
public byte getAsByte() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* convenience method to get this element as a primitive character value.
*
* @return get this element as a primitive char value.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
* char value.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
* @since 1.3
*/
public char getAsCharacter() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* convenience method to get this element as a {@link BigDecimal}.
*
* @return get this element as a {@link BigDecimal}.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive}.
* * @throws NumberFormatException if the element is not a valid {@link BigDecimal}.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
* @since 1.2
*/
public BigDecimal getAsBigDecimal() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* convenience method to get this element as a {@link BigInteger}.
*
* @return get this element as a {@link BigInteger}.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive}.
* @throws NumberFormatException if the element is not a valid {@link BigInteger}.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
* @since 1.2
*/
public BigInteger getAsBigInteger() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* convenience method to get this element as a primitive short value.
*
* @return get this element as a primitive short value.
* @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
* short value.
* @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
* more than a single element.
*/
public short getAsShort() {
throw new UnsupportedOperationException(getClass().getSimpleName());
}
/**
* Returns a String representation of this element.
*/
@Override
public String toString() {
try {
StringWriter stringWriter = new StringWriter();
JsonWriter jsonWriter = new JsonWriter(stringWriter);
jsonWriter.setLenient(true);
Streams.write(this, jsonWriter);
return stringWriter.toString();
} catch (IOException e) {
throw new AssertionError(e);
}
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonIOException.java 0000664 0000000 0000000 00000002507 12604067504 0025566 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* This exception is raised when Gson was unable to read an input stream
* or write to one.
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
public final class JsonIOException extends JsonParseException {
private static final long serialVersionUID = 1L;
public JsonIOException(String msg) {
super(msg);
}
public JsonIOException(String msg, Throwable cause) {
super(msg, cause);
}
/**
* Creates exception with the specified cause. Consider using
* {@link #JsonIOException(String, Throwable)} instead if you can describe what happened.
*
* @param cause root exception that caused this exception to be thrown.
*/
public JsonIOException(Throwable cause) {
super(cause);
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonNull.java 0000775 0000000 0000000 00000003042 12604067504 0024310 0 ustar 00root root 0000000 0000000 /*
* 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 class representing a Json {@code null} value.
*
* @author Inderjeet Singh
* @author Joel Leitch
* @since 1.2
*/
public final class JsonNull extends JsonElement {
/**
* singleton for JsonNull
*
* @since 1.8
*/
public static final JsonNull INSTANCE = new JsonNull();
/**
* Creates a new JsonNull object.
* Deprecated since Gson version 1.8. Use {@link #INSTANCE} instead
*/
@Deprecated
public JsonNull() {
// Do nothing
}
@Override
JsonNull deepCopy() {
return INSTANCE;
}
/**
* All instances of JsonNull have the same hash code since they are indistinguishable
*/
@Override
public int hashCode() {
return JsonNull.class.hashCode();
}
/**
* All instances of JsonNull are the same
*/
@Override
public boolean equals(Object other) {
return this == other || other instanceof JsonNull;
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonObject.java 0000664 0000000 0000000 00000014130 12604067504 0024601 0 ustar 00root root 0000000 0000000 /*
* 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.LinkedTreeMap;
import java.util.Map;
import java.util.Set;
/**
* A class representing an object type in Json. An object consists of name-value pairs where names
* are strings, and values are any other type of {@link JsonElement}. This allows for a creating a
* tree of JsonElements. The member elements of this object are maintained in order they were added.
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
public final class JsonObject extends JsonElement {
private final LinkedTreeMap members =
new LinkedTreeMap();
@Override
JsonObject deepCopy() {
JsonObject result = new JsonObject();
for (Map.Entry entry : members.entrySet()) {
result.add(entry.getKey(), entry.getValue().deepCopy());
}
return result;
}
/**
* Adds a member, which is a name-value pair, to self. The name must be a String, but the value
* can be an arbitrary JsonElement, thereby allowing you to build a full tree of JsonElements
* rooted at this node.
*
* @param property name of the member.
* @param value the member object.
*/
public void add(String property, JsonElement value) {
if (value == null) {
value = JsonNull.INSTANCE;
}
members.put(property, value);
}
/**
* Removes the {@code property} from this {@link JsonObject}.
*
* @param property name of the member that should be removed.
* @return the {@link JsonElement} object that is being removed.
* @since 1.3
*/
public JsonElement remove(String property) {
return members.remove(property);
}
/**
* Convenience method to add a primitive member. The specified value is converted to a
* JsonPrimitive of String.
*
* @param property name of the member.
* @param value the string value associated with the member.
*/
public void addProperty(String property, String value) {
add(property, createJsonElement(value));
}
/**
* Convenience method to add a primitive member. The specified value is converted to a
* JsonPrimitive of Number.
*
* @param property name of the member.
* @param value the number value associated with the member.
*/
public void addProperty(String property, Number value) {
add(property, createJsonElement(value));
}
/**
* Convenience method to add a boolean member. The specified value is converted to a
* JsonPrimitive of Boolean.
*
* @param property name of the member.
* @param value the number value associated with the member.
*/
public void addProperty(String property, Boolean value) {
add(property, createJsonElement(value));
}
/**
* Convenience method to add a char member. The specified value is converted to a
* JsonPrimitive of Character.
*
* @param property name of the member.
* @param value the number value associated with the member.
*/
public void addProperty(String property, Character value) {
add(property, createJsonElement(value));
}
/**
* Creates the proper {@link JsonElement} object from the given {@code value} object.
*
* @param value the object to generate the {@link JsonElement} for
* @return a {@link JsonPrimitive} if the {@code value} is not null, otherwise a {@link JsonNull}
*/
private JsonElement createJsonElement(Object value) {
return value == null ? JsonNull.INSTANCE : new JsonPrimitive(value);
}
/**
* Returns a set of members of this object. The set is ordered, and the order is in which the
* elements were added.
*
* @return a set of members of this object.
*/
public Set> entrySet() {
return members.entrySet();
}
/**
* Convenience method to check if a member with the specified name is present in this object.
*
* @param memberName name of the member that is being checked for presence.
* @return true if there is a member with the specified name, false otherwise.
*/
public boolean has(String memberName) {
return members.containsKey(memberName);
}
/**
* Returns the member with the specified name.
*
* @param memberName name of the member that is being requested.
* @return the member matching the name. Null if no such member exists.
*/
public JsonElement get(String memberName) {
return members.get(memberName);
}
/**
* Convenience method to get the specified member as a JsonPrimitive element.
*
* @param memberName name of the member being requested.
* @return the JsonPrimitive corresponding to the specified member.
*/
public JsonPrimitive getAsJsonPrimitive(String memberName) {
return (JsonPrimitive) members.get(memberName);
}
/**
* Convenience method to get the specified member as a JsonArray.
*
* @param memberName name of the member being requested.
* @return the JsonArray corresponding to the specified member.
*/
public JsonArray getAsJsonArray(String memberName) {
return (JsonArray) members.get(memberName);
}
/**
* Convenience method to get the specified member as a JsonObject.
*
* @param memberName name of the member being requested.
* @return the JsonObject corresponding to the specified member.
*/
public JsonObject getAsJsonObject(String memberName) {
return (JsonObject) members.get(memberName);
}
@Override
public boolean equals(Object o) {
return (o == this) || (o instanceof JsonObject
&& ((JsonObject) o).members.equals(members));
}
@Override
public int hashCode() {
return members.hashCode();
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonParseException.java 0000664 0000000 0000000 00000004530 12604067504 0026327 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* This exception is raised if there is a serious issue that occurs during parsing of a Json
* string. One of the main usages for this class is for the Gson infrastructure. If the incoming
* Json is bad/malicious, an instance of this exception is raised.
*
* This exception is a {@link RuntimeException} because it is exposed to the client. Using a
* {@link RuntimeException} avoids bad coding practices on the client side where they catch the
* exception and do nothing. It is often the case that you want to blow up if there is a parsing
* error (i.e. often clients do not know how to recover from a {@link JsonParseException}.
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
public class JsonParseException extends RuntimeException {
static final long serialVersionUID = -4086729973971783390L;
/**
* Creates exception with the specified message. If you are wrapping another exception, consider
* using {@link #JsonParseException(String, Throwable)} instead.
*
* @param msg error message describing a possible cause of this exception.
*/
public JsonParseException(String msg) {
super(msg);
}
/**
* Creates exception with the specified message and cause.
*
* @param msg error message describing what happened.
* @param cause root exception that caused this exception to be thrown.
*/
public JsonParseException(String msg, Throwable cause) {
super(msg, cause);
}
/**
* Creates exception with the specified cause. Consider using
* {@link #JsonParseException(String, Throwable)} instead if you can describe what happened.
*
* @param cause root exception that caused this exception to be thrown.
*/
public JsonParseException(Throwable cause) {
super(cause);
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonParser.java 0000775 0000000 0000000 00000006133 12604067504 0024636 0 ustar 00root root 0000000 0000000 /*
* 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 java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import com.google.gson.internal.Streams;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.MalformedJsonException;
/**
* A parser to parse Json into a parse tree of {@link JsonElement}s
*
* @author Inderjeet Singh
* @author Joel Leitch
* @since 1.3
*/
public final class JsonParser {
/**
* Parses the specified JSON string into a parse tree
*
* @param json JSON text
* @return a parse tree of {@link JsonElement}s corresponding to the specified JSON
* @throws JsonParseException if the specified text is not valid JSON
* @since 1.3
*/
public JsonElement parse(String json) throws JsonSyntaxException {
return parse(new StringReader(json));
}
/**
* Parses the specified JSON string into a parse tree
*
* @param json JSON text
* @return a parse tree of {@link JsonElement}s corresponding to the specified JSON
* @throws JsonParseException if the specified text is not valid JSON
* @since 1.3
*/
public JsonElement parse(Reader json) throws JsonIOException, JsonSyntaxException {
try {
JsonReader jsonReader = new JsonReader(json);
JsonElement element = parse(jsonReader);
if (!element.isJsonNull() && jsonReader.peek() != JsonToken.END_DOCUMENT) {
throw new JsonSyntaxException("Did not consume the entire document.");
}
return element;
} catch (MalformedJsonException e) {
throw new JsonSyntaxException(e);
} catch (IOException e) {
throw new JsonIOException(e);
} catch (NumberFormatException e) {
throw new JsonSyntaxException(e);
}
}
/**
* Returns the next value from the JSON stream as a parse tree.
*
* @throws JsonParseException if there is an IOException or if the specified
* text is not valid JSON
* @since 1.6
*/
public JsonElement parse(JsonReader json) throws JsonIOException, JsonSyntaxException {
boolean lenient = json.isLenient();
json.setLenient(true);
try {
return Streams.parse(json);
} catch (StackOverflowError e) {
throw new JsonParseException("Failed parsing JSON source: " + json + " to Json", e);
} catch (OutOfMemoryError e) {
throw new JsonParseException("Failed parsing JSON source: " + json + " to Json", e);
} finally {
json.setLenient(lenient);
}
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonPrimitive.java 0000664 0000000 0000000 00000023144 12604067504 0025350 0 ustar 00root root 0000000 0000000 /*
* 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.math.BigDecimal;
import java.math.BigInteger;
import com.google.gson.internal.$Gson$Preconditions;
import com.google.gson.internal.LazilyParsedNumber;
/**
* A class representing a Json primitive value. A primitive value
* is either a String, a Java primitive, or a Java primitive
* wrapper type.
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
public final class JsonPrimitive extends JsonElement {
private static final Class[] PRIMITIVE_TYPES = { int.class, long.class, short.class,
float.class, double.class, byte.class, boolean.class, char.class, Integer.class, Long.class,
Short.class, Float.class, Double.class, Byte.class, Boolean.class, Character.class };
private Object value;
/**
* Create a primitive containing a boolean value.
*
* @param bool the value to create the primitive with.
*/
public JsonPrimitive(Boolean bool) {
setValue(bool);
}
/**
* Create a primitive containing a {@link Number}.
*
* @param number the value to create the primitive with.
*/
public JsonPrimitive(Number number) {
setValue(number);
}
/**
* Create a primitive containing a String value.
*
* @param string the value to create the primitive with.
*/
public JsonPrimitive(String string) {
setValue(string);
}
/**
* Create a primitive containing a character. The character is turned into a one character String
* since Json only supports String.
*
* @param c the value to create the primitive with.
*/
public JsonPrimitive(Character c) {
setValue(c);
}
/**
* Create a primitive using the specified Object. It must be an instance of {@link Number}, a
* Java primitive type, or a String.
*
* @param primitive the value to create the primitive with.
*/
JsonPrimitive(Object primitive) {
setValue(primitive);
}
@Override
JsonPrimitive deepCopy() {
return this;
}
void setValue(Object primitive) {
if (primitive instanceof Character) {
// convert characters to strings since in JSON, characters are represented as a single
// character string
char c = ((Character) primitive).charValue();
this.value = String.valueOf(c);
} else {
$Gson$Preconditions.checkArgument(primitive instanceof Number
|| isPrimitiveOrString(primitive));
this.value = primitive;
}
}
/**
* Check whether this primitive contains a boolean value.
*
* @return true if this primitive contains a boolean value, false otherwise.
*/
public boolean isBoolean() {
return value instanceof Boolean;
}
/**
* convenience method to get this element as a {@link Boolean}.
*
* @return get this element as a {@link Boolean}.
*/
@Override
Boolean getAsBooleanWrapper() {
return (Boolean) value;
}
/**
* convenience method to get this element as a boolean value.
*
* @return get this element as a primitive boolean value.
*/
@Override
public boolean getAsBoolean() {
if (isBoolean()) {
return getAsBooleanWrapper().booleanValue();
} else {
// Check to see if the value as a String is "true" in any case.
return Boolean.parseBoolean(getAsString());
}
}
/**
* Check whether this primitive contains a Number.
*
* @return true if this primitive contains a Number, false otherwise.
*/
public boolean isNumber() {
return value instanceof Number;
}
/**
* convenience method to get this element as a Number.
*
* @return get this element as a Number.
* @throws NumberFormatException if the value contained is not a valid Number.
*/
@Override
public Number getAsNumber() {
return value instanceof String ? new LazilyParsedNumber((String) value) : (Number) value;
}
/**
* Check whether this primitive contains a String value.
*
* @return true if this primitive contains a String value, false otherwise.
*/
public boolean isString() {
return value instanceof String;
}
/**
* convenience method to get this element as a String.
*
* @return get this element as a String.
*/
@Override
public String getAsString() {
if (isNumber()) {
return getAsNumber().toString();
} else if (isBoolean()) {
return getAsBooleanWrapper().toString();
} else {
return (String) value;
}
}
/**
* convenience method to get this element as a primitive double.
*
* @return get this element as a primitive double.
* @throws NumberFormatException if the value contained is not a valid double.
*/
@Override
public double getAsDouble() {
return isNumber() ? getAsNumber().doubleValue() : Double.parseDouble(getAsString());
}
/**
* convenience method to get this element as a {@link BigDecimal}.
*
* @return get this element as a {@link BigDecimal}.
* @throws NumberFormatException if the value contained is not a valid {@link BigDecimal}.
*/
@Override
public BigDecimal getAsBigDecimal() {
return value instanceof BigDecimal ? (BigDecimal) value : new BigDecimal(value.toString());
}
/**
* convenience method to get this element as a {@link BigInteger}.
*
* @return get this element as a {@link BigInteger}.
* @throws NumberFormatException if the value contained is not a valid {@link BigInteger}.
*/
@Override
public BigInteger getAsBigInteger() {
return value instanceof BigInteger ?
(BigInteger) value : new BigInteger(value.toString());
}
/**
* convenience method to get this element as a float.
*
* @return get this element as a float.
* @throws NumberFormatException if the value contained is not a valid float.
*/
@Override
public float getAsFloat() {
return isNumber() ? getAsNumber().floatValue() : Float.parseFloat(getAsString());
}
/**
* convenience method to get this element as a primitive long.
*
* @return get this element as a primitive long.
* @throws NumberFormatException if the value contained is not a valid long.
*/
@Override
public long getAsLong() {
return isNumber() ? getAsNumber().longValue() : Long.parseLong(getAsString());
}
/**
* convenience method to get this element as a primitive short.
*
* @return get this element as a primitive short.
* @throws NumberFormatException if the value contained is not a valid short value.
*/
@Override
public short getAsShort() {
return isNumber() ? getAsNumber().shortValue() : Short.parseShort(getAsString());
}
/**
* convenience method to get this element as a primitive integer.
*
* @return get this element as a primitive integer.
* @throws NumberFormatException if the value contained is not a valid integer.
*/
@Override
public int getAsInt() {
return isNumber() ? getAsNumber().intValue() : Integer.parseInt(getAsString());
}
@Override
public byte getAsByte() {
return isNumber() ? getAsNumber().byteValue() : Byte.parseByte(getAsString());
}
@Override
public char getAsCharacter() {
return getAsString().charAt(0);
}
private static boolean isPrimitiveOrString(Object target) {
if (target instanceof String) {
return true;
}
Class classOfPrimitive = target.getClass();
for (Class standardPrimitive : PRIMITIVE_TYPES) {
if (standardPrimitive.isAssignableFrom(classOfPrimitive)) {
return true;
}
}
return false;
}
@Override
public int hashCode() {
if (value == null) {
return 31;
}
// Using recommended hashing algorithm from Effective Java for longs and doubles
if (isIntegral(this)) {
long value = getAsNumber().longValue();
return (int) (value ^ (value >>> 32));
}
if (value instanceof Number) {
long value = Double.doubleToLongBits(getAsNumber().doubleValue());
return (int) (value ^ (value >>> 32));
}
return value.hashCode();
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
JsonPrimitive other = (JsonPrimitive)obj;
if (value == null) {
return other.value == null;
}
if (isIntegral(this) && isIntegral(other)) {
return getAsNumber().longValue() == other.getAsNumber().longValue();
}
if (value instanceof Number && other.value instanceof Number) {
double a = getAsNumber().doubleValue();
// Java standard types other than double return true for two NaN. So, need
// special handling for double.
double b = other.getAsNumber().doubleValue();
return a == b || (Double.isNaN(a) && Double.isNaN(b));
}
return value.equals(other.value);
}
/**
* Returns true if the specified number is an integral type
* (Long, Integer, Short, Byte, BigInteger)
*/
private static boolean isIntegral(JsonPrimitive primitive) {
if (primitive.value instanceof Number) {
Number number = (Number) primitive.value;
return number instanceof BigInteger || number instanceof Long || number instanceof Integer
|| number instanceof Short || number instanceof Byte;
}
return false;
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonSerializationContext.java 0000664 0000000 0000000 00000003522 12604067504 0027560 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* Context for serialization that is passed to a custom serializer during invocation of its
* {@link JsonSerializer#serialize(Object, Type, JsonSerializationContext)} method.
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
public interface JsonSerializationContext {
/**
* Invokes default serialization on the specified object.
*
* @param src the object that needs to be serialized.
* @return a tree of {@link JsonElement}s corresponding to the serialized form of {@code src}.
*/
public JsonElement serialize(Object src);
/**
* Invokes default serialization on the specified object passing the specific type information.
* It should never be invoked on the element received as a parameter of the
* {@link JsonSerializer#serialize(Object, Type, JsonSerializationContext)} method. Doing
* so will result in an infinite loop since Gson will in-turn call the custom serializer again.
*
* @param src the object that needs to be serialized.
* @param typeOfSrc the actual genericized type of src object.
* @return a tree of {@link JsonElement}s corresponding to the serialized form of {@code src}.
*/
public JsonElement serialize(Object src, Type typeOfSrc);
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonSerializer.java 0000664 0000000 0000000 00000006531 12604067504 0025512 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* Interface representing a custom serializer for Json. You should write a custom serializer, if
* you are not happy with the default serialization done by Gson. You will also need to register
* this serializer through {@link com.google.gson.GsonBuilder#registerTypeAdapter(Type, Object)}.
*
* Let us look at example where defining a serializer will be useful. The {@code Id} class
* defined below has two fields: {@code clazz} and {@code value}.
*
*
* public class Id<T> {
* private final Class<T> clazz;
* private final long value;
*
* public Id(Class<T> clazz, long value) {
* this.clazz = clazz;
* this.value = value;
* }
*
* public long getValue() {
* return value;
* }
* }
*
*
* The default serialization of {@code Id(com.foo.MyObject.class, 20L)} will be
* {"clazz":com.foo.MyObject,"value":20}. Suppose, you just want the output to be
* the value instead, which is {@code 20} in this case. You can achieve that by writing a custom
* serializer:
*
*
* class IdSerializer implements JsonSerializer<Id>() {
* public JsonElement serialize(Id id, Type typeOfId, JsonSerializationContext context) {
* return new JsonPrimitive(id.getValue());
* }
* }
*
*
* You will also need to register {@code IdSerializer} with Gson as follows:
*
* Gson gson = new GsonBuilder().registerTypeAdapter(Id.class, new IdSerializer()).create();
*
*
* New applications should prefer {@link TypeAdapter}, whose streaming API
* is more efficient than this interface's tree API.
*
* @author Inderjeet Singh
* @author Joel Leitch
*
* @param type for which the serializer is being registered. It is possible that a serializer
* may be asked to serialize a specific generic type of the T.
*/
public interface JsonSerializer {
/**
* Gson invokes this call-back method during serialization when it encounters a field of the
* specified type.
*
* In the implementation of this call-back method, you should consider invoking
* {@link JsonSerializationContext#serialize(Object, Type)} method to create JsonElements for any
* non-trivial field of the {@code src} object. However, you should never invoke it on the
* {@code src} object itself since that will cause an infinite loop (Gson will call your
* call-back method again).
*
* @param src the object that needs to be converted to Json.
* @param typeOfSrc the actual type (fully genericized version) of the source object.
* @return a JsonElement corresponding to the specified object.
*/
public JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context);
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonStreamParser.java 0000664 0000000 0000000 00000007334 12604067504 0026013 0 ustar 00root root 0000000 0000000 /*
* 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 java.io.EOFException;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.Iterator;
import java.util.NoSuchElementException;
import com.google.gson.internal.Streams;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.MalformedJsonException;
/**
* A streaming parser that allows reading of multiple {@link JsonElement}s from the specified reader
* asynchronously.
*
* This class is conditionally thread-safe (see Item 70, Effective Java second edition). To
* properly use this class across multiple threads, you will need to add some external
* synchronization. For example:
*
*
* JsonStreamParser parser = new JsonStreamParser("['first'] {'second':10} 'third'");
* JsonElement element;
* synchronized (parser) { // synchronize on an object shared by threads
* if (parser.hasNext()) {
* element = parser.next();
* }
* }
*
*
* @author Inderjeet Singh
* @author Joel Leitch
* @since 1.4
*/
public final class JsonStreamParser implements Iterator {
private final JsonReader parser;
private final Object lock;
/**
* @param json The string containing JSON elements concatenated to each other.
* @since 1.4
*/
public JsonStreamParser(String json) {
this(new StringReader(json));
}
/**
* @param reader The data stream containing JSON elements concatenated to each other.
* @since 1.4
*/
public JsonStreamParser(Reader reader) {
parser = new JsonReader(reader);
parser.setLenient(true);
lock = new Object();
}
/**
* Returns the next available {@link JsonElement} on the reader. Null if none available.
*
* @return the next available {@link JsonElement} on the reader. Null if none available.
* @throws JsonParseException if the incoming stream is malformed JSON.
* @since 1.4
*/
public JsonElement next() throws JsonParseException {
if (!hasNext()) {
throw new NoSuchElementException();
}
try {
return Streams.parse(parser);
} catch (StackOverflowError e) {
throw new JsonParseException("Failed parsing JSON source to Json", e);
} catch (OutOfMemoryError e) {
throw new JsonParseException("Failed parsing JSON source to Json", e);
} catch (JsonParseException e) {
throw e.getCause() instanceof EOFException ? new NoSuchElementException() : e;
}
}
/**
* Returns true if a {@link JsonElement} is available on the input for consumption
* @return true if a {@link JsonElement} is available on the input, false otherwise
* @since 1.4
*/
public boolean hasNext() {
synchronized (lock) {
try {
return parser.peek() != JsonToken.END_DOCUMENT;
} catch (MalformedJsonException e) {
throw new JsonSyntaxException(e);
} catch (IOException e) {
throw new JsonIOException(e);
}
}
}
/**
* This optional {@link Iterator} method is not relevant for stream parsing and hence is not
* implemented.
* @since 1.4
*/
public void remove() {
throw new UnsupportedOperationException();
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/JsonSyntaxException.java 0000664 0000000 0000000 00000002553 12604067504 0026546 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2010 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;
/**
* This exception is raised when Gson attempts to read (or write) a malformed
* JSON element.
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
public final class JsonSyntaxException extends JsonParseException {
private static final long serialVersionUID = 1L;
public JsonSyntaxException(String msg) {
super(msg);
}
public JsonSyntaxException(String msg, Throwable cause) {
super(msg, cause);
}
/**
* Creates exception with the specified cause. Consider using
* {@link #JsonSyntaxException(String, Throwable)} instead if you can
* describe what actually happened.
*
* @param cause root exception that caused this exception to be thrown.
*/
public JsonSyntaxException(Throwable cause) {
super(cause);
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/LongSerializationPolicy.java 0000664 0000000 0000000 00000003360 12604067504 0027361 0 ustar 00root root 0000000 0000000 /*
* 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;
/**
* Defines the expected format for a {@code long} or {@code Long} type when its serialized.
*
* @since 1.3
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
public enum LongSerializationPolicy {
/**
* This is the "default" serialization policy that will output a {@code long} object as a JSON
* number. For example, assume an object has a long field named "f" then the serialized output
* would be:
* {@code {"f":123}}.
*/
DEFAULT() {
public JsonElement serialize(Long value) {
return new JsonPrimitive(value);
}
},
/**
* Serializes a long value as a quoted string. For example, assume an object has a long field
* named "f" then the serialized output would be:
* {@code {"f":"123"}}.
*/
STRING() {
public JsonElement serialize(Long value) {
return new JsonPrimitive(String.valueOf(value));
}
};
/**
* Serialize this {@code value} using this serialization policy.
*
* @param value the long value to be serialized into a {@link JsonElement}
* @return the serialized version of {@code value}
*/
public abstract JsonElement serialize(Long value);
}
gson-gson-2.4/gson/src/main/java/com/google/gson/TreeTypeAdapter.java 0000664 0000000 0000000 00000012011 12604067504 0025577 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 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 com.google.gson.internal.Streams;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
/**
* Adapts a Gson 1.x tree-style adapter as a streaming TypeAdapter. Since the
* tree adapter may be serialization-only or deserialization-only, this class
* has a facility to lookup a delegate type adapter on demand.
*/
final class TreeTypeAdapter extends TypeAdapter {
private final JsonSerializer serializer;
private final JsonDeserializer deserializer;
private final Gson gson;
private final TypeToken typeToken;
private final TypeAdapterFactory skipPast;
/** The delegate is lazily created because it may not be needed, and creating it may fail. */
private TypeAdapter delegate;
private TreeTypeAdapter(JsonSerializer serializer, JsonDeserializer deserializer,
Gson gson, TypeToken typeToken, TypeAdapterFactory skipPast) {
this.serializer = serializer;
this.deserializer = deserializer;
this.gson = gson;
this.typeToken = typeToken;
this.skipPast = skipPast;
}
@Override public T read(JsonReader in) throws IOException {
if (deserializer == null) {
return delegate().read(in);
}
JsonElement value = Streams.parse(in);
if (value.isJsonNull()) {
return null;
}
return deserializer.deserialize(value, typeToken.getType(), gson.deserializationContext);
}
@Override public void write(JsonWriter out, T value) throws IOException {
if (serializer == null) {
delegate().write(out, value);
return;
}
if (value == null) {
out.nullValue();
return;
}
JsonElement tree = serializer.serialize(value, typeToken.getType(), gson.serializationContext);
Streams.write(tree, out);
}
private TypeAdapter delegate() {
TypeAdapter d = delegate;
return d != null
? d
: (delegate = gson.getDelegateAdapter(skipPast, typeToken));
}
/**
* Returns a new factory that will match each type against {@code exactType}.
*/
public static TypeAdapterFactory newFactory(TypeToken exactType, Object typeAdapter) {
return new SingleTypeFactory(typeAdapter, exactType, false, null);
}
/**
* Returns a new factory that will match each type and its raw type against
* {@code exactType}.
*/
public static TypeAdapterFactory newFactoryWithMatchRawType(
TypeToken exactType, Object typeAdapter) {
// only bother matching raw types if exact type is a raw type
boolean matchRawType = exactType.getType() == exactType.getRawType();
return new SingleTypeFactory(typeAdapter, exactType, matchRawType, null);
}
/**
* Returns a new factory that will match each type's raw type for assignability
* to {@code hierarchyType}.
*/
public static TypeAdapterFactory newTypeHierarchyFactory(
Class hierarchyType, Object typeAdapter) {
return new SingleTypeFactory(typeAdapter, null, false, hierarchyType);
}
private static class SingleTypeFactory implements TypeAdapterFactory {
private final TypeToken exactType;
private final boolean matchRawType;
private final Class hierarchyType;
private final JsonSerializer serializer;
private final JsonDeserializer deserializer;
private SingleTypeFactory(Object typeAdapter, TypeToken exactType, boolean matchRawType,
Class hierarchyType) {
serializer = typeAdapter instanceof JsonSerializer
? (JsonSerializer) typeAdapter
: null;
deserializer = typeAdapter instanceof JsonDeserializer
? (JsonDeserializer) typeAdapter
: null;
$Gson$Preconditions.checkArgument(serializer != null || deserializer != null);
this.exactType = exactType;
this.matchRawType = matchRawType;
this.hierarchyType = hierarchyType;
}
@SuppressWarnings("unchecked") // guarded by typeToken.equals() call
public TypeAdapter create(Gson gson, TypeToken type) {
boolean matches = exactType != null
? exactType.equals(type) || matchRawType && exactType.getType() == type.getRawType()
: hierarchyType.isAssignableFrom(type.getRawType());
return matches
? new TreeTypeAdapter((JsonSerializer) serializer,
(JsonDeserializer) deserializer, gson, type, this)
: null;
}
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/TypeAdapter.java 0000664 0000000 0000000 00000025232 12604067504 0024770 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 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.bind.JsonTreeWriter;
import com.google.gson.internal.bind.JsonTreeReader;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
/**
* Converts Java objects to and from JSON.
*
* Defining a type's JSON form
* By default Gson converts application classes to JSON using its built-in type
* adapters. If Gson's default JSON conversion isn't appropriate for a type,
* extend this class to customize the conversion. Here's an example of a type
* adapter for an (X,Y) coordinate point: {@code
*
* public class PointAdapter extends TypeAdapter {
* public Point read(JsonReader reader) throws IOException {
* if (reader.peek() == JsonToken.NULL) {
* reader.nextNull();
* return null;
* }
* String xy = reader.nextString();
* String[] parts = xy.split(",");
* int x = Integer.parseInt(parts[0]);
* int y = Integer.parseInt(parts[1]);
* return new Point(x, y);
* }
* public void write(JsonWriter writer, Point value) throws IOException {
* if (value == null) {
* writer.nullValue();
* return;
* }
* String xy = value.getX() + "," + value.getY();
* writer.value(xy);
* }
* }}
* With this type adapter installed, Gson will convert {@code Points} to JSON as
* strings like {@code "5,8"} rather than objects like {@code {"x":5,"y":8}}. In
* this case the type adapter binds a rich Java class to a compact JSON value.
*
* The {@link #read(JsonReader) read()} method must read exactly one value
* and {@link #write(JsonWriter,Object) write()} must write exactly one value.
* For primitive types this is means readers should make exactly one call to
* {@code nextBoolean()}, {@code nextDouble()}, {@code nextInt()}, {@code
* nextLong()}, {@code nextString()} or {@code nextNull()}. Writers should make
* exactly one call to one of value() or nullValue().
* For arrays, type adapters should start with a call to {@code beginArray()},
* convert all elements, and finish with a call to {@code endArray()}. For
* objects, they should start with {@code beginObject()}, convert the object,
* and finish with {@code endObject()}. Failing to convert a value or converting
* too many values may cause the application to crash.
*
*
Type adapters should be prepared to read null from the stream and write it
* to the stream. Alternatively, they should use {@link #nullSafe()} method while
* registering the type adapter with Gson. If your {@code Gson} instance
* has been configured to {@link GsonBuilder#serializeNulls()}, these nulls will be
* written to the final document. Otherwise the value (and the corresponding name
* when writing to a JSON object) will be omitted automatically. In either case
* your type adapter must handle null.
*
*
To use a custom type adapter with Gson, you must register it with a
* {@link GsonBuilder}:
{@code
*
* GsonBuilder builder = new GsonBuilder();
* builder.registerTypeAdapter(Point.class, new PointAdapter());
* // if PointAdapter didn't check for nulls in its read/write methods, you should instead use
* // builder.registerTypeAdapter(Point.class, new PointAdapter().nullSafe());
* ...
* Gson gson = builder.create();
* }
*
* @since 2.1
*/
// non-Javadoc:
//
// JSON Conversion
// A type adapter registered with Gson is automatically invoked while serializing
// or deserializing JSON. However, you can also use type adapters directly to serialize
// and deserialize JSON. Here is an example for deserialization:
{@code
//
// String json = "{'origin':'0,0','points':['1,2','3,4']}";
// TypeAdapter graphAdapter = gson.getAdapter(Graph.class);
// Graph graph = graphAdapter.fromJson(json);
// }
// And an example for serialization: {@code
//
// Graph graph = new Graph(...);
// TypeAdapter graphAdapter = gson.getAdapter(Graph.class);
// String json = graphAdapter.toJson(graph);
// }
//
// Type adapters are type-specific . For example, a {@code
// TypeAdapter} can convert {@code Date} instances to JSON and JSON to
// instances of {@code Date}, but cannot convert any other types.
//
public abstract class TypeAdapter {
/**
* Writes one JSON value (an array, object, string, number, boolean or null)
* for {@code value}.
*
* @param value the Java object to write. May be null.
*/
public abstract void write(JsonWriter out, T value) throws IOException;
/**
* Converts {@code value} to a JSON document and writes it to {@code out}.
* Unlike Gson's similar {@link Gson#toJson(JsonElement, Appendable) toJson}
* method, this write is strict. Create a {@link
* JsonWriter#setLenient(boolean) lenient} {@code JsonWriter} and call
* {@link #write(com.google.gson.stream.JsonWriter, Object)} for lenient
* writing.
*
* @param value the Java object to convert. May be null.
* @since 2.2
*/
public final void toJson(Writer out, T value) throws IOException {
JsonWriter writer = new JsonWriter(out);
write(writer, value);
}
/**
* This wrapper method is used to make a type adapter null tolerant. In general, a
* type adapter is required to handle nulls in write and read methods. Here is how this
* is typically done: {@code
*
* Gson gson = new GsonBuilder().registerTypeAdapter(Foo.class,
* new TypeAdapter() {
* public Foo read(JsonReader in) throws IOException {
* if (in.peek() == JsonToken.NULL) {
* in.nextNull();
* return null;
* }
* // read a Foo from in and return it
* }
* public void write(JsonWriter out, Foo src) throws IOException {
* if (src == null) {
* out.nullValue();
* return;
* }
* // write src as JSON to out
* }
* }).create();
* }
* You can avoid this boilerplate handling of nulls by wrapping your type adapter with
* this method. Here is how we will rewrite the above example:
* {@code
*
* Gson gson = new GsonBuilder().registerTypeAdapter(Foo.class,
* new TypeAdapter() {
* public Foo read(JsonReader in) throws IOException {
* // read a Foo from in and return it
* }
* public void write(JsonWriter out, Foo src) throws IOException {
* // write src as JSON to out
* }
* }.nullSafe()).create();
* }
* Note that we didn't need to check for nulls in our type adapter after we used nullSafe.
*/
public final TypeAdapter nullSafe() {
return new TypeAdapter() {
@Override public void write(JsonWriter out, T value) throws IOException {
if (value == null) {
out.nullValue();
} else {
TypeAdapter.this.write(out, value);
}
}
@Override public T read(JsonReader reader) throws IOException {
if (reader.peek() == JsonToken.NULL) {
reader.nextNull();
return null;
}
return TypeAdapter.this.read(reader);
}
};
}
/**
* Converts {@code value} to a JSON document. Unlike Gson's similar {@link
* Gson#toJson(Object) toJson} method, this write is strict. Create a {@link
* JsonWriter#setLenient(boolean) lenient} {@code JsonWriter} and call
* {@link #write(com.google.gson.stream.JsonWriter, Object)} for lenient
* writing.
*
* @param value the Java object to convert. May be null.
* @since 2.2
*/
public final String toJson(T value) {
StringWriter stringWriter = new StringWriter();
try {
toJson(stringWriter, value);
} catch (IOException e) {
throw new AssertionError(e); // No I/O writing to a StringWriter.
}
return stringWriter.toString();
}
/**
* Converts {@code value} to a JSON tree.
*
* @param value the Java object to convert. May be null.
* @return the converted JSON tree. May be {@link JsonNull}.
* @since 2.2
*/
public final JsonElement toJsonTree(T value) {
try {
JsonTreeWriter jsonWriter = new JsonTreeWriter();
write(jsonWriter, value);
return jsonWriter.get();
} catch (IOException e) {
throw new JsonIOException(e);
}
}
/**
* Reads one JSON value (an array, object, string, number, boolean or null)
* and converts it to a Java object. Returns the converted object.
*
* @return the converted Java object. May be null.
*/
public abstract T read(JsonReader in) throws IOException;
/**
* Converts the JSON document in {@code in} to a Java object. Unlike Gson's
* similar {@link Gson#fromJson(java.io.Reader, Class) fromJson} method, this
* read is strict. Create a {@link JsonReader#setLenient(boolean) lenient}
* {@code JsonReader} and call {@link #read(JsonReader)} for lenient reading.
*
* @return the converted Java object. May be null.
* @since 2.2
*/
public final T fromJson(Reader in) throws IOException {
JsonReader reader = new JsonReader(in);
return read(reader);
}
/**
* Converts the JSON document in {@code json} to a Java object. Unlike Gson's
* similar {@link Gson#fromJson(String, Class) fromJson} method, this read is
* strict. Create a {@link JsonReader#setLenient(boolean) lenient} {@code
* JsonReader} and call {@link #read(JsonReader)} for lenient reading.
*
* @return the converted Java object. May be null.
* @since 2.2
*/
public final T fromJson(String json) throws IOException {
return fromJson(new StringReader(json));
}
/**
* Converts {@code jsonTree} to a Java object.
*
* @param jsonTree the Java object to convert. May be {@link JsonNull}.
* @since 2.2
*/
public final T fromJsonTree(JsonElement jsonTree) {
try {
JsonReader jsonReader = new JsonTreeReader(jsonTree);
return read(jsonReader);
} catch (IOException e) {
throw new JsonIOException(e);
}
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/TypeAdapterFactory.java 0000664 0000000 0000000 00000014676 12604067504 0026332 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 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.reflect.TypeToken;
/**
* Creates type adapters for set of related types. Type adapter factories are
* most useful when several types share similar structure in their JSON form.
*
* Example: Converting enums to lowercase
* In this example, we implement a factory that creates type adapters for all
* enums. The type adapters will write enums in lowercase, despite the fact
* that they're defined in {@code CONSTANT_CASE} in the corresponding Java
* model: {@code
*
* public class LowercaseEnumTypeAdapterFactory implements TypeAdapterFactory {
* public TypeAdapter create(Gson gson, TypeToken type) {
* Class rawType = (Class) type.getRawType();
* if (!rawType.isEnum()) {
* return null;
* }
*
* final Map lowercaseToConstant = new HashMap();
* for (T constant : rawType.getEnumConstants()) {
* lowercaseToConstant.put(toLowercase(constant), constant);
* }
*
* return new TypeAdapter() {
* public void write(JsonWriter out, T value) throws IOException {
* if (value == null) {
* out.nullValue();
* } else {
* out.value(toLowercase(value));
* }
* }
*
* public T read(JsonReader reader) throws IOException {
* if (reader.peek() == JsonToken.NULL) {
* reader.nextNull();
* return null;
* } else {
* return lowercaseToConstant.get(reader.nextString());
* }
* }
* };
* }
*
* private String toLowercase(Object o) {
* return o.toString().toLowerCase(Locale.US);
* }
* }
* }
*
* Type adapter factories select which types they provide type adapters
* for. If a factory cannot support a given type, it must return null when
* that type is passed to {@link #create}. Factories should expect {@code
* create()} to be called on them for many types and should return null for
* most of those types. In the above example the factory returns null for
* calls to {@code create()} where {@code type} is not an enum.
*
*
A factory is typically called once per type, but the returned type
* adapter may be used many times. It is most efficient to do expensive work
* like reflection in {@code create()} so that the type adapter's {@code
* read()} and {@code write()} methods can be very fast. In this example the
* mapping from lowercase name to enum value is computed eagerly.
*
*
As with type adapters, factories must be registered with a {@link
* com.google.gson.GsonBuilder} for them to take effect:
{@code
*
* GsonBuilder builder = new GsonBuilder();
* builder.registerTypeAdapterFactory(new LowercaseEnumTypeAdapterFactory());
* ...
* Gson gson = builder.create();
* }
* If multiple factories support the same type, the factory registered earlier
* takes precedence.
*
* Example: composing other type adapters
* In this example we implement a factory for Guava's {@code Multiset}
* collection type. The factory can be used to create type adapters for
* multisets of any element type: the type adapter for {@code
* Multiset} is different from the type adapter for {@code
* Multiset}.
*
* The type adapter delegates to another type adapter for the
* multiset elements. It figures out the element type by reflecting on the
* multiset's type token. A {@code Gson} is passed in to {@code create} for
* just this purpose:
{@code
*
* public class MultisetTypeAdapterFactory implements TypeAdapterFactory {
* public TypeAdapter create(Gson gson, TypeToken typeToken) {
* Type type = typeToken.getType();
* if (typeToken.getRawType() != Multiset.class
* || !(type instanceof ParameterizedType)) {
* return null;
* }
*
* Type elementType = ((ParameterizedType) type).getActualTypeArguments()[0];
* TypeAdapter elementAdapter = gson.getAdapter(TypeToken.get(elementType));
* return (TypeAdapter) newMultisetAdapter(elementAdapter);
* }
*
* private TypeAdapter> newMultisetAdapter(
* final TypeAdapter elementAdapter) {
* return new TypeAdapter>() {
* public void write(JsonWriter out, Multiset value) throws IOException {
* if (value == null) {
* out.nullValue();
* return;
* }
*
* out.beginArray();
* for (Multiset.Entry entry : value.entrySet()) {
* out.value(entry.getCount());
* elementAdapter.write(out, entry.getElement());
* }
* out.endArray();
* }
*
* public Multiset read(JsonReader in) throws IOException {
* if (in.peek() == JsonToken.NULL) {
* in.nextNull();
* return null;
* }
*
* Multiset result = LinkedHashMultiset.create();
* in.beginArray();
* while (in.hasNext()) {
* int count = in.nextInt();
* E element = elementAdapter.read(in);
* result.add(element, count);
* }
* in.endArray();
* return result;
* }
* };
* }
* }
* }
* Delegating from one type adapter to another is extremely powerful; it's
* the foundation of how Gson converts Java objects and collections. Whenever
* possible your factory should retrieve its delegate type adapter in the
* {@code create()} method; this ensures potentially-expensive type adapter
* creation happens only once.
*
* @since 2.1
*/
public interface TypeAdapterFactory {
/**
* Returns a type adapter for {@code type}, or null if this factory doesn't
* support {@code type}.
*/
TypeAdapter create(Gson gson, TypeToken type);
}
gson-gson-2.4/gson/src/main/java/com/google/gson/annotations/ 0000775 0000000 0000000 00000000000 12604067504 0024234 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/src/main/java/com/google/gson/annotations/Expose.java 0000664 0000000 0000000 00000006610 12604067504 0026345 0 ustar 00root root 0000000 0000000 /*
* 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.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* An annotation that indicates this member should be exposed for JSON
* serialization or deserialization.
*
* This annotation has no effect unless you build {@link com.google.gson.Gson}
* with a {@link com.google.gson.GsonBuilder} and invoke
* {@link com.google.gson.GsonBuilder#excludeFieldsWithoutExposeAnnotation()}
* method.
*
* Here is an example of how this annotation is meant to be used:
*
* public class User {
* @Expose private String firstName;
* @Expose(serialize = false) private String lastName;
* @Expose (serialize = false, deserialize = false) private String emailAddress;
* private String password;
* }
*
* If you created Gson with {@code new Gson()}, the {@code toJson()} and {@code fromJson()}
* methods will use the {@code password} field along-with {@code firstName}, {@code lastName},
* and {@code emailAddress} for serialization and deserialization. However, if you created Gson
* with {@code Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create()}
* then the {@code toJson()} and {@code fromJson()} methods of Gson will exclude the
* {@code password} field. This is because the {@code password} field is not marked with the
* {@code @Expose} annotation. Gson will also exclude {@code lastName} and {@code emailAddress}
* from serialization since {@code serialize} is set to {@code false}. Similarly, Gson will
* exclude {@code emailAddress} from deserialization since {@code deserialize} is set to false.
*
* Note that another way to achieve the same effect would have been to just mark the
* {@code password} field as {@code transient}, and Gson would have excluded it even with default
* settings. The {@code @Expose} annotation is useful in a style of programming where you want to
* explicitly specify all fields that should get considered for serialization or deserialization.
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Expose {
/**
* If {@code true}, the field marked with this annotation is written out in the JSON while
* serializing. If {@code false}, the field marked with this annotation is skipped from the
* serialized output. Defaults to {@code true}.
* @since 1.4
*/
public boolean serialize() default true;
/**
* If {@code true}, the field marked with this annotation is deserialized from the JSON.
* If {@code false}, the field marked with this annotation is skipped during deserialization.
* Defaults to {@code true}.
* @since 1.4
*/
public boolean deserialize() default true;
}
gson-gson-2.4/gson/src/main/java/com/google/gson/annotations/JsonAdapter.java 0000664 0000000 0000000 00000006401 12604067504 0027312 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2014 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.annotations;
import com.google.gson.TypeAdapter;
import com.google.gson.TypeAdapterFactory;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* An annotation that indicates the Gson {@link TypeAdapter} to use with a class
* or field.
*
*
Here is an example of how this annotation is used:
*
* @JsonAdapter(UserJsonAdapter.class)
* public class User {
* public final String firstName, lastName;
* private User(String firstName, String lastName) {
* this.firstName = firstName;
* this.lastName = lastName;
* }
* }
* public class UserJsonAdapter extends TypeAdapter<User> {
* @Override public void write(JsonWriter out, User user) throws IOException {
* // implement write: combine firstName and lastName into name
* out.beginObject();
* out.name("name");
* out.value(user.firstName + " " + user.lastName);
* out.endObject();
* // implement the write method
* }
* @Override public User read(JsonReader in) throws IOException {
* // implement read: split name into firstName and lastName
* in.beginObject();
* in.nextName();
* String[] nameParts = in.nextString().split(" ");
* in.endObject();
* return new User(nameParts[0], nameParts[1]);
* }
* }
*
*
* Since User class specified UserJsonAdapter.class in @JsonAdapter annotation, it
* will automatically be invoked to serialize/deserialize User instances. Here is an example of how to apply this annotation to a field.
*
* private static final class Gadget {
* @JsonAdapter(UserJsonAdapter2.class)
* final User user;
* Gadget(User user) {
* this.user = user;
* }
* }
*
*
* It's possible to specify different type adapters on a field, that
* field's type, and in the {@link com.google.gson.GsonBuilder}. Field
* annotations take precedence over {@code GsonBuilder}-registered type
* adapters, which in turn take precedence over annotated types.
*
* The class referenced by this annotation must be either a {@link
* TypeAdapter} or a {@link TypeAdapterFactory}. Using the factory interface
* makes it possible to delegate to the enclosing {@code Gson} instance.
*
* @since 2.3
*
* @author Inderjeet Singh
* @author Joel Leitch
* @author Jesse Wilson
*/
// Note that the above example is taken from AdaptAnnotationTest.
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.FIELD})
public @interface JsonAdapter {
/** Either a {@link TypeAdapter} or {@link TypeAdapterFactory}. */
Class value();
}
gson-gson-2.4/gson/src/main/java/com/google/gson/annotations/SerializedName.java 0000664 0000000 0000000 00000006127 12604067504 0030001 0 ustar 00root root 0000000 0000000 /*
* 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.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* An annotation that indicates this member should be serialized to JSON with
* the provided name value as its field name.
*
*
This annotation will override any {@link com.google.gson.FieldNamingPolicy}, including
* the default field naming policy, that may have been set on the {@link com.google.gson.Gson}
* instance. A different naming policy can set using the {@code GsonBuilder} class. See
* {@link com.google.gson.GsonBuilder#setFieldNamingPolicy(com.google.gson.FieldNamingPolicy)}
* for more information.
*
* Here is an example of how this annotation is meant to be used:
*
* public class MyClass {
* @SerializedName("name") String a;
* @SerializedName(value="name1", alternate={"name2", "name3"}) String b;
* String c;
*
* public MyClass(String a, String b, String c) {
* this.a = a;
* this.b = b;
* this.c = c;
* }
* }
*
*
* The following shows the output that is generated when serializing an instance of the
* above example class:
*
* MyClass target = new MyClass("v1", "v2", "v3");
* Gson gson = new Gson();
* String json = gson.toJson(target);
* System.out.println(json);
*
* ===== OUTPUT =====
* {"name":"v1","name1":"v2","c":"v3"}
*
*
* NOTE: The value you specify in this annotation must be a valid JSON field name.
* While deserializing, all values specified in the annotation will be deserialized into the field.
* For example:
*
* MyClass target = gson.fromJson("{'name1':'v1'}", MyClass.class);
* assertEquals("v1", target.b);
* target = gson.fromJson("{'name2':'v2'}", MyClass.class);
* assertEquals("v2", target.b);
* target = gson.fromJson("{'name3':'v3'}", MyClass.class);
* assertEquals("v3", target.b);
*
* Note that MyClass.b is now deserialized from either name1, name2 or name3.
*
* @see com.google.gson.FieldNamingPolicy
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD})
public @interface SerializedName {
/**
* @return the desired names of the field when it is deserialized or serialized. All of the specified names will be deserialized from.
* The specified first name is what is used for serialization.
*/
String value();
String[] alternate() default {};
}
gson-gson-2.4/gson/src/main/java/com/google/gson/annotations/Since.java 0000664 0000000 0000000 00000004304 12604067504 0026141 0 ustar 00root root 0000000 0000000 /*
* 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.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* An annotation that indicates the version number since a member or a type has been present.
* This annotation is useful to manage versioning of your Json classes for a web-service.
*
*
* This annotation has no effect unless you build {@link com.google.gson.Gson} with a
* {@link com.google.gson.GsonBuilder} and invoke
* {@link com.google.gson.GsonBuilder#setVersion(double)} method.
*
*
Here is an example of how this annotation is meant to be used:
*
* public class User {
* private String firstName;
* private String lastName;
* @Since(1.0) private String emailAddress;
* @Since(1.0) private String password;
* @Since(1.1) private Address address;
* }
*
*
* If you created Gson with {@code new Gson()}, the {@code toJson()} and {@code fromJson()}
* methods will use all the fields for serialization and deserialization. However, if you created
* Gson with {@code Gson gson = new GsonBuilder().setVersion(1.0).create()} then the
* {@code toJson()} and {@code fromJson()} methods of Gson will exclude the {@code address} field
* since it's version number is set to {@code 1.1}.
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
public @interface Since {
/**
* the value indicating a version number since this member
* or type has been present.
*/
double value();
}
gson-gson-2.4/gson/src/main/java/com/google/gson/annotations/Until.java 0000664 0000000 0000000 00000004775 12604067504 0026207 0 ustar 00root root 0000000 0000000 /*
* 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.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* An annotation that indicates the version number until a member or a type should be present.
* Basically, if Gson is created with a version number that exceeds the value stored in the
* {@code Until} annotation then the field will be ignored from the JSON output. This annotation
* is useful to manage versioning of your JSON classes for a web-service.
*
*
* This annotation has no effect unless you build {@link com.google.gson.Gson} with a
* {@link com.google.gson.GsonBuilder} and invoke
* {@link com.google.gson.GsonBuilder#setVersion(double)} method.
*
*
Here is an example of how this annotation is meant to be used:
*
* public class User {
* private String firstName;
* private String lastName;
* @Until(1.1) private String emailAddress;
* @Until(1.1) private String password;
* }
*
*
* If you created Gson with {@code new Gson()}, the {@code toJson()} and {@code fromJson()}
* methods will use all the fields for serialization and deserialization. However, if you created
* Gson with {@code Gson gson = new GsonBuilder().setVersion(1.2).create()} then the
* {@code toJson()} and {@code fromJson()} methods of Gson will exclude the {@code emailAddress}
* and {@code password} fields from the example above, because the version number passed to the
* GsonBuilder, {@code 1.2}, exceeds the version number set on the {@code Until} annotation,
* {@code 1.1}, for those fields.
*
* @author Inderjeet Singh
* @author Joel Leitch
* @since 1.3
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
public @interface Until {
/**
* the value indicating a version number until this member
* or type should be ignored.
*/
double value();
}
gson-gson-2.4/gson/src/main/java/com/google/gson/annotations/package-info.java 0000664 0000000 0000000 00000000261 12604067504 0027422 0 ustar 00root root 0000000 0000000 /**
* This package provides annotations that can be used with {@link com.google.gson.Gson}.
*
* @author Inderjeet Singh, Joel Leitch
*/
package com.google.gson.annotations; gson-gson-2.4/gson/src/main/java/com/google/gson/internal/ 0000775 0000000 0000000 00000000000 12604067504 0023513 5 ustar 00root root 0000000 0000000 gson-gson-2.4/gson/src/main/java/com/google/gson/internal/$Gson$Preconditions.java 0000664 0000000 0000000 00000002475 12604067504 0030145 0 ustar 00root root 0000000 0000000 /*
* 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.internal;
/**
* A simple utility class used to check method Preconditions.
*
*
* public long divideBy(long value) {
* Preconditions.checkArgument(value != 0);
* return this.value / value;
* }
*
*
* @author Inderjeet Singh
* @author Joel Leitch
*/
public final class $Gson$Preconditions {
private $Gson$Preconditions() {
throw new UnsupportedOperationException();
}
public static T checkNotNull(T obj) {
if (obj == null) {
throw new NullPointerException();
}
return obj;
}
public static void checkArgument(boolean condition) {
if (!condition) {
throw new IllegalArgumentException();
}
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/internal/$Gson$Types.java 0000664 0000000 0000000 00000050564 12604067504 0026433 0 ustar 00root root 0000000 0000000 /**
* 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.internal;
import static com.google.gson.internal.$Gson$Preconditions.checkArgument;
import static com.google.gson.internal.$Gson$Preconditions.checkNotNull;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.GenericDeclaration;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.util.Arrays;
import java.util.Collection;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Properties;
/**
* Static methods for working with types.
*
* @author Bob Lee
* @author Jesse Wilson
*/
public final class $Gson$Types {
static final Type[] EMPTY_TYPE_ARRAY = new Type[] {};
private $Gson$Types() {
throw new UnsupportedOperationException();
}
/**
* Returns a new parameterized type, applying {@code typeArguments} to
* {@code rawType} and enclosed by {@code ownerType}.
*
* @return a {@link java.io.Serializable serializable} parameterized type.
*/
public static ParameterizedType newParameterizedTypeWithOwner(
Type ownerType, Type rawType, Type... typeArguments) {
return new ParameterizedTypeImpl(ownerType, rawType, typeArguments);
}
/**
* Returns an array type whose elements are all instances of
* {@code componentType}.
*
* @return a {@link java.io.Serializable serializable} generic array type.
*/
public static GenericArrayType arrayOf(Type componentType) {
return new GenericArrayTypeImpl(componentType);
}
/**
* Returns a type that represents an unknown type that extends {@code bound}.
* For example, if {@code bound} is {@code CharSequence.class}, this returns
* {@code ? extends CharSequence}. If {@code bound} is {@code Object.class},
* this returns {@code ?}, which is shorthand for {@code ? extends Object}.
*/
public static WildcardType subtypeOf(Type bound) {
return new WildcardTypeImpl(new Type[] { bound }, EMPTY_TYPE_ARRAY);
}
/**
* Returns a type that represents an unknown supertype of {@code bound}. For
* example, if {@code bound} is {@code String.class}, this returns {@code ?
* super String}.
*/
public static WildcardType supertypeOf(Type bound) {
return new WildcardTypeImpl(new Type[] { Object.class }, new Type[] { bound });
}
/**
* Returns a type that is functionally equal but not necessarily equal
* according to {@link Object#equals(Object) Object.equals()}. The returned
* type is {@link java.io.Serializable}.
*/
public static Type canonicalize(Type type) {
if (type instanceof Class) {
Class c = (Class) type;
return c.isArray() ? new GenericArrayTypeImpl(canonicalize(c.getComponentType())) : c;
} else if (type instanceof ParameterizedType) {
ParameterizedType p = (ParameterizedType) type;
return new ParameterizedTypeImpl(p.getOwnerType(),
p.getRawType(), p.getActualTypeArguments());
} else if (type instanceof GenericArrayType) {
GenericArrayType g = (GenericArrayType) type;
return new GenericArrayTypeImpl(g.getGenericComponentType());
} else if (type instanceof WildcardType) {
WildcardType w = (WildcardType) type;
return new WildcardTypeImpl(w.getUpperBounds(), w.getLowerBounds());
} else {
// type is either serializable as-is or unsupported
return type;
}
}
public static Class getRawType(Type type) {
if (type instanceof Class) {
// type is a normal class.
return (Class) type;
} else if (type instanceof ParameterizedType) {
ParameterizedType parameterizedType = (ParameterizedType) type;
// I'm not exactly sure why getRawType() returns Type instead of Class.
// Neal isn't either but suspects some pathological case related
// to nested classes exists.
Type rawType = parameterizedType.getRawType();
checkArgument(rawType instanceof Class);
return (Class) rawType;
} else if (type instanceof GenericArrayType) {
Type componentType = ((GenericArrayType)type).getGenericComponentType();
return Array.newInstance(getRawType(componentType), 0).getClass();
} else if (type instanceof TypeVariable) {
// we could use the variable's bounds, but that won't work if there are multiple.
// having a raw type that's more general than necessary is okay
return Object.class;
} else if (type instanceof WildcardType) {
return getRawType(((WildcardType) type).getUpperBounds()[0]);
} else {
String className = type == null ? "null" : type.getClass().getName();
throw new IllegalArgumentException("Expected a Class, ParameterizedType, or "
+ "GenericArrayType, but <" + type + "> is of type " + className);
}
}
static boolean equal(Object a, Object b) {
return a == b || (a != null && a.equals(b));
}
/**
* Returns true if {@code a} and {@code b} are equal.
*/
public static boolean equals(Type a, Type b) {
if (a == b) {
// also handles (a == null && b == null)
return true;
} else if (a instanceof Class) {
// Class already specifies equals().
return a.equals(b);
} else if (a instanceof ParameterizedType) {
if (!(b instanceof ParameterizedType)) {
return false;
}
// TODO: save a .clone() call
ParameterizedType pa = (ParameterizedType) a;
ParameterizedType pb = (ParameterizedType) b;
return equal(pa.getOwnerType(), pb.getOwnerType())
&& pa.getRawType().equals(pb.getRawType())
&& Arrays.equals(pa.getActualTypeArguments(), pb.getActualTypeArguments());
} else if (a instanceof GenericArrayType) {
if (!(b instanceof GenericArrayType)) {
return false;
}
GenericArrayType ga = (GenericArrayType) a;
GenericArrayType gb = (GenericArrayType) b;
return equals(ga.getGenericComponentType(), gb.getGenericComponentType());
} else if (a instanceof WildcardType) {
if (!(b instanceof WildcardType)) {
return false;
}
WildcardType wa = (WildcardType) a;
WildcardType wb = (WildcardType) b;
return Arrays.equals(wa.getUpperBounds(), wb.getUpperBounds())
&& Arrays.equals(wa.getLowerBounds(), wb.getLowerBounds());
} else if (a instanceof TypeVariable) {
if (!(b instanceof TypeVariable)) {
return false;
}
TypeVariable va = (TypeVariable) a;
TypeVariable vb = (TypeVariable) b;
return va.getGenericDeclaration() == vb.getGenericDeclaration()
&& va.getName().equals(vb.getName());
} else {
// This isn't a type we support. Could be a generic array type, wildcard type, etc.
return false;
}
}
private static int hashCodeOrZero(Object o) {
return o != null ? o.hashCode() : 0;
}
public static String typeToString(Type type) {
return type instanceof Class ? ((Class) type).getName() : type.toString();
}
/**
* Returns the generic supertype for {@code supertype}. For example, given a class {@code
* IntegerSet}, the result for when supertype is {@code Set.class} is {@code Set} and the
* result when the supertype is {@code Collection.class} is {@code Collection}.
*/
static Type getGenericSupertype(Type context, Class rawType, Class toResolve) {
if (toResolve == rawType) {
return context;
}
// we skip searching through interfaces if unknown is an interface
if (toResolve.isInterface()) {
Class[] interfaces = rawType.getInterfaces();
for (int i = 0, length = interfaces.length; i < length; i++) {
if (interfaces[i] == toResolve) {
return rawType.getGenericInterfaces()[i];
} else if (toResolve.isAssignableFrom(interfaces[i])) {
return getGenericSupertype(rawType.getGenericInterfaces()[i], interfaces[i], toResolve);
}
}
}
// check our supertypes
if (!rawType.isInterface()) {
while (rawType != Object.class) {
Class rawSupertype = rawType.getSuperclass();
if (rawSupertype == toResolve) {
return rawType.getGenericSuperclass();
} else if (toResolve.isAssignableFrom(rawSupertype)) {
return getGenericSupertype(rawType.getGenericSuperclass(), rawSupertype, toResolve);
}
rawType = rawSupertype;
}
}
// we can't resolve this further
return toResolve;
}
/**
* Returns the generic form of {@code supertype}. For example, if this is {@code
* ArrayList}, this returns {@code Iterable} given the input {@code
* Iterable.class}.
*
* @param supertype a superclass of, or interface implemented by, this.
*/
static Type getSupertype(Type context, Class contextRawType, Class supertype) {
checkArgument(supertype.isAssignableFrom(contextRawType));
return resolve(context, contextRawType,
$Gson$Types.getGenericSupertype(context, contextRawType, supertype));
}
/**
* Returns the component type of this array type.
* @throws ClassCastException if this type is not an array.
*/
public static Type getArrayComponentType(Type array) {
return array instanceof GenericArrayType
? ((GenericArrayType) array).getGenericComponentType()
: ((Class) array).getComponentType();
}
/**
* Returns the element type of this collection type.
* @throws IllegalArgumentException if this type is not a collection.
*/
public static Type getCollectionElementType(Type context, Class contextRawType) {
Type collectionType = getSupertype(context, contextRawType, Collection.class);
if (collectionType instanceof WildcardType) {
collectionType = ((WildcardType)collectionType).getUpperBounds()[0];
}
if (collectionType instanceof ParameterizedType) {
return ((ParameterizedType) collectionType).getActualTypeArguments()[0];
}
return Object.class;
}
/**
* Returns a two element array containing this map's key and value types in
* positions 0 and 1 respectively.
*/
public static Type[] getMapKeyAndValueTypes(Type context, Class contextRawType) {
/*
* Work around a problem with the declaration of java.util.Properties. That
* class should extend Hashtable, but it's declared to
* extend Hashtable.
*/
if (context == Properties.class) {
return new Type[] { String.class, String.class }; // TODO: test subclasses of Properties!
}
Type mapType = getSupertype(context, contextRawType, Map.class);
// TODO: strip wildcards?
if (mapType instanceof ParameterizedType) {
ParameterizedType mapParameterizedType = (ParameterizedType) mapType;
return mapParameterizedType.getActualTypeArguments();
}
return new Type[] { Object.class, Object.class };
}
public static Type resolve(Type context, Class contextRawType, Type toResolve) {
// this implementation is made a little more complicated in an attempt to avoid object-creation
while (true) {
if (toResolve instanceof TypeVariable) {
TypeVariable typeVariable = (TypeVariable) toResolve;
toResolve = resolveTypeVariable(context, contextRawType, typeVariable);
if (toResolve == typeVariable) {
return toResolve;
}
} else if (toResolve instanceof Class && ((Class) toResolve).isArray()) {
Class original = (Class) toResolve;
Type componentType = original.getComponentType();
Type newComponentType = resolve(context, contextRawType, componentType);
return componentType == newComponentType
? original
: arrayOf(newComponentType);
} else if (toResolve instanceof GenericArrayType) {
GenericArrayType original = (GenericArrayType) toResolve;
Type componentType = original.getGenericComponentType();
Type newComponentType = resolve(context, contextRawType, componentType);
return componentType == newComponentType
? original
: arrayOf(newComponentType);
} else if (toResolve instanceof ParameterizedType) {
ParameterizedType original = (ParameterizedType) toResolve;
Type ownerType = original.getOwnerType();
Type newOwnerType = resolve(context, contextRawType, ownerType);
boolean changed = newOwnerType != ownerType;
Type[] args = original.getActualTypeArguments();
for (int t = 0, length = args.length; t < length; t++) {
Type resolvedTypeArgument = resolve(context, contextRawType, args[t]);
if (resolvedTypeArgument != args[t]) {
if (!changed) {
args = args.clone();
changed = true;
}
args[t] = resolvedTypeArgument;
}
}
return changed
? newParameterizedTypeWithOwner(newOwnerType, original.getRawType(), args)
: original;
} else if (toResolve instanceof WildcardType) {
WildcardType original = (WildcardType) toResolve;
Type[] originalLowerBound = original.getLowerBounds();
Type[] originalUpperBound = original.getUpperBounds();
if (originalLowerBound.length == 1) {
Type lowerBound = resolve(context, contextRawType, originalLowerBound[0]);
if (lowerBound != originalLowerBound[0]) {
return supertypeOf(lowerBound);
}
} else if (originalUpperBound.length == 1) {
Type upperBound = resolve(context, contextRawType, originalUpperBound[0]);
if (upperBound != originalUpperBound[0]) {
return subtypeOf(upperBound);
}
}
return original;
} else {
return toResolve;
}
}
}
static Type resolveTypeVariable(Type context, Class contextRawType, TypeVariable unknown) {
Class declaredByRaw = declaringClassOf(unknown);
// we can't reduce this further
if (declaredByRaw == null) {
return unknown;
}
Type declaredBy = getGenericSupertype(context, contextRawType, declaredByRaw);
if (declaredBy instanceof ParameterizedType) {
int index = indexOf(declaredByRaw.getTypeParameters(), unknown);
return ((ParameterizedType) declaredBy).getActualTypeArguments()[index];
}
return unknown;
}
private static int indexOf(Object[] array, Object toFind) {
for (int i = 0; i < array.length; i++) {
if (toFind.equals(array[i])) {
return i;
}
}
throw new NoSuchElementException();
}
/**
* Returns the declaring class of {@code typeVariable}, or {@code null} if it was not declared by
* a class.
*/
private static Class declaringClassOf(TypeVariable typeVariable) {
GenericDeclaration genericDeclaration = typeVariable.getGenericDeclaration();
return genericDeclaration instanceof Class
? (Class) genericDeclaration
: null;
}
private static void checkNotPrimitive(Type type) {
checkArgument(!(type instanceof Class) || !((Class) type).isPrimitive());
}
private static final class ParameterizedTypeImpl implements ParameterizedType, Serializable {
private final Type ownerType;
private final Type rawType;
private final Type[] typeArguments;
public ParameterizedTypeImpl(Type ownerType, Type rawType, Type... typeArguments) {
// require an owner type if the raw type needs it
if (rawType instanceof Class) {
Class rawTypeAsClass = (Class) rawType;
boolean isStaticOrTopLevelClass = Modifier.isStatic(rawTypeAsClass.getModifiers())
|| rawTypeAsClass.getEnclosingClass() == null;
checkArgument(ownerType != null || isStaticOrTopLevelClass);
}
this.ownerType = ownerType == null ? null : canonicalize(ownerType);
this.rawType = canonicalize(rawType);
this.typeArguments = typeArguments.clone();
for (int t = 0; t < this.typeArguments.length; t++) {
checkNotNull(this.typeArguments[t]);
checkNotPrimitive(this.typeArguments[t]);
this.typeArguments[t] = canonicalize(this.typeArguments[t]);
}
}
public Type[] getActualTypeArguments() {
return typeArguments.clone();
}
public Type getRawType() {
return rawType;
}
public Type getOwnerType() {
return ownerType;
}
@Override public boolean equals(Object other) {
return other instanceof ParameterizedType
&& $Gson$Types.equals(this, (ParameterizedType) other);
}
@Override public int hashCode() {
return Arrays.hashCode(typeArguments)
^ rawType.hashCode()
^ hashCodeOrZero(ownerType);
}
@Override public String toString() {
StringBuilder stringBuilder = new StringBuilder(30 * (typeArguments.length + 1));
stringBuilder.append(typeToString(rawType));
if (typeArguments.length == 0) {
return stringBuilder.toString();
}
stringBuilder.append("<").append(typeToString(typeArguments[0]));
for (int i = 1; i < typeArguments.length; i++) {
stringBuilder.append(", ").append(typeToString(typeArguments[i]));
}
return stringBuilder.append(">").toString();
}
private static final long serialVersionUID = 0;
}
private static final class GenericArrayTypeImpl implements GenericArrayType, Serializable {
private final Type componentType;
public GenericArrayTypeImpl(Type componentType) {
this.componentType = canonicalize(componentType);
}
public Type getGenericComponentType() {
return componentType;
}
@Override public boolean equals(Object o) {
return o instanceof GenericArrayType
&& $Gson$Types.equals(this, (GenericArrayType) o);
}
@Override public int hashCode() {
return componentType.hashCode();
}
@Override public String toString() {
return typeToString(componentType) + "[]";
}
private static final long serialVersionUID = 0;
}
/**
* The WildcardType interface supports multiple upper bounds and multiple
* lower bounds. We only support what the Java 6 language needs - at most one
* bound. If a lower bound is set, the upper bound must be Object.class.
*/
private static final class WildcardTypeImpl implements WildcardType, Serializable {
private final Type upperBound;
private final Type lowerBound;
public WildcardTypeImpl(Type[] upperBounds, Type[] lowerBounds) {
checkArgument(lowerBounds.length <= 1);
checkArgument(upperBounds.length == 1);
if (lowerBounds.length == 1) {
checkNotNull(lowerBounds[0]);
checkNotPrimitive(lowerBounds[0]);
checkArgument(upperBounds[0] == Object.class);
this.lowerBound = canonicalize(lowerBounds[0]);
this.upperBound = Object.class;
} else {
checkNotNull(upperBounds[0]);
checkNotPrimitive(upperBounds[0]);
this.lowerBound = null;
this.upperBound = canonicalize(upperBounds[0]);
}
}
public Type[] getUpperBounds() {
return new Type[] { upperBound };
}
public Type[] getLowerBounds() {
return lowerBound != null ? new Type[] { lowerBound } : EMPTY_TYPE_ARRAY;
}
@Override public boolean equals(Object other) {
return other instanceof WildcardType
&& $Gson$Types.equals(this, (WildcardType) other);
}
@Override public int hashCode() {
// this equals Arrays.hashCode(getLowerBounds()) ^ Arrays.hashCode(getUpperBounds());
return (lowerBound != null ? 31 + lowerBound.hashCode() : 1)
^ (31 + upperBound.hashCode());
}
@Override public String toString() {
if (lowerBound != null) {
return "? super " + typeToString(lowerBound);
} else if (upperBound == Object.class) {
return "?";
} else {
return "? extends " + typeToString(upperBound);
}
}
private static final long serialVersionUID = 0;
}
}
gson-gson-2.4/gson/src/main/java/com/google/gson/internal/ConstructorConstructor.java 0000664 0000000 0000000 00000016612 12604067504 0031157 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 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.internal;
import com.google.gson.InstanceCreator;
import com.google.gson.JsonIOException;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.EnumSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;
/**
* Returns a function that can construct an instance of a requested type.
*/
public final class ConstructorConstructor {
private final Map> instanceCreators;
public ConstructorConstructor(Map> instanceCreators) {
this.instanceCreators = instanceCreators;
}
public ObjectConstructor get(TypeToken typeToken) {
final Type type = typeToken.getType();
final Class rawType = typeToken.getRawType();
// first try an instance creator
@SuppressWarnings("unchecked") // types must agree
final InstanceCreator typeCreator = (InstanceCreator) instanceCreators.get(type);
if (typeCreator != null) {
return new ObjectConstructor() {
public T construct() {
return typeCreator.createInstance(type);
}
};
}
// Next try raw type match for instance creators
@SuppressWarnings("unchecked") // types must agree
final InstanceCreator rawTypeCreator =
(InstanceCreator) instanceCreators.get(rawType);
if (rawTypeCreator != null) {
return new ObjectConstructor() {
public T construct() {
return rawTypeCreator.createInstance(type);
}
};
}
ObjectConstructor defaultConstructor = newDefaultConstructor(rawType);
if (defaultConstructor != null) {
return defaultConstructor;
}
ObjectConstructor defaultImplementation = newDefaultImplementationConstructor(type, rawType);
if (defaultImplementation != null) {
return defaultImplementation;
}
// finally try unsafe
return newUnsafeAllocator(type, rawType);
}
private ObjectConstructor newDefaultConstructor(Class rawType) {
try {
final Constructor constructor = rawType.getDeclaredConstructor();
if (!constructor.isAccessible()) {
constructor.setAccessible(true);
}
return new ObjectConstructor() {
@SuppressWarnings("unchecked") // T is the same raw type as is requested
public T construct() {
try {
Object[] args = null;
return (T) constructor.newInstance(args);
} catch (InstantiationException e) {
// TODO: JsonParseException ?
throw new RuntimeException("Failed to invoke " + constructor + " with no args", e);
} catch (InvocationTargetException e) {
// TODO: don't wrap if cause is unchecked!
// TODO: JsonParseException ?
throw new RuntimeException("Failed to invoke " + constructor + " with no args",
e.getTargetException());
} catch (IllegalAccessException e) {
throw new AssertionError(e);
}
}
};
} catch (NoSuchMethodException e) {
return null;
}
}
/**
* Constructors for common interface types like Map and List and their
* subtypes.
*/
@SuppressWarnings("unchecked") // use runtime checks to guarantee that 'T' is what it is
private ObjectConstructor newDefaultImplementationConstructor(
final Type type, Class rawType) {
if (Collection.class.isAssignableFrom(rawType)) {
if (SortedSet.class.isAssignableFrom(rawType)) {
return new ObjectConstructor() {
public T construct() {
return (T) new TreeSet();
}
};
} else if (EnumSet.class.isAssignableFrom(rawType)) {
return new ObjectConstructor() {
@SuppressWarnings("rawtypes")
public T construct() {
if (type instanceof ParameterizedType) {
Type elementType = ((ParameterizedType) type).getActualTypeArguments()[0];
if (elementType instanceof Class) {
return (T) EnumSet.noneOf((Class)elementType);
} else {
throw new JsonIOException("Invalid EnumSet type: " + type.toString());
}
} else {
throw new JsonIOException("Invalid EnumSet type: " + type.toString());
}
}
};
} else if (Set.class.isAssignableFrom(rawType)) {
return new ObjectConstructor() {
public T construct() {
return (T) new LinkedHashSet();
}
};
} else if (Queue.class.isAssignableFrom(rawType)) {
return new ObjectConstructor() {
public T construct() {
return (T) new LinkedList();
}
};
} else {
return new ObjectConstructor() {
public T construct() {
return (T) new ArrayList();
}
};
}
}
if (Map.class.isAssignableFrom(rawType)) {
if (SortedMap.class.isAssignableFrom(rawType)) {
return new ObjectConstructor() {
public T construct() {
return (T) new TreeMap