From 542a17c3bc30ae0506800f1600278e11bce551e5 Mon Sep 17 00:00:00 2001 From: Inderjeet Singh Date: Mon, 4 Apr 2011 22:48:34 +0000 Subject: [PATCH] Incorporated comments from r710 --- .../java/com/google/gson/GsonBuilder.java | 31 +++++++++++++------ gson/src/main/java/com/google/gson/Mode.java | 30 ------------------ .../ExclusionStrategyFunctionalTest.java | 29 +++++++++-------- 3 files changed, 35 insertions(+), 55 deletions(-) delete mode 100644 gson/src/main/java/com/google/gson/Mode.java diff --git a/gson/src/main/java/com/google/gson/GsonBuilder.java b/gson/src/main/java/com/google/gson/GsonBuilder.java index c9d672b4..6b1f91c6 100644 --- a/gson/src/main/java/com/google/gson/GsonBuilder.java +++ b/gson/src/main/java/com/google/gson/GsonBuilder.java @@ -353,26 +353,37 @@ public final class GsonBuilder { } /** - * Configures Gson to apply a set of exclusion strategies during either serialization or - * deserialization. Each of the {@code strategies} will be applied as a disjunction rule. + * Configures Gson to apply a set of exclusion strategies during either serialization. + * 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 either serialization or deserialization + * skipped then that field (or object) is skipped during either serialization * depending on the {@code mode} that is passed into this method. * * @param strategies the set of strategy object to apply during the {@code mode}. - * @param mode the mode of Gson (either serialization or deserialization) as to when the - * {@code strategies} should be applied. * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern * @since 1.7 */ - public GsonBuilder setExclusionStrategies(Mode mode, ExclusionStrategy... strategies) { - Set strategySet = - ($Preconditions.checkNotNull(mode) == Mode.SERIALIZE) - ? serializeExclusionStrategies : deserializeExclusionStrategies; - strategySet.addAll(Arrays.asList(strategies)); + public GsonBuilder addSerializationExclusionStrategies(ExclusionStrategy... strategies) { + serializeExclusionStrategies.addAll(Arrays.asList(strategies)); return this; } + + /** + * Configures Gson to apply a set of exclusion strategies during 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 deserialization + * depending on the {@code mode} that is passed into this method. + * + * @param strategies the set of strategy object to apply during the {@code mode}. + * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern + * @since 1.7 + */ + public GsonBuilder addDeserializationExclusionStrategies(ExclusionStrategy... strategies) { + deserializeExclusionStrategies.addAll(Arrays.asList(strategies)); + return this; + } /** * Configures Gson to output Json that fits in a page for pretty printing. This option only * affects Json serialization. diff --git a/gson/src/main/java/com/google/gson/Mode.java b/gson/src/main/java/com/google/gson/Mode.java deleted file mode 100644 index 47fa4cfa..00000000 --- a/gson/src/main/java/com/google/gson/Mode.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * 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; - -/** - * Defines the current context of Gson so that common code for serializing and deserializing can - * distinguish between the two modes. - * - * @author Joel Leitch - * - * @since 1.7 - */ -public enum Mode { - SERIALIZE, - DESERIALIZE; -} diff --git a/gson/src/test/java/com/google/gson/functional/ExclusionStrategyFunctionalTest.java b/gson/src/test/java/com/google/gson/functional/ExclusionStrategyFunctionalTest.java index b7f403a6..4ceadeb7 100644 --- a/gson/src/test/java/com/google/gson/functional/ExclusionStrategyFunctionalTest.java +++ b/gson/src/test/java/com/google/gson/functional/ExclusionStrategyFunctionalTest.java @@ -16,20 +16,19 @@ package com.google.gson.functional; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +import junit.framework.TestCase; + import com.google.gson.ExclusionStrategy; import com.google.gson.FieldAttributes; import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.JsonObject; import com.google.gson.JsonPrimitive; -import com.google.gson.Mode; - -import junit.framework.TestCase; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; /** * Performs some functional tests when Gson is instantiated with some common user defined @@ -48,7 +47,7 @@ public class ExclusionStrategyFunctionalTest extends TestCase { } public void testExclusionStrategySerialization() throws Exception { - Gson gson = createGson(new MyExclusionStrategy(String.class), null); + Gson gson = createGson(new MyExclusionStrategy(String.class), true); String json = gson.toJson(src); assertFalse(json.contains("\"stringField\"")); assertFalse(json.contains("\"annotatedField\"")); @@ -56,7 +55,7 @@ public class ExclusionStrategyFunctionalTest extends TestCase { } public void testExclusionStrategyDeserialization() throws Exception { - Gson gson = createGson(new MyExclusionStrategy(String.class), null); + Gson gson = createGson(new MyExclusionStrategy(String.class), false); JsonObject json = new JsonObject(); json.add("annotatedField", new JsonPrimitive(src.annotatedField + 5)); json.add("stringField", new JsonPrimitive(src.stringField + "blah,blah")); @@ -75,7 +74,7 @@ public class ExclusionStrategyFunctionalTest extends TestCase { src.annotatedField + 5, src.stringField + "blah,blah", src.longField + 655L); - Gson gson = createGson(new MyExclusionStrategy(String.class), Mode.DESERIALIZE); + Gson gson = createGson(new MyExclusionStrategy(String.class), false); JsonObject json = gson.toJsonTree(testObj).getAsJsonObject(); assertEquals(testObj.annotatedField, json.get("annotatedField").getAsInt()); assertEquals(testObj.stringField, json.get("stringField").getAsString()); @@ -89,12 +88,12 @@ public class ExclusionStrategyFunctionalTest extends TestCase { assertEquals(src.stringField, target.stringField); } - private static Gson createGson(ExclusionStrategy exclusionStrategy, Mode mode) { + private static Gson createGson(ExclusionStrategy exclusionStrategy, boolean serialization) { GsonBuilder gsonBuilder = new GsonBuilder(); - if (mode == null) { - gsonBuilder.setExclusionStrategies(exclusionStrategy); + if (serialization) { + gsonBuilder.addSerializationExclusionStrategies(exclusionStrategy); } else { - gsonBuilder.setExclusionStrategies(mode, exclusionStrategy); + gsonBuilder.addDeserializationExclusionStrategies(exclusionStrategy); } return gsonBuilder .serializeNulls()