Move BindingReflections.isSubstitutionFor()

[mdsal.git] / binding / mdsal-binding-dom-codec / src / main / java / org / opendaylight / mdsal / binding / dom / codec / impl / DataContainerCodecContext.java

diff --git a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/DataContainerCodecContext.java b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/DataContainerCodecContext.java
index c14693f0d6ac3ae143aaaa3d385b99b9af103c9d..e7232499fd0c4df694ef5abfb5ba46d90159b4fd 100644 (file)
--- a/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/DataContainerCodecContext.java
+++ b/binding/mdsal-binding-dom-codec/src/main/java/org/opendaylight/mdsal/binding/dom/codec/impl/DataContainerCodecContext.java
@@ -16,7 +16,10 @@ import java.io.IOException;
 import java.lang.invoke.MethodHandles;
 import java.lang.invoke.VarHandle;
 import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 import java.lang.reflect.ParameterizedType;
+import java.util.Arrays;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -34,6 +37,7 @@ import org.opendaylight.mdsal.binding.model.api.Type;
 import org.opendaylight.mdsal.binding.runtime.api.BindingRuntimeContext;
 import org.opendaylight.mdsal.binding.runtime.api.CompositeRuntimeType;
 import org.opendaylight.mdsal.binding.runtime.api.RuntimeTypeContainer;
+import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
 import org.opendaylight.yangtools.util.ClassLoaderUtils;
 import org.opendaylight.yangtools.yang.binding.Augmentation;
 import org.opendaylight.yangtools.yang.binding.BindingObject;
@@ -334,4 +338,67 @@ abstract class DataContainerCodecContext<D extends DataObject, T extends Runtime
     static final Optional<Class<? extends DataContainer>> optionalDataContainer(final Class<?> type) {
         return Optional.of(type.asSubclass(DataContainer.class));
     }
+
+
+    /**
+     * Determines if two augmentation classes or case classes represents same data.
+     *
+     * <p>
+     * Two augmentations or cases could be substituted only if and if:
+     * <ul>
+     *   <li>Both implements same interfaces</li>
+     *   <li>Both have same children</li>
+     *   <li>If augmentations: Both have same augmentation target class. Target class was generated for data node in a
+     *       grouping.</li>
+     *   <li>If cases: Both are from same choice. Choice class was generated for data node in grouping.</li>
+     * </ul>
+     *
+     * <p>
+     * <b>Explanation:</b>
+     * Binding Specification reuses classes generated for groupings as part of normal data tree, this classes from
+     * grouping could be used at various locations and user may not be aware of it and may use incorrect case or
+     * augmentation in particular subtree (via copy constructors, etc).
+     *
+     * @param potential Class which is potential substitution
+     * @param target Class which should be used at particular subtree
+     * @return true if and only if classes represents same data.
+     * @throws NullPointerException if any argument is {@code null}
+     */
+    // FIXME: MDSAL-785: this really should live in BindingRuntimeTypes and should not be based on reflection. The only
+    //                   user is binding-dom-codec and the logic could easily be performed on GeneratedType instead. For
+    //                   a particular world this boils down to a matrix, which can be calculated either on-demand or
+    //                   when we create BindingRuntimeTypes. Achieving that will bring us one step closer to being able
+    //                   to have a pre-compiled Binding Runtime.
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    static boolean isSubstitutionFor(final Class potential, final Class target) {
+        Set<Class> subImplemented = new HashSet<>(Arrays.asList(potential.getInterfaces()));
+        Set<Class> targetImplemented = new HashSet<>(Arrays.asList(target.getInterfaces()));
+        if (!subImplemented.equals(targetImplemented)) {
+            return false;
+        }
+        if (Augmentation.class.isAssignableFrom(potential)
+                && !BindingReflections.findAugmentationTarget(potential).equals(
+                        BindingReflections.findAugmentationTarget(target))) {
+            return false;
+        }
+        for (Method potentialMethod : potential.getMethods()) {
+            if (Modifier.isStatic(potentialMethod.getModifiers())) {
+                // Skip any static methods, as we are not interested in those
+                continue;
+            }
+
+            try {
+                Method targetMethod = target.getMethod(potentialMethod.getName(), potentialMethod.getParameterTypes());
+                if (!potentialMethod.getReturnType().equals(targetMethod.getReturnType())) {
+                    return false;
+                }
+            } catch (NoSuchMethodException e) {
+                // Counterpart method is missing, so classes could not be substituted.
+                return false;
+            } catch (SecurityException e) {
+                throw new IllegalStateException("Could not compare methods", e);
+            }
+        }
+        return true;
+    }
 }