Use the type variable D for all DynamicObject types

Author: rschmitt

src/main/java/com/github/rschmitt/dynamicobject/DynamicObject.java

@@ -16,7 +16,7 @@
 import com.github.rschmitt.dynamicobject.internal.Instances;
 import com.github.rschmitt.dynamicobject.internal.Serialization;
 
-public interface DynamicObject<T extends DynamicObject<T>> {
+public interface DynamicObject<D extends DynamicObject<D>> {
     /**
      * @return the underlying Clojure map backing this instance. Downcasting the return value of this method to any
      * particular Java type (e.g. IPersistentMap) is not guaranteed to work with future versions of Clojure.
@@ -27,7 +27,7 @@ public interface DynamicObject<T extends DynamicObject<T>> {
      * @return the apparent type of this instance. Note that {@code getClass} will return the class of the interface
      * proxy and not the interface itself.
      */
-    Class<T> getType();
+    Class<D> getType();
 
     /**
      * Invokes clojure.pprint/pprint, which writes a pretty-printed representation of the object to the currently bound
@@ -46,7 +46,7 @@ public interface DynamicObject<T extends DynamicObject<T>> {
      * <p/>
      * Equivalent to: {@code (merge-with (fn [a b] (if (nil? b) a b)) this other)}
      */
-    T merge(T other);
+    D merge(D other);
 
     /**
      * Recursively compares this instance with {@code other}, returning a new instance containing all of the common
@@ -55,22 +55,22 @@ public interface DynamicObject<T extends DynamicObject<T>> {
      * <p/>
      * Equivalent to: {@code (nth (clojure.data/diff this other) 2)}
      */
-    T intersect(T other);
+    D intersect(D other);
 
     /**
      * Recursively compares this instance with {@code other}, similar to {@link #intersect}, but returning the fields that
      * are unique to {@code this}. Uses the same recursion strategy as {@code intersect}.
      * <p/>
      * Equivalent to: {@code (nth (clojure.data/diff this other) 0)}
      */
-    T subtract(T other);
+    D subtract(D other);
 
     /**
      * Validate that all fields annotated with @Required are non-null, and that all present fields are of the correct
      * type. Returns the validated instance unchanged, which allows the validate method to be called at the end of a
      * fluent builder chain.
      */
-    T validate();
+    D validate();
 
     /**
      * Serialize the given object to Edn. Any {@code EdnTranslator}s that have been registered through
@@ -141,14 +141,14 @@ static <T> T fromFressianByteArray(byte[] bytes) {
     /**
      * Use the supplied {@code map} to back an instance of {@code type}.
      */
-    static <T extends DynamicObject<T>> T wrap(Object map, Class<T> type) {
+    static <D extends DynamicObject<D>> D wrap(Object map, Class<D> type) {
         return Instances.wrap(map, type);
     }
 
     /**
      * Create a "blank" instance of {@code type}, backed by an empty Clojure map. All fields will be null.
      */
-    static <T extends DynamicObject<T>> T newInstance(Class<T> type) {
+    static <D extends DynamicObject<D>> D newInstance(Class<D> type) {
         return Instances.newInstance(type);
     }
 
@@ -180,14 +180,14 @@ static <T> void deregisterType(Class<T> type) {
      * Register a reader tag for a DynamicObject type. This is useful for reading Edn representations of Clojure
      * records.
      */
-    static <T extends DynamicObject<T>> void registerTag(Class<T> type, String tag) {
+    static <D extends DynamicObject<D>> void registerTag(Class<D> type, String tag) {
         Serialization.registerTag(type, tag);
     }
 
     /**
      * Deregister the reader tag for the given DynamicObject type.
      */
-    static <T extends DynamicObject<T>> void deregisterTag(Class<T> type) {
+    static <D extends DynamicObject<D>> void deregisterTag(Class<D> type) {
         Serialization.deregisterTag(type);
     }
 

src/main/java/com/github/rschmitt/dynamicobject/internal/CustomValidationHook.java

@@ -2,6 +2,6 @@
 
 import com.github.rschmitt.dynamicobject.DynamicObject;
 
-public interface CustomValidationHook<T extends DynamicObject<T>> {
-    T $$customValidate();
+public interface CustomValidationHook<D extends DynamicObject<D>> {
+    D $$customValidate();
 }

src/main/java/com/github/rschmitt/dynamicobject/internal/DynamicObjectInstance.java

@@ -11,18 +11,18 @@
 import com.github.rschmitt.dynamicobject.DynamicObject;
 import clojure.lang.AFn;
 
-public abstract class DynamicObjectInstance<T extends DynamicObject<T>> implements CustomValidationHook<T> {
+public abstract class DynamicObjectInstance<D extends DynamicObject<D>> implements CustomValidationHook<D> {
     private static final Object Default = new Object();
     private static final Object Null = new Object();
 
     Object map;
-    Class<T> type;
+    Class<D> type;
     private final ConcurrentHashMap valueCache = new ConcurrentHashMap();
 
     public DynamicObjectInstance() {
     }
 
-    DynamicObjectInstance(Object map, Class<T> type) {
+    DynamicObjectInstance(Object map, Class<D> type) {
         this.map = map;
         this.type = type;
     }
@@ -31,7 +31,7 @@ public Map getMap() {
         return (Map) map;
     }
 
-    public Class<T> getType() {
+    public Class<D> getType() {
         return type;
     }
 
@@ -62,7 +62,7 @@ public String toFormattedString() {
         return w.toString();
     }
 
-    public T merge(T other) {
+    public D merge(D other) {
         AFn ignoreNulls = new AFn() {
             public Object invoke(Object arg1, Object arg2) {
                 return (arg2 == null) ? arg1 : arg2;
@@ -72,33 +72,33 @@ public Object invoke(Object arg1, Object arg2) {
         return DynamicObject.wrap(mergedMap, type);
     }
 
-    public T intersect(T arg) {
+    public D intersect(D arg) {
         return diff(arg, 2);
     }
 
-    public T subtract(T arg) {
+    public D subtract(D arg) {
         return diff(arg, 0);
     }
 
-    private T diff(T arg, int idx) {
+    private D diff(D arg, int idx) {
         Object array = ClojureStuff.Diff.invoke(map, arg.getMap());
         Object union = ClojureStuff.Nth.invoke(array, idx);
         if (union == null) union = ClojureStuff.EmptyMap;
         union = Metadata.withTypeMetadata(union, type);
         return DynamicObject.wrap(union, type);
     }
 
-    public T convertAndAssoc(Object key, Object value) {
+    public D convertAndAssoc(Object key, Object value) {
         return assoc(key, Conversions.javaToClojure(value));
     }
 
-    public T assoc(Object key, Object value) {
+    public D assoc(Object key, Object value) {
         if (value instanceof DynamicObject)
             value = ((DynamicObject) value).getMap();
         return DynamicObject.wrap(ClojureStuff.Assoc.invoke(map, key, value), type);
     }
 
-    public T assocMeta(Object key, Object value) {
+    public D assocMeta(Object key, Object value) {
         return DynamicObject.wrap(ClojureStuff.VaryMeta.invoke(map, ClojureStuff.Assoc, key, value), type);
     }
 
@@ -132,7 +132,7 @@ public Object getValueFor(Object key, Type genericReturnType) {
         return Conversions.clojureToJava(val, genericReturnType);
     }
 
-    public T validate(T self) {
+    public D validate(D self) {
         Validation.validateInstance(this);
         return self;
     }

src/main/java/com/github/rschmitt/dynamicobject/internal/DynamicObjectInvocationHandler.java

@@ -10,13 +10,13 @@
 
 import com.github.rschmitt.dynamicobject.DynamicObject;
 
-class DynamicObjectInvocationHandler<T extends DynamicObject<T>> implements InvocationHandler {
+class DynamicObjectInvocationHandler<D extends DynamicObject<D>> implements InvocationHandler {
     private static final ConcurrentMap<Method, MethodHandle> methodHandleCache = new ConcurrentHashMap<>();
     private static final ConcurrentMap<Method, Invokee> invocationCache = new ConcurrentHashMap<>();
 
-    private final DynamicObjectInstance<T> instance;
+    private final DynamicObjectInstance<D> instance;
 
-    DynamicObjectInvocationHandler(DynamicObjectInstance<T> instance) {
+    DynamicObjectInvocationHandler(DynamicObjectInstance<D> instance) {
         this.instance = instance;
     }
 
@@ -32,7 +32,7 @@ private Invokee getInvocation(Method method) {
         if (method.isDefault()) {
             if (methodName.equals("validate")) {
                 return (instance, p, a) -> {
-                    instance.validate((T) p);
+                    instance.validate((D) p);
                     return invokeDefaultMethod(p, method, a);
                 };
             }
@@ -53,10 +53,10 @@ private Invokee getInvocation(Method method) {
             case "hashCode": return (instance, p, a) -> instance.hashCode();
             case "prettyPrint": return (instance, p, a) -> { instance.prettyPrint(); return null; };
             case "toFormattedString": return (instance, p, a) -> instance.toFormattedString();
-            case "merge": return (instance, p, a) -> instance.merge((T) a[0]);
-            case "intersect": return (instance, p, a) -> instance.intersect((T) a[0]);
-            case "subtract": return (instance, p, a) -> instance.subtract((T) a[0]);
-            case "validate": return (instance, p, a) -> instance.validate((T) p);
+            case "merge": return (instance, p, a) -> instance.merge((D) a[0]);
+            case "intersect": return (instance, p, a) -> instance.intersect((D) a[0]);
+            case "subtract": return (instance, p, a) -> instance.subtract((D) a[0]);
+            case "validate": return (instance, p, a) -> instance.validate((D) p);
             case "equals": return (instance, p, a) -> instance.equals(a[0]);
             default:
                 if (Reflection.isMetadataGetter(method))

src/main/java/com/github/rschmitt/dynamicobject/internal/EdnSerialization.java

@@ -119,14 +119,14 @@ public static synchronized <T> void deregisterType(Class<T> type) {
         translatorCache.remove(type);
     }
 
-    public static synchronized <T extends DynamicObject<T>> void registerTag(Class<T> type, String tag) {
+    public static synchronized <D extends DynamicObject<D>> void registerTag(Class<D> type, String tag) {
         recordTagCache.put(type, tag);
         translators.getAndUpdate(translators -> ClojureStuff.Assoc.invoke(translators, ClojureStuff.cachedRead(
                 tag), new RecordReader<>(type)));
         definePrintMethod(":" + type.getTypeName(), "RecordPrinter/printRecord", tag);
     }
 
-    public static synchronized <T extends DynamicObject<T>> void deregisterTag(Class<T> type) {
+    public static synchronized <D extends DynamicObject<D>> void deregisterTag(Class<D> type) {
         String tag = recordTagCache.get(type);
         translators.getAndUpdate(translators -> ClojureStuff.Dissoc.invoke(translators, ClojureStuff.cachedRead(tag)));
         recordTagCache.remove(type);

src/main/java/com/github/rschmitt/dynamicobject/internal/FressianSerialization.java

@@ -92,13 +92,13 @@ static synchronized <T> void deregisterType(Class<T> type) {
         }
     }
 
-    static synchronized <T extends DynamicObject<T>> void registerTag(Class<T> type, String tag) {
+    static synchronized <D extends DynamicObject<D>> void registerTag(Class<D> type, String tag) {
         binaryTagCache.put(type, tag);
         Handlers.installHandler(fressianWriteHandlers, type, tag, new FressianWriteHandler(type, tag));
         fressianReadHandlers.putIfAbsent(tag, new FressianReadHandler(type));
     }
 
-    static synchronized <T extends DynamicObject<T>> void deregisterTag(Class<T> type) {
+    static synchronized <D extends DynamicObject<D>> void deregisterTag(Class<D> type) {
         String tag = binaryTagCache.get(type);
         fressianWriteHandlers.remove(type);
         fressianReadHandlers.remove(tag);

src/main/java/com/github/rschmitt/dynamicobject/internal/Instances.java

@@ -13,7 +13,7 @@ public class Instances {
     private static final ConcurrentMap<Class, DynamicProxy> proxyCache = new ConcurrentHashMap<>();
     public static boolean USE_INVOKEDYNAMIC = true;
 
-    public static <T extends DynamicObject<T>> T newInstance(Class<T> type) {
+    public static <D extends DynamicObject<D>> D newInstance(Class<D> type) {
         return wrap(Metadata.withTypeMetadata(EmptyMap, type), type);
     }
 
@@ -44,14 +44,14 @@ private static <T> T createIndyProxy(Object map, Class<T> type) {
         }
     }
 
-    private static <T, U extends DynamicObject<U>> T createReflectionProxy(Object map, Class<T> type) {
-        DynamicObjectInstance<U> instance = new DynamicObjectInstance<U>() {
+    private static <T, D extends DynamicObject<D>> T createReflectionProxy(Object map, Class<T> type) {
+        DynamicObjectInstance<D> instance = new DynamicObjectInstance<D>() {
             @Override
-            public U $$customValidate() {
+            public D $$customValidate() {
                 return null;
             }
         };
-        instance.type = (Class<U>) type;
+        instance.type = (Class<D>) type;
         instance.map = map;
         return (T) Proxy.newProxyInstance(
                 Thread.currentThread().getContextClassLoader(),

src/main/java/com/github/rschmitt/dynamicobject/internal/RecordReader.java

@@ -3,10 +3,10 @@
 import com.github.rschmitt.dynamicobject.DynamicObject;
 import clojure.lang.AFn;
 
-public final class RecordReader<T extends DynamicObject<T>> extends AFn {
-    private final Class<T> type;
+public final class RecordReader<D extends DynamicObject<D>> extends AFn {
+    private final Class<D> type;
 
-    RecordReader(Class<T> type) {
+    RecordReader(Class<D> type) {
         this.type = type;
     }
 

src/main/java/com/github/rschmitt/dynamicobject/internal/Reflection.java

@@ -18,12 +18,12 @@
 import com.github.rschmitt.dynamicobject.Required;
 
 class Reflection {
-    static <T extends DynamicObject<T>> Collection<Method> requiredFields(Class<T> type) {
+    static <D extends DynamicObject<D>> Collection<Method> requiredFields(Class<D> type) {
         Collection<Method> fields = fieldGetters(type);
         return fields.stream().filter(Reflection::isRequired).collect(Collectors.toSet());
     }
 
-    static <T extends DynamicObject<T>> Collection<Method> fieldGetters(Class<T> type) {
+    static <D extends DynamicObject<D>> Collection<Method> fieldGetters(Class<D> type) {
         Collection<Method> ret = new LinkedHashSet<>();
         for (Method method : type.getDeclaredMethods())
             if (method.getParameterCount() == 0 && !method.isDefault() && !isMetadataGetter(method))

src/main/java/com/github/rschmitt/dynamicobject/internal/Serialization.java

@@ -14,12 +14,12 @@ public static synchronized <T> void deregisterType(Class<T> type) {
         FressianSerialization.deregisterType(type);
     }
 
-    public static synchronized <T extends DynamicObject<T>> void registerTag(Class<T> type, String tag) {
+    public static synchronized <D extends DynamicObject<D>> void registerTag(Class<D> type, String tag) {
         EdnSerialization.registerTag(type, tag);
         FressianSerialization.registerTag(type, tag);
     }
 
-    public static synchronized <T extends DynamicObject<T>> void deregisterTag(Class<T> type) {
+    public static synchronized <D extends DynamicObject<D>> void deregisterTag(Class<D> type) {
         EdnSerialization.deregisterTag(type);
         FressianSerialization.deregisterTag(type);
     }