From 3599e380a5330d9cf31f1919fbf9ec3dbf73c852 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Mon, 16 Apr 2018 18:27:54 +0200 Subject: [PATCH] Convert base types to implement CanonicalValue With CanonicalValue concept defined we can now retrofit into our base support types for YANG. Aside from the canonical representation which these classes provided, this allows them to communicate value validation as needed. Change-Id: I3ea24ecc2cbf3c2e23a3020b722b7a038f62b321 Signed-off-by: Robert Varga --- .../yangtools/yang/common/Decimal64.java | 64 +++++++++++++------ .../yangtools/yang/common/Uint16.java | 32 ++++++++-- .../yangtools/yang/common/Uint32.java | 32 ++++++++-- .../yangtools/yang/common/Uint64.java | 32 ++++++++-- .../yangtools/yang/common/Uint8.java | 33 ++++++++-- .../yangtools/yang/common/Decimal64Test.java | 5 -- 6 files changed, 157 insertions(+), 41 deletions(-) diff --git a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Decimal64.java b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Decimal64.java index dc30514253..5fba2e0e3f 100644 --- a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Decimal64.java +++ b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Decimal64.java @@ -14,7 +14,8 @@ import com.google.common.annotations.Beta; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Strings; import java.math.BigDecimal; -import org.opendaylight.yangtools.concepts.Immutable; +import org.eclipse.jdt.annotation.NonNullByDefault; +import org.eclipse.jdt.annotation.Nullable; /** * Dedicated type for YANG's 'type decimal64' type. This class is similar to {@link BigDecimal}, but provides more @@ -23,7 +24,20 @@ import org.opendaylight.yangtools.concepts.Immutable; * @author Robert Varga */ @Beta -public class Decimal64 extends Number implements Comparable, Immutable { +@NonNullByDefault +public class Decimal64 extends Number implements CanonicalValue { + private static final class Support extends AbstractCanonicalValueSupport { + Support() { + super(Decimal64.class); + } + + @Override + public Decimal64 fromString(final String str) { + return Decimal64.valueOf(str); + } + } + + private static final CanonicalValueSupport SUPPORT = new Support(); private static final long serialVersionUID = 1L; private static final int MAX_FRACTION_DIGITS = 18; @@ -301,6 +315,32 @@ public class Decimal64 extends Number implements Comparable, Immutabl return Double.compare(doubleValue(), o.doubleValue()); } + @Override + public final String toCanonicalString() { + // https://tools.ietf.org/html/rfc6020#section-9.3.2 + // + // The canonical form of a positive decimal64 does not include the sign + // "+". The decimal point is required. Leading and trailing zeros are + // prohibited, subject to the rule that there MUST be at least one digit + // before and after the decimal point. The value zero is represented as + // "0.0". + final StringBuilder sb = new StringBuilder(21).append(intPart()).append('.'); + final long fracPart = fracPart(); + if (fracPart != 0) { + // We may need to zero-pad the fraction part + sb.append(Strings.padStart(Long.toString(fracPart), scaleOffset + 1, '0')); + } else { + sb.append('0'); + } + + return sb.toString(); + } + + @Override + public final CanonicalValueSupport support() { + return SUPPORT; + } + @Override public final int hashCode() { // We need to normalize the results in order to be consistent with equals() @@ -308,7 +348,7 @@ public class Decimal64 extends Number implements Comparable, Immutabl } @Override - public final boolean equals(final Object obj) { + public final boolean equals(final @Nullable Object obj) { if (this == obj) { return true; } @@ -326,23 +366,7 @@ public class Decimal64 extends Number implements Comparable, Immutabl @Override public final String toString() { - // https://tools.ietf.org/html/rfc6020#section-9.3.2 - // - // The canonical form of a positive decimal64 does not include the sign - // "+". The decimal point is required. Leading and trailing zeros are - // prohibited, subject to the rule that there MUST be at least one digit - // before and after the decimal point. The value zero is represented as - // "0.0". - final StringBuilder sb = new StringBuilder(21).append(intPart()).append('.'); - final long fracPart = fracPart(); - if (fracPart != 0) { - // We may need to zero-pad the fraction part - sb.append(Strings.padStart(Long.toString(fracPart), scaleOffset + 1, '0')); - } else { - sb.append('0'); - } - - return sb.toString(); + return toCanonicalString(); } private long intPart() { diff --git a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint16.java b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint16.java index 7b9e50f0cb..cc28bd1b3b 100644 --- a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint16.java +++ b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint16.java @@ -13,7 +13,8 @@ import com.google.common.annotations.Beta; import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; -import org.opendaylight.yangtools.concepts.Immutable; +import org.eclipse.jdt.annotation.NonNullByDefault; +import org.eclipse.jdt.annotation.Nullable; /** * Dedicated type for YANG's 'type uint16' type. @@ -21,7 +22,20 @@ import org.opendaylight.yangtools.concepts.Immutable; * @author Robert Varga */ @Beta -public class Uint16 extends Number implements Comparable, Immutable { +@NonNullByDefault +public class Uint16 extends Number implements CanonicalValue { + private static final class Support extends AbstractCanonicalValueSupport { + Support() { + super(Uint16.class); + } + + @Override + public Uint16 fromString(final String str) { + return Uint16.valueOf(str); + } + } + + private static final CanonicalValueSupport SUPPORT = new Support(); private static final long serialVersionUID = 1L; private static final int MIN_VALUE = 0; private static final int MAX_VALUE = 65535; @@ -173,19 +187,29 @@ public class Uint16 extends Number implements Comparable, Immutable { return Integer.compare(intValue(), o.intValue()); } + @Override + public final String toCanonicalString() { + return String.valueOf(intValue()); + } + + @Override + public final CanonicalValueSupport support() { + return SUPPORT; + } + @Override public final int hashCode() { return Short.hashCode(value); } @Override - public final boolean equals(final Object obj) { + public final boolean equals(final @Nullable Object obj) { return this == obj || obj instanceof Uint16 && value == ((Uint16)obj).value; } @Override public final String toString() { - return String.valueOf(intValue()); + return toCanonicalString(); } private Object readResolve() { diff --git a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint32.java b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint32.java index 5dfe099212..d5ddd002aa 100644 --- a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint32.java +++ b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint32.java @@ -14,7 +14,8 @@ import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; import com.google.common.primitives.UnsignedInteger; -import org.opendaylight.yangtools.concepts.Immutable; +import org.eclipse.jdt.annotation.NonNullByDefault; +import org.eclipse.jdt.annotation.Nullable; /** * Dedicated type for YANG's 'type uint32' type. @@ -22,7 +23,20 @@ import org.opendaylight.yangtools.concepts.Immutable; * @author Robert Varga */ @Beta -public class Uint32 extends Number implements Comparable, Immutable { +@NonNullByDefault +public class Uint32 extends Number implements CanonicalValue { + private static final class Support extends AbstractCanonicalValueSupport { + Support() { + super(Uint32.class); + } + + @Override + public Uint32 fromString(final String str) { + return Uint32.valueOf(str); + } + } + + private static final CanonicalValueSupport SUPPORT = new Support(); private static final long serialVersionUID = 1L; private static final long MIN_VALUE = 0; private static final long MAX_VALUE = 0xffffffffL; @@ -179,19 +193,29 @@ public class Uint32 extends Number implements Comparable, Immutable { return Integer.compareUnsigned(value, o.value); } + @Override + public final String toCanonicalString() { + return Integer.toUnsignedString(value); + } + + @Override + public final CanonicalValueSupport support() { + return SUPPORT; + } + @Override public final int hashCode() { return Integer.hashCode(value); } @Override - public final boolean equals(final Object obj) { + public final boolean equals(final @Nullable Object obj) { return this == obj || obj instanceof Uint32 && value == ((Uint32)obj).value; } @Override public final String toString() { - return Integer.toUnsignedString(value); + return toCanonicalString(); } private Object readResolve() { diff --git a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint64.java b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint64.java index 3480b938bc..71af5e8c72 100644 --- a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint64.java +++ b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint64.java @@ -15,7 +15,8 @@ import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; import com.google.common.primitives.UnsignedLong; import java.math.BigInteger; -import org.opendaylight.yangtools.concepts.Immutable; +import org.eclipse.jdt.annotation.NonNullByDefault; +import org.eclipse.jdt.annotation.Nullable; /** * Dedicated type for YANG's 'type uint64' type. @@ -23,7 +24,20 @@ import org.opendaylight.yangtools.concepts.Immutable; * @author Robert Varga */ @Beta -public class Uint64 extends Number implements Comparable, Immutable { +@NonNullByDefault +public class Uint64 extends Number implements CanonicalValue { + private static final class Support extends AbstractCanonicalValueSupport { + Support() { + super(Uint64.class); + } + + @Override + public Uint64 fromString(final String str) { + return Uint64.valueOf(str); + } + } + + private static final CanonicalValueSupport SUPPORT = new Support(); private static final long serialVersionUID = 1L; private static final long MIN_VALUE = 0; @@ -189,19 +203,29 @@ public class Uint64 extends Number implements Comparable, Immutable { return Long.compareUnsigned(value, o.value); } + @Override + public final String toCanonicalString() { + return Long.toUnsignedString(value); + } + + @Override + public final CanonicalValueSupport support() { + return SUPPORT; + } + @Override public final int hashCode() { return Long.hashCode(value); } @Override - public final boolean equals(final Object obj) { + public final boolean equals(final @Nullable Object obj) { return this == obj || obj instanceof Uint64 && value == ((Uint64)obj).value; } @Override public final String toString() { - return Long.toUnsignedString(value); + return toCanonicalString(); } private Object readResolve() { diff --git a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint8.java b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint8.java index 1def9c4759..6dd45c4c64 100644 --- a/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint8.java +++ b/yang/yang-common/src/main/java/org/opendaylight/yangtools/yang/common/Uint8.java @@ -10,7 +10,8 @@ package org.opendaylight.yangtools.yang.common; import static com.google.common.base.Preconditions.checkArgument; import com.google.common.annotations.Beta; -import org.opendaylight.yangtools.concepts.Immutable; +import org.eclipse.jdt.annotation.NonNullByDefault; +import org.eclipse.jdt.annotation.Nullable; /** * Dedicated type for YANG's 'type uint8' type. @@ -18,7 +19,21 @@ import org.opendaylight.yangtools.concepts.Immutable; * @author Robert Varga */ @Beta -public class Uint8 extends Number implements Comparable, Immutable { +@NonNullByDefault +public class Uint8 extends Number implements CanonicalValue { + private static final class Support extends AbstractCanonicalValueSupport { + Support() { + super(Uint8.class); + } + + @Override + public Uint8 fromString(final String str) { + return Uint8.valueOf(str); + } + } + + private static final CanonicalValueSupport SUPPORT = new Support(); + static final short MIN_VALUE = 0; static final short MAX_VALUE = 255; @@ -127,19 +142,29 @@ public class Uint8 extends Number implements Comparable, Immutable { return intValue() - o.intValue(); } + @Override + public final String toCanonicalString() { + return String.valueOf(intValue()); + } + + @Override + public final CanonicalValueSupport support() { + return SUPPORT; + } + @Override public final int hashCode() { return Byte.hashCode(value); } @Override - public final boolean equals(final Object obj) { + public final boolean equals(final @Nullable Object obj) { return this == obj || obj instanceof Uint8 && value == ((Uint8)obj).value; } @Override public final String toString() { - return String.valueOf(intValue()); + return toCanonicalString(); } private Object readResolve() { diff --git a/yang/yang-common/src/test/java/org/opendaylight/yangtools/yang/common/Decimal64Test.java b/yang/yang-common/src/test/java/org/opendaylight/yangtools/yang/common/Decimal64Test.java index c6a52b22c3..45b1234e99 100644 --- a/yang/yang-common/src/test/java/org/opendaylight/yangtools/yang/common/Decimal64Test.java +++ b/yang/yang-common/src/test/java/org/opendaylight/yangtools/yang/common/Decimal64Test.java @@ -56,11 +56,6 @@ public class Decimal64Test { Decimal64.valueOf(".a"); } - @Test(expected = NullPointerException.class) - public void testParseNull() { - Decimal64.valueOf((String)null); - } - @Test(expected = NumberFormatException.class) public void testParseMinus() { Decimal64.valueOf("-"); -- 2.36.6