src/java.base/share/classes/sun/reflect/generics/repository/ClassRepository.java

@@ -24,10 +24,14 @@
  */
 
 package sun.reflect.generics.repository;
 
 import java.lang.reflect.Type;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.function.Function;
+
 import sun.reflect.generics.factory.GenericsFactory;
 import sun.reflect.generics.tree.ClassSignature;
 import sun.reflect.generics.tree.TypeTree;
 import sun.reflect.generics.visitor.Reifier;
 import sun.reflect.generics.parser.SignatureParser;

@@ -96,10 +100,34 @@
             superInterfaces = value;
         }
         return value.clone();
     }
 
+    private volatile Map<Object, Object> derivatives;
+    private static final Object nullDerivative = new Object();
+
+    public <D> D getDerivative(Class<?> clazz, Object key,
+                               Function<Class<?>, ? extends D> function) {
+        Map<Object, Object> dm = derivatives;
+        Object d = (dm == null) ? null : dm.get(key);
+        if (d == null) {
+            d = function.apply(clazz);
+            if (d == null) d = nullDerivative;
+            // re-read derivatives reference to minimize the chance of
+            // loosing concurrent updates...
+            dm = derivatives;
+            Map<Object, Object> newDm = new IdentityHashMap<>(
+                (dm == null) ? 1 : dm.size() + 1);
+            newDm.put(key, d);
+            if (dm != null) newDm.putAll(dm);
+            derivatives = newDm;
+        }
+        @SuppressWarnings("unchecked")
+        D derivative = (d == nullDerivative) ? null : (D) d;
+        return derivative;
+    }
+
     private Type computeSuperclass() {
         Reifier r = getReifier(); // obtain visitor
         // Extract superclass subtree from AST and reify
         getTree().getSuperclass().accept(r);
         return r.getResult();