Fix CodeHelper.nonnull() nullness annotation

[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 568eb8798d3395925e547f31346ffa3021eae710..0356fe5cba1a043ec3dbbbbf93d8fd9fd29c4232 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
@@ -16,6 +16,7 @@ import com.google.common.base.VerifyException;
 import com.google.common.collect.ImmutableList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;
 import java.util.regex.Pattern;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
@@ -66,6 +67,16 @@ public final class CodeHelpers {
         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) {
+        requireNonNull(value, "Supplied value may not be null");
+    }
+
     /**
      * Append a named value to a ToStringHelper. If the value is null, this method does nothing.
      *
@@ -74,7 +85,7 @@ public final class CodeHelpers {
      * @param value Value to append
      * @throws NullPointerException if the name or helper is null
      */
-    public static void appendValue(final @NonNull ToStringHelper helper, final @NonNull String name,
+    public static void appendValue(final ToStringHelper helper, final @NonNull String name,
             final @Nullable Object value) {
         if (value != null) {
             helper.add(name, value);
@@ -184,6 +195,30 @@ public final class CodeHelpers {
         throw new IllegalArgumentException("Invalid range: " + actual + ", expected: " + expected + ".");
     }
 
+    /**
+     * Throw an IllegalArgument exception describing a range violation.
+     *
+     * @param expected String describing expected ranges
+     * @param actual Actual observed value
+     * @throws IllegalArgumentException always
+     */
+    public static void throwInvalidRange(final String expected, final int actual) {
+        // Not a code duplication: provides faster string concat via StringBuilder.append(int)
+        throw new IllegalArgumentException("Invalid range: " + actual + ", expected: " + expected + ".");
+    }
+
+    /**
+     * Throw an IllegalArgument exception describing a range violation.
+     *
+     * @param expected String describing expected ranges
+     * @param actual Actual observed value
+     * @throws IllegalArgumentException always
+     */
+    public static void throwInvalidRange(final String expected, final long actual) {
+        // Not a code duplication: provides faster string concat via StringBuilder.append(long)
+        throw new IllegalArgumentException("Invalid range: " + actual + ", expected: " + expected + ".");
+    }
+
     /**
      * Throw an IllegalArgument exception describing a range violation.
      *
@@ -202,7 +237,48 @@ public final class CodeHelpers {
      * @param input input list, may be null
      * @return Input list or an empty list.
      */
-    public static <T> List<T> nonnull(final @Nullable List<T> input) {
+    public static <T> @NonNull List<T> nonnull(final @Nullable List<T> input) {
         return input != null ? input : ImmutableList.of();
     }
+
+    /**
+     * Return hash code of a single-property wrapper class. Since the wrapper is not null, we really want to discern
+     * this object being present, hence {@link Objects#hashCode()} is not really useful we would end up with {@code 0}
+     * for both non-present and present-with-null objects.
+     *
+     * @param obj Internal object to hash
+     * @return Wrapper object hash code
+     */
+    public static int wrapperHashCode(final @Nullable Object obj) {
+        return wrapHashCode(Objects.hashCode(obj));
+    }
+
+    /**
+     * Return hash code of a single-property wrapper class. Since the wrapper is not null, we really want to discern
+     * this object being present, hence {@link Arrays#hashCode()} is not really useful we would end up with {@code 0}
+     * for both non-present and present-with-null objects.
+     *
+     * @param obj Internal object to hash
+     * @return Wrapper object hash code
+     */
+    public static int wrapperHashCode(final byte @Nullable[] obj) {
+        return wrapHashCode(Arrays.hashCode(obj));
+    }
+
+    /**
+     * The constant '31' is the result of folding this code:
+     * <pre>
+     *     final int prime = 31;
+     *     int result = 1;
+     *     result = result * prime + Objects.hashCode(obj);
+     *     return result;
+     * </pre>
+     * when hashCode is returned as 0, such as due to obj being null or its hashCode being 0.
+     *
+     * @param hash Wrapped object hash
+     * @return Wrapper object hash
+     */
+    private static int wrapHashCode(final int hash) {
+        return hash == 0 ? 31 : hash;
+    }
 }