We have deprecated this method, now move it to its sole user.
Change-Id: Id596e9cea546264e848b302a73ba3bb4e82faee7
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
import org.opendaylight.mdsal.binding.runtime.api.CaseRuntimeType;
import org.opendaylight.mdsal.binding.runtime.api.ChoiceRuntimeType;
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
-import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
final Class<?> substitution = loadCase(context, caseType);
search: for (final Entry<Class<?>, DataContainerCodecPrototype<?>> real : byClassBuilder.entrySet()) {
- if (BindingReflections.isSubstitutionFor(substitution, real.getKey())) {
+ if (isSubstitutionFor(substitution, real.getKey())) {
bySubstitutionBuilder.put(substitution, real.getValue());
break search;
}
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;
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;
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;
+ }
}
if (getBindingClass().equals(augTarget) && belongsToRuntimeContext(childClass)) {
for (final DataContainerCodecPrototype<?> realChild : augmentationByStream.values()) {
if (Augmentation.class.isAssignableFrom(realChild.getBindingClass())
- && BindingReflections.isSubstitutionFor(childClass, realChild.getBindingClass())) {
+ && isSubstitutionFor(childClass, realChild.getBindingClass())) {
return cacheMismatched(oldMismatched, childClass, realChild);
}
}
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
-import java.util.Arrays;
-import java.util.HashSet;
import java.util.Optional;
import java.util.ServiceLoader;
-import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
return module;
}
}
-
- /**
- * 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}
- * @deprecated This method is used only mdsal-binding-dom-codec and is scheduled for removal.
- */
- // 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.
- @Deprecated(since = "10.0.4", forRemoval = true)
- @SuppressWarnings({ "rawtypes", "unchecked" })
- public 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;
- }
}
Code Review / mdsal.git / commitdiff