Specialize relative leafref types during instantiation

[mdsal.git] / binding / yang-binding / src / main / java / org / opendaylight / yangtools / yang / binding / CodeHelpers.java

diff --git a/binding/yang-binding/src/main/java/org/opendaylight/yangtools/yang/binding/CodeHelpers.java b/binding/yang-binding/src/main/java/org/opendaylight/yangtools/yang/binding/CodeHelpers.java
index 74a2cc0e9bee7fdc251f5049fd9b2a6b0e87df5c..50c77d9134dcc287b021488cb1c7c8ccdbdf6f42 100644 (file)
--- a/binding/yang-binding/src/main/java/org/opendaylight/yangtools/yang/binding/CodeHelpers.java
+++ b/binding/yang-binding/src/main/java/org/opendaylight/yangtools/yang/binding/CodeHelpers.java
@@ -20,7 +20,6 @@ import java.math.BigInteger;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.regex.Pattern;
 import org.eclipse.jdt.annotation.NonNull;
@@ -54,13 +53,28 @@ public final class CodeHelpers {
         checkArgument(expression, "expected one of: %s \n%but was: %s", options, value);
     }
 
+    /**
+     * A shortcut for {@code Preconditions.checkNotNull(value, "Key component \"%s\" must not be null", name)}.
+     *
+     * @param value Value itself
+     * @param name Name of the value
+     * @return Non-null value
+     * @throws NullPointerException if value is null
+     */
+    public static <T> @NonNull T requireKeyProp(final @Nullable T value, final @NonNull String name) {
+        if (value == null) {
+            throw new NullPointerException("Key component \"" + name + "\" may not be null");
+        }
+        return value;
+    }
+
     /**
      * A shortcut for {@code Objects.requireNonNull(value, "Supplied value may not be null")}.
      *
      * @param value Value itself
      * @throws NullPointerException if value is null
      */
-    public static void requireValue(@Nullable final Object value) {
+    public static void requireValue(final @Nullable Object value) {
         requireNonNull(value, "Supplied value may not be null");
     }
 
@@ -396,40 +410,45 @@ public final class CodeHelpers {
     }
 
     /**
-     * Utility method for comparing two augmentable objects' augmentations.
+     * Utility method for checking whether a target object is compatible.
      *
-     * @param <T> Augmentable type
-     * @param thisObj The object representing 'this'
-     * @param other The object representing 'obj'
-     * @return True if both object's augmentations are equal
-     * @throws NullPointerException if any argument is null
+     * @param requiredClass Required class
+     * @param fieldName name of the field being filled
+     * @param obj Object to check, may be null
+     * @return Object cast to required class, if its class matches requirement, or null
+     * @throws IllegalArgumentException if {@code obj} is not an instance of {@code requiredClass}
+     * @throws NullPointerException if {@code requiredClass} or {@code fieldName} is null
      */
-    public static <T extends Augmentable<T>> boolean equalsAugmentations(final @NonNull AugmentationHolder<T> thisObj,
-            final @NonNull Augmentable<T> other) {
-        if (other instanceof AugmentationHolder) {
-            // Simple case: other object is also an AugmentationHolder
-            return thisObj.augmentations().equals(((AugmentationHolder<?>) other).augmentations());
-        }
-
-        // Hard case: compare our augments with presence there...
-        for (Entry<Class<? extends Augmentation<T>>, Augmentation<T>> e : thisObj.augmentations().entrySet()) {
-            if (!e.getValue().equals(other.augmentation(e.getKey()))) {
-                return false;
-            }
+    public static <T> @Nullable T checkFieldCast(final @NonNull Class<T> requiredClass, final @NonNull String fieldName,
+            final @Nullable Object obj) {
+        try {
+            return requiredClass.cast(obj);
+        } catch (ClassCastException e) {
+            throw new IllegalArgumentException("Invalid input value for property \"" + fieldName + "\"", e);
         }
-        // .. and give the other one the chance to do the same
-        return other.equals(thisObj);
     }
 
     /**
-     * Utility for extracting augmentations from an implementation of {@link AugmentationHolder} interface.
+     * Utility method for checking whether the items of target list is compatible.
      *
-     * @param obj Implementation object
-     * @return hash code of augmentations
-     * @throws NullPointerException if obj is null
+     * @param requiredClass Required item class
+     * @param fieldName name of the field being filled
+     * @param list List, which items should be checked
+     * @throws IllegalArgumentException if a list item is not instance of {@code requiredItemClass}
+     * @throws NullPointerException if {@code requiredClass} or {@code fieldName} is null
      */
-    public static int hashAugmentations(final @NonNull AugmentationHolder<?> obj) {
-        return obj.augmentations().hashCode();
+    @SuppressWarnings("unchecked")
+    public static <T> @Nullable List<T> checkListFieldCast(final @NonNull Class<?> requiredClass,
+            final @NonNull String fieldName, final @Nullable List<?> list) {
+        if (list != null) {
+            try {
+                list.forEach(item -> requiredClass.cast(requireNonNull(item)));
+            } catch (ClassCastException | NullPointerException e) {
+                throw new IllegalArgumentException("Invalid input list item for property \"" + requireNonNull(fieldName)
+                    + "\"", e);
+            }
+        }
+        return (List<T>) list;
     }
 
     /**