diff --git a/gson/src/main/java/com/google/gson/Gson.java b/gson/src/main/java/com/google/gson/Gson.java index 225b9085..528d129d 100644 --- a/gson/src/main/java/com/google/gson/Gson.java +++ b/gson/src/main/java/com/google/gson/Gson.java @@ -17,9 +17,9 @@ package com.google.gson; import com.google.gson.internal.ConstructorConstructor; -import com.google.gson.internal.ParameterizedTypeHandlerMap; import com.google.gson.internal.Primitives; import com.google.gson.internal.Streams; +import com.google.gson.internal.TypeMap; import com.google.gson.internal.bind.ArrayTypeAdapter; import com.google.gson.internal.bind.BigDecimalTypeAdapter; import com.google.gson.internal.bind.BigIntegerTypeAdapter; @@ -101,8 +101,7 @@ import java.util.Map; */ public final class Gson { @SuppressWarnings("rawtypes") - static final ParameterizedTypeHandlerMap EMPTY_MAP = - new ParameterizedTypeHandlerMap().makeUnmodifiable(); + static final TypeMap EMPTY_MAP = new TypeMap().makeUnmodifiable(); static final boolean DEFAULT_JSON_NON_EXECUTABLE = false; @@ -140,16 +139,31 @@ public final class Gson { private final ConstructorConstructor constructorConstructor; /** Map containing Type or Class objects as keys */ - private final ParameterizedTypeHandlerMap> serializers; + private final TypeMap> serializers; /** Map containing Type or Class objects as keys */ - private final ParameterizedTypeHandlerMap> deserializers; + private final TypeMap> deserializers; private final boolean serializeNulls; private final boolean htmlSafe; private final boolean generateNonExecutableJson; private final boolean prettyPrinting; + final JsonDeserializationContext deserializationContext = new JsonDeserializationContext() { + 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: @@ -195,9 +209,9 @@ public final class Gson { Gson(final ExclusionStrategy deserializationExclusionStrategy, final ExclusionStrategy serializationExclusionStrategy, final FieldNamingStrategy2 fieldNamingPolicy, - final ParameterizedTypeHandlerMap> instanceCreators, boolean serializeNulls, - final ParameterizedTypeHandlerMap> serializers, - final ParameterizedTypeHandlerMap> deserializers, + final TypeMap> instanceCreators, boolean serializeNulls, + final TypeMap> serializers, + final TypeMap> deserializers, boolean complexMapKeySerialization, boolean generateNonExecutableGson, boolean htmlSafe, boolean prettyPrinting, boolean serializeSpecialFloatingPointValues, LongSerializationPolicy longSerializationPolicy, @@ -268,7 +282,7 @@ public final class Gson { factories.add(factory); } - factories.add(new GsonToMiniGsonTypeAdapterFactory(this, serializers, deserializers)); + factories.add(new TreeTypeAdapter.TypeHierarchyFactory(serializers, deserializers)); factories.add(new CollectionTypeAdapterFactory(constructorConstructor)); factories.add(TypeAdapters.URL_FACTORY); factories.add(TypeAdapters.URI_FACTORY); diff --git a/gson/src/main/java/com/google/gson/GsonBuilder.java b/gson/src/main/java/com/google/gson/GsonBuilder.java index 5c029209..e998203f 100644 --- a/gson/src/main/java/com/google/gson/GsonBuilder.java +++ b/gson/src/main/java/com/google/gson/GsonBuilder.java @@ -18,8 +18,8 @@ package com.google.gson; import com.google.gson.DefaultTypeAdapters.DefaultDateTypeAdapter; import com.google.gson.internal.$Gson$Preconditions; -import com.google.gson.internal.ParameterizedTypeHandlerMap; import com.google.gson.internal.Primitives; +import com.google.gson.internal.TypeMap; import com.google.gson.internal.bind.TypeAdapters; import com.google.gson.reflect.TypeToken; import java.lang.reflect.Type; @@ -87,9 +87,9 @@ public final class GsonBuilder { private boolean excludeFieldsWithoutExposeAnnotation; private LongSerializationPolicy longSerializationPolicy; private FieldNamingStrategy2 fieldNamingPolicy; - private final ParameterizedTypeHandlerMap> instanceCreators; - private final ParameterizedTypeHandlerMap> serializers; - private final ParameterizedTypeHandlerMap> deserializers; + private final TypeMap> instanceCreators; + private final TypeMap> serializers; + private final TypeMap> deserializers; private final List typeAdapterFactories = new ArrayList(); private boolean serializeNulls; @@ -124,9 +124,9 @@ public final class GsonBuilder { excludeFieldsWithoutExposeAnnotation = false; longSerializationPolicy = LongSerializationPolicy.DEFAULT; fieldNamingPolicy = Gson.DEFAULT_NAMING_POLICY; - instanceCreators = new ParameterizedTypeHandlerMap>(); - serializers = new ParameterizedTypeHandlerMap>(); - deserializers = new ParameterizedTypeHandlerMap>(); + instanceCreators = new TypeMap>(); + serializers = new TypeMap>(); + deserializers = new TypeMap>(); serializeNulls = false; dateStyle = DateFormat.DEFAULT; timeStyle = DateFormat.DEFAULT; @@ -529,11 +529,9 @@ public final class GsonBuilder { if (typeAdapter instanceof InstanceCreator) { registerInstanceCreator(type, (InstanceCreator) typeAdapter); } - if (typeAdapter instanceof JsonSerializer) { - registerSerializer(type, (JsonSerializer) typeAdapter); - } - if (typeAdapter instanceof JsonDeserializer) { - registerDeserializer(type, (JsonDeserializer) typeAdapter); + if (typeAdapter instanceof JsonSerializer || typeAdapter instanceof JsonDeserializer) { + TypeToken typeToken = TypeToken.get(type); + typeAdapterFactories.add(new TreeTypeAdapter.SingleTypeFactory(typeToken, typeAdapter)); } if (typeAdapter instanceof TypeAdapter.Factory) { typeAdapterFactories.add((TypeAdapter.Factory) typeAdapter); @@ -558,36 +556,6 @@ public final class GsonBuilder { return this; } - /** - * Configures Gson to use a custom JSON serializer for the specified type. You should use this - * method if you want to register different serializers for different generic types corresponding - * to a raw type. - * - * - * @param typeOfT The type definition for T - * @param serializer the custom serializer - * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern - */ - private GsonBuilder registerSerializer(Type typeOfT, JsonSerializer serializer) { - serializers.register(typeOfT, serializer); - return this; - } - - /** - * Configures Gson to use a custom JSON deserializer for the specified type. You should use this - * method if you want to register different deserializers for different generic types - * corresponding to a raw type. - * - * - * @param typeOfT The type definition for T - * @param deserializer the custom deserializer - * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern - */ - private GsonBuilder registerDeserializer(Type typeOfT, JsonDeserializer deserializer) { - deserializers.register(typeOfT, new JsonDeserializerExceptionWrapper(deserializer)); - return this; - } - /** * Configures Gson for custom serialization or deserialization for an inheritance type hierarchy. * This method combines the registration of an {@link InstanceCreator}, {@link JsonSerializer}, @@ -703,8 +671,7 @@ public final class GsonBuilder { } private static void addTypeAdaptersForDate(String datePattern, int dateStyle, int timeStyle, - ParameterizedTypeHandlerMap> serializers, - ParameterizedTypeHandlerMap> deserializers) { + TypeMap> serializers, TypeMap> deserializers) { DefaultDateTypeAdapter dateTypeAdapter = null; if (datePattern != null && !"".equals(datePattern.trim())) { dateTypeAdapter = new DefaultDateTypeAdapter(datePattern); @@ -722,8 +689,7 @@ public final class GsonBuilder { } } - private static void registerIfAbsent(Class type, - ParameterizedTypeHandlerMap adapters, T adapter) { + private static void registerIfAbsent(Class type, TypeMap adapters, T adapter) { if (!adapters.hasSpecificHandlerFor(type)) { adapters.register(type, adapter); } diff --git a/gson/src/main/java/com/google/gson/GsonToMiniGsonTypeAdapterFactory.java b/gson/src/main/java/com/google/gson/GsonToMiniGsonTypeAdapterFactory.java deleted file mode 100644 index f5bfe349..00000000 --- a/gson/src/main/java/com/google/gson/GsonToMiniGsonTypeAdapterFactory.java +++ /dev/null @@ -1,107 +0,0 @@ -/* - * 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.ParameterizedTypeHandlerMap; -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; -import java.lang.reflect.Type; - -final class GsonToMiniGsonTypeAdapterFactory implements TypeAdapter.Factory { - private final ParameterizedTypeHandlerMap> serializers; - private final ParameterizedTypeHandlerMap> deserializers; - private final JsonDeserializationContext deserializationContext; - private final JsonSerializationContext serializationContext; - - public GsonToMiniGsonTypeAdapterFactory(final Gson gson, - ParameterizedTypeHandlerMap> serializers, - ParameterizedTypeHandlerMap> deserializers) { - this.serializers = serializers; - this.deserializers = deserializers; - - this.deserializationContext = new JsonDeserializationContext() { - public T deserialize(JsonElement json, Type typeOfT) throws JsonParseException { - return (T) gson.fromJson(json, typeOfT); - } - }; - - this.serializationContext = new JsonSerializationContext() { - public JsonElement serialize(Object src) { - return gson.toJsonTree(src); - } - public JsonElement serialize(Object src, Type typeOfSrc) { - return gson.toJsonTree(src, typeOfSrc); - } - }; - } - - public TypeAdapter create(final Gson context, final TypeToken typeToken) { - final Type type = typeToken.getType(); - - @SuppressWarnings("unchecked") // guaranteed to match typeOfT - final JsonSerializer serializer - = (JsonSerializer) serializers.getHandlerFor(type, false); - @SuppressWarnings("unchecked") // guaranteed to match typeOfT - final JsonDeserializer deserializer - = (JsonDeserializer) deserializers.getHandlerFor(type, false); - - if (serializer == null && deserializer == null) { - return null; - } - - return new TypeAdapter() { - /** - * The delegate is lazily created because it may not be needed, and - * creating it may fail. - */ - private TypeAdapter delegate; - - @Override public T read(JsonReader reader) throws IOException { - if (deserializer == null) { - return delegate().read(reader); - } - JsonElement value = Streams.parse(reader); - if (value.isJsonNull()) { - return null; - } - return deserializer.deserialize(value, type, deserializationContext); - } - - @Override public void write(JsonWriter writer, T value) throws IOException { - if (serializer == null) { - delegate().write(writer, value); - return; - } - if (value == null) { - writer.nullValue(); - return; - } - JsonElement element = serializer.serialize(value, type, serializationContext); - Streams.write(element, writer); - } - - private TypeAdapter delegate() { - TypeAdapter d = delegate; - return d != null - ? d - : (delegate = context.getNextAdapter(GsonToMiniGsonTypeAdapterFactory.this, typeToken)); - } - }; - } -} diff --git a/gson/src/main/java/com/google/gson/TreeTypeAdapter.java b/gson/src/main/java/com/google/gson/TreeTypeAdapter.java new file mode 100644 index 00000000..ea936037 --- /dev/null +++ b/gson/src/main/java/com/google/gson/TreeTypeAdapter.java @@ -0,0 +1,128 @@ +/* + * 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.internal.TypeMap; +import com.google.gson.reflect.TypeToken; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; +import java.io.IOException; +import java.lang.reflect.Type; + +/** + * 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. + */ +public final class TreeTypeAdapter extends TypeAdapter { + private final JsonSerializer serializer; + private final JsonDeserializer deserializer; + private final Gson gson; + private final TypeToken typeToken; + private final Factory 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, Factory skipPast) { + this.serializer = serializer; + this.deserializer = deserializer; + this.gson = gson; + this.typeToken = typeToken; + this.skipPast = skipPast; + } + + @Override public T read(JsonReader reader) throws IOException { + if (deserializer == null) { + return delegate().read(reader); + } + JsonElement value = Streams.parse(reader); + if (value.isJsonNull()) { + return null; + } + return deserializer.deserialize(value, typeToken.getType(), gson.deserializationContext); + } + + @Override public void write(JsonWriter writer, T value) throws IOException { + if (serializer == null) { + delegate().write(writer, value); + return; + } + if (value == null) { + writer.nullValue(); + return; + } + JsonElement tree = serializer.serialize(value, typeToken.getType(), gson.serializationContext); + Streams.write(tree,writer); + } + + private TypeAdapter delegate() { + TypeAdapter d = delegate; + return d != null + ? d + : (delegate = gson.getNextAdapter(skipPast, typeToken)); + } + + public static class SingleTypeFactory implements TypeAdapter.Factory { + private final TypeToken typeToken; + private final JsonSerializer serializer; + private final JsonDeserializer deserializer; + + public SingleTypeFactory(TypeToken typeToken, Object typeAdapter) { + this.typeToken = typeToken; + serializer = typeAdapter instanceof JsonSerializer + ? (JsonSerializer) typeAdapter + : null; + deserializer = typeAdapter instanceof JsonDeserializer + ? (JsonDeserializer) typeAdapter + : null; + $Gson$Preconditions.checkArgument(serializer != null || deserializer != null); + } + + @SuppressWarnings("unchecked") // guarded by typeToken.equals() call + public TypeAdapter create(Gson context, TypeToken type) { + return typeToken.equals(type) + ? new TreeTypeAdapter((JsonSerializer) serializer, + (JsonDeserializer) deserializer, context, type, this) + : null; + } + } + + public static class TypeHierarchyFactory implements TypeAdapter.Factory { + private final TypeMap> serializers; + private final TypeMap> deserializers; + + public TypeHierarchyFactory(TypeMap> serializers, + TypeMap> deserializers) { + this.serializers = serializers; + this.deserializers = deserializers; + } + + @SuppressWarnings("unchecked") // guaranteed by serializers lookup matching type + public TypeAdapter create(Gson context, TypeToken typeToken) { + Type type = typeToken.getType(); + JsonSerializer serializer = (JsonSerializer) serializers.getHandlerFor(type); + JsonDeserializer deserializer = (JsonDeserializer) deserializers.getHandlerFor(type); + return (serializer != null || deserializer != null) + ? new TreeTypeAdapter(serializer, deserializer, context, typeToken, this) + : null; + } + } +} diff --git a/gson/src/main/java/com/google/gson/internal/ConstructorConstructor.java b/gson/src/main/java/com/google/gson/internal/ConstructorConstructor.java index 971a0b8b..2e611b30 100644 --- a/gson/src/main/java/com/google/gson/internal/ConstructorConstructor.java +++ b/gson/src/main/java/com/google/gson/internal/ConstructorConstructor.java @@ -36,14 +36,14 @@ import java.util.TreeSet; * Returns a function that can construct an instance of a requested type. */ public final class ConstructorConstructor { - private final ParameterizedTypeHandlerMap> instanceCreators; + private final TypeMap> instanceCreators; - public ConstructorConstructor(ParameterizedTypeHandlerMap> instanceCreators) { + public ConstructorConstructor(TypeMap> instanceCreators) { this.instanceCreators = instanceCreators; } public ConstructorConstructor() { - this(new ParameterizedTypeHandlerMap>()); + this(new TypeMap>()); } public ObjectConstructor getConstructor(TypeToken typeToken) { @@ -54,7 +54,7 @@ public final class ConstructorConstructor { @SuppressWarnings("unchecked") // types must agree final InstanceCreator creator - = (InstanceCreator) instanceCreators.getHandlerFor(type, false); + = (InstanceCreator) instanceCreators.getHandlerFor(type); if (creator != null) { return new ObjectConstructor() { public T construct() { diff --git a/gson/src/main/java/com/google/gson/internal/ParameterizedTypeHandlerMap.java b/gson/src/main/java/com/google/gson/internal/TypeMap.java similarity index 61% rename from gson/src/main/java/com/google/gson/internal/ParameterizedTypeHandlerMap.java rename to gson/src/main/java/com/google/gson/internal/TypeMap.java index a208a13e..1da216c1 100644 --- a/gson/src/main/java/com/google/gson/internal/ParameterizedTypeHandlerMap.java +++ b/gson/src/main/java/com/google/gson/internal/TypeMap.java @@ -33,16 +33,14 @@ import java.util.logging.Logger; * * @param The handler that will be looked up by type */ -public final class ParameterizedTypeHandlerMap { - - private static final Logger logger = - Logger.getLogger(ParameterizedTypeHandlerMap.class.getName()); +public final class TypeMap { + private static final Logger logger = Logger.getLogger(TypeMap.class.getName()); /** Map that is meant for storing default type adapters */ - private final Map userMap = new HashMap(); + private final Map typeMap = new HashMap(); /** List of default type hierarchy adapters */ - private final List, T>> userTypeHierarchyList = new ArrayList, T>>(); + private final List, T>> typeHierarchyList = new ArrayList, T>>(); private boolean modifiable = true; public synchronized void registerForTypeHierarchy(Class typeOfT, T value) { @@ -54,14 +52,13 @@ public final class ParameterizedTypeHandlerMap { if (!modifiable) { throw new IllegalStateException("Attempted to modify an unmodifiable map."); } - List, T>> typeHierarchyList = userTypeHierarchyList; int index = getIndexOfSpecificHandlerForTypeHierarchy(pair.first, typeHierarchyList); - if (index >= 0) { + if (index != -1) { logger.log(Level.WARNING, "Overriding the existing type handler for {0}", pair.first); typeHierarchyList.remove(index); } index = getIndexOfAnOverriddenHandler(pair.first, typeHierarchyList); - if (index >= 0) { + if (index != -1) { throw new IllegalArgumentException("The specified type handler for type " + pair.first + " hides the previously registered type hierarchy handler for " + typeHierarchyList.get(index).first + ". Gson does not allow this."); @@ -85,71 +82,41 @@ public final class ParameterizedTypeHandlerMap { if (!modifiable) { throw new IllegalStateException("Attempted to modify an unmodifiable map."); } - if (hasSpecificHandlerFor(typeOfT)) { - logger.log(Level.WARNING, "Overriding the existing type handler for {0}", typeOfT); - } - Map map = userMap; - map.put(typeOfT, value); + typeMap.put(typeOfT, value); } - public synchronized void registerIfAbsent(ParameterizedTypeHandlerMap other) { - if (!modifiable) { - throw new IllegalStateException("Attempted to modify an unmodifiable map."); - } - for (Map.Entry entry : other.userMap.entrySet()) { - if (!userMap.containsKey(entry.getKey())) { - register(entry.getKey(), entry.getValue()); - } - } - // Quite important to traverse the typeHierarchyList from stack bottom first since - // we want to register the handlers in the same order to preserve priority order - for (int i = other.userTypeHierarchyList.size()-1; i >= 0; --i) { - Pair, T> entry = other.userTypeHierarchyList.get(i); - int index = getIndexOfSpecificHandlerForTypeHierarchy(entry.first, userTypeHierarchyList); - if (index < 0) { - registerForTypeHierarchy(entry); - } - } - } - - public synchronized ParameterizedTypeHandlerMap makeUnmodifiable() { + public synchronized TypeMap makeUnmodifiable() { modifiable = false; return this; } - public synchronized T getHandlerFor(Type type, boolean systemOnly) { - T handler; - if (!systemOnly) { - handler = userMap.get(type); - if (handler != null) { - return handler; - } + public synchronized T getHandlerFor(Type type) { + T handler = typeMap.get(type); + if (handler != null) { + return handler; } Class rawClass = $Gson$Types.getRawType(type); if (rawClass != type) { - handler = getHandlerFor(rawClass, systemOnly); + handler = getHandlerFor(rawClass); if (handler != null) { return handler; } } // check if something registered for type hierarchy - handler = getHandlerForTypeHierarchy(rawClass, systemOnly); - return handler; + return getHandlerForTypeHierarchy(rawClass); } - private T getHandlerForTypeHierarchy(Class type, boolean systemOnly) { - if (!systemOnly) { - for (Pair, T> entry : userTypeHierarchyList) { - if (entry.first.isAssignableFrom(type)) { - return entry.second; - } + private T getHandlerForTypeHierarchy(Class type) { + for (Pair, T> entry : typeHierarchyList) { + if (entry.first.isAssignableFrom(type)) { + return entry.second; } } return null; } public synchronized boolean hasSpecificHandlerFor(Type type) { - return userMap.containsKey(type); + return typeMap.containsKey(type); } private static int getIndexOfSpecificHandlerForTypeHierarchy( @@ -162,24 +129,21 @@ public final class ParameterizedTypeHandlerMap { return -1; } - public synchronized ParameterizedTypeHandlerMap copyOf() { - ParameterizedTypeHandlerMap copy = new ParameterizedTypeHandlerMap(); + public synchronized TypeMap copyOf() { + TypeMap copy = new TypeMap(); // Instead of individually registering entries in the map, make an efficient copy // of the list and map - - // TODO (inder): Performance optimization. We can probably just share the - // systemMap and systemTypeHierarchyList instead of making copies - copy.userMap.putAll(userMap); - copy.userTypeHierarchyList.addAll(userTypeHierarchyList); + copy.typeMap.putAll(typeMap); + copy.typeHierarchyList.addAll(typeHierarchyList); return copy; } @Override public String toString() { - StringBuilder sb = new StringBuilder("{userTypeHierarchyList:{"); - appendList(sb, userTypeHierarchyList); - sb.append("},userMap:{"); - appendMap(sb, userMap); + StringBuilder sb = new StringBuilder("{typeHierarchyList:{"); + appendList(sb, typeHierarchyList); + sb.append("},typeMap:{"); + appendMap(sb, typeMap); sb.append("}"); return sb.toString(); } diff --git a/gson/src/test/java/com/google/gson/internal/ParameterizedTypeHandlerMapTest.java b/gson/src/test/java/com/google/gson/internal/TypeMapTest.java similarity index 69% rename from gson/src/test/java/com/google/gson/internal/ParameterizedTypeHandlerMapTest.java rename to gson/src/test/java/com/google/gson/internal/TypeMapTest.java index 9749d75b..33083359 100644 --- a/gson/src/test/java/com/google/gson/internal/ParameterizedTypeHandlerMapTest.java +++ b/gson/src/test/java/com/google/gson/internal/TypeMapTest.java @@ -24,23 +24,23 @@ import java.util.List; import junit.framework.TestCase; /** - * Unit tests for the {@link com.google.gson.internal.ParameterizedTypeHandlerMap} class. + * Unit tests for the {@link TypeMap} class. * * @author Joel Leitch */ -public class ParameterizedTypeHandlerMapTest extends TestCase { - private ParameterizedTypeHandlerMap paramMap; +public class TypeMapTest extends TestCase { + private TypeMap paramMap; @Override protected void setUp() throws Exception { super.setUp(); - paramMap = new ParameterizedTypeHandlerMap(); + paramMap = new TypeMap(); } public void testNullMap() throws Exception { assertFalse(paramMap.hasSpecificHandlerFor(String.class)); - assertNull(paramMap.getHandlerFor(String.class, false)); - assertNull(paramMap.getHandlerFor(String.class, false)); + assertNull(paramMap.getHandlerFor(String.class)); + assertNull(paramMap.getHandlerFor(String.class)); } public void testHasGenericButNotSpecific() throws Exception { @@ -50,9 +50,9 @@ public class ParameterizedTypeHandlerMapTest extends TestCase { assertFalse(paramMap.hasSpecificHandlerFor(specificType)); assertTrue(paramMap.hasSpecificHandlerFor(List.class)); - assertNotNull(paramMap.getHandlerFor(specificType, false)); - assertNotNull(paramMap.getHandlerFor(List.class, false)); - assertEquals(handler, paramMap.getHandlerFor(specificType, false)); + assertNotNull(paramMap.getHandlerFor(specificType)); + assertNotNull(paramMap.getHandlerFor(List.class)); + assertEquals(handler, paramMap.getHandlerFor(specificType)); } public void testHasSpecificType() throws Exception { @@ -62,9 +62,9 @@ public class ParameterizedTypeHandlerMapTest extends TestCase { assertTrue(paramMap.hasSpecificHandlerFor(specificType)); assertFalse(paramMap.hasSpecificHandlerFor(List.class)); - assertNotNull(paramMap.getHandlerFor(specificType, false)); - assertNull(paramMap.getHandlerFor(List.class, false)); - assertEquals(handler, paramMap.getHandlerFor(specificType, false)); + assertNotNull(paramMap.getHandlerFor(specificType)); + assertNull(paramMap.getHandlerFor(List.class)); + assertEquals(handler, paramMap.getHandlerFor(specificType)); } public void testTypeOverridding() throws Exception { @@ -74,7 +74,7 @@ public class ParameterizedTypeHandlerMapTest extends TestCase { paramMap.register(String.class, handler2); assertTrue(paramMap.hasSpecificHandlerFor(String.class)); - assertEquals(handler2, paramMap.getHandlerFor(String.class, false)); + assertEquals(handler2, paramMap.getHandlerFor(String.class)); } public void testMakeUnmodifiable() throws Exception { @@ -87,30 +87,21 @@ public class ParameterizedTypeHandlerMapTest extends TestCase { public void testTypeHierarchy() { paramMap.registerForTypeHierarchy(Base.class, "baseHandler"); - String handler = paramMap.getHandlerFor(Sub.class, false); + String handler = paramMap.getHandlerFor(Sub.class); assertEquals("baseHandler", handler); } public void testTypeHierarchyMultipleHandlers() { paramMap.registerForTypeHierarchy(Base.class, "baseHandler"); paramMap.registerForTypeHierarchy(Sub.class, "subHandler"); - String handler = paramMap.getHandlerFor(SubOfSub.class, false); + String handler = paramMap.getHandlerFor(SubOfSub.class); assertEquals("subHandler", handler); } - public void testTypeHierarchyRegisterIfAbsent() { - paramMap.registerForTypeHierarchy(Base.class, "baseHandler"); - ParameterizedTypeHandlerMap otherMap = new ParameterizedTypeHandlerMap(); - otherMap.registerForTypeHierarchy(Base.class, "baseHandler2"); - paramMap.registerIfAbsent(otherMap); - String handler = paramMap.getHandlerFor(Base.class, false); - assertEquals("baseHandler", handler); - } - public void testReplaceExistingTypeHierarchyHandler() { paramMap.registerForTypeHierarchy(Base.class, "baseHandler"); paramMap.registerForTypeHierarchy(Base.class, "base2Handler"); - String handler = paramMap.getHandlerFor(Base.class, false); + String handler = paramMap.getHandlerFor(Base.class); assertEquals("base2Handler", handler); }