Cut more wobbling code down

JAVA-4751

Author: stIncMale

bson/src/main/org/bson/internal/CodecCache.java

@@ -21,19 +21,21 @@
 import org.bson.codecs.configuration.CodecConfigurationException;
 import org.bson.codecs.configuration.CodecProvider;
 import org.bson.codecs.configuration.CodecRegistry;
-import org.bson.internal.CodecCache.CodecCacheKey;
 
 import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 
 import static java.lang.String.format;
 import static org.bson.assertions.Assertions.isTrueArgument;
 import static org.bson.assertions.Assertions.notNull;
 
 public final class ProvidersCodecRegistry implements CycleDetectingCodecRegistry {
     private final List<CodecProvider> codecProviders;
-    private final CodecCache codecCache = new CodecCache();
+    private final ConcurrentMap<CodecCacheKey, Codec<?>> codecCache = new ConcurrentHashMap<>();
 
     public ProvidersCodecRegistry(final List<? extends CodecProvider> codecProviders) {
         isTrueArgument("codecProviders must not be null or empty", codecProviders != null && codecProviders.size() > 0);
@@ -68,17 +70,17 @@ public <T> Codec<T> get(final Class<T> clazz, final CodecRegistry registry) {
     @SuppressWarnings({"unchecked"})
     public <T> Codec<T> get(final ChildCodecRegistry<T> context) {
         CodecCacheKey codecCacheKey = new CodecCacheKey(context.getCodecClass(), context.getTypes().orElse(null));
-        return codecCache.<T>get(codecCacheKey).orElseGet(() -> {
+        return (Codec<T>) codecCache.computeIfAbsent(codecCacheKey, k -> {
             for (CodecProvider provider : codecProviders) {
-                Codec<T> codec = provider.get(context.getCodecClass(), context);
+                Codec<?> codec = provider.get(context.getCodecClass(), context);
                 if (codec != null) {
                     if (codec instanceof Parameterizable && context.getTypes().isPresent()) {
-                        codec = (Codec<T>) ((Parameterizable) codec).parameterize(context, context.getTypes().get());
+                        codec = ((Parameterizable) codec).parameterize(context, context.getTypes().get());
                     }
-                    return codecCache.putIfAbsent(codecCacheKey, codec);
+                    return codec;
                 }
             }
-            throw new CodecConfigurationException(format("Can't find a codec for %s.", codecCacheKey));
+            throw new CodecConfigurationException(format("Can't find a codec for %s.", k));
         });
     }
 
@@ -114,4 +116,39 @@ public String toString() {
                 + "codecProviders=" + codecProviders
                 + '}';
     }
+
+    private static final class CodecCacheKey {
+        private final Class<?> clazz;
+        private final List<Type> types;
+
+        CodecCacheKey(final Class<?> clazz, final List<Type> types) {
+            this.clazz = clazz;
+            this.types = types;
+        }
+
+        @Override
+        public boolean equals(final Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+            CodecCacheKey that = (CodecCacheKey) o;
+            return clazz.equals(that.clazz) && Objects.equals(types, that.types);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(clazz, types);
+        }
+
+        @Override
+        public String toString() {
+            return "CodecCacheKey{"
+                    + "clazz=" + clazz
+                    + ", types=" + types
+                    + '}';
+        }
+    }
 }