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
* @author Robert Varga
*/
@Beta
-public class Decimal64 extends Number implements Comparable<Decimal64>, Immutable {
+@NonNullByDefault
+public class Decimal64 extends Number implements CanonicalValue<Decimal64> {
+ private static final class Support extends AbstractCanonicalValueSupport<Decimal64> {
+ Support() {
+ super(Decimal64.class);
+ }
+
+ @Override
+ public Decimal64 fromString(final String str) {
+ return Decimal64.valueOf(str);
+ }
+ }
+
+ private static final CanonicalValueSupport<Decimal64> SUPPORT = new Support();
private static final long serialVersionUID = 1L;
private static final int MAX_FRACTION_DIGITS = 18;
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<Decimal64> support() {
+ return SUPPORT;
+ }
+
@Override
public final int hashCode() {
// We need to normalize the results in order to be consistent with equals()
}
@Override
- public final boolean equals(final Object obj) {
+ public final boolean equals(final @Nullable Object obj) {
if (this == obj) {
return true;
}
@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() {
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.
* @author Robert Varga
*/
@Beta
-public class Uint16 extends Number implements Comparable<Uint16>, Immutable {
+@NonNullByDefault
+public class Uint16 extends Number implements CanonicalValue<Uint16> {
+ private static final class Support extends AbstractCanonicalValueSupport<Uint16> {
+ Support() {
+ super(Uint16.class);
+ }
+
+ @Override
+ public Uint16 fromString(final String str) {
+ return Uint16.valueOf(str);
+ }
+ }
+
+ private static final CanonicalValueSupport<Uint16> SUPPORT = new Support();
private static final long serialVersionUID = 1L;
private static final int MIN_VALUE = 0;
private static final int MAX_VALUE = 65535;
return Integer.compare(intValue(), o.intValue());
}
+ @Override
+ public final String toCanonicalString() {
+ return String.valueOf(intValue());
+ }
+
+ @Override
+ public final CanonicalValueSupport<Uint16> 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() {
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.
* @author Robert Varga
*/
@Beta
-public class Uint32 extends Number implements Comparable<Uint32>, Immutable {
+@NonNullByDefault
+public class Uint32 extends Number implements CanonicalValue<Uint32> {
+ private static final class Support extends AbstractCanonicalValueSupport<Uint32> {
+ Support() {
+ super(Uint32.class);
+ }
+
+ @Override
+ public Uint32 fromString(final String str) {
+ return Uint32.valueOf(str);
+ }
+ }
+
+ private static final CanonicalValueSupport<Uint32> SUPPORT = new Support();
private static final long serialVersionUID = 1L;
private static final long MIN_VALUE = 0;
private static final long MAX_VALUE = 0xffffffffL;
return Integer.compareUnsigned(value, o.value);
}
+ @Override
+ public final String toCanonicalString() {
+ return Integer.toUnsignedString(value);
+ }
+
+ @Override
+ public final CanonicalValueSupport<Uint32> 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() {
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.
* @author Robert Varga
*/
@Beta
-public class Uint64 extends Number implements Comparable<Uint64>, Immutable {
+@NonNullByDefault
+public class Uint64 extends Number implements CanonicalValue<Uint64> {
+ private static final class Support extends AbstractCanonicalValueSupport<Uint64> {
+ Support() {
+ super(Uint64.class);
+ }
+
+ @Override
+ public Uint64 fromString(final String str) {
+ return Uint64.valueOf(str);
+ }
+ }
+
+ private static final CanonicalValueSupport<Uint64> SUPPORT = new Support();
private static final long serialVersionUID = 1L;
private static final long MIN_VALUE = 0;
return Long.compareUnsigned(value, o.value);
}
+ @Override
+ public final String toCanonicalString() {
+ return Long.toUnsignedString(value);
+ }
+
+ @Override
+ public final CanonicalValueSupport<Uint64> 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() {
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.
* @author Robert Varga
*/
@Beta
-public class Uint8 extends Number implements Comparable<Uint8>, Immutable {
+@NonNullByDefault
+public class Uint8 extends Number implements CanonicalValue<Uint8> {
+ private static final class Support extends AbstractCanonicalValueSupport<Uint8> {
+ Support() {
+ super(Uint8.class);
+ }
+
+ @Override
+ public Uint8 fromString(final String str) {
+ return Uint8.valueOf(str);
+ }
+ }
+
+ private static final CanonicalValueSupport<Uint8> SUPPORT = new Support();
+
static final short MIN_VALUE = 0;
static final short MAX_VALUE = 255;
return intValue() - o.intValue();
}
+ @Override
+ public final String toCanonicalString() {
+ return String.valueOf(intValue());
+ }
+
+ @Override
+ public final CanonicalValueSupport<Uint8> 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() {
Decimal64.valueOf(".a");
}
- @Test(expected = NullPointerException.class)
- public void testParseNull() {
- Decimal64.valueOf((String)null);
- }
-
@Test(expected = NumberFormatException.class)
public void testParseMinus() {
Decimal64.valueOf("-");
Code Review / yangtools.git / commitdiff