X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fyang-binding%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fbinding%2FCodeHelpers.java;h=dda90f4c8db2355beeeba0349d74f26337e749b1;hb=8fc4a97304080fafab158ef877e6fc180c030ac0;hp=068de8a91eee686a9e6eca242dc3d0edb35e291d;hpb=954537c45ccb749b2a6e2accd5be392520c51419;p=mdsal.git 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 068de8a91e..dda90f4c8d 100644 --- 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 @@ -11,12 +11,20 @@ import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Verify.verify; import static java.util.Objects.requireNonNull; +import com.google.common.base.MoreObjects.ToStringHelper; import com.google.common.base.VerifyException; +import com.google.common.collect.ImmutableList; +import java.math.BigInteger; 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; +import org.opendaylight.yangtools.yang.common.Uint16; +import org.opendaylight.yangtools.yang.common.Uint32; +import org.opendaylight.yangtools.yang.common.Uint64; +import org.opendaylight.yangtools.yang.common.Uint8; /** * Helper methods for generated binding code. This class concentrates useful primitives generated code may call @@ -64,6 +72,45 @@ 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. + * + * @param helper Helper to append to + * @param name Name of the value + * @param value Value to append + * @throws NullPointerException if the name or helper is null + */ + public static void appendValue(final ToStringHelper helper, final @NonNull String name, + final @Nullable Object value) { + if (value != null) { + helper.add(name, value); + } + } + + /** + * Append a named value to a ToStringHelper. If the value is null, this method does nothing. + * + * @param helper Helper to append to + * @param name Name of the value + * @param value Value to append + * @throws NullPointerException if the name or helper is null + */ + public static void appendValue(final ToStringHelper helper, final String name, final byte[] value) { + if (value != null) { + helper.add(name, Arrays.toString(value)); + } + } + /** * Compile a list of pattern regular expressions and return them as an array. The list must hold at least two * expressions. @@ -95,7 +142,7 @@ public final class CodeHelpers { */ public static void checkPattern(final String value, final Pattern pattern, final String regex) { if (!pattern.matcher(value).matches()) { - final String match = BindingMapping.isNegatedPattern(pattern) ? "matches forbidden" + final String match = RegexPatterns.isNegatedPattern(pattern) ? "matches forbidden" : "does not match required"; throw new IllegalArgumentException("Supplied value \"" + value + "\" " + match + " pattern \"" + regex + "\""); @@ -153,6 +200,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. * @@ -163,4 +234,128 @@ public final class CodeHelpers { public static void throwInvalidRange(final Object[] expected, final Object actual) { throwInvalidRange(Arrays.toString(expected), actual); } + + /** + * Throw an IllegalArgument exception describing a range violation of an Uint64 type. + * + * @param expected String describing expected ranges + * @param actual Actual observed value + * @throws IllegalArgumentException always + */ + public static void throwInvalidRangeUnsigned(final String expected, final long actual) { + throw new IllegalArgumentException("Invalid range: " + Long.toUnsignedString(actual) + ", expected: " + expected + + "."); + } + + /** + * Check whether specified List is null and if so return an immutable list instead. This method supports + * non-null default getter methods. + * + * @param input input list, may be null + * @return Input list or an empty list. + */ + public static @NonNull List nonnull(final @Nullable List 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)); + } + + /** + * Compatibility utility for converting a legacy {@link Short} {@code uint8} value to its {@link Uint8} + * counterpart. + * + * @param value Legacy value + * @return Converted value + * @throws IllegalArgumentException if the value does not fit an Uint8 + * @deprecated This method is provided for migration purposes only, do not use it outside of deprecated + * compatibility methods. + */ + @Deprecated + public static @Nullable Uint8 compatUint(final @Nullable Short value) { + return value == null ? null : Uint8.valueOf(value.shortValue()); + } + + /** + * Compatibility utility for converting a legacy {@link Integer} {@code uint16} value to its {@link Uint16} + * counterpart. + * + * @param value Legacy value + * @return Converted value + * @throws IllegalArgumentException if the value does not fit an Uint16 + * @deprecated This method is provided for migration purposes only, do not use it outside of deprecated + * compatibility methods. + */ + @Deprecated + public static @Nullable Uint16 compatUint(final @Nullable Integer value) { + return value == null ? null : Uint16.valueOf(value.intValue()); + } + + /** + * Compatibility utility for converting a legacy {@link Long} {@code uint32} value to its {@link Uint32} + * counterpart. + * + * @param value Legacy value + * @return Converted value + * @throws IllegalArgumentException if the value does not fit an Uint32 + * @deprecated This method is provided for migration purposes only, do not use it outside of deprecated + * compatibility methods. + */ + @Deprecated + public static @Nullable Uint32 compatUint(final @Nullable Long value) { + return value == null ? null : Uint32.valueOf(value.longValue()); + } + + /** + * Compatibility utility for converting a legacy {@link BigInteger} {@code uint64} value to its {@link Uint64} + * counterpart. + * + * @param value Legacy value + * @return Converted value + * @throws IllegalArgumentException if the value does not fit an Uint64 + * @deprecated This method is provided for migration purposes only, do not use it outside of deprecated + * compatibility methods. + */ + @Deprecated + public static @Nullable Uint64 compatUint(final @Nullable BigInteger value) { + return value == null ? null : Uint64.valueOf(value); + } + + /** + * The constant '31' is the result of folding this code: + * 
+     *     final int prime = 31;
+     *     int result = 1;
+     *     result = result * prime + Objects.hashCode(obj);
+     *     return result;
+     *
+ * 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; + } }